每天进步一点点------如何实现Sobel Edge Detector? (Image Processing) (C/C++)

使用C與C++/CLI實現Sobel Edge Detector。

http://www.cnblogs.com/oomusou/archive/2008/07/23/sobel_edge_detector.html

 /*
 (C) OOMusou 2007 http://oomusou.cnblogs.com

 Filename    : sobel_edge.c
 Compiler    : Visual C++ 8.0
 Description : Demo the how to use sobel detector on gray level image
 Release     : 07/23/2008 1.0
 */
 #include <stdio.h>
 #include <stdlib.h>
 #include <math.h>

 #define MASK_N 2
 #define MASK_X 3
 #define MASK_Y 3
 #define WHITE  255
 #define BLACK  0

 unsigned char *image_s = NULL;     // source image array
 unsigned char *image_t = NULL;     // target image array
 FILE *fp_s = NULL;                 // source file handler
 FILE *fp_t = NULL;                 // target file handler

 unsigned int   width, height;      // image width, image height
 unsigned int   rgb_raw_data_offset;// RGB raw data offset
 unsigned char  bit_per_pixel;      // bit per pixel
 unsigned short byte_per_pixel;     // byte per pixel

 // bitmap header
 unsigned char header[] = {
   0x42,        // identity : B
   0x4d,        // identity : M
   , , , ,  // file size
   , ,        // reserved1
   , ,        // reserved2
   , , , , // RGB data offset
   , , , , // struct BITMAPINFOHEADER size
   , , , ,  // bmp width
   , , , ,  // bmp height
   , ,        // planes
   , ,       // bit per pixel
   , , , ,  // compression
   , , , ,  // data size
   , , , ,  // h resolution
   , , , ,  // v resolution
   , , , ,  // used colors
   , , ,    // important colors
 };

 // sobel mask
 int mask[MASK_N][MASK_X][MASK_Y] = {
   {{-,-,-},
    { , , },
    { , , }},

   {{-, , },
    {-, , },
    {-, , }}
 };

 int read_bmp(const char *fname_s) {
   fp_s = fopen(fname_s, "rb");
   if (fp_s == NULL) {
     printf("fopen fp_s error\n");
     return -;
   }

   // move offset to 10 to find rgb raw data offset
   fseek(fp_s, , SEEK_SET);
   fread(&rgb_raw_data_offset, sizeof(unsigned int), , fp_s);

   // move offset to 18 to get width & height;
   fseek(fp_s, , SEEK_SET);
   fread(&width,  sizeof(unsigned int), , fp_s);
   fread(&height, sizeof(unsigned int), , fp_s);

   // get bit per pixel
   fseek(fp_s, , SEEK_SET);
   fread(&bit_per_pixel, sizeof(unsigned short), , fp_s);
   byte_per_pixel = bit_per_pixel / ;

   // move offset to rgb_raw_data_offset to get RGB raw data
   fseek(fp_s, rgb_raw_data_offset, SEEK_SET);

   image_s = (unsigned char *)malloc((size_t)width * height * byte_per_pixel);
   if (image_s == NULL) {
     printf("malloc images_s error\n");
     return -;
   }

   image_t = (unsigned char *)malloc((size_t)width * height * byte_per_pixel);
   if (image_t == NULL) {
     printf("malloc image_t error\n");
     return -;
   }

   fread(image_s, sizeof(unsigned char), (size_t)(long)width * height * byte_per_pixel, fp_s);

   return ;
 }

 // convert RGB to gray level int
 int color_to_int(int r, int g, int b) {
   return (r + g + b) / ;
 }

 int sobel(double threshold) {
   unsigned int  x, y, i, v, u;             // for loop counter
   unsigned char R, G, B;         // color of R, G, B
   double val[MASK_N] = {0.0};
   int adjustX, adjustY, xBound, yBound;
   double total;

   for(y = ; y != height; ++y) {
     for(x = ; x != width; ++x) {
       for(i = ; i != MASK_N; ++i) {
         adjustX = (MASK_X % ) ?  : ;
                 adjustY = (MASK_Y % ) ?  : ;
                 xBound = MASK_X / ;
                 yBound = MASK_Y / ;

         val[i] = 0.0;
         for(v = -yBound; v != yBound + adjustY; ++v) {
                     for (u = -xBound; u != xBound + adjustX; ++u) {
             if (x + u >=  && x + u < width && y + v >=  && y + v < height) {
               R = *(image_s + byte_per_pixel * (width * (y+v) + (x+u)) + );
               G = *(image_s + byte_per_pixel * (width * (y+v) + (x+u)) + );
               B = *(image_s + byte_per_pixel * (width * (y+v) + (x+u)) + );

                   val[i] +=    color_to_int(R, G, B) * mask[i][u + xBound][v + yBound];
             }
                     }
         }
       }

       total = 0.0;
       for (i = ; i != MASK_N; ++i) {
               total += val[i] * val[i];
       }

           total = sqrt(total);

       if (total - threshold >= ) {
         // black
         *(image_t + byte_per_pixel * (width * y + x) + ) = BLACK;
         *(image_t + byte_per_pixel * (width * y + x) + ) = BLACK;
         *(image_t + byte_per_pixel * (width * y + x) + ) = BLACK;
       }
             else {
               // white
         *(image_t + byte_per_pixel * (width * y + x) + ) = WHITE;
         *(image_t + byte_per_pixel * (width * y + x) + ) = WHITE;
         *(image_t + byte_per_pixel * (width * y + x) + ) = WHITE;
       }
     }
   }

   return ;
 }

 int write_bmp(const char *fname_t) {
   unsigned int file_size; // file size

   fp_t = fopen(fname_t, "wb");
   if (fp_t == NULL) {
     printf("fopen fname_t error\n");
     return -;
   }

   // file size
   file_size = width * height * byte_per_pixel + rgb_raw_data_offset;
   header[] = (unsigned char)(file_size & 0x000000ff);
   header[] = (file_size >> )  & 0x000000ff;
   header[] = (file_size >> ) & 0x000000ff;
   header[] = (file_size >> ) & 0x000000ff;

   // width
   header[] = width & 0x000000ff;
   header[] = (width >> )  & 0x000000ff;
   header[] = (width >> ) & 0x000000ff;
   header[] = (width >> ) & 0x000000ff;

   // height
   header[] = height &0x000000ff;
   header[] = (height >> )  & 0x000000ff;
   header[] = (height >> ) & 0x000000ff;
   header[] = (height >> ) & 0x000000ff;

   // bit per pixel
   header[] = bit_per_pixel;

   // write header
   fwrite(header, sizeof(unsigned char), rgb_raw_data_offset, fp_t);

   // write image
   fwrite(image_t, sizeof(unsigned char), (size_t)(long)width * height * byte_per_pixel, fp_t);

   fclose(fp_s);
   fclose(fp_t);

   return ;
 }

 int main() {
   read_bmp("lena.bmp"); // 24 bit gray level image
   sobel(90.0);
   write_bmp("lena_sobel.bmp");
 }

 /*
 (C) OOMusou 2007 http://oomusou.cnblogs.com

 Filename    : sobel_edge.cpp
 Compiler    : C++/CLI / Visual C++ 8.0
 Description : Demo the how to use sobel detector on gray level image
 Release     : 07/23/2008 1.0
 */

 #include "stdafx.h"
 #include <cmath>

 using namespace System::Drawing;
 using namespace System::Drawing::Imaging;

 const int MASK_N = ;
 const int MASK_X = ;
 const int MASK_Y = ;

 // Convert RGB to gray level int
 int colorToInt(Color %color) {
   return (color.R + color.G + color.B) / ;
 }

 void edgeDetector(Bitmap^ oriImg, Bitmap^ resImg, const int mask[MASK_N][MASK_X][MASK_Y], const double &threshold) {
   double val[MASK_N] = {0.0};

   for(int y = ; y != oriImg->Height; ++y) {
     for(int x = ; x != oriImg->Width; ++x) {
       for(int i = ; i != MASK_N; ++i) {
         int adjustX = (MASK_X % ) ?  : ;
                 int adjustY = (MASK_Y % ) ?  : ;
                 int xBound = MASK_X / ;
                 int yBound = MASK_Y / ;

         val[i] = 0.0;
         for(int v = -yBound; v != yBound + adjustY; ++v) {
                     for (int u = -xBound; u != xBound + adjustX; ++u) {
             if (x + u >=  && x + u < oriImg->Width && y + v >=  && y + v < oriImg->Height) {
                           val[i] +=    colorToInt(oriImg->GetPixel(x + u, y + v)) * mask[i][u + xBound][v + yBound];
             }
                     }
         }
       }

       double total = 0.0;
       for (int i = ; i != MASK_N; ++i) {
               total += val[i] * val[i];
       }

           total = sqrt(total);

       if (total - threshold >= )
         resImg->SetPixel(x , y, Color::Black);
             else
         resImg->SetPixel(x, y, Color::White);
     }
   }
 }

 int main() {
   const int mask[MASK_N][MASK_X][MASK_Y] = {
               {{-,-,-},
               { , , },
               { , , }},

               {{-, , },
               {-, , },
               {-, , }}
   };

   Bitmap^ oriImg = gcnew Bitmap("lena.bmp");
   Bitmap^ resImg = gcnew Bitmap(oriImg->Width, oriImg->Height);

   const double threshold = 90.0;
   edgeDetector(oriImg, resImg, mask, threshold);

   resImg->Save("lena_sobel.bmp");

   return ;
 }