Corrections for compiling issues in Win, And and Doc

jperezrua · vpisarev · commit fe7bab499fb4 · 2013-09-30T14:39:17.000+04:00
diff --git a/modules/shape/doc/histogram_cost_matrix.rst b/modules/shape/doc/histogram_cost_matrix.rst
@@ -70,7 +70,7 @@ An Chi based cost extraction. ::
     CV_EXPORTS_W Ptr<HistogramCostExtractor> createChiHistogramCostExtractor(int nDummies=25, float defaultCost=0.2);
 
 EMDL1HistogramCostExtractor
--------------------------
+---------------------------
 .. ocv:class:: EMDL1HistogramCostExtractor : public HistogramCostExtractor
 
 An EMD-L1 based cost extraction. ::
diff --git a/modules/shape/doc/shape_distances.rst b/modules/shape/doc/shape_distances.rst
@@ -1,11 +1,11 @@
-Shape Distance and Common Interfaces 
+Shape Distance and Common Interfaces
 ====================================
 
 .. highlight:: cpp
 
 Shape Distance algorithms in OpenCV are derivated from a common interface that allows you to
 switch between them in a practical way for solving the same problem with different methods.
-Thus, all objects that implement shape distance measures inherit the 
+Thus, all objects that implement shape distance measures inherit the
 :ocv:class:`ShapeDistanceExtractor` interface.
 
 
@@ -123,7 +123,7 @@ ShapeContextDistanceExtractor::setShapeContextWeight
 ----------------------------------------------------
 Set the weight of the shape context distance in the final value of the shape distance.
 The shape context distance between two shapes is defined as the symmetric sum of shape
-context matching costs over best matching points. 
+context matching costs over best matching points.
 The final value of the shape distance is a user-defined linear combination of the shape
 context distance, an image appearance distance, and a bending energy.
 
diff --git a/modules/shape/include/opencv2/shape/emdL1.hpp b/modules/shape/include/opencv2/shape/emdL1.hpp
@@ -55,4 +55,4 @@ CV_EXPORTS float EMDL1(InputArray signature1, InputArray signature2);
 
 }//namespace cv
 
-#endif 
+#endif
diff --git a/modules/shape/src/aff_trans.cpp b/modules/shape/src/aff_trans.cpp
@@ -88,7 +88,7 @@ class AffineTransformerImpl : public AffineTransformer
     virtual void read(const FileNode& fn)
     {
         CV_Assert( (String)fn["name"] == name_ );
-        fullAffine = (int)fn["affine_type"];
+        fullAffine = (bool)int(fn["affine_type"]);
     }
 
 private:
diff --git a/modules/shape/src/emdL1.cpp b/modules/shape/src/emdL1.cpp
@@ -41,11 +41,11 @@
 //M*/
 
 /*
- * Implementation of an optimized EMD for histograms based in 
- * the papers "EMD-L1: An efficient and Robust Algorithm 
- * for comparing histogram-based descriptors", by Haibin Ling and 
+ * Implementation of an optimized EMD for histograms based in
+ * the papers "EMD-L1: An efficient and Robust Algorithm
+ * for comparing histogram-based descriptors", by Haibin Ling and
  * Kazunori Okuda; and "The Earth Mover's Distance is the Mallows
- * Distance: Some Insights from Statistics", by Elizaveta Levina and 
+ * Distance: Some Insights from Statistics", by Elizaveta Levina and
  * Peter Bickel, based on HAIBIN LING AND KAZUNORI OKADA implementation.
  */
  
@@ -393,9 +393,9 @@ bool EmdL1::greedySolution3()
 
                 //- determine which direction to move, either right or upward
                 dFlow = D[i1][i2][i3];
-                f1 = i1<(binsDim1-1)?fabs(dFlow+d1s[i1+1]):VHIGH;
-                f2 = i2<(binsDim2-1)?fabs(dFlow+d2s[i2+1]):VHIGH;
-                f3 = i3<(binsDim3-1)?fabs(dFlow+d3s[i3+1]):VHIGH;
+                f1 = i1<(binsDim1-1)?(float)fabs(dFlow+d1s[i1+1]):VHIGH;
+                f2 = i2<(binsDim2-1)?(float)fabs(dFlow+d2s[i2+1]):VHIGH;
+                f3 = i3<(binsDim3-1)?(float)fabs(dFlow+d3s[i3+1]):VHIGH;
 
                 if(f1<f2 && f1<f3)
                 {
@@ -791,4 +791,3 @@ float cv::EMDL1(InputArray _signature1, InputArray _signature2)
     EmdL1 emdl1;
     return emdl1.getEMDL1(signature1, signature2);
 }
-
diff --git a/modules/shape/src/emdL1_def.hpp b/modules/shape/src/emdL1_def.hpp
@@ -139,4 +139,3 @@ class EmdL1
     int	m_iFrom;
     int m_iTo;
 };
-
diff --git a/modules/shape/src/haus_dis.cpp b/modules/shape/src/haus_dis.cpp
@@ -88,7 +88,7 @@ class HausdorffDistanceExtractorImpl : public HausdorffDistanceExtractor
     {
         CV_Assert( (String)fn["name"] == name_ );
         distanceFlag = (int)fn["distance"];
-        rankProportion = (int)fn["rank"];
+        rankProportion = (float)fn["rank"];
     }
 
 private:
@@ -111,7 +111,7 @@ static float _apply(const Mat &set1, const Mat &set2, int distType, double propR
         for (int c=0; c<disMat.cols; c++)
         {
             Point2f diff = set1.at<Point2f>(0,r)-set2.at<Point2f>(0,c);
-            disMat.at<float>(r,c) = norm(Mat(diff), distType);
+            disMat.at<float>(r,c) = (float)norm(Mat(diff), distType);
         }
     }
 
@@ -147,5 +147,3 @@ Ptr <HausdorffDistanceExtractor> createHausdorffDistanceExtractor(int distanceFl
 }
 
 } // cv
-
-
diff --git a/modules/shape/src/hist_cost.cpp b/modules/shape/src/hist_cost.cpp
@@ -156,7 +156,7 @@ void NormHistogramCostExtractorImpl::buildCostMatrix(InputArray _descriptors1, I
             if (i<scd1.rows && j<scd2.rows)
             {
                 Mat columnDiff = scd1.row(i)-scd2.row(j);
-                costMatrix.at<float>(i,j)=norm(columnDiff, flag);
+                costMatrix.at<float>(i,j)=(float)norm(columnDiff, flag);
             }
             else
             {
@@ -288,11 +288,11 @@ void EMDHistogramCostExtractorImpl::buildCostMatrix(InputArray _descriptors1, In
                 sig2.col(0)=scd2.row(j).t();
                 for (int k=0; k<sig1.rows; k++)
                 {
-                    sig1.at<float>(k,1)=k;
+                    sig1.at<float>(k,1)=float(k);
                 }
                 for (int k=0; k<sig2.rows; k++)
                 {
-                    sig2.at<float>(k,1)=k;
+                    sig2.at<float>(k,1)=float(k);
                 }
 
                 costMatrix.at<float>(i,j) = cv::EMD(sig1, sig2, flag);
@@ -543,5 +543,3 @@ Ptr <HistogramCostExtractor> createEMDL1HistogramCostExtractor(int nDummies, flo
 }
 
 } // cv
-
-
diff --git a/modules/shape/src/sc_dis.cpp b/modules/shape/src/sc_dis.cpp
@@ -42,7 +42,7 @@
 
 /*
  * Implementation of the paper Shape Matching and Object Recognition Using Shape Contexts
- * Belongie et al., 2002 by Juan Manuel Perez for GSoC 2013. 
+ * Belongie et al., 2002 by Juan Manuel Perez for GSoC 2013.
  */
 #include "precomp.hpp"
 //#include "opencv2/highgui.hpp"
@@ -176,7 +176,7 @@ class SCD
         {
           for (int j=0; j<contourMat.cols; j++)
           {
-              disMatrix.at<float>(i,j) = norm( cv::Mat(contourMat.at<cv::Point2f>(0,i)-contourMat.at<cv::Point2f>(0,j)), cv::NORM_L2 );
+              disMatrix.at<float>(i,j) = (float)norm( cv::Mat(contourMat.at<cv::Point2f>(0,i)-contourMat.at<cv::Point2f>(0,j)), cv::NORM_L2 );
               if (_meanDistance<0)
               {
                   if (queryInliers.size()>0)
@@ -193,7 +193,7 @@ class SCD
 
         if (_meanDistance<0)
         {
-          meanDistance=mean(disMatrix, mask)[0];
+          meanDistance=(float)mean(disMatrix, mask)[0];
         }
         else
         {
@@ -239,7 +239,7 @@ class SCD
                           float refAngle = atan2(refPt.y, refPt.x);
                           angleMatrix.at<float>(i,j) -= refAngle;
                       }
-                      angleMatrix.at<float>(i,j) = fmod(angleMatrix.at<float>(i,j)+FLT_EPSILON,2*CV_PI)+CV_PI;
+                      angleMatrix.at<float>(i,j) = float(fmod(double(angleMatrix.at<float>(i,j)+(double)FLT_EPSILON),2*CV_PI)+CV_PI);
                       //angleMatrix.at<float>(i,j) = 1+floor( angleMatrix.at<float>(i,j)*nAngularBins/(2*CV_PI) );
                   }
               }
@@ -426,7 +426,7 @@ class SCDMatcher
             for (j = 0; j < costMatrix.rows; j++)
             {
                 d[j] = costMatrix.at<float>(freerow,j) - v[j];
-                pred[j] = freerow;
+                pred[j] = float(freerow);
                 collist[j] = j;        // init column list.
             }
 
@@ -479,7 +479,7 @@ class SCDMatcher
                         v2 = costMatrix.at<float>(i,j) - v[j] - h;
                         if (v2 < d[j])
                         {
-                            pred[j] = i;
+                            pred[j] = float(i);
                             if (v2 == min)
                             {
                                 if (colsol[j] < 0)
@@ -511,7 +511,7 @@ class SCDMatcher
             // reset row and column assignments along the alternating path.
             do
             {
-                i = pred[endofpath];
+                i = int(pred[endofpath]);
                 colsol[endofpath] = i;
                 j1 = endofpath;
                 endofpath = rowsol[i];
@@ -526,7 +526,7 @@ class SCDMatcher
         {
             double minval;
             minMaxIdx(trueCostMatrix.row(nrow), &minval);
-            leftcost+=minval;
+            leftcost+=float(minval);
         }
         leftcost /= trueCostMatrix.rows;
 
@@ -535,7 +535,7 @@ class SCDMatcher
         {
             double minval;
             minMaxIdx(trueCostMatrix.col(ncol), &minval);
-            rightcost+=minval;
+            rightcost+=float(minval);
         }
         rightcost /= trueCostMatrix.cols;
 
@@ -815,7 +815,7 @@ float ShapeContextDistanceExtractorImpl::computeDistance(InputArray contour1, In
                 {
                     float xx = sset1.at<Point2f>(0,pt).x;
                     float yy = sset1.at<Point2f>(0,pt).y;
-                    float val = std::exp( -( (xx-jj)*(xx-jj) + (yy-ii)*(yy-ii) )/(2*sigma*sigma) ) / (sigma*sigma*2*CV_PI);
+                    float val = float(std::exp( -float( (xx-jj)*(xx-jj) + (yy-ii)*(yy-ii) )/(2*sigma*sigma) ) / (sigma*sigma*2*CV_PI));
                     gaussWindow.at<float>(ii,jj) += val;
                 }
             }
@@ -831,7 +831,7 @@ float ShapeContextDistanceExtractorImpl::computeDistance(InputArray contour1, In
                 appIm.at<float>(ii,jj) = elema*elemb;
             }
         }
-        iAppearance = cv::sum(appIm)[0]/sset1.cols;
+        iAppearance = float(cv::sum(appIm)[0]/sset1.cols);
     }
     sDistance = matcher.getMatchingCost();
 
diff --git a/modules/shape/src/tps_trans.cpp b/modules/shape/src/tps_trans.cpp
@@ -104,7 +104,7 @@ class ThinPlateSplineShapeTransformerImpl : public ThinPlateSplineShapeTransform
     String name_;
 };
 
-static double distance(Point2f p, Point2f q)
+static float distance(Point2f p, Point2f q)
 {
     Point2f diff = p - q;
     float norma = diff.x*diff.x + diff.y*diff.y;// - 2*diff.x*diff.y;
@@ -237,7 +237,7 @@ void ThinPlateSplineShapeTransformerImpl::estimateTransformation(InputArray _pts
         {
             if (i==j)
             {
-                matK.at<float>(i,j)=regularizationParameter;
+                matK.at<float>(i,j)=float(regularizationParameter);
             }
             else
             {
diff --git a/modules/shape/test/test_hausdorff.cpp b/modules/shape/test/test_hausdorff.cpp
@@ -87,15 +87,15 @@ vector<Point2f> CV_HaussTest::normalizeContour(const vector<Point> &contour)
             else
             {
                 disMat.at<float>(ii,jj)=
-                    fabs(contour[ii].x*contour[jj].x)+fabs(contour[ii].y*contour[jj].y);
+                    float(fabs(double(contour[ii].x*contour[jj].x)))+float(fabs(double(contour[ii].y*contour[jj].y)));
             }
         }
         meanpt.x+=contour[ii].x;
         meanpt.y+=contour[ii].y;
     }
     meanpt.x/=contour.size();
     meanpt.y/=contour.size();
-    meanVal=cv::mean(disMat)[0];
+    meanVal=float(cv::mean(disMat)[0]);
     for (size_t ii=0; ii<contour.size(); ii++)
     {
         output[ii].x = (contour[ii].x-meanpt.x)/meanVal;
@@ -274,7 +274,7 @@ void CV_HaussTest::run(int /* */)
 {
     mpegTest();
     displayMPEGResults();
-	ts->set_failed_test_info(cvtest::TS::OK);	
+    ts->set_failed_test_info(cvtest::TS::OK);
 }
 
 TEST(Hauss, regression) { CV_HaussTest test; test.safe_run(); }
diff --git a/modules/shape/test/test_shape.cpp b/modules/shape/test/test_shape.cpp
@@ -81,7 +81,7 @@ CV_ShapeTest::~CV_ShapeTest()
 }
 
 vector <Point2f> CV_ShapeTest::convertContourType(const Mat& currentQuery, int n)
-{    
+{
     vector<vector<Point> > _contoursQuery;
     vector <Point2f> contoursQuery;
     findContours(currentQuery, _contoursQuery, RETR_LIST, CHAIN_APPROX_NONE);
diff --git a/samples/cpp/shape_example.cpp b/samples/cpp/shape_example.cpp
@@ -75,7 +75,7 @@ int main(int argc, char** argv)
     imshow("QUERY", queryToShow);
     moveWindow("TEST", 0,0);
     vector<Point> contQuery = simpleContour(query);
-    int bestMatch;
+    int bestMatch = 0;
     float bestDis=FLT_MAX;
     for ( int ii=1; ii<=20; ii++ )
     {
diff --git a/samples/cpp/shape_transformation.cpp b/samples/cpp/shape_transformation.cpp
@@ -48,7 +48,7 @@ int main(int argc, char** argv)
     BFMatcher matcher(NORM_L2);
     vector<DMatch> matches;
     matcher.match(descriptors1, descriptors2, matches);
-    
+
     // drawing the results
     namedWindow("matches", 1);
     Mat img_matches;

Original file line number	Diff line number	Diff line change
`@@ -55,4 +55,4 @@ CV_EXPORTS float EMDL1(InputArray signature1, InputArray signature2);`
`55`	`55`
`56`	`56`	`}//namespace cv`
`57`	`57`
`58`		`-#endif`
	`58`	`+#endif`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ class AffineTransformerImpl : public AffineTransformer`
`88`	`88`	`virtual void read(const FileNode& fn)`
`89`	`89`	`{`
`90`	`90`	`CV_Assert( (String)fn["name"] == name_ );`
`91`		`- fullAffine = (int)fn["affine_type"];`
	`91`	`+ fullAffine = (bool)int(fn["affine_type"]);`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`private:`
Original file line number	Diff line number	Diff line change
`@@ -88,7 +88,7 @@ class HausdorffDistanceExtractorImpl : public HausdorffDistanceExtractor`
`88`	`88`	`{`
`89`	`89`	`CV_Assert( (String)fn["name"] == name_ );`
`90`	`90`	`distanceFlag = (int)fn["distance"];`
`91`		`- rankProportion = (int)fn["rank"];`
	`91`	`+ rankProportion = (float)fn["rank"];`
`92`	`92`	`}`
`93`	`93`
`94`	`94`	`private:`
`@@ -111,7 +111,7 @@ static float _apply(const Mat &set1, const Mat &set2, int distType, double propR`
`111`	`111`	`for (int c=0; c<disMat.cols; c++)`
`112`	`112`	`{`
`113`	`113`	`Point2f diff = set1.at<Point2f>(0,r)-set2.at<Point2f>(0,c);`
`114`		`- disMat.at<float>(r,c) = norm(Mat(diff), distType);`
	`114`	`+ disMat.at<float>(r,c) = (float)norm(Mat(diff), distType);`
`115`	`115`	`}`
`116`	`116`	`}`
`117`	`117`
`@@ -147,5 +147,3 @@ Ptr <HausdorffDistanceExtractor> createHausdorffDistanceExtractor(int distanceFl`
`147`	`147`	`}`
`148`	`148`
`149`	`149`	`} // cv`
`150`		`-`
`151`		`-`
Original file line number	Diff line number	Diff line change
`@@ -156,7 +156,7 @@ void NormHistogramCostExtractorImpl::buildCostMatrix(InputArray _descriptors1, I`
`156`	`156`	`if (i<scd1.rows && j<scd2.rows)`
`157`	`157`	`{`
`158`	`158`	`Mat columnDiff = scd1.row(i)-scd2.row(j);`
`159`		`- costMatrix.at<float>(i,j)=norm(columnDiff, flag);`
	`159`	`+ costMatrix.at<float>(i,j)=(float)norm(columnDiff, flag);`
`160`	`160`	`}`
`161`	`161`	`else`
`162`	`162`	`{`
`@@ -288,11 +288,11 @@ void EMDHistogramCostExtractorImpl::buildCostMatrix(InputArray _descriptors1, In`
`288`	`288`	`sig2.col(0)=scd2.row(j).t();`
`289`	`289`	`for (int k=0; k<sig1.rows; k++)`
`290`	`290`	`{`
`291`		`- sig1.at<float>(k,1)=k;`
	`291`	`+ sig1.at<float>(k,1)=float(k);`
`292`	`292`	`}`
`293`	`293`	`for (int k=0; k<sig2.rows; k++)`
`294`	`294`	`{`
`295`		`- sig2.at<float>(k,1)=k;`
	`295`	`+ sig2.at<float>(k,1)=float(k);`
`296`	`296`	`}`
`297`	`297`
`298`	`298`	`costMatrix.at<float>(i,j) = cv::EMD(sig1, sig2, flag);`
`@@ -543,5 +543,3 @@ Ptr <HistogramCostExtractor> createEMDL1HistogramCostExtractor(int nDummies, flo`
`543`	`543`	`}`
`544`	`544`
`545`	`545`	`} // cv`
`546`		`-`
`547`		`-`
Original file line number	Diff line number	Diff line change
`@@ -42,7 +42,7 @@`
`42`	`42`
`43`	`43`	`/*`
`44`	`44`	`* Implementation of the paper Shape Matching and Object Recognition Using Shape Contexts`
`45`		`- * Belongie et al., 2002 by Juan Manuel Perez for GSoC 2013.`
	`45`	`+ * Belongie et al., 2002 by Juan Manuel Perez for GSoC 2013.`
`46`	`46`	`*/`
`47`	`47`	`#include "precomp.hpp"`
`48`	`48`	`//#include "opencv2/highgui.hpp"`
`@@ -176,7 +176,7 @@ class SCD`
`176`	`176`	`{`
`177`	`177`	`for (int j=0; j<contourMat.cols; j++)`
`178`	`178`	`{`
`179`		`- disMatrix.at<float>(i,j) = norm( cv::Mat(contourMat.at<cv::Point2f>(0,i)-contourMat.at<cv::Point2f>(0,j)), cv::NORM_L2 );`
	`179`	`+ disMatrix.at<float>(i,j) = (float)norm( cv::Mat(contourMat.at<cv::Point2f>(0,i)-contourMat.at<cv::Point2f>(0,j)), cv::NORM_L2 );`
`180`	`180`	`if (_meanDistance<0)`
`181`	`181`	`{`
`182`	`182`	`if (queryInliers.size()>0)`
`@@ -193,7 +193,7 @@ class SCD`
`193`	`193`
`194`	`194`	`if (_meanDistance<0)`
`195`	`195`	`{`
`196`		`- meanDistance=mean(disMatrix, mask)[0];`
	`196`	`+ meanDistance=(float)mean(disMatrix, mask)[0];`
`197`	`197`	`}`
`198`	`198`	`else`
`199`	`199`	`{`
`@@ -239,7 +239,7 @@ class SCD`
`239`	`239`	`float refAngle = atan2(refPt.y, refPt.x);`
`240`	`240`	`angleMatrix.at<float>(i,j) -= refAngle;`
`241`	`241`	`}`
`242`		`- angleMatrix.at<float>(i,j) = fmod(angleMatrix.at<float>(i,j)+FLT_EPSILON,2*CV_PI)+CV_PI;`
	`242`	`+ angleMatrix.at<float>(i,j) = float(fmod(double(angleMatrix.at<float>(i,j)+(double)FLT_EPSILON),2*CV_PI)+CV_PI);`
`243`	`243`	`//angleMatrix.at<float>(i,j) = 1+floor( angleMatrix.at<float>(i,j)nAngularBins/(2CV_PI) );`
`244`	`244`	`}`
`245`	`245`	`}`
`@@ -426,7 +426,7 @@ class SCDMatcher`
`426`	`426`	`for (j = 0; j < costMatrix.rows; j++)`
`427`	`427`	`{`
`428`	`428`	`d[j] = costMatrix.at<float>(freerow,j) - v[j];`
`429`		`- pred[j] = freerow;`
	`429`	`+ pred[j] = float(freerow);`
`430`	`430`	`collist[j] = j; // init column list.`
`431`	`431`	`}`
`432`	`432`
`@@ -479,7 +479,7 @@ class SCDMatcher`
`479`	`479`	`v2 = costMatrix.at<float>(i,j) - v[j] - h;`
`480`	`480`	`if (v2 < d[j])`
`481`	`481`	`{`
`482`		`- pred[j] = i;`
	`482`	`+ pred[j] = float(i);`
`483`	`483`	`if (v2 == min)`
`484`	`484`	`{`
`485`	`485`	`if (colsol[j] < 0)`
`@@ -511,7 +511,7 @@ class SCDMatcher`
`511`	`511`	`// reset row and column assignments along the alternating path.`
`512`	`512`	`do`
`513`	`513`	`{`
`514`		`- i = pred[endofpath];`
	`514`	`+ i = int(pred[endofpath]);`
`515`	`515`	`colsol[endofpath] = i;`
`516`	`516`	`j1 = endofpath;`
`517`	`517`	`endofpath = rowsol[i];`
`@@ -526,7 +526,7 @@ class SCDMatcher`
`526`	`526`	`{`
`527`	`527`	`double minval;`
`528`	`528`	`minMaxIdx(trueCostMatrix.row(nrow), &minval);`
`529`		`- leftcost+=minval;`
	`529`	`+ leftcost+=float(minval);`
`530`	`530`	`}`
`531`	`531`	`leftcost /= trueCostMatrix.rows;`
`532`	`532`
`@@ -535,7 +535,7 @@ class SCDMatcher`
`535`	`535`	`{`
`536`	`536`	`double minval;`
`537`	`537`	`minMaxIdx(trueCostMatrix.col(ncol), &minval);`
`538`		`- rightcost+=minval;`
	`538`	`+ rightcost+=float(minval);`
`539`	`539`	`}`
`540`	`540`	`rightcost /= trueCostMatrix.cols;`
`541`	`541`
`@@ -815,7 +815,7 @@ float ShapeContextDistanceExtractorImpl::computeDistance(InputArray contour1, In`
`815`	`815`	`{`
`816`	`816`	`float xx = sset1.at<Point2f>(0,pt).x;`
`817`	`817`	`float yy = sset1.at<Point2f>(0,pt).y;`
`818`		`- float val = std::exp( -( (xx-jj)(xx-jj) + (yy-ii)(yy-ii) )/(2sigmasigma) ) / (sigmasigma2*CV_PI);`
	`818`	`+ float val = float(std::exp( -float( (xx-jj)(xx-jj) + (yy-ii)(yy-ii) )/(2sigmasigma) ) / (sigmasigma2*CV_PI));`
`819`	`819`	`gaussWindow.at<float>(ii,jj) += val;`
`820`	`820`	`}`
`821`	`821`	`}`
`@@ -831,7 +831,7 @@ float ShapeContextDistanceExtractorImpl::computeDistance(InputArray contour1, In`
`831`	`831`	`appIm.at<float>(ii,jj) = elema*elemb;`
`832`	`832`	`}`
`833`	`833`	`}`
`834`		`- iAppearance = cv::sum(appIm)[0]/sset1.cols;`
	`834`	`+ iAppearance = float(cv::sum(appIm)[0]/sset1.cols);`
`835`	`835`	`}`
`836`	`836`	`sDistance = matcher.getMatchingCost();`
`837`	`837`
Original file line number	Diff line number	Diff line change
`@@ -104,7 +104,7 @@ class ThinPlateSplineShapeTransformerImpl : public ThinPlateSplineShapeTransform`
`104`	`104`	`String name_;`
`105`	`105`	`};`
`106`	`106`
`107`		`-static double distance(Point2f p, Point2f q)`
	`107`	`+static float distance(Point2f p, Point2f q)`
`108`	`108`	`{`
`109`	`109`	`Point2f diff = p - q;`
`110`	`110`	`float norma = diff.xdiff.x + diff.ydiff.y;// - 2diff.xdiff.y;`
`@@ -237,7 +237,7 @@ void ThinPlateSplineShapeTransformerImpl::estimateTransformation(InputArray _pts`
`237`	`237`	`{`
`238`	`238`	`if (i==j)`
`239`	`239`	`{`
`240`		`- matK.at<float>(i,j)=regularizationParameter;`
	`240`	`+ matK.at<float>(i,j)=float(regularizationParameter);`
`241`	`241`	`}`
`242`	`242`	`else`
`243`	`243`	`{`