Add sample:

MultiDemo
[+] ReameRecon

Signed-off-by: Laex <laex@bk.ru>

Bin/Resource/Distortion.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0"?>
+<opencv_storage>
+<Distortion type_id="opencv-matrix">
+  <rows>4</rows>
+  <cols>1</cols>
+  <dt>f</dt>
+  <data>
+    -0.48542303 -0.37418127 -0.03314986 8.17632210e-003</data></Distortion>
+</opencv_storage>

Bin/Resource/Intrinsics.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0"?>
+<!-- Trust 10007 for 320x240 -->
+<opencv_storage>
+<Intrinsics type_id="opencv-matrix">
+  <rows>3</rows>
+  <cols>3</cols>
+  <dt>f</dt>
+  <data>
+    751.84814453 0. 155.19932556 
+    0. 751.84814453 140.60366821 
+    0. 0. 1.
+  </data></Intrinsics>
+</opencv_storage>

include/calib3d/calib3d.pas

@@ -217,7 +217,7 @@ Uses Core.types_c;
 // CvMat* dr3dr2 CV_DEFAULT(0), CvMat* dr3dt2 CV_DEFAULT(0),
 // CvMat* dt3dr1 CV_DEFAULT(0), CvMat* dt3dt1 CV_DEFAULT(0),
 // CvMat* dt3dr2 CV_DEFAULT(0), CvMat* dt3dt2 CV_DEFAULT(0) );
-//
+
 /// * Projects object points to the view plane using
 // the specified extrinsic and intrinsic camera parameters */
 // CVAPI(void) cvProjectPoints2( const CvMat* object_points, const CvMat* rotation_vector,
@@ -227,8 +227,11 @@ Uses Core.types_c;
 // CvMat* dpdf CV_DEFAULT(NULL), CvMat* dpdc CV_DEFAULT(NULL),
 // CvMat* dpddist CV_DEFAULT(NULL),
 // double aspect_ratio CV_DEFAULT(0));
-//
-/// * Finds extrinsic camera parameters from
+procedure cvProjectPoints2(const object_points: pCvMat; const rotation_vector: pCvMat; const translation_vector: pCvMat;
+  const camera_matrix: pCvMat; const distortion_coeffs: pCvMat; image_points: pCvMat; dpdrot: pCvMat = nil;
+  dpdt: pCvMat = nil; dpdf: pCvMat = nil; dpdc: pCvMat = nil; dpddist: pCvMat = nil; aspect_ratio: double = 0); cdecl;
+
+// * Finds extrinsic camera parameters from
 // a few known corresponding point pairs and intrinsic parameters */
 // CVAPI(void) cvFindExtrinsicCameraParams2( const CvMat* object_points,
 // const CvMat* image_points,
@@ -237,7 +240,10 @@ Uses Core.types_c;
 // CvMat* rotation_vector,
 // CvMat* translation_vector,
 // int use_extrinsic_guess CV_DEFAULT(0) );
-//
+procedure cvFindExtrinsicCameraParams2(const object_points: pCvMat; const image_points: pCvMat;
+  const camera_matrix: pCvMat; const distortion_coeffs: pCvMat; rotation_vector: pCvMat; translation_vector: pCvMat;
+  use_extrinsic_guess: Integer = 0); cdecl;
+
 /// * Computes initial estimate of the intrinsic camera parameters
 // in case of planar calibration target (e.g. chessboard) */
 // CVAPI(void) cvInitIntrinsicParams2D( const CvMat* object_points,
@@ -322,7 +328,7 @@ function cvCalibrateCamera2(
   { } translation_vectors: pCvMat { =nil };
   { } flags: Integer { =0 };
   { } term_crit: TCvTermCriteria { =cvTermCriteria(CV_TERMCRIT_ITER+CV_TERMCRIT_EPS,30,DBL_EPSILON) }
-  ): Double; cdecl;
+  ): double; cdecl;
 
 /// * Computes various useful characteristics of the camera from the data computed by
 // cvCalibrateCamera2 */
@@ -477,5 +483,7 @@ procedure cvReprojectImageTo3D; external calib3d_dll;
 function cvFindChessboardCorners; external calib3d_dll;
 procedure cvDrawChessboardCorners; external calib3d_dll;
 function cvCalibrateCamera2; external calib3d_dll;
+procedure cvProjectPoints2; external calib3d_dll;
+procedure cvFindExtrinsicCameraParams2; external calib3d_dll;
 
 end.

include/imgproc/imgproc.types_c.pas

@@ -341,7 +341,8 @@ const
 
   (* Spatial and central moments *)
 type
-  CvMoments = packed record
+  pCvMoments=^TCvMoments;
+  TCvMoments = packed record
     m00, m10, m01, m20, m11, m02, m30, m21, m12, m03: Double; (* spatial moments *)
     mu20, mu11, mu02, mu30, mu21, mu12, mu03: Double; (* central moments *)
     inv_sqrt_m00: Double; (* m00 != 0 ? 1/sqrt(m00) : 0 *)

include/imgproc/imgproc_c.pas

@@ -590,14 +590,12 @@ function cvContourPerimeter(const contour: Pointer): double; inline;
 // just retrieves pre-calculated rectangle (update=0) *)
 // CVAPI(CvRect)  cvBoundingRect( CvArr* points, Integer update CV_DEFAULT(0) );
 
-{
-  /* Calculates area of a contour or contour segment */
-  CVAPI(double)  cvContourArea( const CvArr* contour,
-  CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ),
-  int oriented CV_DEFAULT(0));
-}
-function cvContourArea(const contour: PCvSeq; slice: TCvSlice { = CV_WHOLE_SEQ }; oriented: Integer { = 0 } )
-  : double; cdecl;
+
+// * Calculates area of a contour or contour segment */
+// CVAPI(double)  cvContourArea( const CvArr* contour,
+// CvSlice slice CV_DEFAULT(CV_WHOLE_SEQ),
+// int oriented CV_DEFAULT(0));
+function cvContourArea(const contour: PCvSeq; slice: TCvSlice { = CV_WHOLE_SEQ }; oriented: Integer = 0): double; cdecl;
 
 // (* Finds minimum area rotated rectangle bounding a set of points *)
 // CVAPI(CvBox2D)  cvMinAreaRect2( const CvArr* points, CvMemStorage* storage CV_DEFAULT(NULL));

include/сore/core_c.pas

@@ -373,20 +373,20 @@ const
 
   // * value = arr(idx0,idx1,...) */
   // CVAPI(CvScalar) cvGet1D( const CvArr* arr, int idx0 );
-  // CVAPI(CvScalar) cvGet2D( const CvArr* arr, int idx0, int idx1 );
+function cvGet1D(const arr: pCvArr; idx0: Integer): TCvScalar; cdecl;
+// CVAPI(CvScalar) cvGet2D( const CvArr* arr, int idx0, int idx1 );
 function cvGet2D(const arr: pCvMat; idx0, idx1: Integer): TCvScalar; cdecl;
 {
   CVAPI(CvScalar) cvGet3D( const CvArr* arr, int idx0, int idx1, int idx2 );
   CVAPI(CvScalar) cvGetND( const CvArr* arr, const int* idx );
 }
-{
-  /* for 1-channel arrays */
-  CVAPI(double) cvGetReal1D( const CvArr* arr, int idx0 );
-}
-function cvGetReal1D(const arr: pIplImage; idx0: Integer): Double; cdecl;
 
+// * for 1-channel arrays */
+// CVAPI(double) cvGetReal1D( const CvArr* arr, int idx0 );
+function cvGetReal1D(const arr: pIplImage; idx0: Integer): Double; cdecl;
 // CVAPI(double) cvGetReal2D( const CvArr* arr, int idx0, int idx1 );
 function cvGetReal2D(const arr: pCvMat; idx0, idx1: Integer): Double; cdecl;
+function cvGet(const mat: pCvMat; i, j: Integer): Single; inline;
 
 {
   CVAPI(double) cvGetReal3D( const CvArr* arr, int idx0, int idx1, int idx2 );
@@ -397,15 +397,16 @@ function cvGetReal2D(const arr: pCvMat; idx0, idx1: Integer): Double; cdecl;
   CVAPI(void) cvSet2D( CvArr* arr, int idx0, int idx1, CvScalar value );
   CVAPI(void) cvSet3D( CvArr* arr, int idx0, int idx1, int idx2, CvScalar value );
   CVAPI(void) cvSetND( CvArr* arr, const int* idx, CvScalar value );
-
-  /* for 1-channel arrays */
-  CVAPI(void) cvSetReal1D( CvArr* arr, int idx0, double value );
-  CVAPI(void) cvSetReal2D( CvArr* arr, int idx0, int idx1, double value );
-  CVAPI(void) cvSetReal3D( CvArr* arr, int idx0,
-  int idx1, int idx2, double value );
-  CVAPI(void) cvSetRealND( CvArr* arr, const int* idx, double value );
 }
-
+// *for 1 - channel arrays * /
+// CVAPI(void) cvSetReal1D( CvArr* arr, int idx0, double value );
+procedure cvSetReal1D(arr: pCvArr; idx0: Integer; value: Double); cdecl;
+// CVAPI(void) cvSetReal2D( CvArr* arr, int idx0, int idx1, double value );
+procedure cvSetReal2D(arr: pCvArr; idx0, idx1: Integer; value: Double); cdecl;
+// CVAPI(void) cvSetReal3D( CvArr* arr, int idx0,int idx1, int idx2, double value );
+procedure cvSetReal3D(arr: pCvArr; idx0, idx1, idx2: Integer; value: Double); cdecl;
+// CVAPI(void) cvSetRealND( CvArr* arr, const int* idx, double value );
+procedure cvSetRealND(arr: pCvArr; const idx: PInteger; value: Double); cdecl;
 
 // (* clears element of ND dense array,
 // in  of sparse arrays it deletes the specified node *)
@@ -485,12 +486,10 @@ procedure _cvGetSize(const arr: pCvArr; var size: TCvSize); cdecl;
 procedure cvCopy(const src: pIplImage; dst: pIplImage; const mask: pIplImage = nil); cdecl;
 procedure cvCopyImage(const src: pIplImage; dst: pIplImage; const mask: pIplImage = nil); cdecl;
 
-{
-  /* Sets all or "masked" elements of input array to the same value*/
-  CVAPI(void)  cvSet( CvArr* arr, CvScalar value,const CvArr* mask CV_DEFAULT(NULL) );
-}
-procedure cvSet(arr: pCvArr; value: TCvScalar; const mask: pCvArr = Nil); cdecl; // overload;
-// procedure cvSet(arr: pIplImage; value: TCvScalar; const mask: pCvArr = Nil); cdecl; overload;
+// * Sets all or "masked" elements of input array to the same value*/
+// CVAPI(void)  cvSet( CvArr* arr, CvScalar value,const CvArr* mask CV_DEFAULT(NULL) );
+procedure cvSet(arr: pCvArr; value: TCvScalar; const mask: pCvArr = Nil); cdecl; overload;
+procedure cvSet(mat: pCvMat; i, j: Integer; val: Single); inline; overload;
 
 // procedure cvSetZero(CvArr * arr: unction mask CV_DEFAULT(v1: 0)): CvArr; ();
 // const cvZero = cvSetZero;
@@ -1523,7 +1522,7 @@ procedure cvFillConvexPoly(img: pIplImage; const pts: pCVPoint; npts: Integer; c
   int line_type CV_DEFAULT(8), int shift CV_DEFAULT(0) );
 }
 
-procedure cvPolyLine(img: pIplImage; pts: pCVPoint; const npts: pInteger; contours: Integer; is_closed: Integer;
+procedure cvPolyLine(img: pIplImage; pts: pCVPoint; const npts: PInteger; contours: Integer; is_closed: Integer;
   color: TCvScalar; thickness: Integer = 1; line_type: Integer = 8; shift: Integer = 0); cdecl;
 
 // const
@@ -1592,9 +1591,9 @@ type
     color: TCvScalar;
     // Qt:ColorFont -> cvScalar(blue_component, green_component, red\_component[, alpha_component])
     font_face: Integer; // Qt: bool italic         /* =CV_FONT_* */
-    ascii: pInteger; // * font data and metrics */
-    greek: pInteger;
-    cyrillic: pInteger;
+    ascii: PInteger; // * font data and metrics */
+    greek: PInteger;
+    cyrillic: PInteger;
     hscale, vscale: Single;
     shear: Single; // * slope coefficient: 0 - normal, >0 - italic */
     thickness: Integer; // Qt: weight               /* letters thickness */
@@ -1887,7 +1886,11 @@ function cvRead(fs: pCvFileStorage; node: pCvFileNode; attributes: pCvAttrList =
 // procedure)cvUnregisterType(type_name: PCVChar); CVAPI(CvTypeInfo)cvFirstType(
 // procedure); CVAPI(type_name: PCVChar);
 // CVAPI(CvTypeInfo)cvTypeOf(Pointer type cvTypeOf(Pointer struct_ptr) = record end:;
-// rocedure)cvRelease(Pointer * type end:; r type end:;
+
+// * universal functions */
+// CVAPI(void) cvRelease( void** struct_ptr );
+procedure cvRelease(Var struct_ptr: Pointer); cdecl; overload;
+procedure cvRelease(Var struct_ptr: pCvSeq); cdecl; overload;
 
 {
   /* simple API for reading/writing data */
@@ -2078,7 +2081,6 @@ procedure _cvGetSize(const arr: pCvArr; var size: TCvSize); external Core_Dll na
 // end;
 // end;
 
-procedure cvSet; external Core_Dll;
 procedure cvInitFont; external Core_Dll;
 procedure cvPutText; external Core_Dll;
 
@@ -2099,7 +2101,7 @@ procedure cvCopy; external Core_Dll;
 procedure cvCopyImage; external Core_Dll name 'cvCopy';
 
 procedure cvSetZero; external Core_Dll;
-procedure cvZero; external Core_Dll;
+procedure cvZero; external Core_Dll name 'cvSetZero';
 // procedure cvZero(arr: pIplImage); cdecl; overload; external Core_Dll name 'cvSetZero';
 // procedure cvZero(arr: pCvMat); cdecl; overload; external Core_Dll name 'cvSetZero';
 
@@ -2241,5 +2243,41 @@ function cvInitImageHeader; external Core_Dll;
 function cvInitMatHeader; external Core_Dll;
 function cvCountNonZero; external Core_Dll;
 procedure cvFillConvexPoly; external Core_Dll;
+function cvGet1D; external Core_Dll;
+procedure cvSetReal1D; external Core_Dll;
+procedure cvSetReal2D; external Core_Dll;
+procedure cvSetReal3D; external Core_Dll;
+procedure cvRelease(Var struct_ptr: Pointer); external Core_Dll name 'cvRelease';
+procedure cvRelease(Var struct_ptr: pCvSeq); external Core_Dll name 'cvRelease';
+procedure cvSetRealND; external Core_Dll;
+
+function cvGet(const mat: pCvMat; i, j: Integer): Single; inline;
+var
+  type_: Integer;
+  ptr: PUCHAR;
+  pf: PSingle;
+begin
+  type_ := CV_MAT_TYPE(mat^._type);
+  assert((i < mat^.rows) and (j < mat^.cols) and (type_ = CV_32FC1));
+  ptr := mat^.data;
+  inc(ptr, mat.step * i + sizeOf(Single) * j);
+  pf := PSingle(ptr);
+  Result := pf^;
+end;
+
+procedure cvSet(arr: pCvArr; value: TCvScalar; const mask: pCvArr = Nil); external Core_Dll;
+procedure cvSet(mat: pCvMat; i, j: Integer; val: Single); inline;
+var
+  type_: Integer;
+  ptr: PUCHAR;
+  pf: PSingle;
+begin
+  type_ := CV_MAT_TYPE(mat._type);
+  assert((i < mat^.rows) and (j < mat^.cols) and (type_ = CV_32FC1));
+  ptr := mat^.data;
+  inc(ptr, mat.step * i + sizeOf(Single) * j);
+  pf := PSingle(ptr);
+  pf^ := val;
+end;
 
 end.

samples/MultiDemo/FrameRecon/FrameRecon.dpr

@@ -0,0 +1,440 @@
+(* /*****************************************************************
+  //                       Delphi-OpenCV Demo
+  //               Copyright (C) 2013 Project Delphi-OpenCV
+  // ****************************************************************
+  // Contributor:
+  // laentir Valetov
+  // email:laex@bk.ru
+  // ****************************************************************
+  // You may retrieve the latest version of this file at the GitHub,
+  // located at git://github.com/Laex/Delphi-OpenCV.git
+  // ****************************************************************
+  // The contents of this file are used with permission, subject to
+  // the Mozilla Public License Version 1.1 (the "License"); you may
+  // not use this file except in compliance with the License. You may
+  // obtain a copy of the License at
+  // http://www.mozilla.org/MPL/MPL-1_1Final.html
+  //
+  // Software distributed under the License is distributed on an
+  // "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
+  // implied. See the License for the specific language governing
+  // rights and limitations under the License.
+  ******************************************************************* *)
+// JCL_DEBUG_EXPERT_GENERATEJDBG OFF
+// JCL_DEBUG_EXPERT_INSERTJDBG OFF
+// JCL_DEBUG_EXPERT_DELETEMAPFILE OFF
+program FrameRecon;
+
+{$APPTYPE CONSOLE}
+{$POINTERMATH ON}
+{$R *.res}
+
+uses
+  System.SysUtils,
+  uLibName in '..\..\..\include\uLibName.pas',
+  highgui_c in '..\..\..\include\highgui\highgui_c.pas',
+  core_c in '..\..\..\include\ñore\core_c.pas',
+  Core.types_c in '..\..\..\include\ñore\Core.types_c.pas',
+  imgproc.types_c in '..\..\..\include\imgproc\imgproc.types_c.pas',
+  imgproc_c in '..\..\..\include\imgproc\imgproc_c.pas',
+  legacy in '..\..\..\include\legacy\legacy.pas',
+  calib3d in '..\..\..\include\calib3d\calib3d.pas',
+  imgproc in '..\..\..\include\imgproc\imgproc.pas',
+  haar in '..\..\..\include\objdetect\haar.pas',
+  objdetect in '..\..\..\include\objdetect\objdetect.pas',
+  tracking in '..\..\..\include\video\tracking.pas',
+  Core in '..\..\..\include\ñore\core.pas';
+
+Var
+  image: pIplImage = nil;
+  imageDiv: pIplImage;
+  outImg: pIplImage = nil;
+  extractedFrame: pIplImage;
+  // gray: pIplImage;
+  pgray, pcontor: pIplImage;
+  intrinsic: PCvMat;
+  distortion: PCvMat;
+  obj, pro: PCvMat;
+  rot, tra: PCvMat;
+  mapMatrix: PCvMat;
+  origQuad, quad: array [0 .. 3] of TCvPoint2D32f;
+  capture: PCvCapture;
+  frame: pIplImage;
+  selcam: longint = 0;
+  cont: integer;
+
+  // Canny/Threshold parameters
+  cbCannyChecked: Boolean = false;
+  sePar1Value: Double = 100;
+  sePar2Value: Double = 50;
+  cbPar3Value: integer = 3;
+  // approx poly param.
+  cbDisplayContChecked: Boolean = false;
+  sePolyPar1Value: Double = 7;
+  sePolyPar2Value: integer = 0;
+  // max perim ratio difference %
+  sePerimRatioDiffValue: Double = 20;
+
+procedure drawPerspective(image: pIplImage);
+var
+  i: integer;
+  pt1, pt2: TCvPoint;
+begin
+
+  cvZero(pro);
+
+  cvProjectPoints2(obj, rot, tra, intrinsic, distortion, pro);
+
+  cvCircle(image, cvPoint(round(cvGet(pro, 0, 0)), round(cvGet(pro, 0, 1))), 10, cv_rgb(255, 0, 0));
+  for i := 0 to 3 do
+  begin
+    pt1.x := round(cvGet(pro, i, 0));
+    pt1.y := round(cvGet(pro, i, 1));
+    if i < 3 then
+    begin
+      pt2.x := round(cvGet(pro, i + 1, 0));
+      pt2.y := round(cvGet(pro, i + 1, 1));
+    end
+    else
+    begin
+      pt2.x := round(cvGet(pro, 0, 0));
+      pt2.y := round(cvGet(pro, 0, 1));
+    end;
+    cvLine(image, pt1, pt2, cv_rgb(0, 255, 0), 1, CV_AA, 0);
+  end;
+end;
+
+procedure extractContours(const origImg, image: pIplImage; const storage: pCvMemStorage; var contList: PCvSeq);
+var
+  nc: integer;
+  contours: PCvSeq;
+
+begin
+  // *********** find contours in Canny result image
+  // find contours and store them all as a list
+  contours := nil;
+  if (origImg.NChannels > 1) then
+  begin
+    pgray := cvCreateImage(cvSize(image.width, image.height), IPL_DEPTH_8U, 1);
+    cvCvtColor(origImg, pgray, CV_BGR2GRAY)
+  end
+  else
+    pgray := cvCloneImage(origImg);
+  pcontor := cvCreateImage(cvSize(image.width, image.height), IPL_DEPTH_8U, 1);
+  if cbCannyChecked then
+    cvCanny(pgray, pcontor, sePar1Value, sePar2Value, cbPar3Value)
+  else
+    cvThreshold(pgray, pcontor, sePar1Value, 255, CV_THRESH_BINARY_INV);
+  if (image.NChannels > 1) and (cbDisplayContChecked) then
+    cvCvtColor(pcontor, image, CV_GRAY2BGR);
+  // warning! findcontours destroy the input image, so display it before the call
+  nc := cvFindContours(pcontor, storage, @contours, sizeof(TCvContour), CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE,
+    cvPoint(0, 0));
+
+  if nc = 0 then
+    contList := nil
+  else
+    contList := contours;
+
+  cvReleaseImage(pgray);
+  cvReleaseImage(pcontor);
+end;
+
+procedure drawFrame(const origImg, image: pIplImage);
+var
+  nc, i: integer;
+  contList, contours: PCvSeq;
+  seqResult, hole, hole2: PCvSeq;
+  storage: pCvMemStorage;
+  a, p: Double;
+  bRect: TCvRect;
+
+  nholes: integer;
+  bol1, bol2, bol3: Boolean;
+  m1, q1: single;
+  m2, q2: single;
+  vert1, vert2: Boolean;
+  mi1, qi1: single;
+  mi2, qi2: single;
+  vertH1, vertH2: Boolean;
+
+  p1, p2: PCvPoint;
+  p1Ext: TCvPoint;
+  frame_found: Boolean;
+
+  moments: PCvMoments;
+  compactness: Double;
+begin
+  storage := cvCreateMemStorage(0);
+  extractContours(origImg, image, storage, contList);
+
+  // test each contour
+  contours := contList;
+  while (contours <> nil) do
+  begin
+    a := cvContourArea(contours, CV_WHOLE_SEQ);
+    if (abs(a) > 500) and (contours.total > 3) then
+    begin
+      seqResult := cvApproxPoly(contours, sizeof(TCvContour), storage, CV_POLY_APPROX_DP, sePolyPar1Value,
+        sePolyPar2Value);
+      if seqResult.total = 4 then
+      begin
+        Writeln('ContourArea ', a:2:2);
+        Writeln('ApproxPoly total ', seqResult.total);
+        frame_found := false;
+        // calcola coefficienti delle rette diagonali del contorno esterno
+        p1 := PCvPoint(cvGetSeqElem(seqResult, 0));
+        p1Ext.x := p1.x;
+        p1Ext.y := p1.y;
+        p2 := PCvPoint(cvGetSeqElem(seqResult, 2));
+        if (p1.x <> p2.x) then
+        begin
+          vert1 := false;
+          m1 := (p2.y - p1.y) / (p2.x - p1.x);
+          q1 := (p2.x * p1.y - p1.x * p2.y) / (p2.x - p1.x);
+        end
+        else
+        begin
+          vert1 := true;
+        end;
+        p1 := PCvPoint(cvGetSeqElem(seqResult, 1));
+        p2 := PCvPoint(cvGetSeqElem(seqResult, 3));
+        if (p1.x <> p2.x) then
+        begin
+          vert2 := false;
+          m2 := (p2.y - p1.y) / (p2.x - p1.x);
+          q2 := (p2.x * p1.y - p1.x * p2.y) / (p2.x - p1.x);
+        end
+        else
+        begin
+          vert2 := true;
+        end;
+
+        // internal contours with CV_RETR_TREE
+        hole := contours.v_next;
+        nholes := 0;
+        // 4) scorre i contorni interni (TREE)
+        while (hole <> nil) do
+        begin
+          inc(nholes);
+          if nholes > 1 then
+            break;
+          if hole.total <= 3 then
+            Continue;
+          // 4.1) approssima ogni contorno con pilogono
+          hole2 := cvApproxPoly(hole, sizeof(TCvContour), storage, CV_POLY_APPROX_DP, sePolyPar1Value, sePolyPar2Value);
+          // 4.2) verifica se poligono ha 4 vertici
+          if hole2.total <> 4 then
+            Continue;
+          p1 := PCvPoint(cvGetSeqElem(hole2, 0));
+
+          // 4.3) calcola coefficienti delle rette diagonali
+          p2 := PCvPoint(cvGetSeqElem(hole2, 2));
+          if (p1.x <> p2.x) then
+          begin
+            vertH1 := false;
+            mi1 := (p2.y - p1.y) / (p2.x - p1.x);
+            qi1 := (p2.x * p1.y - p1.x * p2.y) / (p2.x - p1.x);
+          end
+          else
+          begin
+            vertH1 := true;
+          end;
+          p1 := PCvPoint(cvGetSeqElem(hole2, 1));
+          p2 := PCvPoint(cvGetSeqElem(hole2, 3));
+          if (p1.x <> p2.x) then
+          begin
+            vertH2 := false;
+            mi2 := (p2.y - p1.y) / (p2.x - p1.x);
+            qi2 := (p2.x * p1.y - p1.x * p2.y) / (p2.x - p1.x);
+          end
+          else
+          begin
+            vertH2 := true;
+          end;
+
+          // 4.4) se i coefficienti delle diagonali del poligono interno
+          // sono uguali a quelli del poligono esterno, a meno di errore dato,
+          // la ricerca e' positiva, uscire dalla funzione
+          if (vert1 = vertH1) and (vert2 = vertH2) and (abs(m1 - mi1) / m1 <= (sePerimRatioDiffValue / 100)) and
+            (abs(q1 - qi1) / q1 <= (sePerimRatioDiffValue / 100)) and
+            (abs(m2 - mi2) / m2 <= (sePerimRatioDiffValue / 100)) and
+            (abs(q2 - qi2) / q2 <= (sePerimRatioDiffValue / 100)) then
+          begin
+            frame_found := true;
+            break;
+          end;
+
+          hole := hole.h_next;
+
+        end; // while hole
+        if (frame_found) then
+        begin
+          Writeln('frame_found');
+
+          cvZero(rot);
+          cvZero(tra);
+          // copy projection data to CvMat array
+          for i := 0 to 3 do
+          begin
+            p1 := PCvPoint(cvGetSeqElem(seqResult, i));
+            cvSet(pro, i, 0, p1.x);
+            cvSet(pro, i, 1, p1.y);
+            quad[i].x := p1.x;
+            quad[i].y := p1.y;
+          end;
+
+          cvFindExtrinsicCameraParams2(obj, pro, intrinsic, distortion, rot, tra);
+          Writeln('Z dist. ' + FloatToStr(trunc(cvGet(tra, 0, 2))));
+
+          cvGetPerspectiveTransform(@origQuad, @quad, mapMatrix);
+          bRect := pcvcontour(seqResult).rect;
+
+          cvZero(extractedFrame);
+          cvWarpPerspective(origImg, extractedFrame, mapMatrix,
+            (CV_INTER_LINEAR + CV_WARP_FILL_OUTLIERS + CV_WARP_INVERSE_MAP), cvScalar(0, 0, 0, 0));
+
+          cvDrawContours(image, PCvSeq(seqResult), cv_rgb(255, 0, 0), cv_rgb(0, 255, 0), 0, 4, CV_AA, cvPoint(0, 0));
+
+          break;
+        end;
+      end; // if seqresult.total=4
+    end; // if abs
+    // take the next contour
+    contours := contours.h_next;
+  end;
+  cvRelease(contList);
+  cvReleaseMemStorage(storage);
+end;
+
+procedure main_cycle(frame: pIplImage);
+var
+  cs: TCvSize;
+begin
+  if not(assigned(image)) then
+  begin
+    // * allocate all the buffers
+    cs.width := frame.width;
+    cs.height := frame.height;
+    image := cvCreateImage(cs, 8, 3);
+    image.Origin := frame.Origin;
+    imageDiv := cvCreateImage(cvSize(cs.width div 2, cs.height div 2), 8, 3);
+    imageDiv.Origin := frame.Origin;
+    outImg := cvCreateImage(cs, 8, 3);
+    outImg.Origin := frame.Origin;
+  end;
+
+  cvCopy(frame, image);
+  cvSmooth(image, image, CV_GAUSSIAN, 3, 3);
+
+  cvCopy(image, outImg);
+
+  drawFrame(image, outImg);
+  if cont = 20 then
+  begin
+    cont := 1;
+    cvShowImage('Paint window', extractedFrame);
+  end
+  else
+    inc(cont);
+
+  drawPerspective(outImg);
+  cvCopy(outImg, frame);
+end;
+
+procedure Help;
+begin
+  Writeln('c - CannyChecked');
+  Writeln('d - DisplayContChecked');
+end;
+
+begin
+  try
+    ///
+    // Calibration: Resource\Calibration_Chess.png
+    // Test: Resource\frame.png
+    ///
+
+    // ïîëó÷àåì ëþáóþ ïîäêëþ÷¸ííóþ êàìåðó
+    capture := cvCreateCameraCapture(CV_CAP_ANY);
+    if not assigned(capture) then
+      Halt;
+    cvNamedWindow('Paint window', 1);
+    cvNamedWindow('Original', 1);
+
+    intrinsic := cvLoad('Resource\Intrinsics.xml');
+    // multiply by 2 because the matrix is computed on 320x240 image
+    cvConvertScale(intrinsic, intrinsic, 2.0, 0);
+    distortion := cvLoad('Resource\Distortion.xml');
+    obj := cvCreateMat(4, 3, CV_32FC1);
+    pro := cvCreateMat(4, 2, CV_32FC1);
+    rot := cvCreateMat(1, 3, CV_32FC1);
+    tra := cvCreateMat(1, 3, CV_32FC1);
+    mapMatrix := cvCreateMat(3, 3, CV_32FC1);
+    cvSet(obj, 0, 0, -100);
+    cvSet(obj, 0, 1, -100);
+    cvSet(obj, 0, 2, 0.0);
+    origQuad[0].x := 0;
+    origQuad[0].y := 0;
+
+    cvSet(obj, 1, 0, 100.0);
+    cvSet(obj, 1, 1, -100);
+    cvSet(obj, 1, 2, 0.0);
+    origQuad[1].x := 300;
+    origQuad[1].y := 0;
+
+    cvSet(obj, 2, 0, 100.0);
+    cvSet(obj, 2, 1, 100.0);
+    cvSet(obj, 2, 2, 0.0);
+    origQuad[2].x := 300;
+    origQuad[2].y := 300;
+
+    cvSet(obj, 3, 0, -100);
+    cvSet(obj, 3, 1, 100.0);
+    cvSet(obj, 3, 2, 0.0);
+    origQuad[3].x := 0;
+    origQuad[3].y := 300;
+
+    cvSet(rot, 0, 0, 0.0);
+    cvSet(rot, 0, 1, 0.0);
+    cvSet(rot, 0, 2, 0.0);
+
+    cvSet(tra, 0, 0, 0.0);
+    cvSet(tra, 0, 1, 0.0);
+    // the Z coord on translation vector is set to focal length
+    cvSet(tra, 0, 2, cvGet(intrinsic, 0, 0));
+
+    // appo image for warp perspective
+    extractedFrame := cvCreateImage(cvSize(800, 600), 8, 3);
+
+    Help;
+
+    while true do
+    begin
+      // ïîëó÷àåì êàäð
+      frame := cvQueryFrame(capture);
+      if not assigned(frame) then
+        break;
+      cvShowImage('Original', frame);
+      main_cycle(frame);
+      case cvWaitKey(10) of
+        27:
+          break;
+        Ord('c'):
+          cbCannyChecked := not cbCannyChecked;
+        Ord('d'):
+          cbDisplayContChecked := not cbDisplayContChecked;
+      end;
+    end;
+
+    cvReleaseCapture(capture);
+    cvReleaseImage(image);
+    cvReleaseImage(outImg);
+    cvReleaseImage(extractedFrame);
+    cvDestroyAllWindows;
+  except
+    on e: Exception do
+      Writeln(e.ClassName, ': ', e.Message);
+  end;
+
+end.

samples/MultiDemo/FrameRecon/FrameRecon.dproj

@@ -0,0 +1,160 @@
+<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+    <PropertyGroup>
+        <ProjectGuid>{F0EF9F64-A50A-4420-B381-F2496EFB5E25}</ProjectGuid>
+        <MainSource>FrameRecon.dpr</MainSource>
+        <Base>True</Base>
+        <Config Condition="'$(Config)'==''">Debug</Config>
+        <TargetedPlatforms>1</TargetedPlatforms>
+        <AppType>Console</AppType>
+        <FrameworkType>None</FrameworkType>
+        <ProjectVersion>14.4</ProjectVersion>
+        <Platform Condition="'$(Platform)'==''">Win32</Platform>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Config)'=='Base' or '$(Base)'!=''">
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="('$(Platform)'=='Win32' and '$(Base)'=='true') or '$(Base_Win32)'!=''">
+        <Base_Win32>true</Base_Win32>
+        <CfgParent>Base</CfgParent>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Config)'=='Release' or '$(Cfg_1)'!=''">
+        <Cfg_1>true</Cfg_1>
+        <CfgParent>Base</CfgParent>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Config)'=='Debug' or '$(Cfg_2)'!=''">
+        <Cfg_2>true</Cfg_2>
+        <CfgParent>Base</CfgParent>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="('$(Platform)'=='Win32' and '$(Cfg_2)'=='true') or '$(Cfg_2_Win32)'!=''">
+        <Cfg_2_Win32>true</Cfg_2_Win32>
+        <CfgParent>Cfg_2</CfgParent>
+        <Cfg_2>true</Cfg_2>
+        <Base>true</Base>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Base)'!=''">
+        <DCC_F>false</DCC_F>
+        <DCC_S>false</DCC_S>
+        <DCC_E>false</DCC_E>
+        <Manifest_File>None</Manifest_File>
+        <DCC_ExeOutput>..\..\..\bin\</DCC_ExeOutput>
+        <DCC_N>false</DCC_N>
+        <DCC_ImageBase>00400000</DCC_ImageBase>
+        <DCC_Namespace>System;Xml;Data;Datasnap;Web;Soap;Winapi;$(DCC_Namespace)</DCC_Namespace>
+        <DCC_K>false</DCC_K>
+        <VerInfo_Keys>CompanyName=;FileDescription=;FileVersion=1.0.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProductName=;ProductVersion=1.0.0.0;Comments=;CFBundleName=;CFBundleDisplayName=;CFBundleIdentifier=;CFBundleVersion=;CFBundlePackageType=;CFBundleSignature=;CFBundleAllowMixedLocalizations=;CFBundleExecutable=</VerInfo_Keys>
+        <VerInfo_Locale>1049</VerInfo_Locale>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Base_Win32)'!=''">
+        <VerInfo_Keys>CompanyName=;FileDescription=;FileVersion=1.0.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProductName=;ProductVersion=1.0.0.0;Comments=</VerInfo_Keys>
+        <VerInfo_Locale>1033</VerInfo_Locale>
+        <DCC_Namespace>System.Win;Data.Win;Datasnap.Win;Web.Win;Soap.Win;Xml.Win;Bde;$(DCC_Namespace)</DCC_Namespace>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Cfg_1)'!=''">
+        <DCC_DebugInformation>false</DCC_DebugInformation>
+        <DCC_LocalDebugSymbols>false</DCC_LocalDebugSymbols>
+        <DCC_Define>RELEASE;$(DCC_Define)</DCC_Define>
+        <DCC_SymbolReferenceInfo>0</DCC_SymbolReferenceInfo>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Cfg_2)'!=''">
+        <DCC_Optimize>false</DCC_Optimize>
+        <DCC_GenerateStackFrames>true</DCC_GenerateStackFrames>
+        <DCC_Define>DEBUG;$(DCC_Define)</DCC_Define>
+    </PropertyGroup>
+    <PropertyGroup Condition="'$(Cfg_2_Win32)'!=''">
+        <Manifest_File>None</Manifest_File>
+        <VerInfo_Keys>CompanyName=;FileDescription=;FileVersion=1.0.0.0;InternalName=;LegalCopyright=;LegalTrademarks=;OriginalFilename=;ProductName=;ProductVersion=1.0.0.0;Comments=</VerInfo_Keys>
+        <VerInfo_Locale>1033</VerInfo_Locale>
+    </PropertyGroup>
+    <ItemGroup>
+        <DelphiCompile Include="$(MainSource)">
+            <MainSource>MainSource</MainSource>
+        </DelphiCompile>
+        <DCCReference Include="..\..\..\include\uLibName.pas"/>
+        <DCCReference Include="..\..\..\include\highgui\highgui_c.pas"/>
+        <DCCReference Include="..\..\..\include\сore\core_c.pas"/>
+        <DCCReference Include="..\..\..\include\сore\Core.types_c.pas"/>
+        <DCCReference Include="..\..\..\include\imgproc\imgproc.types_c.pas"/>
+        <DCCReference Include="..\..\..\include\imgproc\imgproc_c.pas"/>
+        <DCCReference Include="..\..\..\include\legacy\legacy.pas"/>
+        <DCCReference Include="..\..\..\include\calib3d\calib3d.pas"/>
+        <DCCReference Include="..\..\..\include\imgproc\imgproc.pas"/>
+        <DCCReference Include="..\..\..\include\objdetect\haar.pas"/>
+        <DCCReference Include="..\..\..\include\objdetect\objdetect.pas"/>
+        <DCCReference Include="..\..\..\include\video\tracking.pas"/>
+        <DCCReference Include="..\..\..\include\сore\core.pas"/>
+        <BuildConfiguration Include="Debug">
+            <Key>Cfg_2</Key>
+            <CfgParent>Base</CfgParent>
+        </BuildConfiguration>
+        <BuildConfiguration Include="Base">
+            <Key>Base</Key>
+        </BuildConfiguration>
+        <BuildConfiguration Include="Release">
+            <Key>Cfg_1</Key>
+            <CfgParent>Base</CfgParent>
+        </BuildConfiguration>
+    </ItemGroup>
+    <ProjectExtensions>
+        <Borland.Personality>Delphi.Personality.12</Borland.Personality>
+        <Borland.ProjectType/>
+        <BorlandProject>
+            <Delphi.Personality>
+                <Source>
+                    <Source Name="MainSource">FrameRecon.dpr</Source>
+                </Source>
+                <VersionInfo>
+                    <VersionInfo Name="IncludeVerInfo">False</VersionInfo>
+                    <VersionInfo Name="AutoIncBuild">False</VersionInfo>
+                    <VersionInfo Name="MajorVer">1</VersionInfo>
+                    <VersionInfo Name="MinorVer">0</VersionInfo>
+                    <VersionInfo Name="Release">0</VersionInfo>
+                    <VersionInfo Name="Build">0</VersionInfo>
+                    <VersionInfo Name="Debug">False</VersionInfo>
+                    <VersionInfo Name="PreRelease">False</VersionInfo>
+                    <VersionInfo Name="Special">False</VersionInfo>
+                    <VersionInfo Name="Private">False</VersionInfo>
+                    <VersionInfo Name="DLL">False</VersionInfo>
+                    <VersionInfo Name="Locale">1049</VersionInfo>
+                    <VersionInfo Name="CodePage">1251</VersionInfo>
+                </VersionInfo>
+                <VersionInfoKeys>
+                    <VersionInfoKeys Name="CompanyName"/>
+                    <VersionInfoKeys Name="FileDescription"/>
+                    <VersionInfoKeys Name="FileVersion">1.0.0.0</VersionInfoKeys>
+                    <VersionInfoKeys Name="InternalName"/>
+                    <VersionInfoKeys Name="LegalCopyright"/>
+                    <VersionInfoKeys Name="LegalTrademarks"/>
+                    <VersionInfoKeys Name="OriginalFilename"/>
+                    <VersionInfoKeys Name="ProductName"/>
+                    <VersionInfoKeys Name="ProductVersion">1.0.0.0</VersionInfoKeys>
+                    <VersionInfoKeys Name="Comments"/>
+                    <VersionInfoKeys Name="CFBundleName"/>
+                    <VersionInfoKeys Name="CFBundleDisplayName"/>
+                    <VersionInfoKeys Name="CFBundleIdentifier"/>
+                    <VersionInfoKeys Name="CFBundleVersion"/>
+                    <VersionInfoKeys Name="CFBundlePackageType"/>
+                    <VersionInfoKeys Name="CFBundleSignature"/>
+                    <VersionInfoKeys Name="CFBundleAllowMixedLocalizations"/>
+                    <VersionInfoKeys Name="CFBundleExecutable"/>
+                </VersionInfoKeys>
+            </Delphi.Personality>
+            <Platforms>
+                <Platform value="OSX32">False</Platform>
+                <Platform value="Win32">True</Platform>
+                <Platform value="Win64">False</Platform>
+            </Platforms>
+        </BorlandProject>
+        <ProjectFileVersion>12</ProjectFileVersion>
+    </ProjectExtensions>
+    <Import Project="$(BDS)\Bin\CodeGear.Delphi.Targets" Condition="Exists('$(BDS)\Bin\CodeGear.Delphi.Targets')"/>
+    <Import Project="$(APPDATA)\Embarcadero\$(BDSAPPDATABASEDIR)\$(PRODUCTVERSION)\UserTools.proj" Condition="Exists('$(APPDATA)\Embarcadero\$(BDSAPPDATABASEDIR)\$(PRODUCTVERSION)\UserTools.proj')"/>
+</Project>
+
+<!-- EurekaLog First Line
+[Exception Log]
+EurekaLog Version=7001
+DeleteMapAfterCompile=1
+EurekaLog Last Line -->

samples/Samples.groupproj

@@ -162,6 +162,9 @@
         <Projects Include="MultiDemo\fback\fback_c.dproj">
             <Dependencies/>
         </Projects>
+        <Projects Include="MultiDemo\FrameRecon\FrameRecon.dproj">
+            <Dependencies/>
+        </Projects>
     </ItemGroup>
     <ProjectExtensions>
         <Borland.Personality>Default.Personality.12</Borland.Personality>
@@ -647,14 +650,23 @@
     <Target Name="fback_c:Make">
         <MSBuild Projects="MultiDemo\fback\fback_c.dproj" Targets="Make"/>
     </Target>
+    <Target Name="FrameRecon">
+        <MSBuild Projects="MultiDemo\FrameRecon\FrameRecon.dproj"/>
+    </Target>
+    <Target Name="FrameRecon:Clean">
+        <MSBuild Projects="MultiDemo\FrameRecon\FrameRecon.dproj" Targets="Clean"/>
+    </Target>
+    <Target Name="FrameRecon:Make">
+        <MSBuild Projects="MultiDemo\FrameRecon\FrameRecon.dproj" Targets="Make"/>
+    </Target>
     <Target Name="Build">
-        <CallTarget Targets="cv_AddWeighted;cvSetImageROI_cvAddWeighted;cv_And;cv_Canny;cv_CopyMakeBorder;cv_CreateCameraCapture;cv_CreateTrackbar;cv_CreateVideoWriter;cv_CvtColor;cv_CvtPixToPlane;cvErode_cvDilate;cv_FindContours;cv_FloodFill;cv_GetSubRect;cv_HoughCircles;cv_HoughLines2;cv_InRangeS;cv_Laplace;cv_LoadImage;cv_LoadImage2;cv_LoadVideo;cv_MorphologyEx;cv_RandInt;cv_Resize;cv_SetImageROI;cv_SetImageROI2;cv_SetMouseCallback;cv_Smooth;cv_Sobel;cvSplit_cvMerge;cv_Save;cv_Sub;cvThreshold_cvAdaptiveThreshold;cv_Integral;cv_WarpPerspective;cv_MatchShapes;cv_WarpAffine;cv_SnakeImage;cv_CalcOpticalFlowPyrLK;cv_CreateGaussianBGModel;cv_CreateFGDStatModel;cvCodeBook;HelloWorld;VideoProcessing;FaceDetect;Stereo;CameraCaptureAndFindContours;HandsDetect;Squares;CameraCalibrate;CameraShift;minarea;fback_c"/>
+        <CallTarget Targets="cv_AddWeighted;cvSetImageROI_cvAddWeighted;cv_And;cv_Canny;cv_CopyMakeBorder;cv_CreateCameraCapture;cv_CreateTrackbar;cv_CreateVideoWriter;cv_CvtColor;cv_CvtPixToPlane;cvErode_cvDilate;cv_FindContours;cv_FloodFill;cv_GetSubRect;cv_HoughCircles;cv_HoughLines2;cv_InRangeS;cv_Laplace;cv_LoadImage;cv_LoadImage2;cv_LoadVideo;cv_MorphologyEx;cv_RandInt;cv_Resize;cv_SetImageROI;cv_SetImageROI2;cv_SetMouseCallback;cv_Smooth;cv_Sobel;cvSplit_cvMerge;cv_Save;cv_Sub;cvThreshold_cvAdaptiveThreshold;cv_Integral;cv_WarpPerspective;cv_MatchShapes;cv_WarpAffine;cv_SnakeImage;cv_CalcOpticalFlowPyrLK;cv_CreateGaussianBGModel;cv_CreateFGDStatModel;cvCodeBook;HelloWorld;VideoProcessing;FaceDetect;Stereo;CameraCaptureAndFindContours;HandsDetect;Squares;CameraCalibrate;CameraShift;minarea;fback_c;FrameRecon"/>
     </Target>
     <Target Name="Clean">
-        <CallTarget Targets="cv_AddWeighted:Clean;cvSetImageROI_cvAddWeighted:Clean;cv_And:Clean;cv_Canny:Clean;cv_CopyMakeBorder:Clean;cv_CreateCameraCapture:Clean;cv_CreateTrackbar:Clean;cv_CreateVideoWriter:Clean;cv_CvtColor:Clean;cv_CvtPixToPlane:Clean;cvErode_cvDilate:Clean;cv_FindContours:Clean;cv_FloodFill:Clean;cv_GetSubRect:Clean;cv_HoughCircles:Clean;cv_HoughLines2:Clean;cv_InRangeS:Clean;cv_Laplace:Clean;cv_LoadImage:Clean;cv_LoadImage2:Clean;cv_LoadVideo:Clean;cv_MorphologyEx:Clean;cv_RandInt:Clean;cv_Resize:Clean;cv_SetImageROI:Clean;cv_SetImageROI2:Clean;cv_SetMouseCallback:Clean;cv_Smooth:Clean;cv_Sobel:Clean;cvSplit_cvMerge:Clean;cv_Save:Clean;cv_Sub:Clean;cvThreshold_cvAdaptiveThreshold:Clean;cv_Integral:Clean;cv_WarpPerspective:Clean;cv_MatchShapes:Clean;cv_WarpAffine:Clean;cv_SnakeImage:Clean;cv_CalcOpticalFlowPyrLK:Clean;cv_CreateGaussianBGModel:Clean;cv_CreateFGDStatModel:Clean;cvCodeBook:Clean;HelloWorld:Clean;VideoProcessing:Clean;FaceDetect:Clean;Stereo:Clean;CameraCaptureAndFindContours:Clean;HandsDetect:Clean;Squares:Clean;CameraCalibrate:Clean;CameraShift:Clean;minarea:Clean;fback_c:Clean"/>
+        <CallTarget Targets="cv_AddWeighted:Clean;cvSetImageROI_cvAddWeighted:Clean;cv_And:Clean;cv_Canny:Clean;cv_CopyMakeBorder:Clean;cv_CreateCameraCapture:Clean;cv_CreateTrackbar:Clean;cv_CreateVideoWriter:Clean;cv_CvtColor:Clean;cv_CvtPixToPlane:Clean;cvErode_cvDilate:Clean;cv_FindContours:Clean;cv_FloodFill:Clean;cv_GetSubRect:Clean;cv_HoughCircles:Clean;cv_HoughLines2:Clean;cv_InRangeS:Clean;cv_Laplace:Clean;cv_LoadImage:Clean;cv_LoadImage2:Clean;cv_LoadVideo:Clean;cv_MorphologyEx:Clean;cv_RandInt:Clean;cv_Resize:Clean;cv_SetImageROI:Clean;cv_SetImageROI2:Clean;cv_SetMouseCallback:Clean;cv_Smooth:Clean;cv_Sobel:Clean;cvSplit_cvMerge:Clean;cv_Save:Clean;cv_Sub:Clean;cvThreshold_cvAdaptiveThreshold:Clean;cv_Integral:Clean;cv_WarpPerspective:Clean;cv_MatchShapes:Clean;cv_WarpAffine:Clean;cv_SnakeImage:Clean;cv_CalcOpticalFlowPyrLK:Clean;cv_CreateGaussianBGModel:Clean;cv_CreateFGDStatModel:Clean;cvCodeBook:Clean;HelloWorld:Clean;VideoProcessing:Clean;FaceDetect:Clean;Stereo:Clean;CameraCaptureAndFindContours:Clean;HandsDetect:Clean;Squares:Clean;CameraCalibrate:Clean;CameraShift:Clean;minarea:Clean;fback_c:Clean;FrameRecon:Clean"/>
     </Target>
     <Target Name="Make">
-        <CallTarget Targets="cv_AddWeighted:Make;cvSetImageROI_cvAddWeighted:Make;cv_And:Make;cv_Canny:Make;cv_CopyMakeBorder:Make;cv_CreateCameraCapture:Make;cv_CreateTrackbar:Make;cv_CreateVideoWriter:Make;cv_CvtColor:Make;cv_CvtPixToPlane:Make;cvErode_cvDilate:Make;cv_FindContours:Make;cv_FloodFill:Make;cv_GetSubRect:Make;cv_HoughCircles:Make;cv_HoughLines2:Make;cv_InRangeS:Make;cv_Laplace:Make;cv_LoadImage:Make;cv_LoadImage2:Make;cv_LoadVideo:Make;cv_MorphologyEx:Make;cv_RandInt:Make;cv_Resize:Make;cv_SetImageROI:Make;cv_SetImageROI2:Make;cv_SetMouseCallback:Make;cv_Smooth:Make;cv_Sobel:Make;cvSplit_cvMerge:Make;cv_Save:Make;cv_Sub:Make;cvThreshold_cvAdaptiveThreshold:Make;cv_Integral:Make;cv_WarpPerspective:Make;cv_MatchShapes:Make;cv_WarpAffine:Make;cv_SnakeImage:Make;cv_CalcOpticalFlowPyrLK:Make;cv_CreateGaussianBGModel:Make;cv_CreateFGDStatModel:Make;cvCodeBook:Make;HelloWorld:Make;VideoProcessing:Make;FaceDetect:Make;Stereo:Make;CameraCaptureAndFindContours:Make;HandsDetect:Make;Squares:Make;CameraCalibrate:Make;CameraShift:Make;minarea:Make;fback_c:Make"/>
+        <CallTarget Targets="cv_AddWeighted:Make;cvSetImageROI_cvAddWeighted:Make;cv_And:Make;cv_Canny:Make;cv_CopyMakeBorder:Make;cv_CreateCameraCapture:Make;cv_CreateTrackbar:Make;cv_CreateVideoWriter:Make;cv_CvtColor:Make;cv_CvtPixToPlane:Make;cvErode_cvDilate:Make;cv_FindContours:Make;cv_FloodFill:Make;cv_GetSubRect:Make;cv_HoughCircles:Make;cv_HoughLines2:Make;cv_InRangeS:Make;cv_Laplace:Make;cv_LoadImage:Make;cv_LoadImage2:Make;cv_LoadVideo:Make;cv_MorphologyEx:Make;cv_RandInt:Make;cv_Resize:Make;cv_SetImageROI:Make;cv_SetImageROI2:Make;cv_SetMouseCallback:Make;cv_Smooth:Make;cv_Sobel:Make;cvSplit_cvMerge:Make;cv_Save:Make;cv_Sub:Make;cvThreshold_cvAdaptiveThreshold:Make;cv_Integral:Make;cv_WarpPerspective:Make;cv_MatchShapes:Make;cv_WarpAffine:Make;cv_SnakeImage:Make;cv_CalcOpticalFlowPyrLK:Make;cv_CreateGaussianBGModel:Make;cv_CreateFGDStatModel:Make;cvCodeBook:Make;HelloWorld:Make;VideoProcessing:Make;FaceDetect:Make;Stereo:Make;CameraCaptureAndFindContours:Make;HandsDetect:Make;Squares:Make;CameraCalibrate:Make;CameraShift:Make;minarea:Make;fback_c:Make;FrameRecon:Make"/>
     </Target>
     <Import Project="$(BDS)\Bin\CodeGear.Group.Targets" Condition="Exists('$(BDS)\Bin\CodeGear.Group.Targets')"/>
 </Project>