www.pudn.com > segmentaion.rar > Source1.cpp

#include "stdafx.h" 
#include  
#include  
 
using namespace System::Drawing; 
using namespace System::Drawing::Imaging; 
 
typedef std::pair MyPoint; 
typedef std::vector MyPointVec; 
typedef int GrayLevel; 
 
// Make kernel by radius 
MyPointVec makeKernel(const int&); 
// Process erosion 
Bitmap^ erosion(Bitmap^, const MyPointVec%);  
// Get min gray level by kernel 
GrayLevel getMinByKernel(Bitmap^, const MyPointVec%, const MyPoint%); 
// Get gray level from Color object 
GrayLevel getGrayLevelFromColor(Color^); 
 
int main() { 
  // Read image from lena.jpg 
  Bitmap^ image = gcnew Bitmap("lena.jpg"); 
  const int radius = 2; 
  // Make kernel by radius 
  MyPointVec kernel = makeKernel(radius); 
  // New eroded image 
  Bitmap^ newImage = erosion(image, kernel); 
  // Save new eroded image to disk 
  newImage->Save("GrayscaleErodedLena.jpg"); 
 
  return 0; 
} 
 
// Make kernel by radius 
MyPointVec makeKernel(const int& radius) { 
  MyPointVec kernel; 
 
  if (radius == 0) { 
    kernel.push_back(std::make_pair(0,0)); 
  } 
  else if (radius == 1) { 
    //   * 
    //  *** 
    //   * 
    kernel.push_back(std::make_pair(0,0)); 
    kernel.push_back(std::make_pair(1,0)); 
    kernel.push_back(std::make_pair(0,1)); 
    kernel.push_back(std::make_pair(-1,0)); 
    kernel.push_back(std::make_pair(0,-1)); 
  } 
  else { 
    kernel.push_back(std::make_pair(-1,2)); 
    kernel.push_back(std::make_pair(0,2)); 
    kernel.push_back(std::make_pair(1,2)); 
 
    kernel.push_back(std::make_pair(-2,1)); 
    kernel.push_back(std::make_pair(-1,1)); 
    kernel.push_back(std::make_pair(0,1)); 
    kernel.push_back(std::make_pair(1,1)); 
    kernel.push_back(std::make_pair(2,1)); 
 
    kernel.push_back(std::make_pair(-2,0)); 
    kernel.push_back(std::make_pair(-1,0)); 
    kernel.push_back(std::make_pair(0,0)); 
    kernel.push_back(std::make_pair(1,0)); 
    kernel.push_back(std::make_pair(2,0)); 
 
    kernel.push_back(std::make_pair(-2,-1)); 
    kernel.push_back(std::make_pair(-1,-1)); 
    kernel.push_back(std::make_pair(0,-1)); 
    kernel.push_back(std::make_pair(1,-1)); 
    kernel.push_back(std::make_pair(2,-1)); 
 
    kernel.push_back(std::make_pair(-1,-2)); 
    kernel.push_back(std::make_pair(0,-2)); 
    kernel.push_back(std::make_pair(1,-2)); 
  } 
 
  return kernel; 
} 
 
// Process erosion  
Bitmap^ erosion(Bitmap^ image, const MyPointVec% kernel) { 
  // New dilated image 
  Bitmap^ newImage = gcnew Bitmap(image->Width, image->Height); 
  for(int x = 0; x != image->Width; ++x) { 
    for(int y = 0; y != image->Height; ++y) { 
      // Get max gray level by kernel 
      GrayLevel gray = getMinByKernel(image, kernel, std::make_pair(x,y)); 
      // Set max gray level to new dilated image 
      newImage->SetPixel(x, y, Color::FromArgb(gray, gray, gray)); 
    } 
  } 
 
  return newImage; 
} 
 
// Get min gray level by kernel 
GrayLevel getMinByKernel(Bitmap^ image, const MyPointVec% kernel, const MyPoint% point) { 
  typedef std::vector NeighborColor; 
  NeighborColor neighborColor; 
 
  // C++/CLI's new for each syntax 
  for each (MyPoint kpoint in kernel) { 
    int x = point.first + kpoint.first; 
    int y = point.second + kpoint.second; 
    if (x >= 0 && x < image->Width) { 
      if (y >= 0 && y < image->Height) { 
        GrayLevel gray = getGrayLevelFromColor(image->GetPixel(x, y)); 
        // push_back new gray level to vector 
        neighborColor.push_back(gray); 
      } 
    } 
  } 
 
  // Use STL min_element() algorithm to get max gray level 
  NeighborColor::iterator minIter = min_element(neighborColor.begin(), neighborColor.end()); 
 
  return *minIter; 
} 
 
// Get gray level from Color object 
GrayLevel getGrayLevelFromColor(Color^ color) { 
  return (color->R + color->G + color->B) /3; 
}