These codes should be included into regular builds.
return cvCreateButton(button_name.c_str(), on_change, userdata, button_type , initial_button_state );
}
+#else
+
+CvFont cv::fontQt(const string&, int, Scalar, int, int, int)
+{
+ CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
+ return CvFont();
+}
+
+void cv::addText( const Mat&, const string&, Point, CvFont)
+{
+ CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
+}
+
+void cv::displayStatusBar(const string&, const string&, int)
+{
+ CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
+}
+
+void cv::displayOverlay(const string&, const string&, int )
+{
+ CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
+}
+
+int cv::startLoop(int (*)(int argc, char *argv[]), int , char**)
+{
+ CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
+ return 0;
+}
+
+void cv::stopLoop()
+{
+ CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
+}
+
+void cv::saveWindowParameters(const string&)
+{
+ CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
+}
+
+void cv::loadWindowParameters(const string&)
+{
+ CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
+}
+
+int cv::createButton(const string&, ButtonCallback, void*, int , bool )
+{
+ CV_Error(CV_StsNotImplemented, "The library is compiled without QT support");
+ return 0;
+}
+
#endif
#if defined WIN32 || defined _WIN32 // see window_w32.cpp
endif()
ENDMACRO()
- file(GLOB cpp_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+ file(GLOB_RECURSE cpp_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+
+ if(NOT HAVE_OPENGL)
+ ocv_list_filterout(cpp_samples Qt_sample)
+ endif()
+
+ if(NOT HAVE_opencv_gpu)
+ ocv_list_filterout(cpp_samples "/gpu/")
+ endif()
foreach(sample_filename ${cpp_samples})
get_filename_component(sample ${sample_filename} NAME_WE)
#include <iostream>
#include <vector>
-
#include <opencv/highgui.h>
-#include <GL/gl.h>
+
+#if defined WIN32 || defined _WIN32 || defined WINCE
+ #include <windows.h>
+ #undef small
+ #undef min
+ #undef max
+ #undef abs
+#endif
+
+#ifdef __APPLE__
+ #include <OpenGL/gl.h>
+#else
+ #include <GL/gl.h>
+#endif
+
#include <opencv/cxcore.h>
#include <opencv/cv.h>
+
using namespace std;
using namespace cv;
-void help()
+
+static void help()
{
cout << "\nThis demo demonstrates the use of the Qt enhanced version of the highgui GUI interface\n"
" and dang if it doesn't throw in the use of of the POSIT 3D tracking algorithm too\n"
#define FOCAL_LENGTH 600
#define CUBE_SIZE 10
-void renderCube(float size)
+static void renderCube(float size)
{
glBegin(GL_QUADS);
// Front Face
}
-void on_opengl(void* param)
+static void on_opengl(void* param)
{
//Draw the object with the estimated pose
glLoadIdentity();
glDisable( GL_LIGHTING );
}
-void initPOSIT(std::vector<CvPoint3D32f> *modelPoints)
+static void initPOSIT(std::vector<CvPoint3D32f> *modelPoints)
{
//Create the model pointss
modelPoints->push_back(cvPoint3D32f(0.0f, 0.0f, 0.0f)); //The first must be (0,0,0)
modelPoints->push_back(cvPoint3D32f(0.0f, CUBE_SIZE, 0.0f));
}
-void foundCorners(vector<CvPoint2D32f> *srcImagePoints,IplImage* source, IplImage* grayImage)
+static void foundCorners(vector<CvPoint2D32f> *srcImagePoints,IplImage* source, IplImage* grayImage)
{
cvCvtColor(source,grayImage,CV_RGB2GRAY);
cvSmooth( grayImage, grayImage,CV_GAUSSIAN,11);
if (contours.size() == srcImagePoints_temp.size())
{
- for(int i = 0 ; i<contours.size(); i++ )
+ for(size_t i = 0 ; i<contours.size(); i++ )
{
p.x = p.y = 0;
- for(int j = 0 ; j<contours[i].size(); j++ )
+ for(size_t j = 0 ; j<contours[i].size(); j++ )
p+=contours[i][j];
srcImagePoints_temp.at(i)=cvPoint2D32f(float(p.x)/contours[i].size(),float(p.y)/contours[i].size());
//< y = 3
//get point 0;
- int index = 0;
- for(int i = 1 ; i<srcImagePoints_temp.size(); i++ )
+ size_t index = 0;
+ for(size_t i = 1 ; i<srcImagePoints_temp.size(); i++ )
{
if (srcImagePoints_temp.at(i).y > srcImagePoints_temp.at(index).y)
index = i;
//get point 1;
index = 0;
- for(int i = 1 ; i<srcImagePoints_temp.size(); i++ )
+ for(size_t i = 1 ; i<srcImagePoints_temp.size(); i++ )
{
if (srcImagePoints_temp.at(i).x > srcImagePoints_temp.at(index).x)
index = i;
//get point 2;
index = 0;
- for(int i = 1 ; i<srcImagePoints_temp.size(); i++ )
+ for(size_t i = 1 ; i<srcImagePoints_temp.size(); i++ )
{
if (srcImagePoints_temp.at(i).x < srcImagePoints_temp.at(index).x)
index = i;
//get point 3;
index = 0;
- for(int i = 1 ; i<srcImagePoints_temp.size(); i++ )
+ for(size_t i = 1 ; i<srcImagePoints_temp.size(); i++ )
{
if (srcImagePoints_temp.at(i).y < srcImagePoints_temp.at(index).y)
index = i;
Mat Msource = source;
stringstream ss;
- for(int i = 0 ; i<srcImagePoints_temp.size(); i++ )
+ for(size_t i = 0 ; i<srcImagePoints_temp.size(); i++ )
{
ss<<i;
circle(Msource,srcImagePoints->at(i),5,CV_RGB(255,0,0));
}
-void createOpenGLMatrixFrom(float *posePOSIT,const CvMatr32f &rotationMatrix, const CvVect32f &translationVector)
+static void createOpenGLMatrixFrom(float *posePOSIT,const CvMatr32f &rotationMatrix, const CvVect32f &translationVector)
{
posePOSIT[15] = 1.0;
}
-int main(int argc, char *argv[])
+int main(void)
{
+ help();
CvCapture* video = cvCaptureFromFile("cube4.avi");
CV_Assert(video);
//For debug
//cvNamedWindow("tempGray",CV_WINDOW_AUTOSIZE);
float OpenGLMatrix[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
- cvCreateOpenGLCallback("POSIT",on_opengl,OpenGLMatrix);
+ cvSetOpenGlDrawCallback("POSIT",on_opengl,OpenGLMatrix);
vector<CvPoint3D32f> modelPoints;
initPOSIT(&modelPoints);
* @author OpenCV team
*/
-#include <cv.h>
-#include <highgui.h>
+#include "opencv2/highgui/highgui.hpp"
+#include <stdio.h>
using namespace cv;
* @function on_trackbar
* @brief Callback for trackbar
*/
-void on_trackbar( int, void* )
+static void on_trackbar( int, void* )
{
alpha = (double) alpha_slider/alpha_slider_max ;
* @function main
* @brief Main function
*/
-int main( int argc, char** argv )
+int main( void )
{
/// Read image ( same size, same type )
src1 = imread("../images/LinuxLogo.jpg");
* @author OpenCV team
*/
-#include <cv.h>
-#include <highgui.h>
+#include "opencv2/highgui/highgui.hpp"
using namespace cv;
/** Matrices to store images */
Mat image;
-Mat new_image;
/**
* @function on_trackbar
* @brief Called whenever any of alpha or beta changes
*/
-void on_trackbar( int, void* )
+static void on_trackbar( int, void* )
{
Mat new_image = Mat::zeros( image.size(), image.type() );
* @function main
* @brief Main function
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Read image given by user
image = imread( argv[1] );
-#include <iostream> // for standard I/O
+#include <iostream> // for standard I/O
#include <string> // for strings
#include <iomanip> // for controlling float print precision
#include <sstream> // string to number conversion
-#include <opencv2/imgproc/imgproc.hpp> // Gaussian Blur
#include <opencv2/core/core.hpp> // Basic OpenCV structures (cv::Mat, Scalar)
+#include <opencv2/imgproc/imgproc.hpp> // Gaussian Blur
#include <opencv2/highgui/highgui.hpp> // OpenCV window I/O
using namespace std;
double getPSNR ( const Mat& I1, const Mat& I2);
Scalar getMSSIM( const Mat& I1, const Mat& I2);
-void help()
+static void help()
{
cout
- << "\n--------------------------------------------------------------------------" << endl
- << "This program shows how to read a video file with OpenCV. In addition, it tests the"
- << " similarity of two input videos first with PSNR, and for the frames below a PSNR " << endl
- << "trigger value, also with MSSIM."<< endl
- << "Usage:" << endl
+ << "------------------------------------------------------------------------------" << endl
+ << "This program shows how to read a video file with OpenCV. In addition, it "
+ << "tests the similarity of two input videos first with PSNR, and for the frames "
+ << "below a PSNR trigger value, also with MSSIM." << endl
+ << "Usage:" << endl
<< "./video-source referenceVideo useCaseTestVideo PSNR_Trigger_Value Wait_Between_Frames " << endl
- << "--------------------------------------------------------------------------" << endl
+ << "--------------------------------------------------------------------------" << endl
<< endl;
}
-int main(int argc, char *argv[], char *window_name)
+
+int main(int argc, char *argv[])
{
help();
+
if (argc != 5)
{
cout << "Not enough parameters" << endl;
return -1;
}
+
stringstream conv;
- const string sourceReference = argv[1],sourceCompareWith = argv[2];
+ const string sourceReference = argv[1], sourceCompareWith = argv[2];
int psnrTriggerValue, delay;
- conv << argv[3] << endl << argv[4]; // put in the strings
- conv >> psnrTriggerValue >> delay;// take out the numbers
+ conv << argv[3] << endl << argv[4]; // put in the strings
+ conv >> psnrTriggerValue >> delay; // take out the numbers
char c;
- int frameNum = -1; // Frame counter
+ int frameNum = -1; // Frame counter
- VideoCapture captRefrnc(sourceReference),
- captUndTst(sourceCompareWith);
+ VideoCapture captRefrnc(sourceReference), captUndTst(sourceCompareWith);
- if ( !captRefrnc.isOpened())
+ if (!captRefrnc.isOpened())
{
cout << "Could not open reference " << sourceReference << endl;
return -1;
}
- if( !captUndTst.isOpened())
+ if (!captUndTst.isOpened())
{
cout << "Could not open case test " << sourceCompareWith << endl;
return -1;
}
Size refS = Size((int) captRefrnc.get(CV_CAP_PROP_FRAME_WIDTH),
- (int) captRefrnc.get(CV_CAP_PROP_FRAME_HEIGHT)),
- uTSi = Size((int) captUndTst.get(CV_CAP_PROP_FRAME_WIDTH),
- (int) captUndTst.get(CV_CAP_PROP_FRAME_HEIGHT));
+ (int) captRefrnc.get(CV_CAP_PROP_FRAME_HEIGHT)),
+ uTSi = Size((int) captUndTst.get(CV_CAP_PROP_FRAME_WIDTH),
+ (int) captUndTst.get(CV_CAP_PROP_FRAME_HEIGHT));
if (refS != uTSi)
{
const char* WIN_RF = "Reference";
// Windows
- namedWindow(WIN_RF, CV_WINDOW_AUTOSIZE );
- namedWindow(WIN_UT, CV_WINDOW_AUTOSIZE );
- cvMoveWindow(WIN_RF, 400 , 0); //750, 2 (bernat =0)
- cvMoveWindow(WIN_UT, refS.width, 0); //1500, 2
+ namedWindow(WIN_RF, CV_WINDOW_AUTOSIZE);
+ namedWindow(WIN_UT, CV_WINDOW_AUTOSIZE);
+ cvMoveWindow(WIN_RF, 400 , 0); //750, 2 (bernat =0)
+ cvMoveWindow(WIN_UT, refS.width, 0); //1500, 2
cout << "Reference frame resolution: Width=" << refS.width << " Height=" << refS.height
- << " of nr#: " << captRefrnc.get(CV_CAP_PROP_FRAME_COUNT) << endl;
+ << " of nr#: " << captRefrnc.get(CV_CAP_PROP_FRAME_COUNT) << endl;
- cout << "PSNR trigger value " <<
- setiosflags(ios::fixed) << setprecision(3) << psnrTriggerValue << endl;
+ cout << "PSNR trigger value " << setiosflags(ios::fixed) << setprecision(3)
+ << psnrTriggerValue << endl;
Mat frameReference, frameUnderTest;
double psnrV;
Scalar mssimV;
- while( true) //Show the image captured in the window and repeat
+ for(;;) //Show the image captured in the window and repeat
{
captRefrnc >> frameReference;
captUndTst >> frameUnderTest;
- if( frameReference.empty() || frameUnderTest.empty())
+ if (frameReference.empty() || frameUnderTest.empty())
{
cout << " < < < Game over! > > > ";
break;
}
++frameNum;
- cout <<"Frame:" << frameNum <<"# ";
+ cout << "Frame: " << frameNum << "# ";
///////////////////////////////// PSNR ////////////////////////////////////////////////////
- psnrV = getPSNR(frameReference,frameUnderTest); //get PSNR
+ psnrV = getPSNR(frameReference,frameUnderTest);
cout << setiosflags(ios::fixed) << setprecision(3) << psnrV << "dB";
//////////////////////////////////// MSSIM /////////////////////////////////////////////////
if (psnrV < psnrTriggerValue && psnrV)
{
- mssimV = getMSSIM(frameReference,frameUnderTest);
+ mssimV = getMSSIM(frameReference, frameUnderTest);
cout << " MSSIM: "
<< " R " << setiosflags(ios::fixed) << setprecision(2) << mssimV.val[2] * 100 << "%"
cout << endl;
////////////////////////////////// Show Image /////////////////////////////////////////////
- imshow( WIN_RF, frameReference);
- imshow( WIN_UT, frameUnderTest);
+ imshow(WIN_RF, frameReference);
+ imshow(WIN_UT, frameUnderTest);
- c = cvWaitKey(delay);
+ c = (char)cvWaitKey(delay);
if (c == 27) break;
}
s1.convertTo(s1, CV_32F); // cannot make a square on 8 bits
s1 = s1.mul(s1); // |I1 - I2|^2
- Scalar s = sum(s1); // sum elements per channel
+ Scalar s = sum(s1); // sum elements per channel
double sse = s.val[0] + s.val[1] + s.val[2]; // sum channels
return 0;
else
{
- double mse =sse /(double)(I1.channels() * I1.total());
- double psnr = 10.0*log10((255*255)/mse);
+ double mse = sse / (double)(I1.channels() * I1.total());
+ double psnr = 10.0 * log10((255 * 255) / mse);
return psnr;
}
}
{
const double C1 = 6.5025, C2 = 58.5225;
/***************************** INITS **********************************/
- int d = CV_32F;
+ int d = CV_32F;
Mat I1, I2;
- i1.convertTo(I1, d); // cannot calculate on one byte large values
+ i1.convertTo(I1, d); // cannot calculate on one byte large values
i2.convertTo(I2, d);
Mat I2_2 = I2.mul(I2); // I2^2
/*************************** END INITS **********************************/
- Mat mu1, mu2; // PRELIMINARY COMPUTING
+ Mat mu1, mu2; // PRELIMINARY COMPUTING
GaussianBlur(I1, mu1, Size(11, 11), 1.5);
GaussianBlur(I2, mu2, Size(11, 11), 1.5);
t1 = 2 * mu1_mu2 + C1;
t2 = 2 * sigma12 + C2;
- t3 = t1.mul(t2); // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
+ t3 = t1.mul(t2); // t3 = ((2*mu1_mu2 + C1).*(2*sigma12 + C2))
t1 = mu1_2 + mu2_2 + C1;
t2 = sigma1_2 + sigma2_2 + C2;
- t1 = t1.mul(t2); // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
+ t1 = t1.mul(t2); // t1 =((mu1_2 + mu2_2 + C1).*(sigma1_2 + sigma2_2 + C2))
Mat ssim_map;
- divide(t3, t1, ssim_map); // ssim_map = t3./t1;
+ divide(t3, t1, ssim_map); // ssim_map = t3./t1;
- Scalar mssim = mean( ssim_map ); // mssim = average of ssim map
+ Scalar mssim = mean(ssim_map); // mssim = average of ssim map
return mssim;
-}
\ No newline at end of file
+}
using namespace std;
using namespace cv;
-void help()
+static void help()
{
cout
- << "\n--------------------------------------------------------------------------" << endl
- << "This program shows how to write video files. You can extract the R or G or B color channel "
- << " of the input video.write " << endl
- << "Usage:" << endl
- << "./video-write inputvideoName [ R | G | B] [Y | N]" << endl
- << "--------------------------------------------------------------------------" << endl
+ << "------------------------------------------------------------------------------" << endl
+ << "This program shows how to write video files." << endl
+ << "You can extract the R or G or B color channel of the input video." << endl
+ << "Usage:" << endl
+ << "./video-write inputvideoName [ R | G | B] [Y | N]" << endl
+ << "------------------------------------------------------------------------------" << endl
<< endl;
}
-int main(int argc, char *argv[], char *window_name)
+
+int main(int argc, char *argv[])
{
help();
+
if (argc != 4)
{
cout << "Not enough parameters" << endl;
return -1;
}
- const string source = argv[1]; // the source file name
+ const string source = argv[1]; // the source file name
const bool askOutputType = argv[3][0] =='Y'; // If false it will use the inputs codec type
- VideoCapture inputVideo(source); // Open input
- if ( !inputVideo.isOpened())
+ VideoCapture inputVideo(source); // Open input
+ if (!inputVideo.isOpened())
{
- cout << "Could not open the input video." << source << endl;
+ cout << "Could not open the input video: " << source << endl;
return -1;
}
- string::size_type pAt = source.find_last_of('.'); // Find extension point
+ string::size_type pAt = source.find_last_of('.'); // Find extension point
const string NAME = source.substr(0, pAt) + argv[2][0] + ".avi"; // Form the new name with container
int ex = static_cast<int>(inputVideo.get(CV_CAP_PROP_FOURCC)); // Get Codec Type- Int form
// Transform from int to char via Bitwise operators
- char EXT[] = {ex & 0XFF , (ex & 0XFF00) >> 8,(ex & 0XFF0000) >> 16,(ex & 0XFF000000) >> 24, 0};
+ char EXT[] = {(char)(ex & 0XFF) , (char)((ex & 0XFF00) >> 8),(char)((ex & 0XFF0000) >> 16),(char)((ex & 0XFF000000) >> 24), 0};
- Size S = Size((int) inputVideo.get(CV_CAP_PROP_FRAME_WIDTH), //Acquire input size
+ Size S = Size((int) inputVideo.get(CV_CAP_PROP_FRAME_WIDTH), // Acquire input size
(int) inputVideo.get(CV_CAP_PROP_FRAME_HEIGHT));
VideoWriter outputVideo; // Open the output
if (askOutputType)
- outputVideo.open(NAME , ex=-1, inputVideo.get(CV_CAP_PROP_FPS),S, true);
+ outputVideo.open(NAME, ex=-1, inputVideo.get(CV_CAP_PROP_FPS), S, true);
else
- outputVideo.open(NAME , ex, inputVideo.get(CV_CAP_PROP_FPS),S, true);
+ outputVideo.open(NAME, ex, inputVideo.get(CV_CAP_PROP_FPS), S, true);
if (!outputVideo.isOpened())
{
return -1;
}
- union { int v; char c[5];} uEx ;
- uEx.v = ex; // From Int to char via union
- uEx.c[4]='\0';
-
cout << "Input frame resolution: Width=" << S.width << " Height=" << S.height
- << " of nr#: " << inputVideo.get(CV_CAP_PROP_FRAME_COUNT) << endl;
+ << " of nr#: " << inputVideo.get(CV_CAP_PROP_FRAME_COUNT) << endl;
cout << "Input codec type: " << EXT << endl;
- int channel = 2; // Select the channel to save
+ int channel = 2; // Select the channel to save
switch(argv[2][0])
{
- case 'R' : {channel = 2; break;}
- case 'G' : {channel = 1; break;}
- case 'B' : {channel = 0; break;}
+ case 'R' : channel = 2; break;
+ case 'G' : channel = 1; break;
+ case 'B' : channel = 0; break;
}
- Mat src,res;
+ Mat src, res;
vector<Mat> spl;
- while( true) //Show the image captured in the window and repeat
+ for(;;) //Show the image captured in the window and repeat
{
inputVideo >> src; // read
- if( src.empty()) break; // check if at end
+ if (src.empty()) break; // check if at end
- split(src, spl); // process - extract only the correct channel
- for( int i =0; i < 3; ++i)
- if (i != channel)
- spl[i] = Mat::zeros(S, spl[0].type());
+ split(src, spl); // process - extract only the correct channel
+ for (int i =0; i < 3; ++i)
+ if (i != channel)
+ spl[i] = Mat::zeros(S, spl[0].type());
merge(spl, res);
//outputVideo.write(res); //save or
cout << "Finished writing" << endl;
return 0;
-}
\ No newline at end of file
+}
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
Mat src, dst;
- char* source_window = "Source image";
- char* equalized_window = "Equalized Image";
+ const char* source_window = "Source image";
+ const char* equalized_window = "Equalized Image";
/// Load image
src = imread( argv[1], 1 );
/// Global Variables
Mat img; Mat templ; Mat result;
-char* image_window = "Source Image";
-char* result_window = "Result window";
+const char* image_window = "Source Image";
+const char* result_window = "Result window";
int match_method;
int max_Trackbar = 5;
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load image and template
img = imread( argv[1], 1 );
namedWindow( result_window, CV_WINDOW_AUTOSIZE );
/// Create Trackbar
- char* trackbar_label = "Method: \n 0: SQDIFF \n 1: SQDIFF NORMED \n 2: TM CCORR \n 3: TM CCORR NORMED \n 4: TM COEFF \n 5: TM COEFF NORMED";
+ const char* trackbar_label = "Method: \n 0: SQDIFF \n 1: SQDIFF NORMED \n 2: TM CCORR \n 3: TM CCORR NORMED \n 4: TM COEFF \n 5: TM COEFF NORMED";
createTrackbar( trackbar_label, image_window, &match_method, max_Trackbar, MatchingMethod );
MatchingMethod( 0, 0 );
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Read the image
src = imread( argv[1], 1 );
mixChannels( &hsv, 1, &hue, 1, ch, 1 );
/// Create Trackbar to enter the number of bins
- char* window_image = "Source image";
+ const char* window_image = "Source image";
namedWindow( window_image, CV_WINDOW_AUTOSIZE );
createTrackbar("* Hue bins: ", window_image, &bins, 180, Hist_and_Backproj );
Hist_and_Backproj(0, 0);
Mat mask;
int lo = 20; int up = 20;
-char* window_image = "Source image";
+const char* window_image = "Source image";
/// Function Headers
void Hist_and_Backproj( );
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Read the image
src = imread( argv[1], 1 );
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
Mat src, dst;
* @author OpenCV team
*/
-#include <cv.h>
-#include <highgui.h>
+#include "opencv2/highgui/highgui.hpp"
#include <iostream>
using namespace cv;
* @function main
* @brief Main function
*/
-int main( int argc, char** argv )
+int main( void )
{
double alpha = 0.5; double beta; double input;
src1 = imread("../images/LinuxLogo.jpg");
src2 = imread("../images/WindowsLogo.jpg");
- if( !src1.data ) { printf("Error loading src1 \n"); return -1; }
- if( !src2.data ) { printf("Error loading src2 \n"); return -1; }
+ if( !src1.data ) { std::cout<< "Error loading src1"<<std::endl; return -1; }
+ if( !src2.data ) { std::cout<< "Error loading src2"<<std::endl; return -1; }
/// Create Windows
namedWindow("Linear Blend", 1);
* @author OpenCV team
*/
-#include <cv.h>
-#include <highgui.h>
+#include "opencv2/highgui/highgui.hpp"
#include <iostream>
using namespace cv;
* @function main
* @brief Main function
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Read image given by user
Mat image = imread( argv[1] );
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
-#include "highgui.h"
#include <stdlib.h>
#include <stdio.h>
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load an image
src = imread( argv[1] );
*/
void Erosion( int, void* )
{
- int erosion_type;
+ int erosion_type = 0;
if( erosion_elem == 0 ){ erosion_type = MORPH_RECT; }
else if( erosion_elem == 1 ){ erosion_type = MORPH_CROSS; }
else if( erosion_elem == 2) { erosion_type = MORPH_ELLIPSE; }
*/
void Dilation( int, void* )
{
- int dilation_type;
+ int dilation_type = 0;
if( dilation_elem == 0 ){ dilation_type = MORPH_RECT; }
else if( dilation_elem == 1 ){ dilation_type = MORPH_CROSS; }
else if( dilation_elem == 2) { dilation_type = MORPH_ELLIPSE; }
int const max_elem = 2;
int const max_kernel_size = 21;
-char* window_name = "Morphology Transformations Demo";
+const char* window_name = "Morphology Transformations Demo";
/** Function Headers */
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load an image
src = imread( argv[1] );
/// Global variables
Mat src, dst, tmp;
-char* window_name = "Pyramids Demo";
+const char* window_name = "Pyramids Demo";
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( void )
{
/// General instructions
printf( "\n Zoom In-Out demo \n " );
imshow( window_name, dst );
/// Loop
- while( true )
+ for(;;)
{
int c;
c = waitKey(10);
char window_name[] = "Smoothing Demo";
/// Function headers
-int display_caption( char* caption );
+int display_caption( const char* caption );
int display_dst( int delay );
/**
* function main
*/
-int main( int argc, char** argv )
+int main( void )
{
namedWindow( window_name, CV_WINDOW_AUTOSIZE );
/**
* @function display_caption
*/
-int display_caption( char* caption )
+int display_caption( const char* caption )
{
dst = Mat::zeros( src.size(), src.type() );
putText( dst, caption,
int const max_BINARY_value = 255;
Mat src, src_gray, dst;
-char* window_name = "Threshold Demo";
+const char* window_name = "Threshold Demo";
-char* trackbar_type = "Type: \n 0: Binary \n 1: Binary Inverted \n 2: Truncate \n 3: To Zero \n 4: To Zero Inverted";
-char* trackbar_value = "Value";
+const char* trackbar_type = "Type: \n 0: Binary \n 1: Binary Inverted \n 2: Truncate \n 3: To Zero \n 4: To Zero Inverted";
+const char* trackbar_value = "Value";
/// Function headers
void Threshold_Demo( int, void* );
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load an image
src = imread( argv[1], 1 );
Threshold_Demo( 0, 0 );
/// Wait until user finishes program
- while(true)
+ for(;;)
{
int c;
c = waitKey( 20 );
int const max_lowThreshold = 100;
int ratio = 3;
int kernel_size = 3;
-char* window_name = "Edge Map";
+const char* window_name = "Edge Map";
/**
* @function CannyThreshold
* @brief Trackbar callback - Canny thresholds input with a ratio 1:3
*/
-void CannyThreshold(int, void*)
+static void CannyThreshold(int, void*)
{
/// Reduce noise with a kernel 3x3
blur( src_gray, detected_edges, Size(3,3) );
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load an image
src = imread( argv[1] );
using namespace std;
/// Global variables
-char* source_window = "Source image";
-char* warp_window = "Warp";
-char* warp_rotate_window = "Warp + Rotate";
+const char* source_window = "Source image";
+const char* warp_window = "Warp";
+const char* warp_rotate_window = "Warp + Rotate";
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
Point2f srcTri[3];
Point2f dstTri[3];
/// Set your 3 points to calculate the Affine Transform
srcTri[0] = Point2f( 0,0 );
- srcTri[1] = Point2f( src.cols - 1, 0 );
- srcTri[2] = Point2f( 0, src.rows - 1 );
+ srcTri[1] = Point2f( src.cols - 1.f, 0 );
+ srcTri[2] = Point2f( 0, src.rows - 1.f );
- dstTri[0] = Point2f( src.cols*0.0, src.rows*0.33 );
- dstTri[1] = Point2f( src.cols*0.85, src.rows*0.25 );
- dstTri[2] = Point2f( src.cols*0.15, src.rows*0.7 );
+ dstTri[0] = Point2f( src.cols*0.0f, src.rows*0.33f );
+ dstTri[1] = Point2f( src.cols*0.85f, src.rows*0.25f );
+ dstTri[2] = Point2f( src.cols*0.15f, src.rows*0.7f );
/// Get the Affine Transform
warp_mat = getAffineTransform( srcTri, dstTri );
/**
* @function main
*/
-int main(int argc, char** argv)
+int main(int, char** argv)
{
Mat src, src_gray;
int min_threshold = 50;
int max_trackbar = 150;
-char* standard_name = "Standard Hough Lines Demo";
-char* probabilistic_name = "Probabilistic Hough Lines Demo";
+const char* standard_name = "Standard Hough Lines Demo";
+const char* probabilistic_name = "Probabilistic Hough Lines Demo";
int s_trackbar = max_trackbar;
int p_trackbar = max_trackbar;
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Read the image
src = imread( argv[1], 1 );
HoughLines( edges, s_lines, 1, CV_PI/180, min_threshold + s_trackbar, 0, 0 );
/// Show the result
- for( int i = 0; i < s_lines.size(); i++ )
+ for( size_t i = 0; i < s_lines.size(); i++ )
{
float r = s_lines[i][0], t = s_lines[i][1];
double cos_t = cos(t), sin_t = sin(t);
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
Mat src, src_gray, dst;
int scale = 1;
int delta = 0;
int ddepth = CV_16S;
- char* window_name = "Laplace Demo";
-
- int c;
+ const char* window_name = "Laplace Demo";
/// Load an image
src = imread( argv[1] );
/// Global variables
Mat src, dst;
Mat map_x, map_y;
-char* remap_window = "Remap demo";
+const char* remap_window = "Remap demo";
int ind = 0;
/// Function Headers
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load the image
src = imread( argv[1], 1 );
namedWindow( remap_window, CV_WINDOW_AUTOSIZE );
/// Loop
- while( true )
+ for(;;)
{
/// Each 1 sec. Press ESC to exit the program
int c = waitKey( 1000 );
case 0:
if( i > src.cols*0.25 && i < src.cols*0.75 && j > src.rows*0.25 && j < src.rows*0.75 )
{
- map_x.at<float>(j,i) = 2*( i - src.cols*0.25 ) + 0.5 ;
- map_y.at<float>(j,i) = 2*( j - src.rows*0.25 ) + 0.5 ;
+ map_x.at<float>(j,i) = 2*( i - src.cols*0.25f ) + 0.5f ;
+ map_y.at<float>(j,i) = 2*( j - src.rows*0.25f ) + 0.5f ;
}
else
{ map_x.at<float>(j,i) = 0 ;
}
break;
case 1:
- map_x.at<float>(j,i) = i ;
- map_y.at<float>(j,i) = src.rows - j ;
+ map_x.at<float>(j,i) = (float)i ;
+ map_y.at<float>(j,i) = (float)(src.rows - j) ;
break;
case 2:
- map_x.at<float>(j,i) = src.cols - i ;
- map_y.at<float>(j,i) = j ;
+ map_x.at<float>(j,i) = (float)(src.cols - i) ;
+ map_y.at<float>(j,i) = (float)j ;
break;
case 3:
- map_x.at<float>(j,i) = src.cols - i ;
- map_y.at<float>(j,i) = src.rows - j ;
+ map_x.at<float>(j,i) = (float)(src.cols - i) ;
+ map_y.at<float>(j,i) = (float)(src.rows - j) ;
break;
} // end of switch
}
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
Mat src, src_gray;
Mat grad;
- char* window_name = "Sobel Demo - Simple Edge Detector";
+ const char* window_name = "Sobel Demo - Simple Edge Detector";
int scale = 1;
int delta = 0;
int ddepth = CV_16S;
- int c;
-
/// Load an image
src = imread( argv[1] );
int top, bottom, left, right;
int borderType;
Scalar value;
-char* window_name = "copyMakeBorder Demo";
+const char* window_name = "copyMakeBorder Demo";
RNG rng(12345);
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
int c;
src = imread( argv[1] );
if( !src.data )
- { return -1;
+ {
printf(" No data entered, please enter the path to an image file \n");
+ return -1;
}
/// Brief how-to for this program
imshow( window_name, dst );
- while( true )
+ for(;;)
{
c = waitKey(500);
/**
* @function main
*/
-int main ( int argc, char** argv )
+int main ( int, char** argv )
{
/// Declare variables
Mat src, dst;
double delta;
int ddepth;
int kernel_size;
- char* window_name = "filter2D Demo";
+ const char* window_name = "filter2D Demo";
int c;
/// Loop - Will filter the image with different kernel sizes each 0.5 seconds
int ind = 0;
- while( true )
+ for(;;)
{
c = waitKey(500);
/// Press 'ESC' to exit the program
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load source image and convert it to gray
src = imread( argv[1], 1 );
blur( src_gray, src_gray, Size(3,3) );
/// Create Window
- char* source_window = "Source";
+ const char* source_window = "Source";
namedWindow( source_window, CV_WINDOW_AUTOSIZE );
imshow( source_window, src );
/// Draw contours
Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
- for( int i = 0; i< contours.size(); i++ )
+ for( size_t i = 0; i< contours.size(); i++ )
{
Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
- drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() );
+ drawContours( drawing, contours, (int)i, color, 2, 8, hierarchy, 0, Point() );
}
/// Show in a window
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load source image and convert it to gray
src = imread( argv[1], 1 );
blur( src_gray, src_gray, Size(3,3) );
/// Create Window
- char* source_window = "Source";
+ const char* source_window = "Source";
namedWindow( source_window, CV_WINDOW_AUTOSIZE );
imshow( source_window, src );
vector<Point2f>center( contours.size() );
vector<float>radius( contours.size() );
- for( int i = 0; i < contours.size(); i++ )
+ for( size_t i = 0; i < contours.size(); i++ )
{ approxPolyDP( Mat(contours[i]), contours_poly[i], 3, true );
boundRect[i] = boundingRect( Mat(contours_poly[i]) );
minEnclosingCircle( contours_poly[i], center[i], radius[i] );
/// Draw polygonal contour + bonding rects + circles
Mat drawing = Mat::zeros( threshold_output.size(), CV_8UC3 );
- for( int i = 0; i< contours.size(); i++ )
+ for( size_t i = 0; i< contours.size(); i++ )
{
Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
- drawContours( drawing, contours_poly, i, color, 1, 8, vector<Vec4i>(), 0, Point() );
+ drawContours( drawing, contours_poly, (int)i, color, 1, 8, vector<Vec4i>(), 0, Point() );
rectangle( drawing, boundRect[i].tl(), boundRect[i].br(), color, 2, 8, 0 );
circle( drawing, center[i], (int)radius[i], color, 2, 8, 0 );
}
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load source image and convert it to gray
src = imread( argv[1], 1 );
blur( src_gray, src_gray, Size(3,3) );
/// Create Window
- char* source_window = "Source";
+ const char* source_window = "Source";
namedWindow( source_window, CV_WINDOW_AUTOSIZE );
imshow( source_window, src );
vector<RotatedRect> minRect( contours.size() );
vector<RotatedRect> minEllipse( contours.size() );
- for( int i = 0; i < contours.size(); i++ )
+ for( size_t i = 0; i < contours.size(); i++ )
{ minRect[i] = minAreaRect( Mat(contours[i]) );
if( contours[i].size() > 5 )
{ minEllipse[i] = fitEllipse( Mat(contours[i]) ); }
/// Draw contours + rotated rects + ellipses
Mat drawing = Mat::zeros( threshold_output.size(), CV_8UC3 );
- for( int i = 0; i< contours.size(); i++ )
+ for( size_t i = 0; i< contours.size(); i++ )
{
Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
// contour
- drawContours( drawing, contours, i, color, 1, 8, vector<Vec4i>(), 0, Point() );
+ drawContours( drawing, contours, (int)i, color, 1, 8, vector<Vec4i>(), 0, Point() );
// ellipse
ellipse( drawing, minEllipse[i], color, 2, 8 );
// rotated rectangle
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load source image and convert it to gray
src = imread( argv[1], 1 );
blur( src_gray, src_gray, Size(3,3) );
/// Create Window
- char* source_window = "Source";
+ const char* source_window = "Source";
namedWindow( source_window, CV_WINDOW_AUTOSIZE );
imshow( source_window, src );
/// Find the convex hull object for each contour
vector<vector<Point> >hull( contours.size() );
- for( int i = 0; i < contours.size(); i++ )
+ for( size_t i = 0; i < contours.size(); i++ )
{ convexHull( Mat(contours[i]), hull[i], false ); }
/// Draw contours + hull results
Mat drawing = Mat::zeros( threshold_output.size(), CV_8UC3 );
- for( int i = 0; i< contours.size(); i++ )
+ for( size_t i = 0; i< contours.size(); i++ )
{
Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
- drawContours( drawing, contours, i, color, 1, 8, vector<Vec4i>(), 0, Point() );
- drawContours( drawing, hull, i, color, 1, 8, vector<Vec4i>(), 0, Point() );
+ drawContours( drawing, contours, (int)i, color, 1, 8, vector<Vec4i>(), 0, Point() );
+ drawContours( drawing, hull, (int)i, color, 1, 8, vector<Vec4i>(), 0, Point() );
}
/// Show in a window
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load source image and convert it to gray
src = imread( argv[1], 1 );
blur( src_gray, src_gray, Size(3,3) );
/// Create Window
- char* source_window = "Source";
+ const char* source_window = "Source";
namedWindow( source_window, CV_WINDOW_AUTOSIZE );
imshow( source_window, src );
/// Get the moments
vector<Moments> mu(contours.size() );
- for( int i = 0; i < contours.size(); i++ )
+ for( size_t i = 0; i < contours.size(); i++ )
{ mu[i] = moments( contours[i], false ); }
/// Get the mass centers:
vector<Point2f> mc( contours.size() );
- for( int i = 0; i < contours.size(); i++ )
- { mc[i] = Point2f( mu[i].m10/mu[i].m00 , mu[i].m01/mu[i].m00 ); }
+ for( size_t i = 0; i < contours.size(); i++ )
+ { mc[i] = Point2f( static_cast<float>(mu[i].m10/mu[i].m00) , static_cast<float>(mu[i].m01/mu[i].m00) ); }
/// Draw contours
Mat drawing = Mat::zeros( canny_output.size(), CV_8UC3 );
- for( int i = 0; i< contours.size(); i++ )
+ for( size_t i = 0; i< contours.size(); i++ )
{
Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
- drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() );
+ drawContours( drawing, contours, (int)i, color, 2, 8, hierarchy, 0, Point() );
circle( drawing, mc[i], 4, color, -1, 8, 0 );
}
/// Calculate the area with the moments 00 and compare with the result of the OpenCV function
printf("\t Info: Area and Contour Length \n");
- for( int i = 0; i< contours.size(); i++ )
+ for( size_t i = 0; i< contours.size(); i++ )
{
- printf(" * Contour[%d] - Area (M_00) = %.2f - Area OpenCV: %.2f - Length: %.2f \n", i, mu[i].m00, contourArea(contours[i]), arcLength( contours[i], true ) );
+ printf(" * Contour[%d] - Area (M_00) = %.2f - Area OpenCV: %.2f - Length: %.2f \n", (int)i, mu[i].m00, contourArea(contours[i]), arcLength( contours[i], true ) );
Scalar color = Scalar( rng.uniform(0, 255), rng.uniform(0,255), rng.uniform(0,255) );
- drawContours( drawing, contours, i, color, 2, 8, hierarchy, 0, Point() );
+ drawContours( drawing, contours, (int)i, color, 2, 8, hierarchy, 0, Point() );
circle( drawing, mc[i], 4, color, -1, 8, 0 );
}
}
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( void )
{
/// Create an image
const int r = 100;
/// Create a sequence of points to make a contour:
vector<Point2f> vert(6);
- vert[0] = Point( 1.5*r, 1.34*r );
+ vert[0] = Point( 3*r/2, static_cast<int>(1.34*r) );
vert[1] = Point( 1*r, 2*r );
- vert[2] = Point( 1.5*r, 2.866*r );
- vert[3] = Point( 2.5*r, 2.866*r );
+ vert[2] = Point( 3*r/2, static_cast<int>(2.866*r) );
+ vert[3] = Point( 5*r/2, static_cast<int>(2.866*r) );
vert[4] = Point( 3*r, 2*r );
- vert[5] = Point( 2.5*r, 1.34*r );
+ vert[5] = Point( 5*r/2, static_cast<int>(1.34*r) );
/// Draw it in src
for( int j = 0; j < 6; j++ )
for( int j = 0; j < src.rows; j++ )
{ for( int i = 0; i < src.cols; i++ )
- { raw_dist.at<float>(j,i) = pointPolygonTest( contours[0], Point2f(i,j), true ); }
+ { raw_dist.at<float>(j,i) = (float)pointPolygonTest( contours[0], Point2f((float)i,(float)j), true ); }
}
double minVal; double maxVal;
{ for( int i = 0; i < src.cols; i++ )
{
if( raw_dist.at<float>(j,i) < 0 )
- { drawing.at<Vec3b>(j,i)[0] = 255 - (int) abs(raw_dist.at<float>(j,i))*255/minVal; }
+ { drawing.at<Vec3b>(j,i)[0] = (uchar)(255 - abs(raw_dist.at<float>(j,i))*255/minVal); }
else if( raw_dist.at<float>(j,i) > 0 )
- { drawing.at<Vec3b>(j,i)[2] = 255 - (int) raw_dist.at<float>(j,i)*255/maxVal; }
+ { drawing.at<Vec3b>(j,i)[2] = (uchar)(255 - raw_dist.at<float>(j,i)*255/maxVal); }
else
{ drawing.at<Vec3b>(j,i)[0] = 255; drawing.at<Vec3b>(j,i)[1] = 255; drawing.at<Vec3b>(j,i)[2] = 255; }
}
}
/// Create Window and show your results
- char* source_window = "Source";
+ const char* source_window = "Source";
namedWindow( source_window, CV_WINDOW_AUTOSIZE );
imshow( source_window, src );
namedWindow( "Distance", CV_WINDOW_AUTOSIZE );
RNG rng(12345);
-char* myHarris_window = "My Harris corner detector";
-char* myShiTomasi_window = "My Shi Tomasi corner detector";
+const char* myHarris_window = "My Harris corner detector";
+const char* myShiTomasi_window = "My Shi Tomasi corner detector";
/// Function headers
void myShiTomasi_function( int, void* );
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load source image and convert it to gray
src = imread( argv[1], 1 );
{
float lambda_1 = myHarris_dst.at<Vec6f>(j, i)[0];
float lambda_2 = myHarris_dst.at<Vec6f>(j, i)[1];
- Mc.at<float>(j,i) = lambda_1*lambda_2 - 0.04*pow( ( lambda_1 + lambda_2 ), 2 );
+ Mc.at<float>(j,i) = lambda_1*lambda_2 - 0.04f*pow( ( lambda_1 + lambda_2 ), 2 );
}
}
int thresh = 200;
int max_thresh = 255;
-char* source_window = "Source image";
-char* corners_window = "Corners detected";
+const char* source_window = "Source image";
+const char* corners_window = "Corners detected";
/// Function header
void cornerHarris_demo( int, void* );
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load source image and convert it to gray
src = imread( argv[1], 1 );
int maxTrackbar = 25;
RNG rng(12345);
-char* source_window = "Image";
+const char* source_window = "Image";
/// Function header
void goodFeaturesToTrack_Demo( int, void* );
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load source image and convert it to gray
src = imread( argv[1], 1 );
/// Draw corners detected
cout<<"** Number of corners detected: "<<corners.size()<<endl;
int r = 4;
- for( int i = 0; i < corners.size(); i++ )
+ for( size_t i = 0; i < corners.size(); i++ )
{ circle( copy, corners[i], r, Scalar(rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255)), -1, 8, 0 ); }
/// Show what you got
cornerSubPix( src_gray, corners, winSize, zeroZone, criteria );
/// Write them down
- for( int i = 0; i < corners.size(); i++ )
+ for( size_t i = 0; i < corners.size(); i++ )
{ cout<<" -- Refined Corner ["<<i<<"] ("<<corners[i].x<<","<<corners[i].y<<")"<<endl; }
}
int maxTrackbar = 100;
RNG rng(12345);
-char* source_window = "Image";
+const char* source_window = "Image";
/// Function header
void goodFeaturesToTrack_Demo( int, void* );
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( int, char** argv )
{
/// Load source image and convert it to gray
src = imread( argv[1], 1 );
/// Draw corners detected
cout<<"** Number of corners detected: "<<corners.size()<<endl;
int r = 4;
- for( int i = 0; i < corners.size(); i++ )
+ for( size_t i = 0; i < corners.size(); i++ )
{ circle( copy, corners[i], r, Scalar(rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255)), -1, 8, 0 ); }
/// Show what you got
#include <iostream>
#include <sstream>
#include <time.h>
+#include <stdio.h>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
using namespace cv;
using namespace std;
-void help()
+static void help()
{
cout << "This is a camera calibration sample." << endl
<< "Usage: calibration configurationFile" << endl
if (readStringList(input, imageList))
{
inputType = IMAGE_LIST;
- nrFrames = (nrFrames < imageList.size()) ? nrFrames : imageList.size();
+ nrFrames = (nrFrames < (int)imageList.size()) ? nrFrames : (int)imageList.size();
}
else
inputType = VIDEO_FILE;
};
-void write(FileStorage& fs, const std::string&, const Settings& x)
-{
- x.write(fs);
-}
-void read(const FileNode& node, Settings& x, const Settings& default_value = Settings())
+static void read(const FileNode& node, Settings& x, const Settings& default_value = Settings())
{
if(node.empty())
x = default_value;
case Settings::ASYMMETRIC_CIRCLES_GRID:
found = findCirclesGrid( view, s.boardSize, pointBuf, CALIB_CB_ASYMMETRIC_GRID );
break;
+ default:
+ found = false;
+ break;
}
if ( found) // If done with success,
//------------------------------ Show image and check for input commands -------------------
imshow("Image View", view);
- char key = waitKey(s.inputCapture.isOpened() ? 50 : s.delay);
+ char key = (char)waitKey(s.inputCapture.isOpened() ? 50 : s.delay);
if( key == ESC_KEY )
break;
continue;
remap(view, rview, map1, map2, INTER_LINEAR);
imshow("Image View", rview);
- char c = waitKey();
+ char c = (char)waitKey();
if( c == ESC_KEY || c == 'q' || c == 'Q' )
break;
}
return 0;
}
-double computeReprojectionErrors( const vector<vector<Point3f> >& objectPoints,
- const vector<vector<Point2f> >& imagePoints,
- const vector<Mat>& rvecs, const vector<Mat>& tvecs,
- const Mat& cameraMatrix , const Mat& distCoeffs,
- vector<float>& perViewErrors)
+
static double computeReprojectionErrors( const vector<vector<Point3f> >& objectPoints,
+
const vector<vector<Point2f> >& imagePoints,
+ const vector<Mat>& rvecs, const vector<Mat>& tvecs,
+ const Mat& cameraMatrix , const Mat& distCoeffs,
+ vector<float>& perViewErrors)
{
vector<Point2f> imagePoints2;
int i, totalPoints = 0;
return std::sqrt(totalErr/totalPoints);
}
-void calcBoardCornerPositions(Size boardSize, float squareSize, vector<Point3f>& corners,
- Settings::Pattern patternType /*= Settings::CHESSBOARD*/)
+
static void calcBoardCornerPositions(Size boardSize, float squareSize, vector<Point3f>& corners,
+ Settings::Pattern patternType /*= Settings::CHESSBOARD*/)
{
corners.clear();
for( int j = 0; j < boardSize.width; j++ )
corners.push_back(Point3f(float((2*j + i % 2)*squareSize), float(i*squareSize), 0));
break;
+ default:
+ break;
}
}
-bool runCalibration( Settings& s, Size& imageSize, Mat& cameraMatrix, Mat& distCoeffs,
- vector<vector<Point2f> > imagePoints, vector<Mat>& rvecs, vector<Mat>& tvecs,
- vector<float>& reprojErrs, double& totalAvgErr)
+static bool runCalibration( Settings& s, Size& imageSize, Mat& cameraMatrix, Mat& distCoeffs,
+
vector<vector<Point2f> > imagePoints, vector<Mat>& rvecs, vector<Mat>& tvecs,
+ vector<float>& reprojErrs, double& totalAvgErr)
{
cameraMatrix = Mat::eye(3, 3, CV_64F);
}
// Print camera parameters to the output file
-void saveCameraParams( Settings& s, Size& imageSize, Mat& cameraMatrix, Mat& distCoeffs,
- const vector<Mat>& rvecs, const vector<Mat>& tvecs,
- const vector<float>& reprojErrs, const vector<vector<Point2f> >& imagePoints,
- double totalAvgErr )
+static void saveCameraParams( Settings& s, Size& imageSize, Mat& cameraMatrix, Mat& distCoeffs,
+ const vector<Mat>& rvecs, const vector<Mat>& tvecs,
+
const vector<float>& reprojErrs, const vector<vector<Point2f> >& imagePoints,
+ double totalAvgErr )
{
FileStorage fs( s.outputFileName, FileStorage::WRITE );
- time_t t;
- time( &t );
- struct tm *t2 = localtime( &t );
+ time_t tm;
+ time( &tm );
+ struct tm *t2 = localtime( &tm );
char buf[1024];
strftime( buf, sizeof(buf)-1, "%c", t2 );
if( !imagePoints.empty() )
{
- Mat imagePtMat((int)imagePoints.size(), imagePoints[0].size(), CV_32FC2);
+ Mat imagePtMat((int)imagePoints.size(), (int)imagePoints[0].size(), CV_32FC2);
for( int i = 0; i < (int)imagePoints.size(); i++ )
{
Mat r = imagePtMat.row(i).reshape(2, imagePtMat.cols);
using namespace cv;
-char *windowDisparity = "Disparity";
+const char *windowDisparity = "Disparity";
void readme();
cv::Mat retinaOutput_magno;
// processing loop with no stop condition
- while(true)
+ for(;;)
{
// if using video stream, then, grabbing a new frame, else, input remains the same
if (videoCapture.isOpened())
* @function main
* @brief Main function
*/
-int main( int argc, char **argv ){
+int main( void ){
/// Windows names
char atom_window[] = "Drawing 1: Atom";
MyEllipse( atom_image, -45 );
/// 1.b. Creating circles
- MyFilledCircle( atom_image, Point( w/2.0, w/2.0) );
+ MyFilledCircle( atom_image, Point( w/2, w/2) );
/// 2. Draw a rook
/// ------------------
/// 2.b. Creating rectangles
rectangle( rook_image,
- Point( 0, 7*w/8.0 ),
+ Point( 0, 7*w/8 ),
Point( w, w),
Scalar( 0, 255, 255 ),
-1,
int lineType = 8;
ellipse( img,
- Point( w/2.0, w/2.0 ),
- Size( w/4.0, w/16.0 ),
+ Point( w/2, w/2 ),
+ Size( w/4, w/16 ),
angle,
0,
360,
circle( img,
center,
- w/32.0,
+ w/32,
Scalar( 0, 0, 255 ),
thickness,
lineType );
/** Create some points */
Point rook_points[1][20];
- rook_points[0][0] = Point( w/4.0, 7*w/8.0 );
- rook_points[0][1] = Point( 3*w/4.0, 7*w/8.0 );
- rook_points[0][2] = Point( 3*w/4.0, 13*w/16.0 );
- rook_points[0][3] = Point( 11*w/16.0, 13*w/16.0 );
- rook_points[0][4] = Point( 19*w/32.0, 3*w/8.0 );
- rook_points[0][5] = Point( 3*w/4.0, 3*w/8.0 );
- rook_points[0][6] = Point( 3*w/4.0, w/8.0 );
- rook_points[0][7] = Point( 26*w/40.0, w/8.0 );
- rook_points[0][8] = Point( 26*w/40.0, w/4.0 );
- rook_points[0][9] = Point( 22*w/40.0, w/4.0 );
- rook_points[0][10] = Point( 22*w/40.0, w/8.0 );
- rook_points[0][11] = Point( 18*w/40.0, w/8.0 );
- rook_points[0][12] = Point( 18*w/40.0, w/4.0 );
- rook_points[0][13] = Point( 14*w/40.0, w/4.0 );
- rook_points[0][14] = Point( 14*w/40.0, w/8.0 );
- rook_points[0][15] = Point( w/4.0, w/8.0 );
- rook_points[0][16] = Point( w/4.0, 3*w/8.0 );
- rook_points[0][17] = Point( 13*w/32.0, 3*w/8.0 );
- rook_points[0][18] = Point( 5*w/16.0, 13*w/16.0 );
- rook_points[0][19] = Point( w/4.0, 13*w/16.0) ;
+ rook_points[0][0] = Point( w/4, 7*w/8 );
+ rook_points[0][1] = Point( 3*w/4, 7*w/8 );
+ rook_points[0][2] = Point( 3*w/4, 13*w/16 );
+ rook_points[0][3] = Point( 11*w/16, 13*w/16 );
+ rook_points[0][4] = Point( 19*w/32, 3*w/8 );
+ rook_points[0][5] = Point( 3*w/4, 3*w/8 );
+ rook_points[0][6] = Point( 3*w/4, w/8 );
+ rook_points[0][7] = Point( 26*w/40, w/8 );
+ rook_points[0][8] = Point( 26*w/40, w/4 );
+ rook_points[0][9] = Point( 22*w/40, w/4 );
+ rook_points[0][10] = Point( 22*w/40, w/8 );
+ rook_points[0][11] = Point( 18*w/40, w/8 );
+ rook_points[0][12] = Point( 18*w/40, w/4 );
+ rook_points[0][13] = Point( 14*w/40, w/4 );
+ rook_points[0][14] = Point( 14*w/40, w/8 );
+ rook_points[0][15] = Point( w/4, w/8 );
+ rook_points[0][16] = Point( w/4, 3*w/8 );
+ rook_points[0][17] = Point( 13*w/32, 3*w/8 );
+ rook_points[0][18] = Point( 5*w/16, 13*w/16 );
+ rook_points[0][19] = Point( w/4, 13*w/16 );
const Point* ppt[1] = { rook_points[0] };
int npt[] = { 20 };
/**
* @function main
*/
-int main( int argc, char** argv )
+int main( void )
{
int c;
*/
int Drawing_Random_Lines( Mat image, char* window_name, RNG rng )
{
- int lineType = 8;
Point pt1, pt2;
for( int i = 0; i < NUMBER; i++ )
/**
* @function Displaying_Big_End
*/
-int Displaying_Big_End( Mat image, char* window_name, RNG rng )
+int Displaying_Big_End( Mat image, char* window_name, RNG )
{
Size textsize = getTextSize("OpenCV forever!", CV_FONT_HERSHEY_COMPLEX, 3, 5, 0);
Point org((window_width - textsize.width)/2, (window_height - textsize.height)/2);
using namespace cv;
using namespace std;
-void help(char* progName)
+static void help(char* progName)
{
cout << endl
<< "This program demonstrated the use of the discrete Fourier transform (DFT). " << endl
using namespace cv;
using namespace std;
-void help(char** av)
+static void help(char** av)
{
cout << endl
<< av[0] << " shows the usage of the OpenCV serialization functionality." << endl
};
//These write and read functions must be defined for the serialization in FileStorage to work
-void write(FileStorage& fs, const std::string&, const MyData& x)
+static void write(FileStorage& fs, const std::string&, const MyData& x)
{
x.write(fs);
}
-void read(const FileNode& node, MyData& x, const MyData& default_value = MyData()){
+static void read(const FileNode& node, MyData& x, const MyData& default_value = MyData()){
if(node.empty())
x = default_value;
else
}
// This function will print our custom class to the console
-ostream& operator<<(ostream& out, const MyData& m)
+static ostream& operator<<(ostream& out, const MyData& m)
{
out << "{ id = " << m.id << ", ";
out << "X = " << m.X << ", ";
using namespace std;
using namespace cv;
-void help()
+static void help()
{
cout
<< "\n--------------------------------------------------------------------------" << endl
uchar table[256];
for (int i = 0; i < 256; ++i)
- table[i] = divideWith* (i/divideWith);
+ table[i] = (uchar)(divideWith * (i/divideWith));
const int times = 100;
double t;
using namespace cv; // The new C++ interface API is inside this namespace. Import it.
using namespace std;
-void help( char* progName)
+static void help( char* progName)
{
cout << endl << progName
<< " shows how to use cv::Mat and IplImages together (converting back and forth)." << endl
using namespace std;
using namespace cv;
-void help(char* progName)
+static void help(char* progName)
{
cout << endl
<< "This program shows how to filter images with mask: the write it yourself and the"
using namespace std;
using namespace cv;
-void help()
+static void help()
{
cout
<< "\n--------------------------------------------------------------------------" << endl
cout << "Vector of floats via Mat = " << Mat(v) << endl << endl;
vector<Point2f> vPoints(20);
- for (size_t E = 0; E < vPoints.size(); ++E)
- vPoints[E] = Point2f((float)(E * 5), (float)(E % 7));
+ for (size_t i = 0; i < vPoints.size(); ++i)
+ vPoints[i] = Point2f((float)(i * 5), (float)(i % 7));
cout << "A vector of 2D Points = " << vPoints << endl << endl;
return 0;
//-- Show detected matches
imshow( "Good Matches", img_matches );
- for( int i = 0; i < good_matches.size(); i++ )
+ for( int i = 0; i < (int)good_matches.size(); i++ )
{ printf( "-- Good Match [%d] Keypoint 1: %d -- Keypoint 2: %d \n", i, good_matches[i].queryIdx, good_matches[i].trainIdx ); }
waitKey(0);
#include "opencv2/features2d/features2d.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/calib3d/calib3d.hpp"
-#include "opencv2/nonfree/features2d.cpp"
+#include "opencv2/nonfree/features2d.hpp"
using namespace cv;
std::vector<Point2f> obj;
std::vector<Point2f> scene;
- for( int i = 0; i < good_matches.size(); i++ )
+ for( size_t i = 0; i < good_matches.size(); i++ )
{
//-- Get the keypoints from the good matches
obj.push_back( keypoints_object[ good_matches[i].queryIdx ].pt );
//-- Draw lines between the corners (the mapped object in the scene - image_2 )
- line( img_matches, scene_corners[0] + Point2f( img_object.cols, 0), scene_corners[1] + Point2f( img_object.cols, 0), Scalar(0, 255, 0), 4 );
- line( img_matches, scene_corners[1] + Point2f( img_object.cols, 0), scene_corners[2] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 );
- line( img_matches, scene_corners[2] + Point2f( img_object.cols, 0), scene_corners[3] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 );
- line( img_matches, scene_corners[3] + Point2f( img_object.cols, 0), scene_corners[0] + Point2f( img_object.cols, 0), Scalar( 0, 255, 0), 4 );
+ Point2f offset( (float)img_object.cols, 0);
+ line( img_matches, scene_corners[0] + offset, scene_corners[1] + offset, Scalar(0, 255, 0), 4 );
+ line( img_matches, scene_corners[1] + offset, scene_corners[2] + offset, Scalar( 0, 255, 0), 4 );
+ line( img_matches, scene_corners[2] + offset, scene_corners[3] + offset, Scalar( 0, 255, 0), 4 );
+ line( img_matches, scene_corners[3] + offset, scene_corners[0] + offset, Scalar( 0, 255, 0), 4 );
//-- Show detected matches
imshow( "Good Matches & Object detection", img_matches );
#include "opencv2/core/core.hpp"
#include "opencv2/features2d/features2d.hpp"
#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/nonfree/features2d.cpp"
+#include "opencv2/nonfree/features2d.hpp"
using namespace cv;
extractor.compute( img_2, keypoints_2, descriptors_2 );
//-- Step 3: Matching descriptor vectors with a brute force matcher
- BruteForceMatcher< L2<float> > matcher;
+ BFMatcher matcher(NORM_L2);
std::vector< DMatch > matches;
matcher.match( descriptors_1, descriptors_2, matches );
#include "opencv2/core/core.hpp"
#include "opencv2/features2d/features2d.hpp"
#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/nonfree/features2d.cpp"
+#include "opencv2/nonfree/features2d.hpp"
using namespace cv;
};
Scalar getMSSIM_GPU_optimized( const Mat& i1, const Mat& i2, BufferMSSIM& b);
-void help()
+static void help()
{
cout
<< "\n--------------------------------------------------------------------------" << endl
<< endl;
}
-int main(int argc, char *argv[])
+int main(int, char *argv[])
{
help();
Mat I1 = imread(argv[1]); // Read the two images
int TIMES;
stringstream sstr(argv[3]);
sstr >> TIMES;
- double time, result;
+ double time, result = 0;
//------------------------------- PSNR CPU ----------------------------------------------------
time = (double)getTickCount();
time /= TIMES;
cout << "Time of PSNR CPU (averaged for " << TIMES << " runs): " << time << " milliseconds."
- << " With result of: " << result << endl;
+ << " With result of: " << result << endl;
//------------------------------- PSNR GPU ----------------------------------------------------
time = (double)getTickCount();
{
const float C1 = 6.5025f, C2 = 58.5225f;
/***************************** INITS **********************************/
- gpu::GpuMat gI1, gI2, gs1, t1,t2;
+ gpu::GpuMat gI1, gI2, gs1, tmp1,tmp2;
gI1.upload(i1);
gI2.upload(i2);
- gI1.convertTo(t1, CV_MAKE_TYPE(CV_32F, gI1.channels()));
- gI2.convertTo(t2, CV_MAKE_TYPE(CV_32F, gI2.channels()));
+ gI1.convertTo(tmp1, CV_MAKE_TYPE(CV_32F, gI1.channels()));
+ gI2.convertTo(tmp2, CV_MAKE_TYPE(CV_32F, gI2.channels()));
vector<gpu::GpuMat> vI1, vI2;
- gpu::split(t1, vI1);
- gpu::split(t2, vI2);
+ gpu::split(tmp1, vI1);
+ gpu::split(tmp2, vI2);
Scalar mssim;
for( int i = 0; i < gI1.channels(); ++i )
Scalar getMSSIM_GPU_optimized( const Mat& i1, const Mat& i2, BufferMSSIM& b)
{
- int cn = i1.channels();
-
const float C1 = 6.5025f, C2 = 58.5225f;
/***************************** INITS **********************************/
double getPSNR ( const Mat& I1, const Mat& I2);
Scalar getMSSIM( const Mat& I1, const Mat& I2);
-void help()
+static void help()
{
cout
<< "\n--------------------------------------------------------------------------" << endl
<< "--------------------------------------------------------------------------" << endl
<< endl;
}
-int main(int argc, char *argv[], char *window_name)
+int main(int argc, char *argv[])
{
help();
if (argc != 5)
double psnrV;
Scalar mssimV;
- while( true) //Show the image captured in the window and repeat
+ for(;;) //Show the image captured in the window and repeat
{
captRefrnc >> frameReference;
captUndTst >> frameUnderTest;
imshow( WIN_RF, frameReference);
imshow( WIN_UT, frameUnderTest);
- c = cvWaitKey(delay);
+ c = (char)cvWaitKey(delay);
if (c == 27) break;
}
using namespace cv;
using namespace std;
-void help()
+static void help()
{
cout<< "\n--------------------------------------------------------------------------" << endl
<< "This program shows Support Vector Machines for Non-Linearly Separable Data. " << endl
/**
* @function main
*/
-int main( int argc, const char** argv )
+int main( void )
{
CvCapture* capture;
Mat frame;
capture = cvCaptureFromCAM( -1 );
if( capture )
{
- while( true )
+ for(;;)
{
frame = cvQueryFrame( capture );
//-- Detect faces
face_cascade.detectMultiScale( frame_gray, faces, 1.1, 2, 0|CV_HAAR_SCALE_IMAGE, Size(30, 30) );
- for( int i = 0; i < faces.size(); i++ )
+ for( size_t i = 0; i < faces.size(); i++ )
{
- Point center( faces[i].x + faces[i].width*0.5, faces[i].y + faces[i].height*0.5 );
- ellipse( frame, center, Size( faces[i].width*0.5, faces[i].height*0.5), 0, 0, 360, Scalar( 255, 0, 255 ), 2, 8, 0 );
+ Point center( faces[i].x + faces[i].width/2, faces[i].y + faces[i].height/2 );
+ ellipse( frame, center, Size( faces[i].width/2, faces[i].height/2), 0, 0, 360, Scalar( 255, 0, 255 ), 2, 8, 0 );
Mat faceROI = frame_gray( faces[i] );
std::vector<Rect> eyes;
//-- In each face, detect eyes
eyes_cascade.detectMultiScale( faceROI, eyes, 1.1, 2, 0 |CV_HAAR_SCALE_IMAGE, Size(30, 30) );
- for( int j = 0; j < eyes.size(); j++ )
+ for( size_t j = 0; j < eyes.size(); j++ )
{
- Point center( faces[i].x + eyes[j].x + eyes[j].width*0.5, faces[i].y + eyes[j].y + eyes[j].height*0.5 );
+ Point eye_center( faces[i].x + eyes[j].x + eyes[j].width/2, faces[i].y + eyes[j].y + eyes[j].height/2 );
int radius = cvRound( (eyes[j].width + eyes[j].height)*0.25 );
- circle( frame, center, radius, Scalar( 255, 0, 0 ), 3, 8, 0 );
+ circle( frame, eye_center, radius, Scalar( 255, 0, 0 ), 3, 8, 0 );
}
}
//-- Show what you got
/**
* @function main
*/
-int main( int argc, const char** argv )
+int main( void )
{
CvCapture* capture;
Mat frame;
capture = cvCaptureFromCAM( -1 );
if( capture )
{
- while( true )
+ for(;;)
{
frame = cvQueryFrame( capture );
//-- Detect faces
face_cascade.detectMultiScale( frame_gray, faces, 1.1, 2, 0, Size(80, 80) );
- for( int i = 0; i < faces.size(); i++ )
+ for( size_t i = 0; i < faces.size(); i++ )
{
Mat faceROI = frame_gray( faces[i] );
std::vector<Rect> eyes;
if( eyes.size() == 2)
{
//-- Draw the face
- Point center( faces[i].x + faces[i].width*0.5, faces[i].y + faces[i].height*0.5 );
- ellipse( frame, center, Size( faces[i].width*0.5, faces[i].height*0.5), 0, 0, 360, Scalar( 255, 0, 0 ), 2, 8, 0 );
+ Point center( faces[i].x + faces[i].width/2, faces[i].y + faces[i].height/2 );
+ ellipse( frame, center, Size( faces[i].width/2, faces[i].height/2), 0, 0, 360, Scalar( 255, 0, 0 ), 2, 8, 0 );
- for( int j = 0; j < eyes.size(); j++ )
+ for( size_t j = 0; j < eyes.size(); j++ )
{ //-- Draw the eyes
- Point center( faces[i].x + eyes[j].x + eyes[j].width*0.5, faces[i].y + eyes[j].y + eyes[j].height*0.5 );
+ Point eye_center( faces[i].x + eyes[j].x + eyes[j].width/2, faces[i].y + eyes[j].y + eyes[j].height/2 );
int radius = cvRound( (eyes[j].width + eyes[j].height)*0.25 );
- circle( frame, center, radius, Scalar( 255, 0, 255 ), 3, 8, 0 );
+ circle( frame, eye_center, radius, Scalar( 255, 0, 255 ), 3, 8, 0 );
}
}
projects / profile / ivi / opencv.git / commitdiff