Split a polygon by a polygon

[petrasvestartas]

Hi,

Is there a way to split a polygon into a sub-parts?

This method can do boolean intersection:
Clipper2Lib::PathsD solution = Clipper2Lib::Intersect(subject, boundary, Clipper2Lib::FillRule::NonZero, 8);

But what I need is this:

[loadship]

I have a similar requirement to you, have you solved it?

[philstopford]

I think you should get the desired result if you declare the bottom left polygon in your example to be an open path - that ought to give you just the section of the path within the top right polygon following an intersection (AND) query.

If you need both parts, I would suggest exploring the use of the Z value (needs Clipper built with the preprocessor directive). With this, you can use the Z coordinate to 'tag' the points on each polygon with the polygon index (allowing you to track which points came from which polygon in the output. You can set a callback to assign a different index (usually -1) to the intersection points. You can then use the Z value to clean up the solution by removing points that came from the polygon other than the one you are interested in.

[loadship]

It helps me a lot, thank you
use this api, it works

bool Execute(ClipType clip_type, FillRule fill_rule,
Paths64& closed_paths, Paths64& open_paths)
{
closed_paths.clear();
open_paths.clear();
if (ExecuteInternal(clip_type, fill_rule, false))
BuildPaths64(closed_paths, &open_paths);
CleanUp();
return succeeded_;
}

[loadship]

This is a method I came up with recently. It can clip closed paths and maintain the original order of the paths.

Clipper2Lib::Paths64 clipContourPath(const Clipper2Lib::Rect64& clipRect,
const Clipper2Lib::Paths64& contourPath)
{
Clipper2Lib::Paths64 result;
if (contourPath.empty())
return result;

for (auto path : contourPath)// 每条路径单独裁剪
{
    int count = path.size();
    if (count < 2)
        continue;// 至少两点才有线段

    if (path.front() != path.back())
    {
        path.push_back(path.front());// 插入起始点，形成闭环
        count++;
    }


    Clipper2Lib::Path64 currentPath;
    for (int i = 0; i < count - 1; i++)
    {
        const auto& p1 = path[i];
        const auto& p2 = path[i + 1];

        bool inside1 = clipRect.Contains(p1);
        bool inside2 = clipRect.Contains(p2);

        if (inside1 && !inside2)
        {
            // p1 在内，p2 在外
            if (currentPath.empty())
                currentPath.push_back(p1);
            auto inters = segmentRectIntersections(clipRect, p1, p2);
            if (!inters.empty())
            {
                currentPath.push_back(inters.front());
                result.push_back(currentPath);
                currentPath.clear();
            }
        }
        else if (!inside1 && inside2)
        {
            // p1 在外，p2 在内
            auto inters = segmentRectIntersections(clipRect, p1, p2);
            if (!inters.empty())
                currentPath.push_back(inters.front());
            currentPath.push_back(p2);
        }
        else if (inside1 && inside2)
        {
            // 全在内
            if (currentPath.empty())
                currentPath.push_back(p1);
            currentPath.push_back(p2);
        }
        else
        {
            // 都在外，但可能穿过矩形
            auto inters = segmentRectIntersections(clipRect, p1, p2);
            if (inters.size() == 2)
            {
                currentPath.push_back(inters[0]);
                currentPath.push_back(inters[1]);
                result.push_back(currentPath);
                currentPath.clear();
            }
        }
    }
    if (!currentPath.empty())
    {
        result.push_back(currentPath);
        currentPath.clear();
    }
}
return result;

}

std::vectorClipper2Lib::Point64 segmentRectIntersections(const Clipper2Lib::Rect64& rect,
const Clipper2Lib::Point64& p1,
const Clipper2Lib::Point64& p2)
{
std::vectorClipper2Lib::Point64 intersections;

auto intersectLine = [&](int64_t x1, int64_t y1, int64_t x2, int64_t y2) -> std::optional<Clipper2Lib::Point64>
{
    double dx = p2.x - p1.x;
    double dy = p2.y - p1.y;
    double dxL = x2 - x1;
    double dyL = y2 - y1;

    double denom = dx * dyL - dy * dxL;
    if (std::fabs(denom) < 1e-9)
        return std::nullopt; // 平行

    double ua = ((x1 - p1.x) * dyL - (y1 - p1.y) * dxL) / denom;
    double ub = ((x1 - p1.x) * dy  - (y1 - p1.y) * dx)  / denom;

    if (ua >= 0.0 && ua <= 1.0 && ub >= 0.0 && ub <= 1.0)
    {
        return Clipper2Lib::Point64(
            static_cast<int64_t>(std::llround(p1.x + ua * dx)),
            static_cast<int64_t>(std::llround(p1.y + ua * dy))
            );
    }
    return std::nullopt;
};

// 矩形的四条边
std::array<std::pair<Clipper2Lib::Point64, Clipper2Lib::Point64>, 4> edges = {
    std::make_pair(Clipper2Lib::Point64(rect.left, rect.top),    Clipper2Lib::Point64(rect.right, rect.top)),    // 上
    std::make_pair(Clipper2Lib::Point64(rect.right, rect.top),   Clipper2Lib::Point64(rect.right, rect.bottom)), // 右
    std::make_pair(Clipper2Lib::Point64(rect.right, rect.bottom),Clipper2Lib::Point64(rect.left, rect.bottom)),  // 下
    std::make_pair(Clipper2Lib::Point64(rect.left, rect.bottom), Clipper2Lib::Point64(rect.left, rect.top))      // 左
};

for (auto& e : edges)
{
    auto pt = intersectLine(e.first.x, e.first.y, e.second.x, e.second.y);
    if (pt)
        intersections.push_back(*pt);
}

return intersections;

}