099. 编写代码实现简单的机器视觉算法

在C语言中实现一个简单的机器视觉算法可以帮助你理解图像处理和计算机视觉的基本概念。这里我将展示一个简单的边缘检测算法，使用Sobel算子来检测图像中的边缘。Sobel算子是一种常用的梯度计算方法，用于突出图像中亮度变化快的区域，通常用于边缘检测。

Sobel边缘检测算法简介

Sobel算子通过计算图像中每个像素的水平和垂直梯度来检测边缘。它使用两个3x3的卷积核分别计算水平和垂直方向的梯度。

水平方向的Sobel算子：Gx​=​−1−2−1​000​121​​

垂直方向的Sobel算子：Gy​=​−101​−202​−101​​

每个像素的梯度幅度可以通过以下公式计算：G=Gx2​+Gy2​​

通常，为了简化计算，可以使用：G=∣Gx​∣+∣Gy​∣

示例代码：简单的Sobel边缘检测

用C语言实现的简单Sobel边缘检测算法。为了简化实现，我们假设输入图像为灰度图像，并使用简单的二维数组来表示图像数据。

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

#define MAX_IMAGE_SIZE 512

// 图像结构
typedef struct {
    int width;
    int height;
    unsigned char data[MAX_IMAGE_SIZE][MAX_IMAGE_SIZE];
} Image;

// 读取PGM图像文件
int readPGM(const char* filename, Image* img) {
    FILE* file = fopen(filename, "rb");
    if (!file) {
        printf("Error opening file %s\n", filename);
        return -1;
    }

    char header[3];
    fscanf(file, "%s", header);
    if (strcmp(header, "P5") != 0) {
        printf("Invalid PGM file format\n");
        fclose(file);
        return -1;
    }

    fscanf(file, "%d %d", &img->width, &img->height);
    int maxVal;
    fscanf(file, "%d", &maxVal);
    if (maxVal != 255) {
        printf("Unsupported PGM file format\n");
        fclose(file);
        return -1;
    }

    for (int i = 0; i < img->height; i++) {
        for (int j = 0; j < img->width; j++) {
            img->data[i][j] = fgetc(file);
        }
    }

    fclose(file);
    return 0;
}

// 写入PGM图像文件
int writePGM(const char* filename, Image* img) {
    FILE* file = fopen(filename, "wb");
    if (!file) {
        printf("Error opening file %s\n", filename);
        return -1;
    }

    fprintf(file, "P5\n%d %d\n255\n", img->width, img->height);
    for (int i = 0; i < img->height; i++) {
        for (int j = 0; j < img->width; j++) {
            fputc(img->data[i][j], file);
        }
    }

    fclose(file);
    return 0;
}

// Sobel边缘检测
void sobelEdgeDetection(Image* input, Image* output) {
    int width = input->width;
    int height = input->height;

    // Sobel算子
    int Gx[3][3] = {{-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1}};
    int Gy[3][3] = {{-1, -2, -1}, {0, 0, 0}, {1, 2, 1}};

    for (int y = 1; y < height - 1; y++) {
        for (int x = 1; x < width - 1; x++) {
            int gx = 0, gy = 0;

            for (int i = -1; i <= 1; i++) {
                for (int j = -1; j <= 1; j++) {
                    unsigned char pixel = input->data[y + i][x + j];
                    gx += pixel * Gx[i + 1][j + 1];
                    gy += pixel * Gy[i + 1][j + 1];
                }
            }

            int gradient = abs(gx) + abs(gy);
            output->data[y][x] = (gradient > 255) ? 255 : gradient;
        }
    }
}

int main() {
    Image input, output;

    if (readPGM("input.pgm", &input) != 0) {
        printf("Failed to read input.pgm\n");
        return -1;
    }

    output.width = input.width;
    output.height = input.height;

    sobelEdgeDetection(&input, &output);

    if (writePGM("output.pgm", &output) != 0) {
        printf("Failed to write output.pgm\n");
        return -1;
    }

    printf("Edge detection completed. Output saved to output.pgm\n");

    return 0;
}

代码说明

图像结构：

• 定义了一个 Image 结构来存储图像的宽度、高度和像素数据。

读取PGM图像：

• 使用 readPGM 函数读取灰度图像文件（PGM格式）。

• PGM格式是一种简单的灰度图像格式，适合用于简单的图像处理任务。

写入PGM图像：

• 使用 writePGM 函数将处理后的图像保存为PGM文件。

Sobel边缘检测：

• 使用 sobelEdgeDetection 函数对输入图像进行边缘检测。

• 使用Sobel算子计算每个像素的水平和垂直梯度。

• 计算梯度幅度并将其值存储在输出图像中。

主函数：

• 读取输入图像。

• 调用边缘检测函数。

• 将结果保存为输出图像。

示例运行

假设你有一个输入图像 input.pgm，运行程序后，输出图像 output.pgm 将包含检测到的边缘。

扩展功能

1. 支持彩色图像：可以扩展算法以支持彩色图像，通过分别处理RGB通道来计算边缘。
2. 优化性能：使用多线程或并行计算来加速边缘检测过程。
3. 其他边缘检测算法：实现其他边缘检测算法，如Canny边缘检测。
4. 图像预处理：在边缘检测之前对图像进行预处理，如降噪或对比度增强。

C语言代码实现简单的机器视觉算法的几种方法

C语言实现边缘检测（Sobel算子）

边缘检测是机器视觉的基础算法之一。Sobel算子通过计算图像梯度来检测边缘。以下是实现步骤：

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

#define WIDTH 640
#define HEIGHT 480

void sobel_edge_detection(unsigned char* input, unsigned char* output) {
    int Gx[3][3] = {{-1,0,1}, {-2,0,2}, {-1,0,1}};
    int Gy[3][3] = {{-1,-2,-1}, {0,0,0}, {1,2,1}};
    
    for(int y=1; y<HEIGHT-1; y++) {
        for(int x=1; x<WIDTH-1; x++) {
            int sumX = 0, sumY = 0;
            
            for(int i=-1; i<=1; i++) {
                for(int j=-1; j<=1; j++) {
                    sumX += input[(y+i)*WIDTH + (x+j)] * Gx[i+1][j+1];
                    sumY += input[(y+i)*WIDTH + (x+j)] * Gy[i+1][j+1];
                }
            }
            
            output[y*WIDTH + x] = (unsigned char)fmin(255, sqrt(sumX*sumX + sumY*sumY));
        }
    }
}

C语言实现图像阈值处理

阈值处理是简单有效的图像分割方法：

void threshold_image(unsigned char* input, unsigned char* output, int threshold) {
    for(int i=0; i<WIDTH*HEIGHT; i++) {
        output[i] = (input[i] > threshold) ? 255 : 0;
    }
}

C语言实现模板匹配

模板匹配可用于对象检测：

int template_matching(unsigned char* image, unsigned char* template, int t_width, int t_height) {
    int min_diff = INT_MAX;
    int match_x = 0, match_y = 0;
    
    for(int y=0; y<=HEIGHT-t_height; y++) {
        for(int x=0; x<=WIDTH-t_width; x++) {
            int diff = 0;
            
            for(int ty=0; ty<t_height; ty++) {
                for(int tx=0; tx<t_width; tx++) {
                    int image_val = image[(y+ty)*WIDTH + (x+tx)];
                    int template_val = template[ty*t_width + tx];
                    diff += abs(image_val - template_val);
                }
            }
            
            if(diff < min_diff) {
                min_diff = diff;
                match_x = x;
                match_y = y;
            }
        }
    }
    
    return match_y * WIDTH + match_x;
}

C语言实现颜色检测

检测特定颜色范围的对象：

typedef struct {
    unsigned char r;
    unsigned char g;
    unsigned char b;
} RGBPixel;

void color_detection(RGBPixel* image, unsigned char* output, 
                    unsigned char r_min, unsigned char r_max,
                    unsigned char g_min, unsigned char g_max,
                    unsigned char b_min, unsigned char b_max) {
    
    for(int i=0; i<WIDTH*HEIGHT; i++) {
        output[i] = (image[i].r >= r_min && image[i].r <= r_max &&
                    image[i].g >= g_min && image[i].g <= g_max &&
                    image[i].b >= b_min && image[i].b <= b_max) ? 255 : 0;
    }
}

C语言实现连通区域分析

用于图像分割和对象计数：

typedef struct {
    int x;
    int y;
} Point;

void flood_fill(unsigned char* image, int x, int y, int label, int* labels) {
    Point stack[WIDTH*HEIGHT];
    int top = 0;
    stack[top].x = x;
    stack[top].y = y;
    
    while(top >= 0) {
        Point p = stack[top--];
        if(p.x < 0 || p.x >= WIDTH || p.y < 0 || p.y >= HEIGHT) continue;
        if(image[p.y*WIDTH + p.x] == 0 || labels[p.y*WIDTH + p.x] != 0) continue;
        
        labels[p.y*WIDTH + p.x] = label;
        
        stack[++top].x = p.x+1; stack[top].y = p.y;
        stack[++top].x = p.x-1; stack[top].y = p.y;
        stack[++top].x = p.x; stack[top].y = p.y+1;
        stack[++top].x = p.x; stack[top].y = p.y-1;
    }
}

void connected_components(unsigned char* binary_image, int* labels) {
    int current_label = 1;
    
    for(int y=0; y<HEIGHT; y++) {
        for(int x=0; x<WIDTH; x++) {
            if(binary_image[y*WIDTH + x] == 255 && labels[y*WIDTH + x] == 0) {
                flood_fill(binary_image, x, y, current_label, labels);
                current_label++;
            }
        }
    }
}

什么情况下适用

性能需求较高时

C语言以高效著称，适合处理实时性要求高的机器视觉任务（如工业检测、自动驾驶）。其直接内存访问和低延迟特性能够满足帧率稳定的需求，避免Python等语言因解释器或垃圾回收导致的性能波动。

嵌入式或资源受限环境

在嵌入式设备（如树莓派、ARM芯片）或移动端部署时，C语言生成的轻量级二进制文件占用内存少，无需依赖虚拟机或大型运行时库。适合摄像头模块直接处理图像，减少硬件成本。

需要与硬件深度交互

操作特定硬件（如FPGA、DSP）或调用厂商SDK（如Intel IPP、NVIDIA CUDA）时，C语言接口兼容性最佳。例如直接通过指针操作图像缓冲区，或编写OpenCV的底层优化模块。

算法需要跨平台复用

C语言代码可编译为Windows/Linux/macOS等多平台版本，避免重写逻辑。例如将核心算法封装为动态库（.dll/.so），供Python、Java等高级语言调用，兼顾开发效率和执行速度。

代码示例：边缘检测（Sobel算子）

#include <stdint.h>
void sobel_filter(uint8_t* input, uint8_t* output, int width, int height) {
    int gx, gy, sum;
    for (int y = 1; y < height-1; y++) {
        for (int x = 1; x < width-1; x++) {
            gx = -input[(y-1)*width + x-1] - 2*input[y*width + x-1] - input[(y+1)*width + x-1]
                 + input[(y-1)*width + x+1] + 2*input[y*width + x+1] + input[(y+1)*width + x+1];
            gy = -input[(y-1)*width + x-1] - 2*input[(y-1)*width + x] - input[(y-1)*width + x+1]
                 + input[(y+1)*width + x-1] + 2*input[(y+1)*width + x] + input[(y+1)*width + x+1];
            sum = abs(gx) + abs(gy);
            output[y*width + x] = (sum > 255) ? 255 : sum;
        }
    }
}