c语言实现otus阈值分割

OTUS算法是一种基于图像灰度直方图的自适应阈值分割算法。下面是使用C语言实现OTUS阈值分割的步骤：

1. 读入图像并将其转化为灰度图像。

2. 计算图像的灰度直方图。

3. 计算图像的总像素数。

4. 初始化类间方差和最佳阈值。

5. 遍历灰度级别，计算当前阈值下的类间方差。

6. 如果当前类间方差大于已知最大类间方差，则更新最佳阈值。

7. 将阈值应用于图像，生成二值图像。

下面是C语言实现OTUS阈值分割的代码：

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

#define MAX_GRAY_LEVEL 256

int main()
{
    FILE *fpIn = NULL, *fpOut = NULL;
    unsigned char *image = NULL, *output = NULL;
    char fileName[100];
    int width, height;
    int pixelCount[MAX_GRAY_LEVEL];
    int pixelSum = 0;
    double pixelPro[MAX_GRAY_LEVEL];
    double w0, w1, u0tmp, u1tmp, u0, u1, deltaTmp, deltaMax = 0;
    int threshold = 0, i, j, k;

    printf("Enter the file name of the image to be processed: ");
    scanf("%s", fileName);

    fpIn = fopen(fileName, "rb");
    if (fpIn == NULL)
    {
        printf("Cannot open input file.\n");
        return 0;
    }

    fscanf(fpIn, "%*s %d %d %*s", &width, &height);

    image = (unsigned char *)malloc(width * height * sizeof(unsigned char));
    output = (unsigned char *)malloc(width * height * sizeof(unsigned char));

    fread(image, sizeof(unsigned char), width * height, fpIn);

    for (i = 0; i < MAX_GRAY_LEVEL; i++)
    {
        pixelCount[i] = 0;
        pixelPro[i] = 0;
    }

    for (i = 0; i < height; i++)
    {
        for (j = 0; j < width; j++)
        {
            pixelCount[(int)image[i * width + j]]++;
        }
    }

    for (i = 0; i < MAX_GRAY_LEVEL; i++)
    {
        pixelPro[i] = (double)pixelCount[i] / (double)(width * height);
        pixelSum += i * pixelCount[i];
    }

    w0 = 0;
    u0tmp = 0;
    u1tmp = (double)pixelSum / (double)(width * height);

    for (i = 0; i < MAX_GRAY_LEVEL; i++)
    {
        w0 += pixelPro[i];
        w1 = 1 - w0;
        if (w0 == 0 || w1 == 0) continue;

        u0tmp += (double)(i * pixelPro[i]);
        u0 = u0tmp / w0;
        u1 = (double)(pixelSum - u0tmp) / w1;
        deltaTmp = (double)w0 * (double)w1 * (u0 - u1) * (u0 - u1);

        if (deltaTmp > deltaMax)
        {
            deltaMax = deltaTmp;
            threshold = i;
        }
    }

    for (i = 0; i < height; i++)
    {
        for (j = 0; j < width; j++)
        {
            if (image[i * width + j] > threshold)
            {
                output[i * width + j] = 255;
            }
            else
            {
                output[i * width + j] = 0;
            }
        }
    }

    fpOut = fopen("output.raw", "wb");
    fprintf(fpOut, "P5\n%d %d\n255\n", width, height);
    fwrite(output, sizeof(unsigned char), width * height, fpOut);

    fclose(fpIn);
    fclose(fpOut);
    free(image);
    free(output);

    return 0;
}

在该代码中，我们使用了一个名为pixelCount的数组来存储每个灰度级别的像素数。我们还使用一个名为pixelPro的数组来存储每个灰度级别的出现概率。

在计算类间方差时，我们首先遍历所有灰度级别，计算每个灰度级别的前景像素和背景像素的像素数和像素概率，并计算出阈值为i时前景像素和背景像素的平均灰度值u0和u1。然后，我们计算类间方差deltaTmp，并将其与已知的最大类间方差deltaMax比较。如果deltaTmp大于deltaMax，则更新最佳阈值。

最后，我们将最佳阈值应用于图像，生成二值图像，并将其写入输出文件。