opencv.pas

Delphi版本的OpenCV头文件库(以及诸多实例)

 CV_HAAR_MAGIC_VAL =   $42500000;
 CV_TYPE_NAME_HAAR  = 'opencv-haar-classifier';
 CV_HAAR_FEATURE_MAX = 10;
{#define CV_IS_HAAR_CLASSIFIER( haar )                                                    \
    ((haar) != NULL &&                                                                   \
    (((const CvHaarClassifierCascade*)(haar))->flags & CV_MAGIC_MASK)==CV_HAAR_MAGIC_VAL)
           }
type

CvHaarFeatureData = record
  r : cvRect;
  weight : float;
end;
pCvHaarFeature = ^CvHaarFeature;
CvHaarFeature = record
    tilted : integer;
    rect : array [0..CV_HAAR_FEATURE_MAX-1] of CvHaarFeatureData;
end;
pCvHaarClassifier = ^CvHaarClassifier;
CvHaarClassifier = record
    count : integer;
    haar_feature : pCvHaarFeature;
    threshold : pFloat;
    left : pInteger;
    right : pInteger;
    alpha : pFloat;
end;

CvHaarStageClassifier = record
     count : integer;
     threshold : float;
     classifier :  pCvHaarClassifier;
     next, child, parent : integer;
end;

CvHidHaarClassifierCascade = record end;

pCvHaarStageClassifier  = ^CvHaarStageClassifier;
pCvHaarClassifierCascade = ^CvHaarClassifierCascade ;

CvHaarClassifierCascade = record
    flags ,count : integer;
    orig_window_size : CvSize;
    real_window_size : CvSize;
    scale:double;
    stage_classifier: pCvHaarStageClassifier;
    hid_cascade:CvHidHaarClassifierCascade;
end;

CvAvgComp = record
    rect : cvRect;
    neighbors : integer;
end;

pCvAttrList = ^CvAttrList;
CvAttrList = record
    attr : pChar; //* NULL-terminated array of (attribute_name,attribute_value) pairs */
    next : pCvAttrList; //* pointer to next chunk of the attributes list */
end;

const
  CV_HAAR_DO_CANNY_PRUNING = 1;

 function CV_IS_HAAR_CLASSIFIER(haar : pointer) : boolean;
{CVAPI(CvSeq*) cvHaarDetectObjects( const CvArr* image,
                     CvHaarClassifierCascade* cascade,
                     CvMemStorage* storage, double scale_factor CV_DEFAULT(1.1),
                     int min_neighbors CV_DEFAULT(3), int flags CV_DEFAULT(0),
                     CvSize min_size CV_DEFAULT(cvSize(0,0))); }
  function  cvHaarDetectObjects(image : pcvArr; cascade :pCvHaarClassifierCascade; storage : pcvMemStorage;
                                 scale_factor : double ; min_neighbors : integer ; flags : integer ;
                                  min_size : cvSize  ) : pcvSeq; cdecl;

//* simple API for reading/writing data */
 procedure cvSave(fileName : pChar;struct_ptr : pointer; name : pChar ; comment :pChar ; attributes :  pCvAttrList);cdecl;

  function cvLoad(fileName : pChar; memstorage : pCvMemStorage =nil; name : pChar =nil; real_name :ppChar =nil ) : pointer ; cdecl;
{-----------------------------------------------------------------------}
  {Delphi procedure to convert a OCV iplImage to a Delphi bitmap}
  procedure IplImage2Bitmap(iplImg: PIplImage; var bitmap: TBitmap);


  {functions/procedures not in DLL, written in this unit}
  function cvScalar_(val0:double; val1:double; val2:double; val3:double):CvScalar;
  function cvScalarAll_(val0123:double):CvScalar;
  function cvFloor(value: double): longint;
  function cvRound(value:double):longint;
  function cvPoint_( x, y: longint ): CvPoint;
  function cvPoint2D32f_(  x, y: single  ): cvPoint2D32f;
  function cvPointFrom32f_( point: CvPoint2D32f ): CvPoint;
  function cvTermCriteria_( type_: longint; max_iter: longint; epsilon: double ): CvTermCriteria;
  function CV_RGB(r,g,b : longint) : CvScalar;
  procedure cvEllipseBox(img:PCvArr; box:CvBox2D; color:CvScalar; thickness:longint;
              line_type:longint; shift:longint);
  function  cvRect_( x, y, width, height: longint ): CvRect;

  procedure CV_SWAP(var a, b, t: pointer);

  function hsv2rgb(  hue : float )  :CvScalar ;
  function  cvPointTo32f_(point: CvPoint ):  CvPoint2D32f;

  procedure cvCalcBackProject(image:P2PIplImage; dst:PCvArr; hist:PCvHistogram);
  procedure cvCalcHist(image:P2PIplImage; hist:PCvHistogram; accumulate:longint; mask:PCvArr);

 {-----------------------------------------------}

 function cvFindContours( img : PIplImage; storage : PCvMemStorage;
                          firstContour : PCvSeq; headerSize :integer;
                          mode : CvContourRetrievalMode ;
                          method :CvChainApproxMethod  ;
                          offset : CvPoint ) : integer ; cdecl;
{ CvSeq* cvApproxPoly( CvSeq* srcSeq, int headerSize, CvMemStorage* storage,
    CvPolyApproxMethod method, float parameter,int recursive=0 ); }
 function cvApproxPoly(  srcSeq : PCvSeq; headerSize :integer;
                          storage : pCvMemStorage ;
                          method :integer  ;
                          parameter : float ;
                          recursive : integer = 0 ) : PCvSeq ; cdecl;

 function cvBoundingRect(  contour : PCvArr;header : integer = 0 ) : cvRect  ; cdecl;

 procedure cvBoxPoints(  box : CvBox2D ; pt : array of  CvPoint2D32f  ) ; cdecl;

{CVAPI(void)  cvSnakeImage( const IplImage* image, CvPoint* points,
                           int  length, float* alpha,
                           float* beta, float* gamma,
                           int coeff_usage, CvSize  win,
                           CvTermCriteria criteria, int calc_gradient CV_DEFAULT(1)); }
 procedure cvSnakeImage ( image : pIplImage; points : pCvPoint; length : integer;
                          alpha : PFloat; beta : pFloat; gamma : pFloat; coeff_Usage : integer;
                          win : CvSize ; criteria  : CvTermCriteria; calc_gradient : integer = 1);cdecl;

 function cvMinAreaRect2(contour : pCvSeq; storage : PCvMemStorage  ) : CvBox2D  ; cdecl;

 procedure cvDrawContours( img : PIplImage; contour : pCvSeq;
                          external_color,hole_color :CvScalar;  v1,v2,v3 : integer ;
                           offset : CvPoint   )  ; cdecl;

  function cvNamedWindow(caption : pchar ; flags : integer) : integer;cdecl;
  procedure cvShowImage(caption : pchar ; img : PIplImage);cdecl;
  procedure cvDestroyWindow(caption : pchar );cdecl;

  function cvWaitKey(delay : integer) : integer;cdecl;
  { Creates IPL image (header and data)  }
  function cvCreateImage(size:CvSize; depth:longint; channels:longint):PIplImage;
                        cdecl;

  { Returns width and height of array in elements  }
  function cvGetSize(const arr: PCvArr):CvSize; cdecl;

  { Copies source array to destination array  }
  procedure cvCopy(src:PCvArr; dst:PCvArr; mask:PCvArr); cdecl;

  { dst(idx) = lower <= src(idx) < upper  }
  procedure cvInRangeS(src:PCvArr; lower:CvScalar; upper:CvScalar; dst:PCvArr);
                cdecl;


  { Creates new histogram  }

  function cvCreateHist(dims:longint; sizes:Plongint; _type:longint; ranges:P2Pfloat;
        uniform:longint): PCvHistogram; cdecl;

  { Calculates array histogram  }
  procedure cvCalcArrHist(arr:P2PCvArr; hist:PCvHistogram; accumulate:longint; mask:PCvArr);
                cdecl;

  { Finds indices and values of minimum and maximum histogram bins  }
  procedure cvGetMinMaxHistValue(hist:PCvHistogram; min_value:Pdouble;
                max_value:Pdouble; min_idx:Plongint; max_idx:Plongint);  cdecl;

  { Calculates back project  }
  procedure cvCalcArrBackProject(image:P2PCvArr; dst:PCvArr; hist:PCvHistogram);
                cdecl;


    { Clears all the array elements (sets them to 0)  }

  procedure cvSetZero(arr:PCvArr); cdecl;
  procedure cvZero(arr:PCvArr); cdecl;

  { Sets image ROI (region of interest) (COI is not changed)  }

  procedure cvSetImageROI(image:PIplImage; rect:CvRect); cdecl;

  { Resets image ROI and COI  }
  procedure cvResetImageROI(image:PIplImage); cdecl;

  { Performs linear transformation on every source array element:
     dst(x,y,c) = scale*src(x,y,c)+shift.
     Arbitrary combination of input and output array depths are allowed
     (number of channels must be the same), thus the function can be used
     for type conversion  }
  procedure cvConvertScale(src:PCvArr; dst:PCvArr; scale:double; shift:double);            cdecl;

  { Splits a multi-channel array into the set of single-channel arrays or
     extracts particular [color] plane  }

  procedure cvSplit(src:PCvArr; dst0:PCvArr; dst1:PCvArr; dst2:PCvArr; dst3:PCvArr);
                cdecl;

  { dst(idx) = src1(idx) & src2(idx)  }
  procedure cvSubRS(src:PCvArr;value : cvScalar;  dst:PCvArr; mask:PCvArr);  cdecl;
  procedure cvAnd(src1:PCvArr; src2:PCvArr; dst:PCvArr; mask:PCvArr);  cdecl;
  procedure cvSub(src1:PCvArr; src2:PCvArr; dst:PCvArr; mask:PCvArr);  cdecl;
  procedure cvXor(src1:PCvArr; src2:PCvArr; dst:PCvArr; mask:PCvArr = nil);  cdecl;

// Mirror array data around horizontal (flip=0),   vertical (flip=1) or both(flip=-1) axises:
//   cvFlip(src) flips images vertically and sequences horizontally (inplace) */
//CVAPI(void)  cvFlip( const CvArr* src, CvArr* dst CV_DEFAULT(NULL),                      int flip_mode CV_DEFAULT(0));
  procedure cvFlip(src,dest : pcvArr; flip_mode : integer = 0);cdecl;

    { for 1-channel arrays  }
  function cvGetReal1D(arr:PCvArr; idx0:longint):double; cdecl;
  function cvGetReal2D(arr:PCvArr; idx0:longint; idx1:longint):double; cdecl;
  function cvGetReal3D(arr:PCvArr; idx0:longint; idx1:longint; idx2:longint):double; cdecl;
  function cvGetRealND(arr:PCvArr; idx:Plongint):double; cdecl;

  procedure cvSet1D(arr:PCvArr; idx0:longint; aVal:CvScalar); cdecl;
  procedure cvSet2D(arr:PCvArr; idx0,idx1:longint; aVal:CvScalar); cdecl;

  procedure cvSetReal1D(arr:PCvArr; idx0:longint; aVal:double); cdecl;
  procedure cvSetReal2D(arr:PCvArr; idx0:longint; idx1:longint; aval:double); cdecl;
  { dst(idx) = src(idx) ^ value  }
  procedure cvXorS(src:PCvArr; value:CvScalar; dst:PCvArr; mask:PCvArr); cdecl;

  { Draws a rectangle given two opposite corners of the rectangle (pt1 & pt2),
     if thickness<0 (e.g. thickness == CV_FILLED), the filled box is drawn  }

  procedure cvRectangle(img:PCvArr; pt1:CvPoint; pt2:CvPoint; color:CvScalar;
               thickness:longint; line_type:longint; shift:longint); cdecl;
  { Draws ellipse outline, filled ellipse, elliptic arc or filled elliptic sector,
     depending on <thickness>, <start_angle> and <end_angle> parameters. The resultant figure
     is rotated by <angle>. All the angles are in degrees  }

  procedure cvEllipse(img:PCvArr; center:CvPoint; axes:CvSize; angle:double;
                start_angle:double; end_angle:double; color:CvScalar;
                thickness:longint; line_type:longint; shift:longint); cdecl;



  { Implements CAMSHIFT algorithm - determines object position, size and orientation
     from the object histogram back project (extension of meanshift)  }
  function cvCamShift(prob_image:PCvArr; window:CvRect; criteria:CvTermCriteria;
                comp:PCvConnectedComp; box:PCvBox2D):longint; cdecl;

  {***************************************************************************************\
  *                         Working with Video Files and Cameras                           *
  \*************************************************************************************** }
  { "black box" capture structure  }

  type
    CvCapture = record
    end;
    PCvCapture = ^CvCapture;
    P2PCvCapture = ^PCvCapture;

  { start capturing frames from video file  }
  function cvCaptureFromFile(filename:Pchar): PCvCapture; cdecl;


  const
     CV_CAP_ANY = 0;
     CV_CAP_MIL = 100;
     CV_CAP_VFW = 200;
     CV_CAP_V4L = 200;
     CV_CAP_V4L2 = 200;
     CV_CAP_FIREWARE = 300;
     CV_CAP_IEEE1394 = 300;
     CV_CAP_DC1394 = 300;
     CV_CAP_CMU1394 = 300;

  { start capturing frames from camera: index = camera_index + domain_offset (CV_CAP_*)  }
//  function cvCaptureFromCAM(index:longint):PCvCapture; cdecl;

  { grab a frame, return 1 on success, 0 on fail.
    this function is thought to be fast                }
  function cvGrabFrame(capture:PCvCapture):longint; cdecl;

  { get the frame grabbed with cvGrabFrame(..)
   This function may apply some frame processing like
   frame decompression, flipping etc.
  !!!DO NOT RELEASE or MODIFY the retrieved frame!!!  }

  function cvRetrieveFrame(capture:PCvCapture): PIplImage; cdecl;

  { Just a combination of cvGrabFrame and cvRetrieveFrame
     !!!DO NOT RELEASE or MODIFY the retrieved frame!!!       }
  function cvQueryFrame(capture:PCvCapture):PIplImage;  cdecl;

  { stop capturing/reading and free resources  }
  procedure cvReleaseCapture(capture:P2PCvCapture);  cdecl;




{*****************************************************************************}

implementation


 Procedure cvCreateData;                  external cxCore name 'cvCreateData';
 function  cvCreateMatHeader ;            external cxCore name 'cvCreateMatHeader';
 Procedure cvReleaseData;                 external cxCore name 'cvReleaseData';

 function   cvGetSeqElem ;                 external cxCore name 'cvGetSeqElem';
 Function  cvCreateImageHeader;           external cvDLL name 'cvCreateImageHeader';
 Procedure cvReleaseImageHeader;          external cvDLL name 'cvReleaseImageHeader';
 procedure cvReleaseImage(var image: PIplImage); external cxCore;

 procedure  cvCalcOpticalFlowPyrLK;        external cvDLL name 'cvCalcOpticalFlowPyrLK';

 Procedure cvCalibrateCamera;             external cvDLL name 'cvCalibrateCamera';

 Procedure cvFindExtrinsicCameraParams;   external cvDLL name 'cvFindExtrinsicCameraParams';
 Procedure cvRodrigues;                   external cvDLL name 'cvRodrigues';
 Function  cvInvert;                      external cvDLL name 'cvInvert';
 Procedure cvMatMulAdd;                   external cvDLL name 'cvMatMulAdd';
 procedure cvLaplace;                     external cvDLL name 'cvLaplace';
 procedure cvSobel;                       external cvDLL name 'cvSobel';
 function cvHoughLines2;                  external cvDLL name 'cvHoughLines2';

 procedure cvSmooth;                      external cvDLL name 'cvSmooth';
 procedure cvThreshold;                   external cvDLL name 'cvThreshold';
 procedure cvCanny;                       external cvDLL name 'cvCanny';
 Procedure cvCvtColor;                    external cvDLL name 'cvCvtColor';
 Function  cvCloneImage;                  external cxCore name 'cvCloneImage';

 Function  cvCreateMemStorage;            external cxCore name 'cvCreateMemStorage';
 Procedure cvReleaseMemStorage;           external cxCore name 'cvReleaseMemStorage';

 function cvNamedWindow;                  external HighGUI_DLL name 'cvNamedWindow';
 procedure cvShowImage  ;                 external HighGUI_DLL name 'cvShowImage';
 procedure cvDestroyWindow  ;                 external HighGUI_DLL name 'cvDestroyWindow';
 function cvWaitKey;                      external HighGUI_DLL name 'cvWaitKey';
 Procedure cvDrawContours;                external cxCore name 'cvDrawContours';
 function cvFindContours  ;               external cvDLL name 'cvFindContours';
 function cvMinAreaRect2 ;                external cvDLL name 'cvMinAreaRect2';

 procedure cvSnakeImage ;                 external cvDLL name 'cvSnakeImage';
 procedure cvBoxPoints  ;                 external cvDLL name 'cvBoxPoints';

 function  cvHaarDetectObjects;            external cvDLL name 'cvHaarDetectObjects';

 procedure cvSave ;                       external cxCore name 'cvSave';
 function  cvLoad;                         external cxCore name 'cvLoad';

 function cvBoundingRect  ;               external cvDLL name 'cvBoundingRect';
 function cvApproxPoly  ;                 external cvDLL name 'cvFindContours';
 Function  cvFindChessBoardCornerGuesses; external cvDLL name 'cvFindChessBoardCornerGuesses';
 Procedure cvFindCornerSubPix;            external cvDLL name 'cvFindCornerSubPix';

 procedure  cvSetMouseCallback;           external HighGUI_DLL name 'cvSetMouseCallback';
 function   cvCreateTrackbar;             external HighGUI_DLL name 'cvCreateTrackbar';

 procedure cvCircle;                      external cxCore name 'cvCircle';
 procedure cvLine;                        external cxCore name 'cvLine';

 procedure cvWarpAffine;                  external cvDLL name 'cvWarpAffine';
 function  cv2DRotationMatrix;            external cvDLL name 'cv2DRotationMatrix';
 function  cvCreateMat;                   external cxCore name 'cvCreateMat';
 Function  cvLoadImage;                   external HighGUI_DLL name 'cvLoadImage';
 Function  cvSaveImage;                   external HighGUI_DLL name 'cvSaveImage';


 procedure  cvGoodFeaturesToTrack;        external cvDLL name 'cvGoodFeaturesToTrack';


{----------------------------------------------------}