write a C code to complete using partition method first and then Otsu’s method

Here is a sample code that performs image thresholding using partition method first and then Otsu's method:

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

#define MAX_PIXEL_VALUE 255

int partition_thresholding(int *histogram, int num_pixels);
int otsu_thresholding(int *histogram, int num_pixels);

int main() {
    int width = 256, height = 256;
    unsigned char *image = malloc(width * height);

    // Generate a sample image
    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            image[i * width + j] = i % 256;
        }
    }

    // Compute histogram of the image
    int *histogram = calloc(MAX_PIXEL_VALUE + 1, sizeof(int));
    for (int i = 0; i < height; ++i) {
        for (int j = 0; j < width; ++j) {
            histogram[image[i * width + j]]++;
        }
    }

    // Threshold using partition method
    int partition_threshold = partition_thresholding(histogram, width * height);
    printf("Partition threshold: %d\n", partition_threshold);

    // Threshold using Otsu's method
    int otsu_threshold = otsu_thresholding(histogram, width * height);
    printf("Otsu threshold: %d\n", otsu_threshold);

    free(image);
    free(histogram);
    return 0;
}

int partition_thresholding(int *histogram, int num_pixels) {
    int sum = 0, num_background = 0, num_foreground = 0;
    for (int i = 0; i <= MAX_PIXEL_VALUE; ++i) {
        sum += i * histogram[i];
        num_foreground += histogram[i];
    }

    int threshold = 0, max_variance = 0;
    for (int i = 0; i <= MAX_PIXEL_VALUE; ++i) {
        num_background += histogram[i];
        num_foreground -= histogram[i];
        if (num_background == 0 || num_foreground == 0) {
            continue;
        }
        int mean_background = sum - i * num_foreground;
        mean_background /= num_background;
        int mean_foreground = sum - mean_background * num_background;
        mean_foreground /= num_foreground;
        int variance = num_background * num_foreground * pow(mean_background - mean_foreground, 2);
        if (variance > max_variance) {
            max_variance = variance;
            threshold = i;
        }
    }

    return threshold;
}

int otsu_thresholding(int *histogram, int num_pixels) {
    float sum = 0, num_background = 0, num_foreground = 0;
    for (int i = 0; i <= MAX_PIXEL_VALUE; ++i) {
        sum += i * histogram[i];
    }

    float sum_background = 0, sum_foreground = 0;
    int threshold = 0;
    float max_variance = 0;
    for (int i = 0; i <= MAX_PIXEL_VALUE; ++i) {
        num_background += histogram[i];
        if (num_background == 0) {
            continue;
        }
        num_foreground = num_pixels - num_background;
        if (num_foreground == 0) {
            break;
        }
        sum_background += i * histogram[i];
        sum_foreground = sum - sum_background;
        float mean_background = sum_background / num_background;
        float mean_foreground = sum_foreground / num_foreground;
        float variance = num_background * num_foreground * pow(mean_background - mean_foreground, 2);
        if (variance > max_variance) {
            max_variance = variance;
            threshold = i;
        }
    }

    return threshold;
}

In this code, we first generate a sample image and compute its histogram. Then, we apply partition method and Otsu's method to compute the threshold value. Finally, we print the threshold values obtained from both methods.

Note that this code assumes that the input image is a grayscale image with pixel values ranging from 0 to 255. You may need to modify the code if your input image has a different format.