// 간단한 픽셀 구조체 정의
typedef struct {
    unsigned char r;  // Red (0-255)
    unsigned char g;  // Green (0-255)
    unsigned char b;  // Blue (0-255)
} Pixel;

// 이미지 구조체 정의
typedef struct {
    int width;        // 이미지 너비
    int height;       // 이미지 높이
    Pixel *data;      // 픽셀 데이터 배열
} Image;

// BMP 파일 헤더 구조체
#pragma pack(push, 1)  // 구조체 패딩 제거
typedef struct {
    unsigned short type;        // 파일 타입 (BM = 0x4D42)
    unsigned int size;          // 파일 크기
    unsigned short reserved1;   // 예약됨
    unsigned short reserved2;   // 예약됨
    unsigned int offset;        // 픽셀 데이터 시작 위치
} BMPFileHeader;

// BMP 정보 헤더 구조체
typedef struct {
    unsigned int size;          // 헤더 크기
    int width;                  // 이미지 너비
    int height;                 // 이미지 높이
    unsigned short planes;      // 색상 평면 수
    unsigned short bitCount;    // 픽셀당 비트 수
    unsigned int compression;   // 압축 방식
    unsigned int imageSize;     // 이미지 크기
    int xPixelsPerMeter;        // 수평 해상도
    int yPixelsPerMeter;        // 수직 해상도
    unsigned int colorsUsed;    // 사용된 색상 수
    unsigned int colorsImportant; // 중요한 색상 수
} BMPInfoHeader;
#pragma pack(pop)

Image* loadBMP(const char* filename) {
    FILE* file = fopen(filename, "rb");
    if (!file) {
        printf("파일을 열 수 없습니다: %s\n", filename);
        return NULL;
    }
    
    // 헤더 읽기
    BMPFileHeader fileHeader;
    BMPInfoHeader infoHeader;
    
    fread(&fileHeader, sizeof(BMPFileHeader), 1, file);
    fread(&infoHeader, sizeof(BMPInfoHeader), 1, file);
    
    // BMP 파일인지 확인
    if (fileHeader.type != 0x4D42) {
        printf("BMP 파일이 아닙니다!\n");
        fclose(file);
        return NULL;
    }
    
    // 24비트 BMP만 지원
    if (infoHeader.bitCount != 24) {
        printf("24비트 BMP만 지원합니다!\n");
        fclose(file);
        return NULL;
    }
    
    // 이미지 구조체 생성
    Image* img = (Image*)malloc(sizeof(Image));
    img->width = infoHeader.width;
    img->height = abs(infoHeader.height);  // 높이가 음수일 수 있음
    img->data = (Pixel*)malloc(img->width * img->height * sizeof(Pixel));
    
    // 픽셀 데이터 위치로 이동
    fseek(file, fileHeader.offset, SEEK_SET);
    
    // BMP는 행이 4바이트 단위로 정렬됨
    int rowSize = ((img->width * 3 + 3) / 4) * 4;
    unsigned char* rowData = (unsigned char*)malloc(rowSize);
    
    // 픽셀 데이터 읽기 (BMP는 아래에서 위로 저장됨)
    for (int y = img->height - 1; y >= 0; y--) {
        fread(rowData, 1, rowSize, file);
        for (int x = 0; x < img->width; x++) {
            int idx = y * img->width + x;
            // BMP는 BGR 순서로 저장됨
            img->data[idx].b = rowData[x * 3];
            img->data[idx].g = rowData[x * 3 + 1];
            img->data[idx].r = rowData[x * 3 + 2];
        }
    }
    
    free(rowData);
    fclose(file);
    return img;
}

int saveBMP(const char* filename, Image* img) {
    FILE* file = fopen(filename, "wb");
    if (!file) {
        printf("파일을 생성할 수 없습니다: %s\n", filename);
        return 0;
    }
    
    // 행 크기 계산 (4바이트 정렬)
    int rowSize = ((img->width * 3 + 3) / 4) * 4;
    int imageSize = rowSize * img->height;
    
    // 파일 헤더 작성
    BMPFileHeader fileHeader;
    fileHeader.type = 0x4D42;
    fileHeader.size = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader) + imageSize;
    fileHeader.reserved1 = 0;
    fileHeader.reserved2 = 0;
    fileHeader.offset = sizeof(BMPFileHeader) + sizeof(BMPInfoHeader);
    
    // 정보 헤더 작성
    BMPInfoHeader infoHeader;
    infoHeader.size = sizeof(BMPInfoHeader);
    infoHeader.width = img->width;
    infoHeader.height = img->height;
    infoHeader.planes = 1;
    infoHeader.bitCount = 24;
    infoHeader.compression = 0;
    infoHeader.imageSize = imageSize;
    infoHeader.xPixelsPerMeter = 2835;  // 72 DPI
    infoHeader.yPixelsPerMeter = 2835;
    infoHeader.colorsUsed = 0;
    infoHeader.colorsImportant = 0;
    
    // 헤더 쓰기
    fwrite(&fileHeader, sizeof(BMPFileHeader), 1, file);
    fwrite(&infoHeader, sizeof(BMPInfoHeader), 1, file);
    
    // 픽셀 데이터 쓰기
    unsigned char* rowData = (unsigned char*)calloc(rowSize, 1);
    
    for (int y = img->height - 1; y >= 0; y--) {
        for (int x = 0; x < img->width; x++) {
            int idx = y * img->width + x;
            rowData[x * 3] = img->data[idx].b;      // B
            rowData[x * 3 + 1] = img->data[idx].g;  // G
            rowData[x * 3 + 2] = img->data[idx].r;  // R
        }
        fwrite(rowData, 1, rowSize, file);
    }
    
    free(rowData);
    fclose(file);
    return 1;
}

void convertToGrayscale(Image* img) {
    for (int i = 0; i < img->width * img->height; i++) {
        // 가중 평균 계산
        unsigned char gray = (unsigned char)(
            0.299 * img->data[i].r +
            0.587 * img->data[i].g +
            0.114 * img->data[i].b
        );
        
        // 모든 채널에 같은 값 적용
        img->data[i].r = gray;
        img->data[i].g = gray;
        img->data[i].b = gray;
    }
}

void adjustBrightness(Image* img, int value) {
    for (int i = 0; i < img->width * img->height; i++) {
        // 각 채널에 값을 더하되, 0-255 범위를 벗어나지 않도록
        int r = img->data[i].r + value;
        int g = img->data[i].g + value;
        int b = img->data[i].b + value;
        
        // 클리핑(Clipping) - 범위 제한
        img->data[i].r = (r > 255) ? 255 : (r < 0) ? 0 : r;
        img->data[i].g = (g > 255) ? 255 : (g < 0) ? 0 : g;
        img->data[i].b = (b > 255) ? 255 : (b < 0) ? 0 : b;
    }
}

void adjustContrast(Image* img, float factor) {
    // factor > 1.0: 대비 증가
    // factor < 1.0: 대비 감소
    
    for (int i = 0; i < img->width * img->height; i++) {
        // 128을 중심으로 확대/축소
        int r = (int)((img->data[i].r - 128) * factor + 128);
        int g = (int)((img->data[i].g - 128) * factor + 128);
        int b = (int)((img->data[i].b - 128) * factor + 128);
        
        // 클리핑
        img->data[i].r = (r > 255) ? 255 : (r < 0) ? 0 : r;
        img->data[i].g = (g > 255) ? 255 : (g < 0) ? 0 : g;
        img->data[i].b = (b > 255) ? 255 : (b < 0) ? 0 : b;
    }
}

void invertImage(Image* img) {
    for (int i = 0; i < img->width * img->height; i++) {
        img->data[i].r = 255 - img->data[i].r;
        img->data[i].g = 255 - img->data[i].g;
        img->data[i].b = 255 - img->data[i].b;
    }
}

void threshold(Image* img, unsigned char thresholdValue) {
    // 먼저 그레이스케일로 변환
    convertToGrayscale(img);
    
    for (int i = 0; i < img->width * img->height; i++) {
        unsigned char value = (img->data[i].r >= thresholdValue) ? 255 : 0;
        img->data[i].r = value;
        img->data[i].g = value;
        img->data[i].b = value;
    }
}

// 커널 구조체
typedef struct {
    int size;        // 커널 크기 (예: 3, 5, 7)
    float* data;     // 커널 값들
    float divisor;   // 정규화를 위한 나눗셈 값
} Kernel;

// 3x3 커널 생성 함수
Kernel* createKernel(int size) {
    Kernel* kernel = (Kernel*)malloc(sizeof(Kernel));
    kernel->size = size;
    kernel->data = (float*)calloc(size * size, sizeof(float));
    kernel->divisor = 1.0f;
    return kernel;
}

// 컨볼루션 적용 함수
Image* applyConvolution(Image* img, Kernel* kernel) {
    Image* result = (Image*)malloc(sizeof(Image));
    result->width = img->width;
    result->height = img->height;
    result->data = (Pixel*)malloc(img->width * img->height * sizeof(Pixel));
    
    int halfSize = kernel->size / 2;
    
    for (int y = 0; y < img->height; y++) {
        for (int x = 0; x < img->width; x++) {
            float sumR = 0, sumG = 0, sumB = 0;
            
            // 커널 적용
            for (int ky = -halfSize; ky <= halfSize; ky++) {
                for (int kx = -halfSize; kx <= halfSize; kx++) {
                    int px = x + kx;
                    int py = y + ky;
                    
                    // 경계 처리
                    if (px < 0) px = 0;
                    if (px >= img->width) px = img->width - 1;
                    if (py < 0) py = 0;
                    if (py >= img->height) py = img->height - 1;
                    
                    int idx = py * img->width + px;
                    int kidx = (ky + halfSize) * kernel->size + (kx + halfSize);
                    
                    sumR += img->data[idx].r * kernel->data[kidx];
                    sumG += img->data[idx].g * kernel->data[kidx];
                    sumB += img->data[idx].b * kernel->data[kidx];
                }
            }
            
            // 정규화 및 클리핑
            int outIdx = y * img->width + x;
            int r = (int)(sumR / kernel->divisor);
            int g = (int)(sumG / kernel->divisor);
            int b = (int)(sumB / kernel->divisor);
            
            result->data[outIdx].r = (r > 255) ? 255 : (r < 0) ? 0 : r;
            result->data[outIdx].g = (g > 255) ? 255 : (g < 0) ? 0 : g;
            result->data[outIdx].b = (b > 255) ? 255 : (b < 0) ? 0 : b;
        }
    }
    
    return result;
}

// 3x3 박스 블러 커널
Kernel* createBoxBlurKernel() {
    Kernel* kernel = createKernel(3);
    
    // 모든 값을 1로 설정
    for (int i = 0; i < 9; i++) {
        kernel->data[i] = 1.0f;
    }
    
    // 평균을 내기 위해 9로 나눔
    kernel->divisor = 9.0f;
    
    return kernel;
}

// 가우시안 블러 커널 (더 자연스러운 블러)
Kernel* createGaussianBlurKernel() {
    Kernel* kernel = createKernel(3);
    
    // 가우시안 분포를 따르는 가중치
    kernel->data[0] = 1.0f;  kernel->data[1] = 2.0f;  kernel->data[2] = 1.0f;
    kernel->data[3] = 2.0f;  kernel->data[4] = 4.0f;  kernel->data[5] = 2.0f;
    kernel->data[6] = 1.0f;  kernel->data[7] = 2.0f;  kernel->data[8] = 1.0f;
    
    kernel->divisor = 16.0f;  // 모든 값의 합
    
    return kernel;
}

// 샤프닝 커널
Kernel* createSharpenKernel() {
    Kernel* kernel = createKernel(3);
    
    // 중심은 강하게, 주변은 약하게
    kernel->data[0] =  0.0f;  kernel->data[1] = -1.0f;  kernel->data[2] =  0.0f;
    kernel->data[3] = -1.0f;  kernel->data[4] =  5.0f;  kernel->data[5] = -1.0f;
    kernel->data[6] =  0.0f;  kernel->data[7] = -1.0f;  kernel->data[8] =  0.0f;
    
    kernel->divisor = 1.0f;
    
    return kernel;
}

// 더 강한 샤프닝
Kernel* createStrongSharpenKernel() {
    Kernel* kernel = createKernel(3);
    
    kernel->data[0] = -1.0f;  kernel->data[1] = -1.0f;  kernel->data[2] = -1.0f;
    kernel->data[3] = -1.0f;  kernel->data[4] =  9.0f;  kernel->data[5] = -1.0f;
    kernel->data[6] = -1.0f;  kernel->data[7] = -1.0f;  kernel->data[8] = -1.0f;
    
    kernel->divisor = 1.0f;
    
    return kernel;
}

// 소벨 X 방향 커널 (수직 엣지 검출)
Kernel* createSobelXKernel() {
    Kernel* kernel = createKernel(3);
    
    kernel->data[0] = -1.0f;  kernel->data[1] = 0.0f;  kernel->data[2] = 1.0f;
    kernel->data[3] = -2.0f;  kernel->data[4] = 0.0f;  kernel->data[5] = 2.0f;
    kernel->data[6] = -1.0f;  kernel->data[7] = 0.0f;  kernel->data[8] = 1.0f;
    
    kernel->divisor = 1.0f;
    
    return kernel;
}

// 소벨 Y 방향 커널 (수평 엣지 검출)
Kernel* createSobelYKernel() {
    Kernel* kernel = createKernel(3);
    
    kernel->data[0] = -1.0f;  kernel->data[1] = -2.0f;  kernel->data[2] = -1.0f;
    kernel->data[3] =  0.0f;  kernel->data[4] =  0.0f;  kernel->data[5] =  0.0f;
    kernel->data[6] =  1.0f;  kernel->data[7] =  2.0f;  kernel->data[8] =  1.0f;
    
    kernel->divisor = 1.0f;
    
    return kernel;
}

// 소벨 엣지 검출 적용
Image* applySobelEdgeDetection(Image* img) {
    // 먼저 그레이스케일로 변환
    convertToGrayscale(img);
    
    // X, Y 방향 커널 생성
    Kernel* sobelX = createSobelXKernel();
    Kernel* sobelY = createSobelYKernel();
    
    // 각 방향으로 컨볼루션 적용
    Image* gradX = applyConvolution(img, sobelX);
    Image* gradY = applyConvolution(img, sobelY);
    
    // 결과 이미지 생성
    Image* result = (Image*)malloc(sizeof(Image));
    result->width = img->width;
    result->height = img->height;
    result->data = (Pixel*)malloc(img->width * img->height * sizeof(Pixel));
    
    // 그래디언트 크기 계산
    for (int i = 0; i < img->width * img->height; i++) {
        float gx = gradX->data[i].r;
        float gy = gradY->data[i].r;
        
        // 그래디언트 크기 = sqrt(gx^2 + gy^2)
        int magnitude = (int)sqrt(gx * gx + gy * gy);
        
        magnitude = (magnitude > 255) ? 255 : magnitude;
        
        result->data[i].r = magnitude;
        result->data[i].g = magnitude;
        result->data[i].b = magnitude;
    }
    
    // 메모리 정리
    free(gradX->data);
    free(gradX);
    free(gradY->data);
    free(gradY);
    free(sobelX->data);
    free(sobelX);
    free(sobelY->data);
    free(sobelY);
    
    return result;
}

// 히스토그램 계산
void calculateHistogram(Image* img, int histogram[256]) {
    // 초기화
    for (int i = 0; i < 256; i++) {
        histogram[i] = 0;
    }
    
    // 그레이스케일 값 카운트
    for (int i = 0; i < img->width * img->height; i++) {
        unsigned char gray = (unsigned char)(
            0.299 * img->data[i].r +
            0.587 * img->data[i].g +
            0.114 * img->data[i].b
        );
        histogram[gray]++;
    }
}

// 히스토그램 평활화
void equalizeHistogram(Image* img) {
    int histogram[256];
    int cdf[256];  // 누적 분포 함수
    
    // 그레이스케일로 변환
    convertToGrayscale(img);
    
    // 히스토그램 계산
    calculateHistogram(img, histogram);
    
    // 누적 분포 함수 계산
    cdf[0] = histogram[0];
    for (int i = 1; i < 256; i++) {
        cdf[i] = cdf[i-1] + histogram[i];
    }
    
    // 정규화
    int totalPixels = img->width * img->height;
    int cdfMin = cdf[0];
    
    // 새로운 값 계산 및 적용
    for (int i = 0; i < totalPixels; i++) {
        unsigned char oldValue = img->data[i].r;
        unsigned char newValue = (unsigned char)(
            ((float)(cdf[oldValue] - cdfMin) / (totalPixels - cdfMin)) * 255
        );
        
        img->data[i].r = newValue;
        img->data[i].g = newValue;
        img->data[i].b = newValue;
    }
}

// 이미지 회전 (각도는 라디안)
Image* rotateImage(Image* img, float angle) {
    float cosA = cos(angle);
    float sinA = sin(angle);
    
    // 회전 후 이미지 크기 계산
    int newWidth = (int)(fabs(img->width * cosA) + fabs(img->height * sinA));
    int newHeight = (int)(fabs(img->width * sinA) + fabs(img->height * cosA));
    
    // 결과 이미지 생성
    Image* result = (Image*)malloc(sizeof(Image));
    result->width = newWidth;
    result->height = newHeight;
    result->data = (Pixel*)calloc(newWidth * newHeight, sizeof(Pixel));
    
    // 중심점 계산
    float centerX = img->width / 2.0f;
    float centerY = img->height / 2.0f;
    float newCenterX = newWidth / 2.0f;
    float newCenterY = newHeight / 2.0f;
    
    // 역변환을 사용한 회전
    for (int y = 0; y < newHeight; y++) {
        for (int x = 0; x < newWidth; x++) {
            // 새 좌표를 중심 기준으로 변환
            float dx = x - newCenterX;
            float dy = y - newCenterY;
            
            // 역회전 적용
            float srcX = dx * cosA + dy * sinA + centerX;
            float srcY = -dx * sinA + dy * cosA + centerY;
            
            // 원본 이미지 범위 내에 있는지 확인
            if (srcX >= 0 && srcX < img->width - 1 &&
                srcY >= 0 && srcY < img->height - 1) {
                
                // 바이리니어 보간
                int x0 = (int)srcX;
                int y0 = (int)srcY;
                int x1 = x0 + 1;
                int y1 = y0 + 1;
                
                float fx = srcX - x0;
                float fy = srcY - y0;
                
                int idx00 = y0 * img->width + x0;
                int idx01 = y0 * img->width + x1;
                int idx10 = y1 * img->width + x0;
                int idx11 = y1 * img->width + x1;
                
                int outIdx = y * newWidth + x;
                
                // 각 채널에 대해 보간
                result->data[outIdx].r = (unsigned char)(
                    (1 - fx) * (1 - fy) * img->data[idx00].r +
                    fx * (1 - fy) * img->data[idx01].r +
                    (1 - fx) * fy * img->data[idx10].r +
                    fx * fy * img->data[idx11].r
                );
                
                result->data[outIdx].g = (unsigned char)(
                    (1 - fx) * (1 - fy) * img->data[idx00].g +
                    fx * (1 - fy) * img->data[idx01].g +
                    (1 - fx) * fy * img->data[idx10].g +
                    fx * fy * img->data[idx11].g
                );
                
                result->data[outIdx].b = (unsigned char)(
                    (1 - fx) * (1 - fy) * img->data[idx00].b +
                    fx * (1 - fy) * img->data[idx01].b +
                    (1 - fx) * fy * img->data[idx10].b +
                    fx * fy * img->data[idx11].b
                );
            }
        }
    }
    
    return result;
}

// 바이리니어 보간을 사용한 이미지 크기 조절
Image* resizeImage(Image* img, int newWidth, int newHeight) {
    Image* result = (Image*)malloc(sizeof(Image));
    result->width = newWidth;
    result->height = newHeight;
    result->data = (Pixel*)malloc(newWidth * newHeight * sizeof(Pixel));
    
    float xRatio = (float)img->width / newWidth;
    float yRatio = (float)img->height / newHeight;
    
    for (int y = 0; y < newHeight; y++) {
        for (int x = 0; x < newWidth; x++) {
            float srcX = x * xRatio;
            float srcY = y * yRatio;
            
            int x0 = (int)srcX;
            int y0 = (int)srcY;
            int x1 = (x0 + 1 < img->width) ? x0 + 1 : x0;
            int y1 = (y0 + 1 < img->height) ? y0 + 1 : y0;
            
            float fx = srcX - x0;
            float fy = srcY - y0;
            
            int idx00 = y0 * img->width + x0;
            int idx01 = y0 * img->width + x1;
            int idx10 = y1 * img->width + x0;
            int idx11 = y1 * img->width + x1;
            
            int outIdx = y * newWidth + x;
            
            result->data[outIdx].r = (unsigned char)(
                (1 - fx) * (1 - fy) * img->data[idx00].r +
                fx * (1 - fy) * img->data[idx01].r +
                (1 - fx) * fy * img->data[idx10].r +
                fx * fy * img->data[idx11].r
            );
            
            result->data[outIdx].g = (unsigned char)(
                (1 - fx) * (1 - fy) * img->data[idx00].g +
                fx * (1 - fy) * img->data[idx01].g +
                (1 - fx) * fy * img->data[idx10].g +
                fx * fy * img->data[idx11].g
            );
            
            result->data[outIdx].b = (unsigned char)(
                (1 - fx) * (1 - fy) * img->data[idx00].b +
                fx * (1 - fy) * img->data[idx01].b +
                (1 - fx) * fy * img->data[idx10].b +
                fx * fy * img->data[idx11].b
            );
        }
    }
    
    return result;
}

// 간단한 코너 검출 (해리스 알고리즘 간소화 버전)
typedef struct {
    int x;
    int y;
    float response;
} Corner;

Corner* detectCorners(Image* img, int* numCorners, float threshold) {
    // 그레이스케일로 변환
    convertToGrayscale(img);
    
    // 그래디언트 계산
    Kernel* sobelX = createSobelXKernel();
    Kernel* sobelY = createSobelYKernel();
    
    Image* gradX = applyConvolution(img, sobelX);
    Image* gradY = applyConvolution(img, sobelY);
    
    // 코너 응답 계산
    float* cornerResponse = (float*)malloc(img->width * img->height * sizeof(float));
    
    for (int y = 1; y < img->height - 1; y++) {
        for (int x = 1; x < img->width - 1; x++) {
            int idx = y * img->width + x;
            
            // 구조 텐서 계산 (3x3 윈도우)
            float Ixx = 0, Iyy = 0, Ixy = 0;
            
            for (int dy = -1; dy <= 1; dy++) {
                for (int dx = -1; dx <= 1; dx++) {
                    int nidx = (y + dy) * img->width + (x + dx);
                    float gx = gradX->data[nidx].r;
                    float gy = gradY->data[nidx].r;
                    
                    Ixx += gx * gx;
                    Iyy += gy * gy;
                    Ixy += gx * gy;
                }
            }
            
            // 해리스 응답 계산
            float det = Ixx * Iyy - Ixy * Ixy;
            float trace = Ixx + Iyy;
            float k = 0.04f;
            
            cornerResponse[idx] = det - k * trace * trace;
        }
    }
    
    // 임계값보다 큰 응답을 가진 점들을 코너로 선택
    Corner* corners = (Corner*)malloc(img->width * img->height * sizeof(Corner));
    *numCorners = 0;
    
    for (int y = 1; y < img->height - 1; y++) {
        for (int x = 1; x < img->width - 1; x++) {
            int idx = y * img->width + x;
            
            if (cornerResponse[idx] > threshold) {
                // 비최대 억제 (주변보다 큰 값만 선택)
                int isMax = 1;
                for (int dy = -1; dy <= 1 && isMax; dy++) {
                    for (int dx = -1; dx <= 1 && isMax; dx++) {
                        if (dx == 0 && dy == 0) continue;
                        int nidx = (y + dy) * img->width + (x + dx);
                        if (cornerResponse[nidx] > cornerResponse[idx]) {
                            isMax = 0;
                        }
                    }
                }
                
                if (isMax) {
                    corners[*numCorners].x = x;
                    corners[*numCorners].y = y;
                    corners[*numCorners].response = cornerResponse[idx];
                    (*numCorners)++;
                }
            }
        }
    }
    
    // 메모리 정리
    free(cornerResponse);
    free(gradX->data);
    free(gradX);
    free(gradY->data);
    free(gradY);
    free(sobelX->data);
    free(sobelX);
    free(sobelY->data);
    free(sobelY);
    
    return corners;
}

// LoG (Laplacian of Gaussian) 커널 생성
Kernel* createLoGKernel(int size, float sigma) {
    Kernel* kernel = createKernel(size);
    int halfSize = size / 2;
    float sum = 0;
    
    for (int y = -halfSize; y <= halfSize; y++) {
        for (int x = -halfSize; x <= halfSize; x++) {
            int idx = (y + halfSize) * size + (x + halfSize);
            float r2 = x * x + y * y;
            float sigma2 = sigma * sigma;
            
            // LoG 공식
            kernel->data[idx] = -1.0f / (M_PI * sigma2 * sigma2) *
                               (1 - r2 / (2 * sigma2)) *
                               exp(-r2 / (2 * sigma2));
            
            sum += kernel->data[idx];
        }
    }
    
    // 정규화 (합이 0이 되도록)
    for (int i = 0; i < size * size; i++) {
        kernel->data[i] -= sum / (size * size);
    }
    
    kernel->divisor = 1.0f;
    return kernel;
}

// 블롭 검출
Image* detectBlobs(Image* img, float sigma) {
    convertToGrayscale(img);
    
    int kernelSize = (int)(6 * sigma) | 1;  // 홀수로 만들기
    Kernel* logKernel = createLoGKernel(kernelSize, sigma);
    
    Image* result = applyConvolution(img, logKernel);
    
    // 절댓값 취하고 정규화
    for (int i = 0; i < result->width * result->height; i++) {
        int value = abs((int)result->data[i].r - 128);
        value = (value > 255) ? 255 : value;
        
        result->data[i].r = value;
        result->data[i].g = value;
        result->data[i].b = value;
    }
    
    free(logKernel->data);
    free(logKernel);
    
    return result;
}

// 간단한 연결 요소 레이블링 (4-연결성)
int* labelConnectedComponents(Image* img, int* numComponents) {
    int* labels = (int*)calloc(img->width * img->height, sizeof(int));
    int currentLabel = 1;
    
    // 이진화 (임계값 128)
    for (int i = 0; i < img->width * img->height; i++) {
        if (img->data[i].r > 128) {
            labels[i] = -1;  // 전경 픽셀 표시
        }
    }
    
    // 플러드 필 방식으로 레이블링
    for (int y = 0; y < img->height; y++) {
        for (int x = 0; x < img->width; x++) {
            int idx = y * img->width + x;
            
            if (labels[idx] == -1) {
                // 새로운 컴포넌트 발견
                floodFill(labels, img->width, img->height, x, y, currentLabel);
                currentLabel++;
            }
        }
    }
    
    *numComponents = currentLabel - 1;
    return labels;
}

// 플러드 필 헬퍼 함수
void floodFill(int* labels, int width, int height, int x, int y, int label) {
    // 스택 기반 플러드 필 (재귀 대신)
    int* stackX = (int*)malloc(width * height * sizeof(int));
    int* stackY = (int*)malloc(width * height * sizeof(int));
    int stackSize = 0;
    
    stackX[stackSize] = x;
    stackY[stackSize] = y;
    stackSize++;
    
    while (stackSize > 0) {
        stackSize--;
        int cx = stackX[stackSize];
        int cy = stackY[stackSize];
        int idx = cy * width + cx;
        
        if (cx < 0 || cx >= width || cy < 0 || cy >= height) continue;
        if (labels[idx] != -1) continue;
        
        labels[idx] = label;
        
        // 4방향 이웃 추가
        stackX[stackSize] = cx + 1; stackY[stackSize] = cy; stackSize++;
        stackX[stackSize] = cx - 1; stackY[stackSize] = cy; stackSize++;
        stackX[stackSize] = cx; stackY[stackSize] = cy + 1; stackSize++;
        stackX[stackSize] = cx; stackY[stackSize] = cy - 1; stackSize++;
    }
    
    free(stackX);
    free(stackY);
}

// 이미지 메모리 해제 함수
void freeImage(Image* img) {
    if (img) {
        if (img->data) {
            free(img->data);
        }
        free(img);
    }
}

// 커널 메모리 해제 함수
void freeKernel(Kernel* kernel) {
    if (kernel) {
        if (kernel->data) {
            free(kernel->data);
        }
        free(kernel);
    }
}

// 사용 예시
int main() {
    Image* img = loadBMP("input.bmp");
    if (!img) return 1;
    
    // 이미지 처리
    convertToGrayscale(img);
    
    Kernel* blurKernel = createGaussianBlurKernel();
    Image* blurred = applyConvolution(img, blurKernel);
    
    saveBMP("output.bmp", blurred);
    
    // 메모리 정리 - 중요!
    freeImage(img);
    freeImage(blurred);
    freeKernel(blurKernel);
    
    return 0;
}

// 나쁜 예 - 열 우선 접근
void badExample(Image* img) {
    for (int x = 0; x < img->width; x++) {
        for (int y = 0; y < img->height; y++) {
            int idx = y * img->width + x;  // 메모리 점프!
            img->data[idx].r = 0;
        }
    }
}

// 좋은 예 - 행 우선 접근
void goodExample(Image* img) {
    for (int y = 0; y < img->height; y++) {
        for (int x = 0; x < img->width; x++) {
            int idx = y * img->width + x;  // 순차적 접근!
            img->data[idx].r = 0;
        }
    }
}

#include <emmintrin.h>  // SSE2

// SIMD를 사용한 밝기 조절 (SSE2)
void adjustBrightnessSIMD(Image* img, int value) {
    int totalPixels = img->width * img->height;
    unsigned char* data = (unsigned char*)img->data;
    
    // 16바이트씩 처리 (RGB 픽셀 5개 + 1바이트)
    int simdCount = (totalPixels * 3) / 16;
    
    __m128i addValue = _mm_set1_epi8(value);
    
    for (int i = 0; i < simdCount; i++) {
        __m128i pixels = _mm_loadu_si128((__m128i*)(data + i * 16));
        
        // 부호 있는 덧셈 후 포화 연산
        if (value >= 0) {
            pixels = _mm_adds_epu8(pixels, addValue);
        } else {
            pixels = _mm_subs_epu8(pixels, addValue);
        }
        
        _mm_storeu_si128((__m128i*)(data + i * 16), pixels);
    }
    
    // 나머지 픽셀 처리
    for (int i = simdCount * 16; i < totalPixels * 3; i++) {
        int newValue = data[i] + value;
        data[i] = (newValue > 255) ? 255 : (newValue < 0) ? 0 : newValue;
    }
}

#include <omp.h>

// OpenMP를 사용한 병렬 처리
void convertToGrayscaleParallel(Image* img) {
    int totalPixels = img->width * img->height;
    
    #pragma omp parallel for
    for (int i = 0; i < totalPixels; i++) {
        unsigned char gray = (unsigned char)(
            0.299 * img->data[i].r +
            0.587 * img->data[i].g +
            0.114 * img->data[i].b
        );
        
        img->data[i].r = gray;
        img->data[i].g = gray;
        img->data[i].b = gray;
    }
}

// 컨볼루션도 병렬화 가능
Image* applyConvolutionParallel(Image* img, Kernel* kernel) {
    Image* result = (Image*)malloc(sizeof(Image));
    result->width = img->width;
    result->height = img->height;
    result->data = (Pixel*)malloc(img->width * img->height * sizeof(Pixel));
    
    int halfSize = kernel->size / 2;
    
    #pragma omp parallel for collapse(2)
    for (int y = 0; y < img->height; y++) {
        for (int x = 0; x < img->width; x++) {
            float sumR = 0, sumG = 0, sumB = 0;
            
            for (int ky = -halfSize; ky <= halfSize; ky++) {
                for (int kx = -halfSize; kx <= halfSize; kx++) {
                    int px = x + kx;
                    int py = y + ky;
                    
                    if (px < 0) px = 0;
                    if (px >= img->width) px = img->width - 1;
                    if (py < 0) py = 0;
                    if (py >= img->height) py = img->height - 1;
                    
                    int idx = py * img->width + px;
                    int kidx = (ky + halfSize) * kernel->size + (kx + halfSize);
                    
                    sumR += img->data[idx].r * kernel->data[kidx];
                    sumG += img->data[idx].g * kernel->data[kidx];
                    sumB += img->data[idx].b * kernel->data[kidx];
                }
            }
            
            int outIdx = y * img->width + x;
            int r = (int)(sumR / kernel->divisor);
            int g = (int)(sumG / kernel->divisor);
            int b = (int)(sumB / kernel->divisor);
            
            result->data[outIdx].r = (r > 255) ? 255 : (r < 0) ? 0 : r;
            result->data[outIdx].g = (g > 255) ? 255 : (g < 0) ? 0 : g;
            result->data[outIdx].b = (b > 255) ? 255 : (b < 0) ? 0 : b;
        }
    }
    
    return result;
}

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

// 앞에서 정의한 모든 구조체와 함수들이 포함되어 있다고 가정

void printUsage() {
    printf("사용법: imageproc [옵션] 입력파일 출력파일\n");
    printf("옵션:\n");
    printf("  -gray          그레이스케일 변환\n");
    printf("  -bright N      밝기 조절 (N: -255 ~ 255)\n");
    printf("  -contrast F    대비 조절 (F: 0.0 ~ 3.0)\n");
    printf("  -invert        색상 반전\n");
    printf("  -blur          가우시안 블러\n");
    printf("  -sharpen       샤프닝\n");
    printf("  -edge          엣지 검출 (소벨)\n");
    printf("  -threshold N   임계값 처리 (N: 0 ~ 255)\n");
    printf("  -rotate A      회전 (A: 각도)\n");
    printf("  -resize WxH    크기 조절 (예: 800x600)\n");
}

int main(int argc, char* argv[]) {
    if (argc < 4) {
        printUsage();
        return 1;
    }
    
    char* option = argv[1];
    char* inputFile = argv[2];
    char* outputFile = argv[3];
    
    // 이미지 로드
    printf("이미지 로딩 중: %s\n", inputFile);
    Image* img = loadBMP(inputFile);
    if (!img) {
        printf("이미지를 로드할 수 없습니다!\n");
        return 1;
    }
    
    printf("이미지 크기: %dx%d\n", img->width, img->height);
    
    // 옵션에 따라 처리
    if (strcmp(option, "-gray") == 0) {
        printf("그레이스케일 변환 중...\n");
        convertToGrayscale(img);
    }
    else if (strcmp(option, "-bright") == 0) {
        if (argc < 5) {
            printf("밝기 값을 지정해주세요!\n");
            freeImage(img);
            return 1;
        }
        int value = atoi(argv[4]);
        printf("밝기 조절 중 (값: %d)...\n", value);
        adjustBrightness(img, value);
    }
    else if (strcmp(option, "-contrast") == 0) {
        if (argc < 5) {
            printf("대비 값을 지정해주세요!\n");
            freeImage(img);
            return 1;
        }
        float factor = atof(argv[4]);
        printf("대비 조절 중 (배율: %.2f)...\n", factor);
        adjustContrast(img, factor);
    }
    else if (strcmp(option, "-invert") == 0) {
        printf("색상 반전 중...\n");
        invertImage(img);
    }
    else if (strcmp(option, "-blur") == 0) {
        printf("블러 적용 중...\n");
        Kernel* kernel = createGaussianBlurKernel();
        Image* result = applyConvolution(img, kernel);
        freeImage(img);
        img = result;
        freeKernel(kernel);
    }
    else if (strcmp(option, "-sharpen") == 0) {
        printf("샤프닝 적용 중...\n");
        Kernel* kernel = createSharpenKernel();
        Image* result = applyConvolution(img, kernel);
        freeImage(img);
        img = result;
        freeKernel(kernel);
    }
    else if (strcmp(option, "-edge") == 0) {
        printf("엣지 검출 중...\n");
        Image* result = applySobelEdgeDetection(img);
        freeImage(img);
        img = result;
    }
    else if (strcmp(option, "-threshold") == 0) {
        if (argc < 5) {
            printf("임계값을 지정해주세요!\n");
            freeImage(img);
            return 1;
        }
        unsigned char value = (unsigned char)atoi(argv[4]);
        printf("임계값 처리 중 (값: %d)...\n", value);
        threshold(img, value);
    }
    else if (strcmp(option, "-rotate") == 0) {
        if (argc < 5) {
            printf("회전 각도를 지정해주세요!\n");
            freeImage(img);
            return 1;
        }
        float angle = atof(argv[4]) * M_PI / 180.0f;  // 도를 라디안으로
        printf("회전 중 (각도: %.1f도)...\n", atof(argv[4]));
        Image* result = rotateImage(img, angle);
        freeImage(img);
        img = result;
    }
    else if (strcmp(option, "-resize") == 0) {
        if (argc < 5) {
            printf("크기를 지정해주세요! (예: 800x600)\n");
            freeImage(img);
            return 1;
        }
        int newWidth, newHeight;
        sscanf(argv[4], "%dx%d", &newWidth, &newHeight);
        printf("크기 조절 중 (%dx%d)...\n", newWidth, newHeight);
        Image* result = resizeImage(img, newWidth, newHeight);
        freeImage(img);
        img = result;
    }
    else {
        printf("알 수 없는 옵션: %s\n", option);
        printUsage();
        freeImage(img);
        return 1;
    }
    
    // 결과 저장
    printf("결과 저장 중: %s\n", outputFile);
    if (saveBMP(outputFile, img)) {
        printf("완료!\n");
    } else {
        printf("저장 실패!\n");
    }
    
    freeImage(img);
    return 0;
}

# 그레이스케일 변환
./imageproc -gray input.bmp output.bmp

# 밝기 50 증가
./imageproc -bright 50 input.bmp output.bmp

# 블러 적용
./imageproc -blur input.bmp output.bmp

# 엣지 검출
./imageproc -edge input.bmp output.bmp

# 45도 회전
./imageproc -rotate 45 input.bmp output.bmp

# 800x600으로 크기 조절
./imageproc -resize 800x600 input.bmp output.bmp

#!/bin/bash
# batch_process.sh

if [ $# -lt 2 ]; then
    echo "사용법: $0 [옵션] [입력디렉토리]"
    exit 1
fi

OPTION=$1
INPUT_DIR=$2
OUTPUT_DIR="${INPUT_DIR}_processed"

mkdir -p "$OUTPUT_DIR"

for file in "$INPUT_DIR"/*.bmp; do
    filename=$(basename "$file")
    echo "처리 중: $filename"
    ./imageproc $OPTION "$file" "$OUTPUT_DIR/$filename"
done

echo "모든 파일 처리 완료!"

#include <opencv2/opencv.hpp>

using namespace cv;

int main() {
    // 이미지 로드
    Mat img = imread("input.jpg");
    
    // 그레이스케일 변환
    Mat gray;
    cvtColor(img, gray, COLOR_BGR2GRAY);
    
    // 가우시안 블러
    Mat blurred;
    GaussianBlur(gray, blurred, Size(5, 5), 1.5);
    
    // 캐니 엣지 검출
    Mat edges;
    Canny(blurred, edges, 50, 150);
    
    // 결과 저장
    imwrite("output.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* data = stbi_load("input.jpg", &width, &height, &channels, 0);
    
    if (data) {
        printf("이미지 크기: %dx%d, 채널: %d\n", width, height, channels);
        
        // 이미지 처리...
        
        // PNG로 저장
        stbi_write_png("output.png", width, height, channels, data, width * channels);
        
        // 메모리 해제
        stbi_image_free(data);
    }
    
    return 0;
}