Обработка изображений в C: оптимизация и примеры использования

typedef struct {
unsigned char* data; // указатель на массив пикселей
int width; // ширина изображения
int height; // высота изображения
int channels; // количество каналов (1 – оттенки серого, 3 – RGB, 4 – RGBA)
} Image;

// Получение значения пикселя в позиции (x, y) для канала c
unsigned char get_pixel(Image* img, int x, int y, int c) {
return img->data[(y * img->width + x) * img->channels + c];
}

// Установка значения пикселя
void set_pixel(Image* img, int x, int y, int c, unsigned char value) {
img->data[(y * img->width + x) * img->channels + c] = value;
}

#include <opencv2/opencv.hpp>

int main() {
// Загрузка изображения
cv::Mat image = cv::imread("input.jpg");
if (image.empty()) {
printf("Ошибка загрузки изображения\n");
return -1;
}

// Преобразование в оттенки серого
cv::Mat gray;
cv::cvtColor(image, gray, cv::COLOR_BGR2GRAY);

// Обнаружение краев с помощью алгоритма Canny
cv::Mat edges;
cv::Canny(gray, edges, 100, 200);

// Сохранение результата
cv::imwrite("edges.jpg", edges);

return 0;
}

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"

int main() {
int width, height, channels;
unsigned char *img = stbi_load("input.png", &width, &height, &channels, 0);
if (img == NULL) {
printf("Ошибка загрузки изображения\n");
return -1;
}

// Инвертирование цветов
for (int i = 0; i < width * height * channels; i++) {
img[i] = 255 – img[i];
}

// Сохранение результата
stbi_write_png("inverted.png", width, height, channels, img, width * channels);
stbi_image_free(img);

return 0;
}

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"

int main() {
int width, height, channels;
unsigned char *img = stbi_load("input.jpg", &width, &height, &channels, 0);

if (img == NULL) {
printf("Ошибка загрузки изображения\n");
return -1;
}

printf("Загружено изображение: %dx%d, %d каналов\n", width, height, channels);

// Работа с изображением...

stbi_image_free(img); // Освобождение памяти
return 0;
}

// Преобразование цветного изображения в оттенки серого
void convert_to_grayscale(unsigned char *img, int width, int height, int channels) {
if (channels < 3) return; // Изображение уже в оттенках серого или имеет альфа-канал

for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
int pixel_index = (y * width + x) * channels;

// Формула для преобразования RGB в оттенки серого
unsigned char gray = (unsigned char)(
0.299 * img[pixel_index] + // R
0.587 * img[pixel_index + 1] + // G
0.114 * img[pixel_index + 2] // B
);

// Заменяем все каналы на одинаковое значение серого
img[pixel_index] = gray; // R
img[pixel_index + 1] = gray; // G
img[pixel_index + 2] = gray; // B
}
}
}

#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"

// ...

// Сохранение в различных форматах
stbi_write_png("output.png", width, height, channels, img, width * channels);
stbi_write_jpg("output.jpg", width, height, channels, img, 90); // 90 – качество JPEG
stbi_write_bmp("output.bmp", width, height, channels, img);

// Простая реализация размытия по Гауссу с ядром 5x5
void gaussian_blur(unsigned char *src, unsigned char *dst, int width, int height, int channels) {
// Ядро фильтра Гаусса 5x5
const float kernel[5][5] = {
{0.003, 0.013, 0.022, 0.013, 0.003},
{0.013, 0.059, 0.097, 0.059, 0.013},
{0.022, 0.097, 0.159, 0.097, 0.022},
{0.013, 0.059, 0.097, 0.059, 0.013},
{0.003, 0.013, 0.022, 0.013, 0.003}
};

for (int y = 2; y < height-2; y++) {
for (int x = 2; x < width-2; x++) {
for (int c = 0; c < channels; c++) {
float sum = 0.0f;

for (int ky = -2; ky <= 2; ky++) {
for (int kx = -2; kx <= 2; kx++) {
int pixel_index = ((y+ky) * width + (x+kx)) * channels + c;
sum += src[pixel_index] * kernel[ky+2][kx+2];
}
}

dst[(y * width + x) * channels + c] = (unsigned char)(sum);
}
}
}
}

void sobel_edge_detection(unsigned char *src, unsigned char *dst, int width, int height) {
// Предполагаем, что изображение в оттенках серого (1 канал)

// Ядра фильтров Собеля
const int sobel_x[3][3] = {
{-1, 0, 1},
{-2, 0, 2},
{-1, 0, 1}
};

const int sobel_y[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 ky = -1; ky <= 1; ky++) {
for (int kx = -1; kx <= 1; kx++) {
int pixel = src[(y+ky) * width + (x+kx)];
gx += pixel * sobel_x[ky+1][kx+1];
gy += pixel * sobel_y[ky+1][kx+1];
}
}

// Вычисляем градиент
int magnitude = (int)sqrt(gx*gx + gy*gy);
// Ограничиваем значения в диапазоне 0-255
dst[y * width + x] = (magnitude > 255) ? 255 : magnitude;
}
}
}

// Поворот изображения на 90 градусов по часовой стрелке
void rotate_90_clockwise(unsigned char *src, unsigned char *dst, int width, int height, int channels) {
for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
for (int c = 0; c < channels; c++) {
// В повернутом изображении x становится y, а height-1-y становится x
int src_idx = (y * width + x) * channels + c;
int dst_idx = (x * height + (height – 1 – y)) * channels + c;
dst[dst_idx] = src[src_idx];
}
}
}
}

void threshold(unsigned char *src, unsigned char *dst, int width, int height, int threshold) {
// Предполагаем работу с одноканальным изображением
for (int i = 0; i < width * height; i++) {
dst[i] = (src[i] > threshold) ? 255 : 0;
}
}

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// Настройка яркости
void adjust_brightness(unsigned char *img, int width, int height, int channels, int value) {
for (int i = 0; i < width * height * channels; i++) {
int new_value = img[i] + value;
img[i] = (new_value > 255) ? 255 : (new_value < 0) ? 0 : new_value;
}
}

// Настройка контрастности
void adjust_contrast(unsigned char *img, int width, int height, int channels, float factor) {
for (int i = 0; i < width * height * channels; i++) {
float new_value = ((img[i] / 255.0f – 0.5f) * factor + 0.5f) * 255.0f;
img[i] = (new_value > 255) ? 255 : (new_value < 0) ? 0 : (unsigned char)new_value;
}
}

int main(int argc, char *argv[]) {
if (argc < 3) {
printf("Использование: %s input.jpg output.jpg [brightness] [contrast]\n", argv[0]);
return -1;
}

int width, height, channels;
unsigned char *img = stbi_load(argv[1], &width, &height, &channels, 0);
if (img == NULL) {
printf("Ошибка загрузки изображения %s\n", argv[1]);
return -1;
}

if (argc > 3) {
int brightness = atoi(argv[3]);
adjust_brightness(img, width, height, channels, brightness);
}

if (argc > 4) {
float contrast = atof(argv[4]);
adjust_contrast(img, width, height, channels, contrast);
}

stbi_write_jpg(argv[2], width, height, channels, img, 90);
stbi_image_free(img);

printf("Изображение успешно обработано и сохранено как %s\n", argv[2]);
return 0;
}

gcc -o photo_editor photo_editor.c -lm
./photo_editor input.jpg output.jpg 10 1.2

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"
#include <stdio.h>
#include <stdlib.h>
#include <math.h>

// Функция вычисления разницы между двумя кадрами
int detect_motion(unsigned char *frame1, unsigned char *frame2, 
int width, int height, int channels, 
unsigned char *diff_map, int threshold) {
int motion_pixels = 0;

for (int y = 0; y < height; y++) {
for (int x = 0; x < width; x++) {
int diff = 0;

for (int c = 0; c < channels; c++) {
int idx = (y * width + x) * channels + c;
diff += abs(frame1[idx] – frame2[idx]);
}

diff /= channels; // Среднее отличие по всем каналам

// Если разница превышает порог, отмечаем движение
if (diff > threshold) {
motion_pixels++;
diff_map[y * width + x] = 255; // Белый цвет для движения
} else {
diff_map[y * width + x] = 0; // Черный цвет для статичных областей
}
}
}

return motion_pixels;
}

int main(int argc, char *argv[]) {
if (argc < 4) {
printf("Использование: %s frame1.jpg frame2.jpg diff_output.jpg [threshold]\n", argv[0]);
return -1;
}

int threshold = (argc > 4) ? atoi(argv[4]) : 30;

int width1, height1, channels1;
unsigned char *frame1 = stbi_load(argv[1], &width1, &height1, &channels1, 0);

int width2, height2, channels2;
unsigned char *frame2 = stbi_load(argv[2], &width2, &height2, &channels2, 0);

if (!frame1 || !frame2) {
printf("Ошибка загрузки кадров\n");
return -1;
}

if (width1 != width2 || height1 != height2 || channels1 != channels2) {
printf("Кадры имеют разные размеры или форматы\n");
return -1;
}

// Создаем карту отличий (одноканальное изображение)
unsigned char *diff_map = (unsigned char *)malloc(width1 * height1);

int motion_pixels = detect_motion(frame1, frame2, width1, height1, channels1, diff_map, threshold);

float motion_percentage = 100.0f * motion_pixels / (width1 * height1);
printf("Обнаружено движение: %.2f%% пикселей изменились\n", motion_percentage);

stbi_write_jpg(argv[3], width1, height1, 1, diff_map, 90);

free(diff_map);
stbi_image_free(frame1);
stbi_image_free(frame2);

return 0;
}

#define STB_IMAGE_IMPLEMENTATION
#include "stb_image.h"
#define STB_IMAGE_WRITE_IMPLEMENTATION
#include "stb_image_write.h"
#include <stdio.h>
#include <stdlib.h>

// Функция наложения водяного знака
void apply_watermark(unsigned char *base_image, unsigned char *watermark,
int base_width, int base_height, int base_channels,
int wm_width, int wm_height, int wm_channels,
int pos_x, int pos_y, float opacity) {

for (int y = 0; y < wm_height; y++) {
for (int x = 0; x < wm_width; x++) {
// Проверяем, не выходим ли за границы базового изображения
int base_x = x + pos_x;
int base_y = y + pos_y;

if (base_x >= 0 && base_x < base_width && base_y >= 0 && base_y < base_height) {
for (int c = 0; c < base_channels; c++) {
// Индексы в массивах пикселей
int base_idx = (base_y * base_width + base_x) * base_channels + c;
int wm_idx = (y * wm_width + x) * wm_channels + c;

// Не выходим за границы каналов водяного знака
if (c < wm_channels) {
// Альфа-смешивание
base_image[base_idx] = (1.0f – opacity) * base_image[base_idx] +
opacity * watermark[wm_idx];
}
}
}
}
}
}

int main(int argc, char *argv[]) {
if (argc < 6) {
printf("Использование: %s base.jpg watermark.png output.jpg pos_x pos_y [opacity]\n", argv[0]);
return -1;
}

// Загружаем базовое изображение
int base_width, base_height, base_channels;
unsigned char *base_image = stbi_load(argv[1], &base_width, &base_height, &base_channels, 0);

// Загружаем водяной знак
int wm_width, wm_height, wm_channels;
unsigned char *watermark = stbi_load(argv[2], &wm_width, &wm_height, &wm_channels, 0);

if (!base_image || !watermark) {
printf("Ошибка загрузки изображений\n");
return -1;
}

// Позиция водяного знака
int pos_x = atoi(argv[4]);
int pos_y = atoi(argv[5]);

// Непрозрачность (по умолчанию 0.3)
float opacity = (argc > 6) ? atof(argv[6]) : 0.3f;

apply_watermark(base_image, watermark, base_width, base_height, base_channels,
wm_width, wm_height, wm_channels, pos_x, pos_y, opacity);

// Сохраняем результат
stbi_write_jpg(argv[3], base_width, base_height, base_channels, base_image, 90);

stbi_image_free(base_image);
stbi_image_free(watermark);

printf("Водяной знак успешно добавлен\n");
return 0;
}