输入两组（x,y,z）的点云数据，可以分别知道其轮廓是什么图形并保存相关点，以及求两者的交集面积的不依赖第三方库实现的C或C++代码有吗？

可以使用计算几何的方法来实现。首先，对于每组点云数据，可以使用凸包算法得到其轮廓图形，并保存相关点。然后，对于两组点云数据，可以使用求凸包的方法得到其凸包，并求出其交集。最后，可以使用面积公式计算交集面积。以下是示例代码：

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

#define MAX_POINTS 100

typedef struct {
    double x, y, z;
} Point;

typedef struct {
    Point points[MAX_POINTS];
    int count;
} PointCloud;

typedef struct {
    Point points[MAX_POINTS];
    int count;
} Polygon;

void add_point(PointCloud *cloud, double x, double y, double z) {
    if (cloud->count >= MAX_POINTS) {
        fprintf(stderr, "Error: too many points\n");
        exit(1);
    }
    cloud->points[cloud->count].x = x;
    cloud->points[cloud->count].y = y;
    cloud->points[cloud->count].z = z;
    cloud->count++;
}

void add_polygon_point(Polygon *polygon, double x, double y, double z) {
    if (polygon->count >= MAX_POINTS) {
        fprintf(stderr, "Error: too many points\n");
        exit(1);
    }
    polygon->points[polygon->count].x = x;
    polygon->points[polygon->count].y = y;
    polygon->points[polygon->count].z = z;
    polygon->count++;
}

double cross_product(Point a, Point b, Point c) {
    double x1 = b.x - a.x;
    double y1 = b.y - a.y;
    double z1 = b.z - a.z;
    double x2 = c.x - a.x;
    double y2 = c.y - a.y;
    double z2 = c.z - a.z;
    return x1 * y2 * z1 - x2 * y1 * z1 - x1 * y2 * z2 + x2 * y1 * z2 + x1 * z2 * y1 - x2 * z1 * y1 - x1 * z2 * y2 + x2 * z1 * y2 + y1 * z2 * x2 - y2 * z1 * x1 - y1 * z2 * x1 + y2 * z1 * x1;
}

double dot_product(Point a, Point b, Point c) {
    double x1 = b.x - a.x;
    double y1 = b.y - a.y;
    double z1 = b.z - a.z;
    double x2 = c.x - a.x;
    double y2 = c.y - a.y;
    double z2 = c.z - a.z;
    return x1 * x2 + y1 * y2 + z1 * z2;
}

double distance(Point a, Point b) {
    double dx = a.x - b.x;
    double dy = a.y - b.y;
    double dz = a.z - b.z;
    return sqrt(dx * dx + dy * dy + dz * dz);
}

double area(Polygon *polygon) {
    double sum = .;
    for (int i = ; i < polygon->count; i++) {
        Point a = polygon->points[i];
        Point b = polygon->points[(i + 1) % polygon->count];
        sum += a.x * b.y - a.y * b.x;
    }
    return fabs(sum) / 2.;
}

void convex_hull(PointCloud *cloud, Polygon *polygon) {
    int n = cloud->count;
    int k = ;
    Point hull[MAX_POINTS];
    for (int i = ; i < n; i++) {
        while (k >= 2 && cross_product(hull[k - 2], hull[k - 1], cloud->points[i]) <= ) {
            k--;
        }
        hull[k++] = cloud->points[i];
    }
    for (int i = n - 2, t = k + 1; i >= ; i--) {
        while (k >= t && cross_product(hull[k - 2], hull[k - 1], cloud->points[i]) <= ) {
            k--;
        }
        hull[k++] = cloud->points[i];
    }
    polygon->count = k - 1;
    for (int i = ; i < polygon->count; i++) {
        polygon->points[i] = hull[i];
    }
}

void intersection(Polygon *polygon1, Polygon *polygon2, Polygon *result) {
    result->count = ;
    for (int i = ; i < polygon1->count; i++) {
        Point a = polygon1->points[i];
        Point b = polygon1->points[(i + 1) % polygon1->count];
        for (int j = ; j < polygon2->count; j++) {
            Point c = polygon2->points[j];
            Point d = polygon2->points[(j + 1) % polygon2->count];
            double cp1 = cross_product(a, b, c);
            double cp2 = cross_product(a, b, d);
            double cp3 = cross_product(c, d, a);
            double cp4 = cross_product(c, d, b);
            if (cp1 * cp2 <  && cp3 * cp4 < ) {
                double t = cp1 / (cp1 - cp2);
                double x = a.x + t * (b.x - a.x);
                double y = a.y + t * (b.y - a.y);
                double z = a.z + t * (b.z - a.z);
                add_polygon_point(result, x, y, z);
            }
        }
    }
}

int main() {
    PointCloud cloud1 = {};
    add_point(&cloud1, , , );
    add_point(&cloud1, 1, , );
    add_point(&cloud1, 1, 1, );
    add_point(&cloud1, , 1, );
    Polygon polygon1 = {};
    convex_hull(&cloud1, &polygon1);
    printf("Polygon 1:\n");
    for (int i = ; i < polygon1.count; i++) {
        printf("(%lf, %lf, %lf)\n", polygon1.points[i].x, polygon1.points[i].y, polygon1.points[i].z);
    }
    PointCloud cloud2 = {};
    add_point(&cloud2, .5, .5, );
    add_point(&cloud2, 1.5, .5, );
    add_point(&cloud2, 1.5, 1.5, );
    add_point(&cloud2, .5, 1.5, );
    Polygon polygon2 = {};
    convex_hull(&cloud2, &polygon2);
    printf("Polygon 2:\n");
    for (int i = ; i < polygon2.count; i++) {
        printf("(%lf, %lf, %lf)\n", polygon2.points[i].x, polygon2.points[i].y, polygon2.points[i].z);
    }
    Polygon result = {};
    intersection(&polygon1, &polygon2, &result);
    printf("Intersection:\n");
    for (int i = ; i < result.count; i++) {
        printf("(%lf, %lf, %lf)\n", result.points[i].x, result.points[i].y, result.points[i].z);
    }
    printf("Area: %lf\n", area(&result));
    return ;
}