计算多段线的偏置，用C++实现

以下是用C实现计算多段线偏置的示例代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>

#define MAX_VERTICES 1000 // 多边形顶点数的最大值

typedef struct {
    double x, y;
} Point; // 二维点结构体

typedef struct {
    int num_vertices;
    Point vertices[MAX_VERTICES];
} Polygon; // 多边形结构体

typedef struct {
    int num_points;
    Point points[MAX_VERTICES * 2];
} OffsetPolygon; // 偏置多边形结构体

// 计算两点之间的距离
double distance(Point p1, Point p2) {
    return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
}

// 计算两点之间的斜率
double slope(Point p1, Point p2) {
    return (p2.y - p1.y) / (p2.x - p1.x);
}

// 计算两点之间的角度
double angle(Point p1, Point p2) {
    return atan2(p2.y - p1.y, p2.x - p1.x);
}

// 判断两条线段是否相交
int is_intersect(Point p1, Point p2, Point p3, Point p4) {
    double d1 = (p4.x - p3.x) * (p1.y - p3.y) - (p4.y - p3.y) * (p1.x - p3.x);
    double d2 = (p4.x - p3.x) * (p2.y - p3.y) - (p4.y - p3.y) * (p2.x - p3.x);
    double d3 = (p2.x - p1.x) * (p3.y - p1.y) - (p2.y - p1.y) * (p3.x - p1.x);
    double d4 = (p2.x - p1.x) * (p4.y - p1.y) - (p2.y - p1.y) * (p4.x - p1.x);
    if (d1 * d2 < 0 && d3 * d4 < 0) {
        return 1;
    } else {
        return 0;
    }
}

// 计算线段的偏置
void offset_segment(Point p1, Point p2, double distance, Point *offset1, Point *offset2) {
    double angle1 = angle(p1, p2) + M_PI / 2;
    double angle2 = angle(p1, p2) - M_PI / 2;
    offset1->x = p1.x + distance * cos(angle1);
    offset1->y = p1.y + distance * sin(angle1);
    offset2->x = p2.x + distance * cos(angle2);
    offset2->y = p2.y + distance * sin(angle2);
}

// 计算多边形的偏置
OffsetPolygon offset_polygon(Polygon polygon, double distance) {
    OffsetPolygon offset_polygon;
    offset_polygon.num_points = 0;
    if (polygon.num_vertices < 2) {
        return offset_polygon;
    }
    int i, j, k;
    Point p1, p2, p3, p4, offset1, offset2, intersection;
    for (i = 0; i < polygon.num_vertices; i++) {
        j = (i + 1) % polygon.num_vertices;
        k = (i + 2) % polygon.num_vertices;
        p1 = polygon.vertices[i];
        p2 = polygon.vertices[j];
        p3 = polygon.vertices[k];
        if (distance(p1, p2) < 1e-6 || distance(p2, p3) < 1e-6) {
            continue;
        }
        offset_segment(p1, p2, distance, &offset1, &offset2);
        offset_polygon.points[offset_polygon.num_points++] = offset1;
        int intersect = 0;
        for (int m = 0; m < polygon.num_vertices; m++) {
            if (m != i && m != j) {
                p4 = polygon.vertices[m];
                if (is_intersect(p1, p2, p3, p4)) {
                    intersect = 1;
                    intersection.x = (p1.x * slope(p1, p2) - p3.x * slope(p3, p4) + p4.y - p1.y) / (slope(p1, p2) - slope(p3, p4));
                    intersection.y = p1.y + slope(p1, p2) * (intersection.x - p1.x);
                    if (slope(p1, p2) > 1e6 || slope(p1, p2) < -1e6) {
                        intersection.x = p1.x;
                        intersection.y = slope(p3, p4) * (intersection.x - p3.x) + p3.y;
                    }
                    if (slope(p3, p4) > 1e6 || slope(p3, p4) < -1e6) {
                        intersection.x = p3.x;
                        intersection.y = slope(p1, p2) * (intersection.x - p1.x) + p1.y;
                    }
                    if (distance(p1, intersection) > 1e-6 && distance(p2, intersection) > 1e-6) {
                        offset_polygon.points[offset_polygon.num_points++] = intersection;
                    }
                    break;
                }
            }
        }
        if (!intersect) {
            offset_polygon.points[offset_polygon.num_points++] = offset2;
        }
    }
    return offset_polygon;
}

// 输出多边形的顶点
void print_polygon(Polygon polygon) {
    printf("Polygon:\n");
    for (int i = 0; i < polygon.num_vertices; i++) {
        printf("(%lf, %lf)\n", polygon.vertices[i].x, polygon.vertices[i].y);
    }
}

// 输出偏置多边形的顶点
void print_offset_polygon(OffsetPolygon offset_polygon) {
    printf("Offset Polygon:\n");
    for (int i = 0; i < offset_polygon.num_points; i++) {
        printf("(%lf, %lf)\n", offset_polygon.points[i].x, offset_polygon.points[i].y);
    }
}

int main() {
    Polygon polygon;
    polygon.num_vertices = 4;
    polygon.vertices[0] = (Point) {0, 0};
    polygon.vertices[1] = (Point) {0, 1};
    polygon.vertices[2] = (Point) {1, 1};
    polygon.vertices[3] = (Point) {1, 0};
    print_polygon(polygon);
    OffsetPolygon offset_polygon = offset_polygon(polygon, 0.2);
    print_offset_polygon(offset_polygon);
    return 0;
}

在这个示例代码中，我们定义了一个`Point`结构体来表示二维点，一个`Polygon`结构体来表示多边形，一个`OffsetPolygon`结构体来表示偏置多边形。我们用`distance`函数计算两点之间的距离，用`slope`函数计算两点之间的斜率，用`angle`函数计算两点之间的角度，用`is_intersect`函数判断两条线段是否相交。

主要的函数是`offset_polygon`函数，它接受一个`Polygon`和一个距离参数`distance`，返回一个`OffsetPolygon`表示多边形的偏置。它使用`offset_segment`函数计算每个线段的偏置。然后它对于每个线段，检查它是否和多边形的其它线段相交，如果相交，则计算交点，并添加到偏置多边形中。如果没有相交，则添加线段的另一个端点的偏置。

最后，我们通过`print_polygon`函数和`print_offset_polygon`函数来输出多边形和偏置多边形的顶点。在这个示例代码中，我们使用一个正方形作为多边形，并计算它的内偏置。