CHAPTER 5 OpenCV

Document Sample
CHAPTER 5 OpenCV Powered By Docstoc
					   Ơ
   Ư

 ổ




             cvSmooth()
         void cvSmooth(
                  const CvArr* src,
                  CvArr* dst,
                  int smoothtype = CV_GAUSSIAN,
                  int param1 = 3,
                  int param2 = 0,
                  double param3 = 0,
                  double param4 = 0
         );
src và dst                                              cv_Smooth()


                                       smooth type
                                                     src và dst
                         CV_BLUR




                                                  CV_BLUR_NO_SCALE




                          IPL_DEPTH_16S (CV_16S) hay IPL_DEPTH_32S
(CV_32S)




           CV_MEDIAN




                       CV_GAUSSIAN
       nx    
x        1.0.30  0.80 , nx  param1
       2     
      n      
 y   y  1.0.30  0.80, n y  param2
       2     
             
                                     cvErode() và cvDilate()
void cvErode(
          IplImage* src,
          IplImage* dst,
          IplConvKernel* B = NULL,
          int iterations = 1
);
       void cvDilate(
                 IplImage* src,
                 IplImage* dst,
                 IplConvKernel* B = NULL,
                 int iterations = 1
       );
  cvErode() và cvDilate()
                                            NULL
NULL




                            cvErode()
erode( x, y )            min              src ( x  x \ , y  y ' )
                   ( x , y )ker nel
                      \   \



dilate( x, y )           max              src ( x  x \ , y  y ' )
                   ( x \ , y \ )ker nel




                       IplConvKernel
cvCreateStructuringElementEx() và                                      cvReleaseStructuringElement()
        IplConvKernel* cvCreateStructuringElementEx(
                 int cols,
                 int rows,
                 int anchor_x,
                 int anchor_y,
                 int shape,
                 int* values=NULL
        );
        void cvReleaseStructuringElement( IplConvKernel** element );
                       cols và rows
           anchor_x và anchor_y
           shape
                    value
    rows     cols


              value là NULL

                                      có thể

   CV_SHAPE_RECT
   CV_SHAPE_CROSS
   CV_SHAPE_ELLIPSE
   CV_SHAPE_CUSTOM                               value




                              cvMorphologyEx()
void cvMorphologyEx(
                 const CvArr* src,
                 CvArr* dst,
                 CvArr* temp,
                 IplConvKernel* element,
                 int operation,
                 int iterations = 1
        );
                        src dst element    iterations
cvMorphologyEx() có                                 temp


                    operation

                                                           ỏ
             CV_MOP_OPEN
             CV_MOP_CLOSE
             CV_MOP_GRADIENT
             CV_MOP_TOPHAT                           src = dst
             CV_MOP_BLACKHAT                          src = dst




                                                               iterations
                                                      cvFloodFill()




                          cvFloodFill()
        loDiff   upDiff
flags                                     seedPoint
       void cvFloodFill(
                 IplImage* img,
                 CvPoint seedPoint,
                 CvScalar newVal,
                 CvScalar loDiff= cvScalarAll(0),
                 CvScalar upDiff= cvScalarAll(0),
                 CvConnectedComp* comp = NULL,
                 int flags = 4,
                 CvArr* mask = NULL
       );
         img
                 seedPoint      newVal
                                                                loDiff
                                               upDiff   flags
CV_FLOODFILL_FIXED_RANGE
                 NULL comp là một CvConnectedComp
         lags
mask                                      cvFloodFill()
                                cvFloodFill()
                       NULL               mask phải là



       cvFloodFill() sẽ không

                                          img hay         mask
              flags




           flags



                                   CV_FLOODFILL_FIXED_RANGE


CV_FLOODFILL_MASK_ONLY
                                   CV_FLOODFILL_MASK_ONLY
           flags có thể                                                flags




      flags = 8
      | CV_FLOODFILL_MASK_ONLY
      | CV_FLOODFILL_FIXED_RANGE
      | (47<<8);
                                   CV_FLOODFILL_FIXED_RANGE
                                                  newVal loDiff   upDiff
                   CvScalar
                                     CV_RGB()            lowDiff= CV_RGB(20,30,40) sẽ
lowDiff




          cvResize()



          void cvResize(
                   const CvArr* src,
                   CvArr* dst,
                   int interpolation = CV_INTER_LINEAR
          );




             CV_INTER_NN
             CV_INTER_LINEAR
             CV_INTER_AREA
             CV_INTER_CUBIC
                                                                                              nôi suy
điều khiển




                                                                                         CV_INTER_NN


                                    CV_INTER_LINEAR
                                                                                  CV_INTER_AREA



   CV_INTER_CUBIC




        void cvPyrDown(
                  IplImage* src,
                  IplImage* dst,
                  IplFilter filter = IPL_GAUSSIAN_5x5
        );
                        filter hỗ trợ



        void cvPyrUp(
                  IplImage* src,
                  IplImage* dst,
                  IplFilter filter = IPL_GAUSSIAN_5x5
        );




                                        PyrUp() không là nghịch đảo   PyrDown()
PyrDown()



         Li  Gi  UP (Gi 1 )   5 x 5
               UP()
               ⊗
         ⊗                         PyrUp()
Li  Gi  PyrUp (Gi 1 )




                                   cvPyrSegmentation()
void cvPyrSegmentation(
          IplImage* src,
          IplImage* dst,
          CvMemStorage* storage,
          CvSeq** comp,
          int level,
          double threshold1,
          double threshold2
);
          src và dst


 dst



 NULL
     src và dst




storage là một vùng

CvMemStorage* storage = cvCreateMemStorage();
  comp


                                                cvPyrSegmentation()
           void f(
                     IplImage* src,
                     IplImage* dst
           ){
                     CvMemStorage* storage = cvCreateMemStorage(0);
                     CvSeq* comp = NULL;
                     cvPyrSegmentation( src, dst, storage, &comp, 4, 200, 50 );
                     int n_comp = comp->total;
                     for( int i=0; i<n_comp; i++ ) {
                                 CvConnectedComp* cc = (CvConnectedComp*) cvGetSeqElem( comp, i );
                                 do_something_with( cc );
                     }
                     cvReleaseMemStorage( &storage );
           }


cvPyrSegmentation() sẽ                                                                                       comp
                            CvSeq*                              NULL vì giá trị hiện tại của nó có nghĩa không
không gì                       cvPyrSegmentation()                      comp sao cho comp có thể
                                    cvPyrSegmentation()
                                                                                                 cvGetSeqElem()
chung                                 comp               cvGetSeqElem()
                                                                             CvConnectedComp*



           typedef struct CvConnectedComponent {
                     double area;
                     CvScalar value;
                     CvRect rect;
                     CvSeq* contour;
           };
 rea là vùng của                      alue là màu trung bình                              rect
                                                                              contour


                                         CvPoint
                                  cvPyrSegmentation()



                                                                                          rect
                                                cvFloodFill()




                                         cvThreshold()



           double cvThreshold(
                    CvArr* src,
                    CvArr* dst,
                    double threshold,
                    double max_value,
                    int threshold_type
           );
                                                  max_value


      CV_THRESH_BINARY
                             dsti  ( src i  T ) ? M : 0
      CV_THRESH_BINARY_INV
                             dsti  ( src i  T ) ? 0 : M
      CV_THRESH_TRUNC
                             dsti  ( src i  T ) ? M : src i
      CV_THRESH_TOZERO_INV
                             dsti  ( srci  T ) ? 0 : srci
      CV_THRESH_TOZERO
                             dsti  ( srci  T ) ? srci : 0




#include <stdio.h>
#include <cv.h>
#include <highgui.h>
       void sum_rgb( IplImage* src, IplImage* dst ) {
                  // Allocate individual image planes.
                  IplImage* r = cvCreateImage( cvGetSize(src), IPL_DEPTH_8U, 1 );
                  IplImage* g = cvCreateImage( cvGetSize(src), IPL_DEPTH_8U, 1 );
                  IplImage* b = cvCreateImage( cvGetSize(src), IPL_DEPTH_8U, 1 );
                  // Split image onto the color planes.
                  cvSplit( src, r, g, b, NULL );
                  // Temporary storage.
                  IplImage* s = cvCreateImage( cvGetSize(src), IPL_DEPTH_8U, 1 );
                  // Add equally weighted rgb values.
                  cvAddWeighted( r, 1./3., g, 1./3., 0.0, s );
                  cvAddWeighted( s, 2./3., b, 1./3., 0.0, s );
                  // Truncate values above 100.
                  cvThreshold( s, dst, 100, 100, CV_THRESH_TRUNC );
                  cvReleaseImage( &r );
                  cvReleaseImage( &g );
                  cvReleaseImage( &b );
                  cvReleaseImage( &s );
       }
       int main(int argc, char** argv)
       {
                  // tạo a named window withthe name of the file.
                  cvNamedWindow( argv[1], 1 );
                  // Load the image from the given file name.
                  IplImage* src = cvLoadImage( argv[1] );
                  IplImage* dst = cvCreateImage( cvGetSize(src), src->depth, 1);
                  sum_rgb( src, dst);
                  // Show the image in the named window
                  cvShowImage( argv[1], dst );
                  // Idle until the user hits the “Esc” key.
                  while( 1 ) { if( (cvWaitKey( 10 )&0x7f) == 27 ) break; }
                  // Clean up và không be piggies
                  cvDestroyWindow( argv[1] );
                  cvReleaseImage( &src );
                  cvReleaseImage( &dst );
       }



cvAddWeighted()                                                                     cvThreshold()

                                              cvThreshold()
                                                                trong
                                               cvAcc() có thể
                                cvADD() không thể

       IplImage* s = cvCreateImage(cvGetSize(src), IPL_DEPTH_32F, 1);
       cvZero(s);
       cvAcc(b,s);
       cvAcc(g,s);
       cvAcc(r,s);
       cvThreshold( s, s, 100, 100, CV_THRESH_TRUNC );
       cvConvertScale( s, dst, 1, 0 );




                    cvAdaptiveThreshold()
       void cvAdaptiveThreshold(
                CvArr* src,
                CvArr* dst,
                double max_val,
                int adaptive_method = CV_ADAPTIVE_THRESH_MEAN_C
                int threshold_type = CV_THRESH_BINARY,
                int block_size = 3,
                double param1 = 5
       );
cvAdaptiveThreshold() cho phép
adaptive_method


       block_size và                          param1
CV_ADAPTIVE_THRESH_MEAN_C
   CV_ADAPTIVE_THRESH_GAUSSIAN_C
                                                                 threshold_type
                  cvThreshold() được thấy trong




                       cvAdaptiveThreshold() và cvThreshold()


                                                 cvThreshold()
                     cvAdaptiveThreshold()



        ./adaptThresh15 1 1 71 15 ../Data/cal3-L.bmp




        // Compare thresholding withadaptive thresholding
        // CALL:
        // ./adaptThreshold Threshold 1binary 1adaptivemean \
        // blocksize offset filename
        #include “cv.h”
      #include “highgui.h”
      #include “math.h”
      IplImage *Igray=0, *It = 0, *Iat;
      int main( int argc, char** argv )
      {
                 if(argc != 7){return -1; }
                 //Command line
                 double threshold = (double)atof(argv[1]);
                 int threshold_type = atoi(argv[2]) ?
                             CV_THRESH_BINARY : CV_THRESH_BINARY_INV;
                 int adaptive_method = atoi(argv[3]) ?
                             CV_ADAPTIVE_THRESH_MEAN_C : CV_ADAPTIVE_THRESH_GAUSSIAN_C;
                 int block_size = atoi(argv[4]);
                 double offset = (double)atof(argv[5]);
                 //Read in gray image
                 if((Igray = cvLoadImage( argv[6], CV_LOAD_IMAGE_GRAYSCALE)) == 0){
                             return -1;}
                 // tạo the grayscale output images
                 It = cvCreateImage(cvSize(Igray->width,Igray->height),
                             IPL_DEPTH_8U, 1);
                 Iat = cvCreateImage(cvSize(Igray->width,Igray->height),
                             IPL_DEPTH_8U, 1);
                 //Threshold
                 cvThreshold(Igray,It,threshold,255,threshold_type);
                 cvAdaptiveThreshold(Igray, Iat, 255, adaptive_method,
                             threshold_type, block_size, offset);
                 //PUT UP 2 WINDOWS
                 cvNamedWindow(“Raw”,1);
                 cvNamedWindow(“Threshold”,1);
                 cvNamedWindow(“Adaptive Threshold”,1);
                 //Show kết quảs
                 cvShowImage(“Raw”,Igray);
                 cvShowImage(“Threshold”,It);
                 cvShowImage(“Adaptive Threshold”,Iat);
                 cvWaitKey(0);
                 //Clean up
                 cvReleaseImage(&Igray);
                 cvReleaseImage(&It);
                 cvReleaseImage(&Iat);
                 cvDestroyWindow(“Raw”);
                 cvDestroyWindow(“Threshold”);
                 cvDestroyWindow(“Adaptive Threshold”);
                 return(0);
      }


                                                               cvSmooth()
smoothtype=CV_GAUSSIAN




                                          cvSmooth() dùng
    param1=param2=9                      param3
          param1=param2=0 trước khi        param3

            param1=param2=0                   param3=1 và param4=9
                           param3=9 và param4=1



                                                                     param3=param4=9 và param3=param4=0



                                            src1 và src1
                            src1          src1                               diff12 và
            diff12
    cleandiff            cvErode() và            cvDilate()   diff12


dirtydiff            cvDilate() và       cvErode()       diff12 và

                             cleandiff     dirtydiff




  CV_MOP_OPEN




                                     cvCopy()




  cvResize()
                             cvPyrDown()



                              cvPyrSegmentation() và
                                                           cvThreshold()




                       cvAdaptiveThreshold()           param1=5
               param1=0 và       param1=-5


page 128-129

				
DOCUMENT INFO
Shared By:
Categories:
Tags:
Stats:
views:3
posted:2/11/2013
language:Latin
pages:29