lines.hpp

浏览该文件的文档.

/*
 * @Description: 线列表类 头文件及其实现
 * @Version:
 * @Autor: dreamy-xay
 * @date: 2023-12-04
 * @LastEditors: dreamy-xay
 * @LastEditTime: 2024-06-06
 */
#ifndef COMMON_LINES_HPP
#define COMMON_LINES_HPP
 
#include <unordered_set>
 
#include "common/base/disjoint_set.hpp"
#include "common/base/interval.hpp"
#include "common/base/line.hpp"
#include "common/base/list.hpp"
#include "common/base/rect.hpp"
#include "common/enum.h"
#include "common/macro.h"
#include "common/type.h"
#include "common/utils/string.hpp"
#include "opencv2/core.hpp"
 
namespace cm {
 
class Lines : public List<Line> {
   public:
    using List<Line>::List;
 
    Lines() = default;
    Lines(const Lines& lines) = default;
    Lines(const std::vector<cv::Vec4i>& lines);
    Lines(const std::vector<std::vector<int>>& lines);
    ~Lines() = default;
 
    Lines& operator=(const std::vector<cv::Vec4i>& lines);
    Lines& operator=(const std::vector<std::vector<int>>& lines);
 
    Lines& RemoveLines(const std::unordered_set<size_t>& deleted_indexes);
    Lines& RemoveLines(const std::unordered_set<Line, Line::Hash>& deleted_lines);
    Lines& RemoveLines(const Lines& deleted_lines);
 
    const Lines& ClassifyLines(Lines& hlines, Lines& vlines) const;
    double LineLength(Statistic type, const Interval& x_range = Interval::All(), const Interval& y_range = Interval::All(), bool is_rough = false);
 
    Line MergeLines(LineType line_type) const;
 
    Rect Boundary(int margin = 0) const;
    cm::size_t NumberInInterval(const Interval& x_range, const Interval& y_range);
    std::unordered_set<int> GetLinesIndexInLine(const Line& line, int threshold = 2, bool strict_inspect = true);
    Lines& ConnectLines(LineType line_type = ULINE, int threshold = 4, int max_distance = 100, bool strict_inspect = true, const Interval& old_line_len_range = Interval::All(), bool oline_len_condition = true, const Interval& new_line_len_range = Interval::All());
    Lines& ConnectAdjacentLines(int threshold = 4, int max_distance = 100, bool strict_inspect = true, const Interval& old_line_len_range = Interval::All(), bool oline_len_condition = true, const Interval& new_line_len_range = Interval::All());
    template <typename FUNC = Line::CompareByLength>
    std::unordered_set<size_t> GetDuplicateLines(LineType line_type = ULINE, double threshold = 5, double min_overlap_ratio = 0.5, Statistic near_method = cm::MAXIMUM, const FUNC& func = Line::CompareByLength(true)) const;
    template <typename FUNC = Line::CompareByLength>
    std::unordered_set<size_t> GetAdjacentDuplicateLines(double threshold, double min_overlap_ratio = 0.5, Statistic near_method = cm::MAXIMUM, const FUNC& func = Line::CompareByLength(true)) const;
    template <typename FUNC = Line::CompareByLength>
    Lines& RmDuplicateLines(LineType line_type = ULINE, double threshold = 5, double min_overlap_ratio = 0.5, Statistic near_method = cm::MAXIMUM, const FUNC& func = Line::CompareByLength(true));
    template <typename FUNC = Line::CompareByLength>
    Lines& RmAdjacentDuplicateLines(double threshold, double min_overlap_ratio = 0.5, Statistic near_method = cm::MAXIMUM, const FUNC& func = Line::CompareByLength(true));
};
 
inline Lines::Lines(const std::vector<cv::Vec4i>& lines) {
    for (auto& line : lines)
        this->emplace_back(line[0], line[1], line[2], line[3]);
}
 
inline Lines::Lines(const std::vector<std::vector<int>>& lines) {
    for (auto& line : lines)
        this->emplace_back(line[0], line[1], line[2], line[3]);
}
 
inline Lines& Lines::operator=(const std::vector<cv::Vec4i>& lines) {
    this->clear();
    for (auto& line : lines)
        this->emplace_back(line[0], line[1], line[2], line[3]);
 
    return *this;
}
 
inline Lines& Lines::operator=(const std::vector<std::vector<int>>& lines) {
    this->clear();
    for (auto& line : lines)
        this->emplace_back(line[0], line[1], line[2], line[3]);
 
    return *this;
}
 
inline Lines& Lines::RemoveLines(const std::unordered_set<size_t>& deleted_indexes) {
    // 记录 原始数组：
    auto& this_lines = *this;
    size_t num_lines = this_lines.size();
 
    Lines new_lines;  // 暂时存储不删的数据
 
    for (size_t i = 0; i < num_lines; ++i)
        if (!deleted_indexes.count(i))
            new_lines.emplace_back(this_lines[i]);
 
    this_lines = std::move(new_lines);
 
    return this_lines;
}
 
inline Lines& Lines::RemoveLines(const std::unordered_set<Line, Line::Hash>& deleted_lines) {
    // 记录原始列表：
    auto& this_lines = *this;
 
    Lines new_lines;
 
    for (auto& line : this_lines)
        if (!deleted_lines.count(line))
            new_lines.emplace_back(line);
 
    this_lines = std::move(new_lines);
 
    return this_lines;
}
 
inline Lines& Lines::RemoveLines(const Lines& deleted_lines) {
    // 考虑先将 Lines 转变成 std::unordered_set<Line, Line::Hash>
    std::unordered_set<Line, Line::Hash> lines_hash;
    for (auto& line : deleted_lines)
        lines_hash.insert(line);
 
    // 调用重载的函数：
    return this->RemoveLines(lines_hash);
}
 
inline const Lines& Lines::ClassifyLines(Lines& hlines, Lines& vlines) const {
    hlines.clear();
    vlines.clear();
 
    for (auto& line : *this) {
        if (line.Type() == HLINE)
            hlines.emplace_back(line);
        else
            vlines.emplace_back(line);
    }
    return *this;
}
 
inline double Lines::LineLength(Statistic type, const Interval& x_range, const Interval& y_range, bool is_rough) {
    Lines effective_lines = std::move(this->Filter([&x_range, &y_range](const Line& line) {
        return line.InInterval(x_range, y_range);
    }));
 
    switch (type) {
        case AVERAGE:
            return effective_lines.Reduce<double>([=](double sum, const Line& line) {
                return sum + line.Length(is_rough);
            }) / effective_lines.size();
        case MAXIMUM:
            return effective_lines.Max(Line::CompareByLength(is_rough))->Length(is_rough);
        case MINIMUM:
            return effective_lines.Min(Line::CompareByLength(is_rough))->Length(is_rough);
        default:
            throw Exception("The type(Statistic) of param \"type\" is incorrect!");
    }
}
 
inline Line Lines::MergeLines(LineType line_type) const {
    Line new_line;  // 合并的新线
 
    switch (line_type) {
        case HLINE:  // 如果是横线
            new_line.pt1 = this->Min([](const Line& line1, const Line& line2) { return line1.pt1.x < line2.pt1.x; })->pt1;
 
            new_line.pt2 = this->Max([](const Line& line1, const Line& line2) { return line1.pt2.x < line2.pt2.x; })->pt2;
            break;
        case VLINE:  // 否则是竖线
            new_line.pt1 = this->Min([](const Line& line1, const Line& line2) { return line1.pt1.y < line2.pt1.y; })->pt1;
 
            new_line.pt2 = this->Max([](const Line& line1, const Line& line2) { return line1.pt2.y < line2.pt2.y; })->pt2;
            break;
        default:
            throw Exception("The \"line type\" only supports \"cm::HLINE\" or \"cm::VLINE\" types!");
    }
 
    return std::move(new_line);
}
 
inline Rect Lines::Boundary(int margin) const {
    int left_boundary = INT_MAX, right_boundary = INT_MIN;
    int upper_boundary = INT_MAX, lower_boundary = INT_MIN;
 
    for (const Line& line : *this) {
        left_boundary = std::min(left_boundary, line.pt1.x);
        right_boundary = std::max(right_boundary, line.pt2.x);
        upper_boundary = std::min(upper_boundary, line.pt1.y);
        lower_boundary = std::max(lower_boundary, line.pt2.y);
    }
 
    upper_boundary -= margin;  // 根据 margin 向上扩充像素
    lower_boundary += margin;  // 根据 margin 向下扩充像素
    left_boundary -= margin;   // 根据 margin 向左扩充像素
    right_boundary += margin;  // 根据 margin 向右扩充像素
 
    return {left_boundary, upper_boundary, right_boundary - left_boundary + 1, lower_boundary - upper_boundary + 1};
}
 
inline size_t Lines::NumberInInterval(const Interval& x_range, const Interval& y_range) {
    return this->Count([&x_range, &y_range](const Line& line) {
        return line.InInterval(x_range, y_range);
    });
}
 
inline std::unordered_set<int> Lines::GetLinesIndexInLine(const Line& line, int threshold, bool strict_inspect) {
    auto& lines = *this;  // 自身作为线列表
 
    // 获取线列表的长度
    int lines_len = lines.size();
 
    // 如果线列表为空则返回
    if (lines_len == 0)
        return std::unordered_set<int>();
 
    // 断言查看所有线是否都是同一类型
    Cm_Assert(lines.Filter([lines](const Line& line) { return line.Type() == lines[0].Type(); }).size() == lines.size(), "All lines must be of the same type!!!");
 
    std::unordered_set<int> indexes;  // 结果
 
    // 计算线的斜率截距式方程
    auto ge = line.GECoefficients();
 
    if (line.Type() == VLINE) {
        // 子线段最小的x坐标和最大的x坐标
        int vline_min_x = line.X(MINIMUM) - threshold / 2;
        int vline_max_x = line.X(MAXIMUM) + threshold / 2;
 
        // 遍历所有直线
        for (int i = 0; i < lines_len; ++i) {
            if (lines[i].pt1.y < line.pt1.y || lines[i].pt2.y > line.pt2.y)  // 如果线 lines[i] 在y坐标上不是被线 v_line 所包含的，则不做处理
                continue;
 
            // 开启严格检查模式后，检查x坐标范围：如果 lines[i] 在x坐标上不是被线 v_line 所包含的，则不做处理
            if (strict_inspect && (lines[i].X(MINIMUM) < vline_min_x || lines[i].X(MAXIMUM) > vline_max_x))
                continue;
 
            int x1 = ge.GetX(lines[i].pt1.y);  // 计算上端点y坐标在线 v_line 上的x坐标
            int x2 = ge.GetX(lines[i].pt2.y);  // 计算下端点y坐标在线 v_line 上的x坐标
 
            // 如果线lines[i]的两个端点无限接近于线v_line，则表示线 lines[i] 属于线 v_line 的一部分
            if (std::abs(x1 - lines[i].pt1.x) <= threshold && std::abs(x2 - lines[i].pt2.x) <= threshold)
                indexes.emplace(i);
        }
    } else {
        // 子线段最小的y坐标和最大的y坐标
        int hline_min_y = line.Y(MINIMUM) - threshold / 2;
        int hline_max_y = line.Y(MAXIMUM) + threshold / 2;
 
        // 遍历所有直线
        for (int i = 0; i < lines_len; ++i) {
            if (lines[i].pt1.x < line.pt1.x || lines[i].pt2.x > line.pt2.x)  // 如果线 lines[i] 在x坐标上不是被线 h_line 所包含的，则不做处理
                continue;
 
            // 开启严格检查模式后，检查x坐标范围：如果 lines[i] 在y坐标上不是被线 h_line 所包含的，则不做处理
            if (strict_inspect && (lines[i].Y(MINIMUM) < hline_min_y || lines[i].Y(MAXIMUM) > hline_max_y))
                continue;
 
            int y1 = ge.GetY(lines[i].pt1.x);  // 计算左端点x坐标在线 h_line 上的y坐标
            int y2 = ge.GetY(lines[i].pt2.x);  // 计算右端点x坐标在线 h_line 上的y坐标
 
            // 如果线lines[i]的两个端点无限接近于线h_line，则表示线 lines[i] 属于线 h_line 的一部分
            if (abs(y1 - lines[i].pt1.y) <= threshold && abs(y2 - lines[i].pt2.y) <= threshold)
                indexes.emplace(i);
        }
    }
 
    return std::move(indexes);
}
 
inline Lines& Lines::ConnectLines(LineType line_type, int threshold, int max_distance, bool strict_inspect, const Interval& old_line_len_range, bool oline_len_condition, const Interval& new_line_len_range) {
    auto& lines = *this;  // 自身作为线列表
 
    // 获取线列表的长度
    int lines_len = lines.size();
 
    // 如果线的数量小于2，则直接返回
    if (lines_len < 2)
        return lines;
 
    if (line_type == HLINE || line_type == VLINE) {
        // 断言查看所有线是否都是指定线类型
        Cm_Assert(lines.Filter([line_type](const cm::Line& line) { return line.Type() == line_type; }).size() == lines.size(), Sprintf("The line type in the line list must all be \"%s\"!!!", line_type == HLINE ? "cm::HLINE" : "cm::VLINE"));
 
        // 当前线计算距离的距离类型
        LineDistanceType line_dis_type = line_type == HLINE ? LDIS_HLINE_H : LDIS_VLINE_V;
 
        // 使用并查集去计算能连接的线的集合
        DisjointSet<Line> disjoint_set(lines);
 
        // 判断两根原始线长度是否满足连接需求的函数
        bool (*old_len_ok)(const Line&, const Line&, const Interval&);
        if (oline_len_condition)
            old_len_ok = [](const Line& line1, const Line& line2, const Interval& old_line_len_range) {
                return old_line_len_range.Include(line1.Length()) && old_line_len_range.Include(line2.Length());
            };
        else
            old_len_ok = [](const Line& line1, const Line& line2, const Interval& old_line_len_range) {
                return old_line_len_range.Include(line1.Length()) || old_line_len_range.Include(line2.Length());
            };
 
        // 能相互连接的线合并成一个个集合
        disjoint_set.UnionAll([&](const Line& line1, const Line& line2) {
            // 如果两条短线小于最小线长度或者大于最大线长度，则不处理这两条短线
            if (!old_len_ok(line1, line2, old_line_len_range))
                return false;
 
            // 两条线合并成新的线
            Line new_line = line1.SimpleConnect(line2);
 
            // 如果新线的长度小于最小线长度或者大于最大线长度，则不处理该线
            if (new_line.Type() != line1.Type() || !new_line_len_range.Include(new_line.Length()))
                return false;
 
            // 获取新线上所有子线段在线列表（线列表：线1和线2）上的索引
            std::unordered_set<int> indexes = std::move(Lines({line1, line2}).GetLinesIndexInLine(new_line, threshold, strict_inspect));
 
            // 如果线1和线2是新线的子线段（两条线是由新线分裂开来的），并且 两条线的距离 <= 线最大距离，则连接线1和线2并组成新的线
            if (indexes.size() == 2 && line1.DistanceTo(line2, line_dis_type) <= max_distance)
                return true;
 
            return false;
        });
 
        // 获取线列表集合列表
        auto lines_collections = std::move(disjoint_set.GetAllCollections());
 
        // 清空原来横线
        lines.clear();
 
        // 遍历所有可合并线的集合
        for (auto& lines_collection : lines_collections)
            lines.emplace_back(static_cast<Lines&>(lines_collection).MergeLines(line_type));
    } else if (line_type == ULINE) {
        // 横线列表和竖线列表
        Lines hlines, vlines;
 
        // 分类横竖线
        lines.ClassifyLines(hlines, vlines);
 
        // 横线列表和竖线列表分别做线连接
        hlines.ConnectLines(HLINE, threshold, max_distance, strict_inspect, old_line_len_range, oline_len_condition, new_line_len_range);
        vlines.ConnectLines(VLINE, threshold, max_distance, strict_inspect, old_line_len_range, oline_len_condition, new_line_len_range);
 
        // 合并线列表
        lines.clear();
        lines += hlines;
        lines += vlines;
    } else
        throw Exception("The type(LineType) of param \"line_type\" is incorrect!");
 
    return lines;
}
 
inline Lines& Lines::ConnectAdjacentLines(int threshold, int max_distance, bool strict_inspect, const Interval& old_line_len_range, bool oline_len_condition, const Interval& new_line_len_range) {
    auto& lines = *this;  // 自身作为线列表
 
    // 获取线列表的长度
    int lines_len = lines.size();
 
    // 如果线的数量小于2，则直接返回
    if (lines_len < 2)
        return lines;
 
    // 断言查看所有线是否都是同一类型
    Cm_Assert(lines.Filter([lines](const Line& line) { return line.Type() == lines[0].Type(); }).size() == lines.size(), "All lines must be of the same type!!!");
 
    // 当前线计算距离的距离类型
    LineDistanceType line_dis_type = lines[0].Type() == HLINE ? LDIS_HLINE_H : LDIS_VLINE_V;
 
    // 临时变量，两条线合并的新线
    Line new_line;
 
    // 构造新的线列表，首先添加前一根线进去
    Lines new_lines;
    new_lines.emplace_back(lines[0]);
 
    // 判断两根原始线长度是否满足连接需求的函数
    bool (*old_len_ok)(const Line&, const Line&, const Interval&);
    if (oline_len_condition)
        old_len_ok = [](const Line& line1, const Line& line2, const Interval& old_line_len_range) {
            return old_line_len_range.Include(line1.Length()) && old_line_len_range.Include(line2.Length());
        };
    else
        old_len_ok = [](const Line& line1, const Line& line2, const Interval& old_line_len_range) {
            return old_line_len_range.Include(line1.Length()) || old_line_len_range.Include(line2.Length());
        };
 
    // 遍历所有相邻线
    for (int i = 1; i < lines_len; ++i) {
        // 判断是否合并线1和线2
        const Line &line1 = new_lines.back(), line2 = lines[i];
 
        // 如果两条短线小于最小线长度或者大于最大线长度，则不处理这两条短线
        if (!old_len_ok(line1, line2, old_line_len_range)) {
            new_lines.emplace_back(line2);  // 线2未与线1合并，单独加入线2
            continue;
        }
 
        // 两条线合并成新的线
        new_line = line1.SimpleConnect(line2);
 
        // 如果新线的长度小于最小线长度或者大于最大线长度，则不处理该线
        if (new_line.Type() != line1.Type() || !new_line_len_range.Include(new_line.Length())) {
            new_lines.emplace_back(line2);  // 线2未与线1合并，单独加入线2
            continue;
        }
 
        // 获取新线上所有子线段在线列表（线列表：线1和线2）上的索引
        std::unordered_set<int> indexes = std::move(Lines({line1, line2}).GetLinesIndexInLine(new_line, threshold, strict_inspect));
 
        // 如果线1和线2是新线的子线端（两条线是由新线分裂开来的），并且 两条线的距离 <= 线最大距离，则连接线1和线2并组成新的线
        if (indexes.size() == 2 && line1.DistanceTo(line2, line_dis_type) <= max_distance) {
            new_lines.pop_back();              // 删除线1
            new_lines.emplace_back(new_line);  // 加入线1和线2合并的新线
        } else
            new_lines.emplace_back(line2);  // 线2未与线1合并，单独加入线2
    }
 
    // 更新线列表
    lines = std::move(new_lines);
 
    return lines;
}
 
template <typename FUNC>
inline std::unordered_set<size_t> Lines::GetDuplicateLines(LineType line_type, double threshold, double min_overlap_ratio, Statistic near_method, const FUNC& func) const {
    auto& lines = *this;  // 自身作为线列表
 
    // 获取线列表的长度
    const int lines_len = lines.size();
 
    // 移除的线的索引
    std::unordered_set<size_t> erase_lines_indexes;
 
    // 如果线的数量小于2，则直接返回
    if (lines_len < 2)
        return erase_lines_indexes;
 
    if (line_type == HLINE || line_type == VLINE) {
        // 断言查看所有线是否都是指定线类型
        Cm_Assert(lines.Filter([line_type](const cm::Line& line) { return line.Type() == line_type; }).size() == lines.size(), Sprintf("The line type in the line list must all be \"%s\"!!!", line_type == HLINE ? "cm::HLINE" : "cm::VLINE"));
 
        // 新的线列表
        Lines new_lines;
 
        // 当前线计算距离的距离类型
        LineDistanceType line_dis_type = line_type == HLINE ? LDIS_HLINE_H : LDIS_VLINE_V;
 
        // 遍历所有线
        for (size_t i = 0; i < lines_len; ++i) {
            double line1_len = lines[i].Length(true);
 
            // 遍历第 i 根线之后的线
            for (size_t j = i + 1; j < lines_len; ++j)
                // 如果两线类型相同，两线距离很近，两线重叠部分长度占最短线长（粗糙线长）的比率 >= 最小重叠比率，则删除重复线
                if (lines[i].IsNear(lines[j], threshold, near_method) && lines[i].DistanceTo(lines[j], line_dis_type) <= -min_overlap_ratio * std::min(line1_len, lines[j].Length(true)))
                    erase_lines_indexes.emplace(func(lines[i], lines[j]) ? i : j);  // func 函数返回 true，删除第一根横线，反之删除第二根横线
        }
    } else if (line_type == ULINE) {
        // 横线列表和竖线列表
        Lines hlines, vlines;
 
        // 横竖线原始索引
        std::vector<size_t> hlines_index, vlines_index;
 
        // 分类横竖线
        for (size_t i = 0; i < lines_len; ++i) {
            auto& line = lines[i];
            if (line.Type() == HLINE) {
                hlines.emplace_back(line);
                hlines_index.emplace_back(i);
            } else {
                vlines.emplace_back(line);
                vlines_index.emplace_back(i);
            }
        }
 
        // 横线列表和竖线列表分别获取重复线
        std::unordered_set<size_t> erase_hlines_indexes = std::move(hlines.GetDuplicateLines(HLINE, threshold, min_overlap_ratio, near_method, func));
        std::unordered_set<size_t> erase_vlines_indexes = std::move(vlines.GetDuplicateLines(VLINE, threshold, min_overlap_ratio, near_method, func));
 
        // 获取重复横线索引
        for (auto erase_hline_index : erase_hlines_indexes)
            erase_lines_indexes.emplace(hlines_index[erase_hline_index]);
 
        // 获取重复竖线索引
        for (auto erase_vline_index : erase_vlines_indexes)
            erase_lines_indexes.emplace(vlines_index[erase_vline_index]);
    } else
        throw Exception("The type(LineType) of param \"line_type\" is incorrect!");
 
    return erase_lines_indexes;
}
 
template <typename FUNC>
inline std::unordered_set<size_t> Lines::GetAdjacentDuplicateLines(double threshold, double min_overlap_ratio, Statistic near_method, const FUNC& func) const {
    auto& lines = *this;  // 自身作为线列表
 
    // 获取线列表的长度
    const int lines_len = lines.size();
 
    // 移除的线的索引
    std::unordered_set<size_t> erase_lines_indexes;
 
    // 如果线的数量小于2，则直接返回
    if (lines_len < 2)
        return erase_lines_indexes;
 
    // 断言查看所有线是否都是同一类型
    Cm_Assert(lines.Filter([lines](const Line& line) { return line.Type() == lines[0].Type(); }).size() == lines.size(), "All lines must be of the same type!!!");
 
    // 当前线计算距离的距离类型
    LineDistanceType line_dis_type = lines[0].Type() == HLINE ? LDIS_HLINE_H : LDIS_VLINE_V;
 
    // 遍历所有相邻线
    for (size_t i = 1; i < lines_len; ++i)
        // 如果两线类型相同，两线距离很近，两线重叠部分长度占最短线长（粗糙线长）的比率 >= 最小重叠比率，则判断为重复线
        if (lines[i - 1].IsNear(lines[i], threshold, near_method) && lines[i - 1].DistanceTo(lines[i], line_dis_type) <= -min_overlap_ratio * std::min(lines[i - 1].Length(true), lines[i].Length(true)))
            erase_lines_indexes.emplace(func(lines[i - 1], lines[i]) ? i - 1 : i);  // func 函数返回 true，选择第一根横线，反之选择第二根横线
 
    return erase_lines_indexes;
}
 
template <typename FUNC>
inline Lines& Lines::RmDuplicateLines(LineType line_type, double threshold, double min_overlap_ratio, Statistic near_method, const FUNC& func) {
    // 重复的线的索引
    std::unordered_set<size_t> erase_lines_indexes = std::move(this->GetDuplicateLines(line_type, threshold, min_overlap_ratio, near_method, func));
 
    // 删除重复线
    return this->RemoveLines(erase_lines_indexes);
}
 
template <typename FUNC>
inline Lines& Lines::RmAdjacentDuplicateLines(double threshold, double min_overlap_ratio, Statistic near_method, const FUNC& func) {
    // 重复的线的索引
    std::unordered_set<size_t> erase_lines_indexes = std::move(this->GetAdjacentDuplicateLines(threshold, min_overlap_ratio, near_method, func));
 
    // 删除重复线
    return this->RemoveLines(erase_lines_indexes);
}
 
}  // namespace cm
 
#endif