Function clean_noisy_paths

src/svgfill/src/arrange_polygons.cpp:2269–2579

}

void clean_noisy_paths(DebugWriter& debug_output, Arrangement_2& arr, SegmentLookup& segment_lookup, double& threshold) {
    using SK = CGAL::Simple_cartesian<double>;
    CGAL::Cartesian_converter<K, SK> C{};

    auto other = [](const Segment_2& e, const Point_2& v) {
        return (e.source() == v) ? e.target() : e.source();
    };

    std::set<Segment_2, Segment_2_less> edges;
    for (auto he = arr.edges_begin(); he != arr.edges_end(); ++he) {
        auto a = he->source()->point();
        auto b = he->target()->point();
        if (a < b) {
            edges.insert({a, b});
        } else {
            edges.insert({b, a});
        }
    }

    auto edge_badness = [&](const Segment_2& e) -> double {
        auto closest = segment_lookup.n_closest_input_segments(e, 2);
        if (closest.size() != 2) {
            throw std::runtime_error("Unable to locate two nearby edges");
        }

        auto get_dir = [&](const Segment_2& s) {
            auto a = C(s.source());
            auto b = C(s.target());
            SK::Vector_2 v = b - a;
            double l = std::sqrt(v.squared_length());
            if (l <= 1e-12) {
                return std::make_pair(SK::Vector_2(0, 0), 0.);
            }
            return std::make_pair(v / l, l);
        };

        auto [own_dir, own_length] = get_dir(e);

        auto angle = [&](const SK::Vector_2& ov) {
            double d = std::abs(own_dir * ov);
            if (d > 1.0) {
                d = 1.0;
            }
            return std::acos(d);
        };

        double best = std::numeric_limits<double>::infinity();
        for (auto& s : closest) {
            auto [dv, dl] = get_dir(s);
            best = std::min(best, angle(dv));
        }
        return (best + 0.01) / own_length;
    };

    std::map<Segment_2, double, Segment_2_less> badnesses;
    for (auto& e : edges) {
        badnesses[e] = edge_badness(e);
    }