Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· openaiHugging Face Suzhen/CodeChat

如何用clipper库判断闭合图形是否自交

  1. User

    如何用clipper库判断闭合图形是否自交

  2. Assistant

    要使用clipper库判断闭合图形是否自交,可以按以下步骤进行:

    1. 使用clipper库的AddPath函数将待判断的闭合图形加入到clipper库中。

    2. 使用clipper库的Execute函数进行剪裁/求交/求并运算,得到图形的轮廓。

    3. 根据轮廓是否与原闭合图形完全重合,判断原闭合图形是否自交。如果轮廓与原闭合图形不重合,则原闭合图形自交。

    代码示例:

    import pyclipper
    
    path = [(0,0), (50,0), (50,50), (0,50)] # 待判断的图形
    pc = pyclipper.Pyclipper()
    
    # 将待判断的图形加入clipper库
    pc.AddPath(path, pyclipper.PT_SUBJECT, True)
    
    # 进行求交运算
    solution = pc.Execute2(pyclipper.CT_INTERSECTION)
    
    # 判断结果是否为闭合图形
    if len(solution) > 0 and len(solution[0]) > 2 and solution[0][0] == solution[0][-1]:
        print('图形自交')
    else:
        print('图形不自交')
    

    在上面的代码示例中,我们将待判断的图形加入了clipper库中,并进行了求交运算,将结果保存在solution中。然后判断solution是否为闭合图形,如果是则表示原闭合图形不自交,否则表示原闭合图形自交。

  3. User

    使用c++编写

  4. Assistant

    使用C++编写clipper库判断闭合图形是否自交的代码示例如下:

    #include "clipper.hpp"
    #include <iostream>
    
    using namespace ClipperLib;
    
    int main() {
        Paths paths; // 存储待判断的闭合图形
        Path p = {{0, 0}, {50, 0}, {50, 50}, {0, 50}}; // 待判断的图形
        paths.push_back(p);
    
        Clipper clipper;
        clipper.AddPaths(paths, ptSubject, true); // 将闭合图形添加到clipper库
    
        Paths solution; // 存储求解得到的轮廓
        clipper.Execute(ctIntersection, solution, pftNonZero, pftNonZero); // 求交运算
    
        bool isSelfIntersection = false; // 是否自交的标志
        for (Path poly : solution) {
            if (poly.size() > 2 && poly.front() == poly.back()) {
                isSelfIntersection = true; // 发现闭合轮廓,表示原图形不自交
                break;
            }
        }
    
        if (isSelfIntersection) {
            std::cout << "图形自交" << std::endl;
        } else {
            std::cout << "图形不自交" << std::endl;
        }
    
        return 0;
    }
    

    这个示例代码中,我们创建了一个Path,将待判断的闭合图形存储在Paths结构中,然后将Paths添加到Clipper实例中,对其进行求交运算,结果存储在结果Paths中。遍历所有结果Paths,查找包含第一个点和最后一个点的Path,如果找到则表示原始闭合图形不自交。

  5. User

    c++ 如何利用clipper2判断是否自交

  6. Assistant

    使用Clipper2来判断闭合图形是否自交,可以参考以下示例代码:

    #include "clipper.hpp"
    #include <iostream>
    
    using namespace ClipperLib;
    
    int main() {
        PolyTree solution; // 存储求解得到的轮廓
        Paths paths; // 存储待判断的闭合图形
        Path p = {{0, 0}, {50, 0}, {50, 50}, {0, 50}}; // 待判断的图形
        paths.push_back(p);
    
        Clipper c;
        c.AddPaths(paths, ptSubject, true); // 将闭合图形添加到clipper库
    
        c.Execute(ctUnion, solution, pftNonZero, pftNonZero); // 求解得到轮廓
    
        bool isSelfIntersection = false; // 是否自交的标志
        for (PolyNode* node : solution.Childs) {
            if (node->IsHole() || node->Contour.size() < 3) continue;
            for (int i = 0; i < node->Contour.size(); i++) {
                IntPoint& p1 = node->Contour[i];
                for (int j = i + 1; j < node->Contour.size(); j++) {
                    IntPoint& p2 = node->Contour[j];
                    if (p1 == p2) continue;
                    for (int k = 0; k < node->Contour.size(); k++) {
                        IntPoint& p3 = node->Contour[k];
                        if (k + 1 < node->Contour.size())
                            if (p1 == node->Contour[k + 1]) continue;
                        for (int l = 0; l < node->Contour.size(); l++) {
                            if (l == i || l == j || l == k) continue;
                            IntPoint& p4 = node->Contour[l];
                            if (l + 1 < node->Contour.size())
                                if (p2 == node->Contour[l + 1]) continue;
                            if (Orientation({p1, p2, p3}) * Orientation({p1, p2, p4}) == -1 &&
                                Orientation({p3, p4, p1}) * Orientation({p3, p4, p2}) == -1) {
                                    isSelfIntersection = true; // 发现自交点
                                    break;
                            }
                        }
                    }
                    if (isSelfIntersection) break;
                }
                if (isSelfIntersection) break;
            }
            if (isSelfIntersection) break;
        }
    
        if (isSelfIntersection) {
            std::cout << "图形自交" << std::endl;
        } else {
            std::cout << "图形不自交" << std::endl;
        }
    
        return 0;
    }
    

    在Clipper2中,执行ctUnion求解得到PolyTree。为了验证路径是否自交,我们遍历PolyNode,检查其是否具有自交边界。如果发现任何自交边界,则可以标记路径具有自交。虽然此代码可以判断自交,但此代码并不是特别高效。

  7. User

    如何判断一个闭合图形是否自交 ,c++编写

  8. Assistant

    要使用C++来判断一个闭合图形是否自交,可以使用Clipper库来完成该任务。Clipper库是一个CC0许可的开源库,提供了用于进行点集操作的一系列函数,包括剪切、合并、修剪和聚焦等。Clipper库提供的函数用于计算点集的轮廓,并可以让我们查看轮廓是否自交。

    以下是一个使用Clipper库判断一个闭合图形是否自交的示例C++代码:

    #include "clipper.hpp"
    
    void isPolygonSelfIntersected(const ClipperLib::Path &poly) {
        ClipperLib::Clipper clipper;
        ClipperLib::PolyTree solution;
        
        clipper.AddPath(poly, ClipperLib::ptSubject, true);
        clipper.Execute(ClipperLib::ctUnion, solution);  // 求解得到结果
    
        for (int i = 0; i < solution.ChildCount(); i++) {
            const ClipperLib::PolyNode* node = solution.Childs[i];
            if (typeof(node)== typeof(nullptr)) {
                continue;
            }
            if (node->Contour.empty()) {
                continue;
            }
            if (node->IsHole()) {
                continue;
            }
            // 判断该节点表示的图形是否自交
            if (typeof(node->Childs) != typeof(nullptr)) {
                for (int j = 0; j < node->Childs.size(); j++) {
                    const ClipperLib::PolyNode* childNode = node->Childs[j];
                    if (childNode->Contour.empty()) {
                        continue;
                    }
                    if (childNode->IsHole()) {
                        continue;
                    }
                    if (typeof(childNode->Childs) != typeof(nullptr)) { // 如果还有子节点,递归处理
                        isPolygonSelfIntersected(childNode->Contour);
                    }
                }
            } else {
                if (typeof(node->Contour) == typeof(nullptr)) { continue; }
                for (int j = 0; j < node->Contour.size() - 1; j++) {
                    int rIdx = (j + 1) % node->Contour.size();
                // 判断线段是否交叉
                    for (int k = j + 1; k < node->Contour.size() - 1; k++) {
                        int rIdx2 = (k + 1) % node->Contour.size();
                        const ClipperLib::IntPoint a = node->Contour[j],
                                b = node->Contour[rIdx],
                                c = node->Contour[k],
                                d = node->Contour[rIdx2];
                        // 如果有交,表示该多边形自交
                        if (ClipperLib::IntersectLineSegments (a, b, c, d)) {
                            std::cout << "该多边形" << poly << "自交" << std::endl;
                            return;
                        }
                    }
                }
            }
        }
    
        std::cout << "该多边形" << poly << "不自交" << std::endl;
    }
    

    使用Clipper库判断一个闭合图形是否自交的步骤如下:

    1. 将闭合图形添加到clipper库中;

    2. 使用clipper的Execute函数执行求解操作;

    3. 遍历返回的PolyTree,判断其中每个子对象的轮廓是否与其他轮廓相交或相切。

    在示例中我们通过判断两条线段是否相交来判断这个图形是否自交,如果有任何一对相交的线段,则该图形自交。

    这个函数用于判断一个闭合图形是否自交,如果是,则返回true;否则返回false。

  9. User

    c++ 判断闭合图形是否自交

  10. Assistant

    以下是一个使用C++判断一个闭合图形是否自交的示例代码:

    #include <vector>
    #include <set>
    #include <cmath>
    
    struct Point {
        double x;
        double y;
    };
    
    typedef std::vector<Point> Polygon;
    
    bool intersect(Point A, Point B, Point C, Point D) {
        auto CA = Point{C.x - A.x, C.y - A.y};
        auto CD = Point{D.x - C.x, D.y - C.y};
        auto AB = Point{B.x - A.x, B.y - A.y};
        auto AD = Point{D.x - A.x, D.y - A.y};
    
        // t1: the intersection with AB
        auto t1 = (CA.x * AB.y - CA.y * AB.x) / (CD.x * AB.y - CD.y * AB.x);
    
        // t2: the intersection with CD
        auto t2 = (CA.x + t1 * CD.x) / AB.x;
    
        if (0.0 <= t1 && t1 <= 1.0 && 0.0 <= t2 && t2 <= 1.0) {
            return true;
        }
        return false;
    }
    
    bool isSelfIntersect(const Polygon &polygon) {
        for (std::size_t i = 0; i < polygon.size(); i++) {
            for (std::size_t j = i + 1; j < polygon.size(); j++) {
                if (i == 0 && j == polygon.size() - 1) {
                    continue;
                }
                if (j == i + 1) {
                    continue;
                }
    
                auto A = polygon[i];
                auto B = polygon[(i + 1) % polygon.size()];
                auto C = polygon[j];
                auto D = polygon[(j + 1) % polygon.size()];
    
                if (intersect(A, B, C, D)) {
                    return true;
                }
            }
        }
        return false;
    }
    
    int main() {
        Polygon polygon = {{0, 0}, {0, 1}, {1, 1}, {1, 0}}; // 待判断的多边形
        bool is_self_intersected = isSelfIntersect(polygon);
        if (is_self_intersected) {
            std::cout << "该多边形自交" << std::endl;
        } else {
            std::cout << "该多边形不自交" << std::endl;
        }
    
        return 0;
    }
    

    示例中定义了Point结构体和Polygon类型,分别代表一个点和一个多边形。isSelfIntersect函数接收一个Polygon类型参数,判断该多边形是否自交,返回值为bool类型,true表示自交,false表示不自交。函数处理过程中,遍历每条线段,对于任意的两条线段,如果它们相交,则表明该多边形自交。如果没有任何两条线段相交,则表明多边形不自交。

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.