interval.hpp

浏览该文件的文档.

/*
 * @Description: 区间类 头文件及其实现
 * @Version:
 * @Autor: dreamy-xay
 * @Date: 2023-12-01 15:02:12
 * @LastEditors: dreamy-xay
 * @LastEditTime: 2024-03-06
 */
 
#ifndef COMMON_INTERVAL_HPP
#define COMMON_INTERVAL_HPP
 
#include <iostream>
#include <opencv2/core.hpp>
 
#include "common/enum.h"
#include "common/macro.h"
#include "common/type.h"
 
namespace cm {
 
class Interval {
   public:
    int start;
    int end;
 
    struct CompareByLength {
       private:
        bool (*compare)(const Interval&, const Interval&);
 
       public:
        explicit CompareByLength(bool is_ascending = true);
        bool operator()(const Interval& interval1, const Interval& interval2) const;
    };
 
    Interval();
    Interval(int start, int end);
    Interval(const Interval& interval);
    Interval(const cv::Range& range);
    ~Interval();
 
    operator cv::Range() const;
 
    friend bool operator==(const Interval& interval1, const Interval& interval2);
    friend bool operator!=(const Interval& interval1, const Interval& interval2);
    friend bool operator<(const Interval& interval1, const Interval& interval2);
    friend bool operator>(const Interval& interval1, const Interval& interval2);
    friend bool operator<=(const Interval& interval1, const Interval& interval2);
    friend bool operator>=(const Interval& interval1, const Interval& interval2);
 
    friend std::ostream& operator<<(std::ostream& out, const Interval& interval);
 
    int Length() const;
    template <typename T>
    bool Include(T value) const;
    double Middle() const;
    bool IsValid(int min_interval_len = 1) const;
    bool IsIntersect(const Interval& interval) const;
    Interval Intersect(const Interval& interval) const;
    Interval Union(const Interval& interval) const;
    Interval& Translate(int start_trans_value, int end_trans_value);
    Interval& Translate(int trans_value);
 
    static Interval All();
};
 
inline Interval::CompareByLength::CompareByLength(bool is_ascending) {
    if (is_ascending)
        compare = [](const Interval& interval1, const Interval& interval2) {
            return interval1.Length() < interval2.Length();
        };
    else
        compare = [](const Interval& interval1, const Interval& interval2) {
            return interval1.Length() > interval2.Length();
        };
}
 
inline bool Interval::CompareByLength::operator()(const Interval& interval1, const Interval& interval2) const {
    return compare(interval1, interval2);
}
 
inline Interval::Interval() : start{}, end{} {}
 
inline Interval::Interval(int start, int end) : start(start), end(end) {}
 
inline Interval::Interval(const Interval& interval) : start(interval.start), end(interval.end) {}
 
inline Interval::Interval(const cv::Range& range) : start(range.start), end(range.end) {}
 
inline Interval::~Interval() {}
 
inline Interval::operator cv::Range() const {
    return cv::Range(start, end);
}
 
inline bool operator==(const Interval& interval1, const Interval& interval2) {
    return interval1.start == interval2.start && interval1.end == interval2.end;
}
 
inline bool operator!=(const Interval& interval1, const Interval& interval2) {
    return interval1.start != interval2.start || interval1.end != interval2.end;
}
 
inline bool operator<(const Interval& interval1, const Interval& interval2) {
    if (interval1.start == interval2.start)
        return interval1.end < interval2.end;
    return interval1.start < interval2.start;
}
 
inline bool operator>(const Interval& interval1, const Interval& interval2) {
    if (interval1.start == interval2.start)
        return interval1.end > interval2.end;
    return interval1.start > interval2.start;
}
 
inline bool operator<=(const Interval& interval1, const Interval& interval2) {
    if (interval1.start == interval2.start)
        return interval1.end <= interval2.end;
    return interval1.start < interval2.start;
}
 
inline bool operator>=(const Interval& interval1, const Interval& interval2) {
    if (interval1.start == interval2.start)
        return interval1.end >= interval2.end;
    return interval1.start > interval2.start;
}
 
inline std::ostream& operator<<(std::ostream& out, const Interval& interval) {
    out << '[' << interval.start << ", " << interval.end << ")";
    return out;
}
 
inline int Interval::Length() const {
    return end - start;
}
 
template <typename T>
inline bool Interval::Include(T value) const {
    return value >= start && value < end;
}
 
inline double Interval::Middle() const {
    return (start + end - 1) / 2.0;
}
 
inline bool Interval::IsValid(int min_interval_len) const {
    return end - start >= min_interval_len;
}
 
inline bool Interval::IsIntersect(const Interval& interval) const {
    return this->Intersect(interval).Length() > 0;
}
 
inline Interval Interval::Intersect(const Interval& interval) const {
    return {std::max(start, interval.start), std::min(end, interval.end)};
}
 
inline Interval Interval::Union(const Interval& interval) const {
    return {std::min(start, interval.start), std::max(end, interval.end)};
}
 
inline Interval& Interval::Translate(int start_trans_value, int end_trans_value) {
    start += start_trans_value;
    end += end_trans_value;
 
    return *this;
}
 
inline Interval& Interval::Translate(int trans_value) {
    start += trans_value;
    end += trans_value;
 
    return *this;
}
 
inline Interval Interval::All() {
    return {INT_MIN, INT_MAX};
}
 
}  // namespace cm
 
#endif