用c++写一个距离变换的代码

### 回答1：
C 语言代码实现距离变换如下：

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

double distance(double x1, double y1, double x2, double y2) {
  return sqrt(pow(x2 - x1, 2) + pow(y2 - y1, 2));
}

int main() {
  double x1, y1, x2, y2;
  printf("请输入第一个点的坐标：\n");
  scanf("%lf%lf", &x1, &y1);
  printf("请输入第二个点的坐标：\n");
  scanf("%lf%lf", &x2, &y2);
  printf("两点之间的距离为：%lf\n", distance(x1, y1, x2, y2));
  return 0;
}

这段代码使用了勾股定理来计算两点之间的距离，用户可以输入两个点的坐标，最后输出两点间的距离。

### 回答2：
距离变换是一种图像处理的方法，在计算机视觉和图像分析领域有广泛的应用。距离变换将图像中的每个像素点与其最近的对象边界的距离作为该像素点的数值，并生成一个新的图像。

下面是一个用C语言编写的简单距离变换代码示例：

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

#define INFINITY 9999

// 定义图像尺寸
#define ROWS 5
#define COLS 5

// 计算距离变换
void distanceTransform(int image[ROWS][COLS], int output[ROWS][COLS]) {
    int i, j;

    // 创建一个与原图像相同大小的临时图像
    int temp[ROWS][COLS];

    // 初始化临时图像
    for(i=0; i<ROWS; i++) {
        for(j=0; j<COLS; j++) {
            if (image[i][j] == 0)
                temp[i][j] = INFINITY;  // 背景像素设为无限远
            else
                temp[i][j] = 0;  // 前景像素设为零
        }
    }

    // 前向扫描，从左上角到右下角
    for(i=0; i<ROWS; i++) {
        for(j=0; j<COLS; j++) {
            if (i > 0)
                temp[i][j] = min(temp[i][j], temp[i-1][j] + 1);  // 上方像素
            if (j > 0)
                temp[i][j] = min(temp[i][j], temp[i][j-1] + 1);  // 左方像素
        }
    }

    // 后向扫描，从右下角到左上角
    for(i=ROWS-1; i>=0; i--) {
        for(j=COLS-1; j>=0; j--) {
            if (i < ROWS - 1)
                temp[i][j] = min(temp[i][j], temp[i+1][j] + 1);  // 下方像素
            if (j < COLS - 1)
                temp[i][j] = min(temp[i][j], temp[i][j+1] + 1);  // 右方像素
        }
    }

    // 将临时图像转换为最终距离变换后的图像
    for(i=0; i<ROWS; i++) {
        for(j=0; j<COLS; j++) {
            output[i][j] = temp[i][j];
        }
    }
}

// 求两个数的最小值
int min(int a, int b) {
    return a < b ? a : b;
}

// 主程序入口
int main() {
    int image[ROWS][COLS] = {
        {0, 0, 1, 1, 0},
        {0, 1, 1, 1, 0},
        {1, 1, 1, 1, 1},
        {0, 0, 0, 1, 0},
        {0, 0, 0, 0, 0}
    };

    int output[ROWS][COLS];

    // 进行距离变换
    distanceTransform(image, output);

    // 打印变换后的图像
    printf("距离变换后的图像：\n");
    for(int i=0; i<ROWS; i++) {
        for(int j=0; j<COLS; j++) {
            printf("%d ", output[i][j]);
        }
        printf("\n");
    }

    return 0;
}

这个代码示例中，定义了一个5x5大小的图像`image`作为输入图像。通过调用`distanceTransform`函数，将输入图像进行距离变换，并将结果保存在`output`中。最后，通过打印`output`中的元素来显示变换后的图像。

需要注意的是，这里使用了一个辅助函数`min`来比较两个数字的最小值。另外，图像中的像素值为0表示背景，非零表示前景，初始化时背景像素被设为无限远，前景像素被设为零。前向扫描和后向扫描分别计算了图像中每个像素点到其最近对象边界的距离，并最终生成了距离变换后的图像。

### 回答3：
距离变换是指通过计算图像中每个像素点到离它最近的边缘像素点的距离来得到一幅新的图像。

下面是一个用C语言写的进行距离变换的代码：

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
 
#define INFINITY 99999

int min(int a, int b, int c) {
    if(a <= b && a <= c)
        return a;
    else if(b <= a && b <= c)
        return b;
    else
        return c;
}

void distanceTransform(int** image, int width, int height) {
    int i, j;
    
    // 初始化距离数组
    int** distance = malloc(height * sizeof(int*));
    for(i = 0; i < height; i++) {
        distance[i] = malloc(width * sizeof(int));
        for(j = 0; j < width; j++) {
            // 如果像素点是边缘点，则距离为0，否则设为无穷大
            if(image[i][j] == 0)
                distance[i][j] = 0;
            else
                distance[i][j] = INFINITY;
        }
    }
    
    // 第一次遍历计算距离
    for(i = 1; i < height-1; i++) {
        for(j = 1; j < width-1; j++) {
            distance[i][j] = min(distance[i-1][j-1] + 1, distance[i-1][j] + 1, distance[i][j-1] + 1);
        }
    }
    
    // 第二次遍历计算距离
    for(i = height-2; i >= 1; i--) {
        for(j = width-2; j >= 1; j--) {
            distance[i][j] = min(distance[i][j], distance[i+1][j+1] + 1, distance[i+1][j] + 1);
            distance[i][j] = min(distance[i][j], distance[i][j+1] + 1, distance[i+1][j-1] + 1);
        }
    }
    
    // 打印距离变换结果
    printf("距离变换结果：\n");
    for(i = 0; i < height; i++) {
        for(j = 0; j < width; j++) {
            printf("%d ", distance[i][j]);
        }
        printf("\n");
    }
    
    // 释放内存
    for(i = 0; i < height; i++)
        free(distance[i]);
    free(distance);
}

int main() {
    int i, j;
    int width = 5;
    int height = 5;
    
    // 初始化图像
    int** image = malloc(height * sizeof(int*));
    for(i = 0; i < height; i++) {
        image[i] = malloc(width * sizeof(int));
        for(j = 0; j < width; j++) {
            image[i][j] = 0;
        }
    }
    image[2][2] = 1;
    
    // 进行距离变换
    distanceTransform(image, width, height);
    
    // 释放内存
    for(i = 0; i < height; i++)
        free(image[i]);
    free(image);
    
    return 0;
}

这段代码实现了基于模板的距离变换算法。首先初始化距离数组为无穷大，然后第一次遍历计算从左上到右下的距离，再进行第二次遍历计算从右下到左上的距离。最后打印距离变换结果。

在main函数中，首先初始化一个5x5大小的图像，其中中心位置为前景点，其余为背景点。然后调用distanceTransform函数进行距离变换。最后释放内存。

以上就是一个用C语言实现的距离变换的代码示例。