이미지 처리 라이브러리 개발의 세계로 풍덩! 🏊‍♂️

안녕, 친구들! 오늘은 정말 신나는 주제로 이야기를 나눠볼 거야. 바로 이미지 처리 라이브러리 개발에 대해서 말이지. 필터랑 변환 같은 걸 만드는 거야. 어때, 벌써부터 두근두근하지 않아? 😆

우리가 매일 사용하는 스마트폰 카메라 앱이나 인스타그램 같은 SNS에서 사진을 예쁘게 만들어주는 필터들, 그게 다 이미지 처리 기술 덕분이라는 거 알고 있었어? 그리고 그런 멋진 기능들을 만드는 사람들이 바로 우리 같은 개발자들이야! 👨‍💻👩‍💻

자, 이제부터 우리는 C언어를 사용해서 직접 이미지 처리 라이브러리를 만들어볼 거야. 어렵게 들릴 수도 있지만, 걱정 마. 내가 친구처럼 하나하나 쉽게 설명해줄게. 그리고 우리가 만든 라이브러리로 멋진 필터도 만들어보고, 이미지도 변환해볼 거야. 재밌겠지? 🎨✨

아, 그리고 말이야. 혹시 재능넷이라는 사이트 알아? 거기서는 이런 프로그래밍 실력을 다른 사람들과 나눌 수 있대. 나중에 우리가 만든 라이브러리로 멋진 프로젝트를 완성하면, 재능넷에서 다른 사람들에게 도움을 줄 수도 있을 거야. 멋지지 않아? 😎

자, 이제 정말 시작해볼까? 준비됐어? 그럼 고고! 🚀

1. 이미지 처리의 기초: 픽셀이 뭐야? 🖼️

자, 친구야. 이미지 처리를 시작하기 전에 우리가 꼭 알아야 할 게 있어. 바로 픽셀이라는 녀석이야. 픽셀이 뭔지 알아? 간단히 말하면 디지털 이미지를 구성하는 가장 작은 단위라고 할 수 있어. 우리가 컴퓨터나 스마트폰 화면으로 보는 모든 이미지는 이 작은 픽셀들이 모여서 만들어진 거야. 😮

픽셀은 마치 작은 색깔 점들의 모음이라고 생각하면 돼. 이 점들이 촘촘하게 모여서 하나의 이미지를 만드는 거지. 예를 들어, 우리가 멀리서 볼 때는 하나의 완벽한 그림으로 보이지만, 아주 가까이 다가가서 보면 작은 점들이 모여 있는 걸 볼 수 있어. 그게 바로 픽셀이야! 🔍

그럼 이 픽셀은 어떻게 구성되어 있을까? 보통 우리가 사용하는 컬러 이미지의 경우, 각 픽셀은 빨강(Red), 초록(Green), 파랑(Blue) 세 가지 색상 정보를 가지고 있어. 이걸 우리는 RGB 색상 모델이라고 불러. 각 색상은 0부터 255까지의 숫자로 표현되는데, 이 세 가지 색을 조합해서 우리가 보는 모든 색을 만들어낼 수 있어. 신기하지? 🌈

🧠 알아두면 좋은 팁: 255, 0, 0은 순수한 빨간색을, 0, 255, 0은 순수한 초록색을, 0, 0, 255는 순수한 파란색을 나타내. 그리고 0, 0, 0은 검정색, 255, 255, 255는 흰색이야!

자, 이제 픽셀에 대해 기본적인 이해가 됐지? 이게 바로 우리가 이미지 처리를 할 때 다루게 될 가장 기본적인 단위야. 우리는 이 픽셀들의 색상 정보를 변경하거나 조작해서 다양한 효과를 만들어낼 수 있어. 예를 들어, 모든 픽셀의 밝기를 높이면 전체 이미지가 밝아지고, 특정 색상 값을 조정하면 색감을 변경할 수 있지. 😎

이제 우리가 만들 이미지 처리 라이브러리의 기본 재료인 픽셀에 대해 알았으니, 다음 단계로 넘어가볼까? 우리는 C언어를 사용해서 이 픽셀들을 다루는 방법을 배우고, 점점 더 복잡한 처리를 할 수 있게 될 거야. 재밌겠지? 🚀

그리고 말이야, 이런 기초적인 이미지 처리 지식은 정말 다양한 분야에서 활용될 수 있어. 예를 들어, 재능넷에서 그래픽 디자인이나 웹 개발 관련 프로젝트를 진행할 때도 큰 도움이 될 거야. 이미지의 구조를 이해하고 있으면, 더 효과적으로 작업할 수 있거든. 😉

자, 이제 정말 본격적으로 시작해볼까? 다음 섹션에서는 C언어로 이미지 파일을 읽고 쓰는 방법에 대해 알아볼 거야. 준비됐지? 고고! 🏃‍♂️💨

2. C언어로 이미지 파일 다루기: 읽고 쓰는 게 이렇게 쉽다고? 📂

안녕, 친구야! 이제 우리는 C언어를 사용해서 실제로 이미지 파일을 다뤄볼 거야. 어렵게 들릴 수도 있지만, 걱정 마. 내가 차근차근 설명해줄게. 😊

먼저, 우리가 다룰 이미지 파일 형식에 대해 알아보자. 이미지 파일에는 여러 가지 형식이 있는데, 우리는 가장 간단한 형식 중 하나인 BMP(비트맵) 파일을 사용할 거야. BMP 파일은 압축되지 않은 raw 데이터를 저장하기 때문에, 처리하기가 비교적 쉬워. 👍

BMP 파일 구조 이해하기

BMP 파일은 크게 세 부분으로 나눌 수 있어:

파일 헤더: 파일 크기, 형식 등의 기본 정보를 담고 있어.
정보 헤더: 이미지의 너비, 높이, 색상 깊이 등 더 자세한 정보가 있어.
픽셀 데이터: 실제 이미지를 구성하는 픽셀들의 색상 정보야.

자, 이제 이 구조를 C언어로 어떻게 표현할 수 있는지 볼까? 🤓


#include <stdio.h>
#include <stdint.h>

#pragma pack(push, 1)

typedef struct {
    uint16_t type;              // 매직 넘버 (BM)
    uint32_t size;              // 파일 크기
    uint16_t reserved1;         // 예약된 필드
    uint16_t reserved2;         // 예약된 필드
    uint32_t offset;            // 픽셀 데이터 시작 위치
} BMPFileHeader;

typedef struct {
    uint32_t size;              // 정보 헤더 크기
    int32_t width;              // 이미지 너비
    int32_t height;             // 이미지 높이
    uint16_t planes;            // 색상면 수 (항상 1)
    uint16_t bitCount;          // 픽셀당 비트 수
    uint32_t compression;       // 압축 방식
    uint32_t sizeImage;         // 이미지 크기
    int32_t xPelsPerMeter;      // 가로 해상도
    int32_t yPelsPerMeter;      // 세로 해상도
    uint32_t clrUsed;           // 사용된 색상 수
    uint32_t clrImportant;      // 중요한 색상 수
} BMPInfoHeader;

#pragma pack(pop)
  </stdint.h></stdio.h>

우와, 코드가 좀 길어 보이지? 하지만 걱정 마. 이건 그냥 BMP 파일의 구조를 C언어로 표현한 거야. 각 필드가 무엇을 의미하는지 간단히 설명해놨어. 이 구조체들을 사용하면 BMP 파일의 헤더 정보를 쉽게 읽고 쓸 수 있어. 😎

🧠 알아두면 좋은 팁: #pragma pack(push, 1)과 #pragma pack(pop)은 구조체의 메모리 정렬을 1바이트 단위로 설정하는 거야. 이렇게 하면 파일에서 읽은 데이터와 우리 구조체가 정확히 일치하게 돼!

이미지 파일 읽기

자, 이제 실제로 BMP 파일을 읽어보자. 아래 코드를 따라해봐:


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

// ... (위에서 정의한 구조체들)

int main() {
    FILE *file = fopen("example.bmp", "rb");
    if (!file) {
        printf("파일을 열 수 없어요 ㅠㅠ\n");
        return 1;
    }

    BMPFileHeader fileHeader;
    BMPInfoHeader infoHeader;

    // 파일 헤더 읽기
    fread(&fileHeader, sizeof(BMPFileHeader), 1, file);

    // 정보 헤더 읽기
    fread(&infoHeader, sizeof(BMPInfoHeader), 1, file);

    // 이미지 정보 출력
    printf("이미지 크기: %d x %d\n", infoHeader.width, infoHeader.height);
    printf("색상 깊이: %d bits\n", infoHeader.bitCount);

    // 픽셀 데이터 읽기
    int imageSize = infoHeader.width * infoHeader.height * (infoHeader.bitCount / 8);
    uint8_t *pixelData = (uint8_t*)malloc(imageSize);
    fread(pixelData, 1, imageSize, file);

    // 여기서 pixelData를 사용해 이미지 처리를 할 수 있어!

    free(pixelData);
    fclose(file);
    return 0;
}
  </stdlib.h></stdio.h>

우와, 정말 대단하지 않아? 이렇게 간단한 코드로 BMP 파일을 읽을 수 있다니! 😃

이 코드는 BMP 파일을 열고, 파일 헤더와 정보 헤더를 읽은 다음, 실제 픽셀 데이터를 메모리에 로드해. 그리고 이미지의 크기와 색상 깊이 같은 기본 정보를 출력해주지.

이미지 파일 쓰기

이미지를 읽었으니, 이제 쓰는 방법도 알아볼까? 아래 코드를 봐봐:


void writeBMPFile(const char *filename, int width, int height, uint8_t *pixelData) {
    FILE *file = fopen(filename, "wb");
    if (!file) {
        printf("파일을 생성할 수 없어요 ㅠㅠ\n");
        return;
    }

    BMPFileHeader fileHeader = {0};
    BMPInfoHeader infoHeader = {0};

    // 파일 헤더 설정
    fileHeader.type = 0x4D42;  // "BM"
    fileHeader.size = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader) + width * height * 3;
    fileHeader.offset = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader);

    // 정보 헤더 설정
    infoHeader.size = sizeof(BMPInfoHeader);
    infoHeader.width = width;
    infoHeader.height = height;
    infoHeader.planes = 1;
    infoHeader.bitCount = 24;  // 24비트 컬러
    infoHeader.compression = 0;
    infoHeader.sizeImage = width * height * 3;

    // 헤더 쓰기
    fwrite(&fileHeader, sizeof(BMPFileHeader), 1, file);
    fwrite(&infoHeader, sizeof(BMPInfoHeader), 1, file);

    // 픽셀 데이터 쓰기
    fwrite(pixelData, 1, infoHeader.sizeImage, file);

    fclose(file);
}

이 함수를 사용하면 우리가 만든 이미지 데이터를 BMP 파일로 저장할 수 있어. 멋지지 않아? 😎

자, 이제 우리는 이미지 파일을 읽고 쓸 수 있게 됐어. 이게 바로 우리가 만들 이미지 처리 라이브러리의 기초가 될 거야. 이걸 바탕으로 다양한 필터와 변환 기능을 추가할 수 있지!

그리고 말이야, 이런 기술은 재능넷 같은 플랫폼에서 정말 유용하게 쓰일 수 있어. 예를 들어, 사용자들의 프로필 이미지를 자동으로 리사이징하거나, 업로드된 이미지에 워터마크를 추가하는 등의 기능을 만들 수 있지. 우리가 배운 이 기술로 정말 많은 걸 할 수 있다니, 신나지 않아? 🚀

다음 섹션에서는 이 기초를 바탕으로 실제 이미지 처리 기능들을 구현해볼 거야. 준비됐어? 그럼 고고! 💪

3. 기본적인 이미지 처리 기능 구현하기: 필터의 세계로! 🎨

안녕, 친구야! 이제 우리는 정말 재미있는 부분에 도달했어. 바로 실제 이미지 처리 기능을 구현하는 거지! 😃 우리가 배운 기초를 바탕으로 몇 가지 멋진 필터들을 만들어볼 거야. 준비됐어? 그럼 시작해보자!

1. 그레이스케일 필터

가장 기본적이면서도 유용한 필터 중 하나가 바로 그레이스케일이야. 컬러 이미지를 흑백으로 바꾸는 거지. 어떻게 만들 수 있을까? 🤔


void applyGrayscaleFilter(uint8_t *pixelData, int width, int height) {
    for (int i = 0; i < width * height * 3; i += 3) {
        uint8_t r = pixelData[i];
        uint8_t g = pixelData[i + 1];
        uint8_t b = pixelData[i + 2];
        
        // 그레이스케일 값 계산
        uint8_t gray = (uint8_t)(0.299 * r + 0.587 * g + 0.114 * b);
        
        // RGB 값을 모두 같은 그레이스케일 값으로 설정
        pixelData[i] = gray;
        pixelData[i + 1] = gray;
        pixelData[i + 2] = gray;
    }
}

우와, 생각보다 간단하지? 이 함수는 각 픽셀의 RGB 값을 읽어서 그레이스케일 값으로 변환해. 여기서 사용한 공식(0.299R + 0.587G + 0.114B)은 인간의 눈이 각 색상을 인식하는 민감도를 고려한 거야. 멋지지 않아? 😎

🧠 알아두면 좋은 팁: 그레이스케일 변환에는 여러 가지 방법이 있어. 단순히 (R+G+B)/3을 사용할 수도 있지만, 우리가 사용한 방법이 인간의 눈에 더 자연스럽게 보여.

2. 세피아 필터

다음으로 만들어볼 건 세피아 필터야. 오래된 사진 같은 느낌을 주는 필터지. 어떻게 만들 수 있을까? 👀


void applySepiaFilter(uint8_t *pixelData, int width, int height) {
    for (int i = 0; i < width * height * 3; i += 3) {
        uint8_t r = pixelData[i];
        uint8_t g = pixelData[i + 1];
        uint8_t b = pixelData[i + 2];
        
        // 세피아 값 계산
        int newR = (int)(0.393 * r + 0.769 * g + 0.189 * b);
        int newG = (int)(0.349 * r + 0.686 * g + 0.168 * b);
        int newB = (int)(0.272 * r + 0.534 * g + 0.131 * b);
        
        // 값이 255를 넘지 않도록 조정
        pixelData[i] = (newR > 255) ? 255 : newR;
        pixelData[i + 1] = (newG > 255) ? 255 : newG;
        pixelData[i + 2] = (newB > 255) ? 255 : newB;
    }
}

세피아 필터도 그레이스케일과 비슷한 원리로 동작해. 다만 각 색상 채널에 다른 가중치를 적용해서 붉은 빛이 도는 효과를 만들어내지. 이 필터를 적용하면 사진이 마치 오래된 것처럼 보여. 멋지지 않아? 🌅

3. 밝기 조절 필터

이번엔 이미지의 밝기를 조절하는 필터를 만들어볼 거야. 이 필터는 사용자가 원하는 만큼 이미지를 밝게 하거나 어둡게 할 수 있어. 어떻게 구현할 수 있을까? 💡


void adjustBrightness(uint8_t *pixelData, int width, int height, int brightness) {
    for (int i = 0; i < width * height * 3; i++) {
        int newValue = pixelData[i] + brightness;
        
        // 값이 0에서 255 사이에 있도록 조정
        if (newValue < 0) newValue = 0;
        if (newValue > 255) newValue = 255;
        
        pixelData[i] = newValue;
    }
}

이 함수는 각 픽셀의 RGB 값에 brightness 값을 더해. brightness가 양수면 이미지가 밝아지고, 음수면 어두워져. 그리고 결과 값이 0보다 작아지거나 255보다 커지지 않도록 조정하고 있어. 이렇게 하면 이미지가 너무 밝거나 어두워지는 걸 방지할 수 있지. 👍

🧠 알아두면 좋은 팁: 이 밝기 조절 함수를 사용할 때는 -255에서 255 사이의 값을 사용하는 게 좋아. 그래야 모든 경우의 밝기 변화를 표현할 수 있거든!

4. 대비(Contrast) 조절 필터

마지막으로 대비를 조절하는 필터를 만들어볼 거야. 대비를 높이면 이미지의 밝은 부분은 더 밝게, 어두운 부분은 더 어둡게 만들어서 이미지가 더 선명해 보이게 할 수 있어. 어떻게 만들까? 🎭


void adjustContrast(uint8_t *pixelData, int width, int height, float contrast) {
    float factor = (259 * (contrast + 255)) / (255 * (259 - contrast));
    
    for (int i = 0; i < width * height * 3; i++) {
        int newValue = (int)(factor * (pixelData[i] - 128) + 128);
        
        // 값이 0에서 255 사이에 있도록 조정
        if (newValue < 0) newValue = 0;
        if (newValue > 255) newValue = 255;
        
        pixelData[i] = newValue;
    }
}

이 함수는 조금 복잡해 보일 수 있지만, 걱정 마! 기본 아이디어는 각 픽셀 값을 중간값(128)을 기준으로 늘리거나 줄이는 거야. contrast 값이 양수면 대비가 높아지고, 음수면 낮아져. 여기서 사용한 공식은 대비를 부드럽게 조절할 수 있게 해주는 특별한 공식이야. 😊

자, 이제 우리는 네 가지 기본적인 이미지 처리 필터를 만들었어! 이 필터들을 조합하면 정말 다양한 효과를 만들 수 있지. 예를 들어, 그레이스케일 필터를 적용한 후 대비를 높이면 흑백 영화 같은 느낌의 이미지를 만들 수 있어. 또는 세피아 필터를 적용한 후 밝기를 조절하면 오래된 사진 효과를 더 강조할 수 있지.

이런 기술들은 재능넷 같은 플랫폼에서 정말 유용하게 사용될 수 있어. 예를 들어, 사용자들이 자신의 포트폴리오 이미지에 이런 필터들을 적용해서 더 멋진 작품을 만들 수 있지. 또는 웹 디자이너들이 웹사이트의 이미지를 자동으로 처리해서 일관된 스타일을 만들 수도 있어. 정말 무궁무진한 가능성이 있는 거지! 🌟

다음 섹션에서는 이 기본적인 필터들을 바탕으로 더 복잡하고 흥미로운 이미지 처리 기능들을 만들어볼 거야. 준비됐어? 그럼 고고! 🚀

4. 고급 이미지 처리 기능 구현하기: 마법 같은 변환의 세계! ✨

안녕, 친구야! 이제 우리는 더 흥미진진한 고급 이미지 처리 기능들을 만들어볼 거야. 이 기능들은 조금 복잡할 수 있지만, 그만큼 더 멋진 결과를 만들어낼 수 있어. 준비됐어? 그럼 시작해보자! 🎩✨

1. 블러 효과 (Gaussian Blur)

첫 번째로 만들어볼 건 블러 효과야. 이 효과는 이미지를 부드럽게 만들어주는데, 주로 노이즈를 제거하거나 배경을 흐리게 만들 때 사용해. 가우시안 블러라는 방법을 사용할 건데, 이게 가장 자연스러운 블러 효과를 만들어내거든. 😊


#include <math.h>

void applyGaussianBlur(uint8_t *pixelData, int width, int height, float sigma) {
    int kernelSize = (int)(6 * sigma);
    if (kernelSize % 2 == 0) kernelSize++;

    float *kernel = (float*)malloc(kernelSize * kernelSize * sizeof(float));
    float sum = 0.0f;

    // 가우시안 커널 생성
    for (int y = 0; y < kernelSize; y++) {
        for (int x = 0; x < kernelSize; x++) {
            int index = y * kernelSize + x;
            float x1 = x - (kernelSize / 2);
            float y1 = y - (kernelSize / 2);
            kernel[index] = exp(-(x1*x1 + y1*y1) / (2 * sigma * sigma));
            sum += kernel[index];
        }
    }

    // 커널 정규화
    for (int i = 0; i < kernelSize * kernelSize; i++) {
        kernel[i] /= sum;
    }

    // 블러 적용
    uint8_t *tempData = (uint8_t*)malloc(width * height * 3 * sizeof(uint8_t));
    memcpy(tempData, pixelData, width * height * 3 * sizeof(uint8_t));

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            float sumR = 0, sumG = 0, sumB = 0;
            for (int ky = 0; ky < kernelSize; ky++) {
                for (int kx = 0; kx < kernelSize; kx++) {
                    int pixelX = x + kx - kernelSize / 2;
                    int pixelY = y + ky - kernelSize / 2;
                    if (pixelX >= 0 && pixelX < width && pixelY >= 0 && pixelY < height) {
                        int index = (pixelY * width + pixelX) * 3;
                        float kernelValue = kernel[ky * kernelSize + kx];
                        sumR += tempData[index] * kernelValue;
                        sumG += tempData[index + 1] * kernelValue;
                        sumB += tempData[index + 2] * kernelValue;
                    }
                }
            }
            int index = (y * width + x) * 3;
            pixelData[index] = (uint8_t)sumR;
            pixelData[index + 1] = (uint8_t)sumG;
            pixelData[index + 2] = (uint8_t)sumB;
        }
    }

    free(kernel);
    free(tempData);
}
  </math.h>

우와, 코드가 좀 길어 보이지? 하지만 걱정 마! 이 코드는 크게 세 부분으로 나눌 수 있어:

가우시안 커널 생성: 이 부분에서는 블러 효과를 만들 때 사용할 '가중치'를 계산해.
커널 정규화: 계산한 가중치의 합이 1이 되도록 조정해.
블러 적용: 실제로 이미지의 각 픽셀에 블러 효과를 적용해.

이 함수를 사용하면 sigma 값을 조절해서 블러의 강도를 조절할 수 있어. sigma 값이 클수록 더 강한 블러 효과가 적용돼. 😎

🧠 알아두면 좋은 팁: 가우시안 블러는 포토샵 같은 전문 이미지 편집 프로그램에서도 사용하는 고급 기술이야. 이걸 이해하고 구현할 수 있다는 건 정말 대단한 거야!

2. 엣지 검출 (Sobel Edge Detection)

다음으로 만들어볼 건 엣지 검출 기능이야. 이 기능은 이미지에서 물체의 윤곽선을 찾아내는 거야. 주로 컴퓨터 비전이나 이미지 분석에서 많이 사용되는 기술이지. 우리는 소벨 연산자라는 방법을 사용할 거야. 👀


void applySobelEdgeDetection(uint8_t *pixelData, int width, int height) {
    uint8_t *tempData = (uint8_t*)malloc(width * height * sizeof(uint8_t));

    // 그레이스케일로 변환
    for (int i = 0; i < width * height; i++) {
        int index = i * 3;
        tempData[i] = (uint8_t)(0.299 * pixelData[index] + 0.587 * pixelData[index + 1] + 0.114 * pixelData[index + 2]);
    }

    // Sobel 연산자
    int sobelX[3][3] = {{-1, 0, 1}, {-2, 0, 2}, {-1, 0, 1}};
    int sobelY[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 pixelX = 0, pixelY = 0;
            for (int i = -1; i <= 1; i++) {
                for (int j = -1; j <= 1; j++) {
                    int pixel = tempData[(y + i) * width + (x + j)];
                    pixelX += pixel * sobelX[i + 1][j + 1];
                    pixelY += pixel * sobelY[i + 1][j + 1];
                }
            }
            int magnitude = (int)sqrt(pixelX * pixelX + pixelY * pixelY);
            if (magnitude > 255) magnitude = 255;
            int index = (y * width + x) * 3;
            pixelData[index] = pixelData[index + 1] = pixelData[index + 2] = magnitude;
        }
    }

    free(tempData);
}

이 코드도 몇 가지 단계로 나눌 수 있어:

이미지를 그레이스케일로 변환해. 엣지 검출은 보통 흑백 이미지에서 수행하거든.
소벨 연산자를 적용해. 이 연산자는 이미지의 수평과 수직 방향의 변화를 감지해.
변화의 크기를 계산해서 엣지를 표현해.

이 함수를 사용하면 이미지의 윤곽선만 남은 멋진 결과를 얻을 수 있어. 마치 연필로 스케치한 것 같은 효과를 낼 수 있지! 🖌️

3. 이미지 회전

마지막으로 만들어볼 건 이미지 회전 기능이야. 이 기능은 이미지를 원하는 각도만큼 회전시킬 수 있어. 생각보다 복잡할 수 있지만, 한 번 해보자! 🔄


void rotateImage(uint8_t *pixelData, int width, int height, float angle) {
    uint8_t *tempData = (uint8_t*)malloc(width * height * 3 * sizeof(uint8_t));
    memcpy(tempData, pixelData, width * height * 3 * sizeof(uint8_t));

    float radians = angle * M_PI / 180.0f;
    float cosTheta = cos(radians);
    float sinTheta = sin(radians);

    int centerX = width / 2;
    int centerY = height / 2;

    for (int y = 0; y < height; y++) {
        for (int x = 0; x < width; x++) {
            int newX = (int)((x - centerX) * cosTheta - (y - centerY) * sinTheta + centerX);
            int newY = (int)((x - centerX) * sinTheta + (y - centerY) * cosTheta + centerY);

            if (newX >= 0 && newX < width && newY >= 0 && newY < height) {
                int oldIndex = (y * width + x) * 3;
                int newIndex = (newY * width + newX) * 3;
                pixelData[oldIndex] = tempData[newIndex];
                pixelData[oldIndex + 1] = tempData[newIndex + 1];
                pixelData[oldIndex + 2] = tempData[newIndex + 2];
            } else {
                int index = (y * width + x) * 3;
                pixelData[index] = pixelData[index + 1] = pixelData[index + 2] = 255; // 흰색으로 채우기
            }
        }
    }

    free(tempData);
}

이 코드는 다음과 같은 단계로 동작해:

회전 각도를 라디안으로 변환하고, 삼각함수 값을 계산해.
이미지의 중심을 기준으로 각 픽셀의 새로운 위치를 계산해.
새로운 위치에 해당하는 원래 픽셀의 색상 값을 가져와 적용해.
회전 후 빈 공간은 흰색으로 채워.

이 함수를 사용하면 이미지를 원하는 각도만큼 자유롭게 회전시킬 수 있어. 멋지지 않아? 😃

🧠 알아두면 좋은 팁: 이미지 회전 시 품질 손실을 줄이기 위해 보간법(interpolation)을 사용할 수 있어. 이건 더 고급 기술이니, 나중에 한번 도전해보는 것도 좋을 거야!

자, 이제 우리는 정말 멋진 고급 이미지 처리 기능들을 구현했어! 이 기능들을 조합하면 정말 다양한 효과를 만들 수 있지. 예를 들어, 블러 효과를 적용한 후 엣지 검출을 하면 부드러운 윤곽선만 남은 독특한 이미지를 만들 수 있어. 또는 이미지를 회전시킨 후 세피아 필터를 적용하면 재미있는 빈티지 스타일의 사진을 만들 수 있지.

이런 고급 기능들은 재능넷 같은 플랫폼에서 정말 유용하게 사용될 수 있어. 예를 들어, 사용자들이 자신의 작품 이미지에 특별한 효과를 줄 수 있게 하거나, 프로필 사진을 자동으로 보정하고 스타일링하는 기능을 만들 수 있지. 또는 이미지 기반의 로고 생성 도구를 만들 때도 이런 기술들이 큰 도움이 될 거야. 가능성은 무한해! 🌟

다음 섹션에서는 우리가 만든 이 모든 기능들을 하나의 라이브러리로 묶고, 사용하기 쉬운 인터페이스를 만들어볼 거야. 그리고 이 라이브러리를 실제 프로젝트에 어떻게 적용할 수 있는지도 알아볼 거야. 준비됐어? 그럼 고고! 🚀

5. 라이브러리 완성과 실제 활용: 우리의 작품을 세상에 선보이자! 🌟

안녕, 친구야! 드디어 우리의 여정이 마지막 단계에 도달했어. 지금까지 우리가 만든 모든 멋진 기능들을 하나의 라이브러리로 묶고, 실제로 사용해볼 거야. 정말 신나지 않아? 😃

1. 라이브러리 구조 만들기

먼저, 우리의 모든 함수들을 하나의 헤더 파일과 소스 파일로 정리해보자. 이렇게 하면 나중에 다른 프로젝트에서도 쉽게 사용할 수 있어.


// imagelib.h
#ifndef IMAGELIB_H
#define IMAGELIB_H

#include <stdint.h>

typedef struct {
    uint8_t *data;
    int width;
    int height;
} Image;

Image* loadBMP(const char *filename);
void saveBMP(const char *filename, Image *img);
void applyGrayscaleFilter(Image *img);
void applySepiaFilter(Image *img);
void adjustBrightness(Image *img, int brightness);
void adjustContrast(Image *img, float contrast);
void applyGaussianBlur(Image *img, float sigma);
void applySobelEdgeDetection(Image *img);
void rotateImage(Image *img, float angle);

void freeImage(Image *img);

#endif
  </stdint.h>

이렇게 헤더 파일을 만들면, 우리의 라이브러리를 사용하는 사람들이 어떤 함수들을 사용할 수 있는지 한눈에 볼 수 있어. 그리고 Image 구조체를 만들어서 이미지 데이터를 더 쉽게 다룰 수 있게 했어. 👍

2. 사용하기 쉬운 인터페이스 만들기

이제 우리의 라이브러리를 사용하는 사람들이 더 쉽게 사용할 수 있도록 인터페이스를 개선해보자. 예를 들어, 여러 필터를 한 번에 적용할 수 있는 함수를 만들 수 있어.


// imagelib.c (일부)

void applyFilters(Image *img, const char *filters) {
    char *token = strtok((char*)filters, ",");
    while (token != NULL) {
        if (strcmp(token, "grayscale") == 0) {
            applyGrayscaleFilter(img);
        } else if (strcmp(token, "sepia") == 0) {
            applySepiaFilter(img);
        } else if (strncmp(token, "brightness:", 11) == 0) {
            int value = atoi(token + 11);
            adjustBrightness(img, value);
        }
        // ... 다른 필터들도 추가
        token = strtok(NULL, ",");
    }
}

이런 함수를 만들면 사용자들이 더 쉽게 여러 필터를 조합해서 사용할 수 있어. 예를 들어, "grayscale,brightness:20,blur:2.5" 이런 식으로 문자열을 전달하면 그레이스케일, 밝기 조정, 블러 효과를 한 번에 적용할 수 있지. 편리하지 않아? 😊

3. 실제 프로젝트에 적용하기

이제 우리의 라이브러리를 실제 프로젝트에 어떻게 적용할 수 있는지 예제를 통해 알아보자. 예를 들어, 간단한 이미지 편집 프로그램을 만들어볼 수 있어.


#include "imagelib.h"
#include <stdio.h>

int main() {
    Image *img = loadBMP("input.bmp");
    if (img == NULL) {
        printf("이미지를 불러올 수 없어요 ㅠㅠ\n");
        return 1;
    }

    printf("어떤 효과를 적용할까요? (예: grayscale,brightness:20,blur:2.5)\n");
    char filters[100];
    fgets(filters, sizeof(filters), stdin);

    applyFilters(img, filters);

    saveBMP("output.bmp", img);
    printf("이미지 처리가 완료됐어요! output.bmp 파일을 확인해보세요.\n");

    freeImage(img);
    return 0;
}
  </stdio.h>

이 프로그램은 사용자로부터 적용할 필터를 입력받아 이미지를 처리하고 저장해. 정말 간단하지만 강력한 이미지 편집 도구가 된 거야! 🎨

🧠 알아두면 좋은 팁: 실제 프로덕션 환경에서는 사용자 입력을 더 엄격하게 검증하고, 에러 처리를 더 꼼꼼히 해야 해. 안전하고 안정적인 프로그램을 만드는 건 정말 중요하거든!

4. 재능넷에서의 활용

우리가 만든 이 라이브러리는 재능넷에서 정말 다양하게 활용될 수 있어. 몇 가지 아이디어를 제안해볼게:

프로필 사진 자동 보정: 사용자가 프로필 사진을 업로드하면 자동으로 밝기와 대비를 조정하고, 약간의 블러 효과를 적용해 더 멋지게 만들 수 있어.
포트폴리오 이미지 워터마크: 사용자의 작품 이미지에 자동으로 워터마크를 추가하는 기능을 만들 수 있어. 이미지 회전 기능을 활용해 비스듬한 워터마크도 가능하지!
이미지 기반 로고 생성기: 사용자가 업로드한 이미지를 바탕으로 엣지 검출, 색상 반전 등의 효과를 적용해 독특한 로고를 만들어주는 도구를 개발할 수 있어.
온라인 포토 에디터: 재능넷 사용자들이 직접 자신의 이미지를 편집할 수 있는 간단한 온라인 툴을 제공할 수 있어. 우리가 만든 다양한 필터들을 활용하면 되지!

이런 기능들은 재능넷 사용자들의 경험을 더욱 풍부하게 만들어줄 거야. 사용자들이 더 쉽게 자신의 재능을 표현하고 공유할 수 있게 되는 거지. 멋지지 않아? 😎