Sutherland-Hodgman算法裁剪多边形 求矩形和多边形相交

 bool on_segment(const silly_point& p, const silly_point& q1, const silly_point& q2)
{
     return std::min(q1.lgtd, q2.lgtd) <= p.lgtd && p.lgtd <= std::max(q1.lgtd, q2.lgtd) && std::min(q1.lttd, q2.lttd) <= p.lttd && p.lttd <= std::max(q1.lttd, q2.lttd);
 }
 silly_point line_intersection_wa(const silly_point& p1, const silly_point& p2, const silly_point& q1, const silly_point& q2)
{
     // 利用直线方程求解交点
     double a1 = p2.lttd - p1.lttd;
     double b1 = p1.lgtd - p2.lgtd;
     double c1 = a1 * p1.lgtd + b1 * p1.lttd;
     double a2 = q2.lttd - q1.lttd;
     double b2 = q1.lgtd - q2.lgtd;
     double c2 = a2 * q1.lgtd + b2 * q1.lttd;
     double determinant = a1 * b2 - a2 * b1;
     if (fabs(determinant) < 1e-6)
     {
         return silly_point();  // 没有交点或线段重叠
     }
     double x = (b2 * c1 - b1 * c2) / determinant;
     double y = (a1 * c2 - a2 * c1) / determinant;
     if (on_segment(silly_point(x, y), p1, p2) && on_segment(silly_point(x, y), q1, q2))
     {
         return silly_point(x, y);
     }
     return silly_point();
 }
 
// 计算两点的交点
silly_point line_intersection(const silly_point& p1, const silly_point& p2, const silly_point& q1, const silly_point& q2)
{
    // 点斜式方程 y = mx + b 转换为一般形式 Ax + By + C = 0
    double A1 = p2.lttd - p1.lttd;
    double B1 = p1.lgtd - p2.lgtd;
    double C1 = A1 * p1.lgtd + B1 * p1.lttd;

    double A2 = q2.lttd - q1.lttd;
    double B2 = q1.lgtd - q2.lgtd;
    double C2 = A2 * q1.lgtd + B2 * q1.lttd;

    double det = A1 * B2 - A2 * B1;
    if (std::fabs(det) < 1e-6)  // 绝对值小于1e-6认为平行或重合
    {
        return silly_point();
    }
    else
    {
        double x = (B2 * C1 - B1 * C2) / det;
        double y = (A1 * C2 - A2 * C1) / det;
        return silly_point(x, y);
    }
}

// 定义一个函数来判断点是否在裁剪边界内
bool is_inside(const silly_point& p, const silly_point& clip_start, const silly_point& clip_end)
{
    // 修改方向，确保裁剪边界的判断是正确的
    double dx = clip_end.lgtd - clip_start.lgtd;
    double dy = clip_end.lttd - clip_start.lttd;
    double t = dy * (p.lgtd - clip_start.lgtd) - dx * (p.lttd - clip_start.lttd);
    // t>0,点 p 在向量 (clip_end - clip_start) 的左侧
    // t<0,点 p 在向量 (clip_end - clip_start) 的右侧
    return t >= 0;  // 顺时针>=0
}


// Sutherland-Hodgman 算法裁剪多边形
std::vector<silly_point> sutherland_hodgman_clip(const std::vector<silly_point>& subject_polygon, const std::vector<silly_point>& clip_polygon)
{
    std::vector<silly_point> output_list = subject_polygon;

    for (size_t i = 0; i < clip_polygon.size(); ++i)
    {
        std::vector<silly_point> input_list = output_list;
        output_list.clear();

        const silly_point& clip_start = clip_polygon[i];
        const silly_point& clip_end = clip_polygon[(i + 1) % clip_polygon.size()];  // 取下一个点，如果到了最后一个点，则回到第一个点[0]

        for (size_t j = 0; j < input_list.size(); ++j)
        {
            const silly_point& subject_start = input_list[j];
            const silly_point& subject_end = input_list[(j + 1) % input_list.size()];

            // 判断一个点是否在裁剪边界的左侧
            if (is_inside(subject_end, clip_start, clip_end))
            {
                if (!is_inside(subject_start, clip_start, clip_end))
                {
                    silly_point temp_point = line_intersection(subject_start, subject_end, clip_start, clip_end);
                    output_list.push_back(temp_point);
                }
                output_list.push_back(subject_end);
            }
            else if (is_inside(subject_start, clip_start, clip_end))
            {
                silly_point temp_point = line_intersection(subject_start, subject_end, clip_start, clip_end);
                output_list.push_back(temp_point);
            }
        }
    }

    return output_list;
}

bool intersect_polygon_rectangle(const silly_poly& poly, const silly_poly& rect, silly_poly& intersection)
{
    // 获取四边形的边界
    std::vector<silly_point> rect_points = rect.outer_ring.points;
    size_t rect_size = rect_points.size();

    // 验证四边形是否有效
    if (rect_size < 4 || rect_size > 5)
    {
        std::cout << "The rect must have exactly 4 or 5 points (with the first and last being the same)." << std::endl;
        return false;
    }
    // 如果四边形由五个点组成，确保首尾两点重合
    if (rect_size == 5 && rect_points.front() != rect_points.back())
    {
        std::cout << "The first and last points of the rect must be the same." << std::endl;
        return false;
    }

    // Sutherland-Hodgman 算法裁剪多边形
    std::vector<silly_point> clipped_polygon = sutherland_hodgman_clip(poly.outer_ring.points, rect_points);
    if (clipped_polygon.size() < 3)
    {
        return false;
    }
    clipped_polygon.push_back(clipped_polygon.front());  // 闭合环
                                                         // 创建结果的多边形
    intersection.outer_ring.points = std::move(clipped_polygon);
    intersection.outer_ring.is_outer = 1;

    return true;
}

缺点:当处理凹多边形时,即当得到两个面的时候 两个面中间会有一条线