#include <DetectionBasedTracker_jni.h>
-#include <opencv2/core/core.hpp>
+#include <opencv2/core.hpp>
#include <opencv2/objdetect.hpp>
#include <string>
#include <jni.h>
-#include <opencv2/core/core.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/features2d/features2d.hpp>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/features2d.hpp>
#include <vector>
using namespace std;
* 3calibration.cpp -- Calibrate 3 cameras in a horizontal line together.
*/
-#include "opencv2/calib3d/calib3d.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
-#include "opencv2/imgcodecs/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/calib3d.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/imgcodecs.hpp"
+#include "opencv2/highgui.hpp"
#include "opencv2/core/utility.hpp"
#include <stdio.h>
-#include "opencv2/imgproc/imgproc.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
#include <math.h>
#include <iostream>
-#include "opencv2/imgproc/imgproc.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include <fstream>
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
using namespace cv;
*
*/
-#include "opencv2/core/core.hpp"
+#include "opencv2/core.hpp"
#include <iostream>
using namespace std;
#if defined(__linux__) || defined(LINUX) || defined(__APPLE__) || defined(ANDROID)
-#include <opencv2/imgproc/imgproc.hpp> // Gaussian Blur
-#include <opencv2/core/core.hpp> // Basic OpenCV structures (cv::Mat, Scalar)
-#include <opencv2/videoio/videoio.hpp>
-#include <opencv2/highgui/highgui.hpp> // OpenCV window I/O
-#include <opencv2/features2d/features2d.hpp>
-#include <opencv2/objdetect/objdetect.hpp>
+#include <opencv2/imgproc.hpp> // Gaussian Blur
+#include <opencv2/core.hpp> // Basic OpenCV structures (cv::Mat, Scalar)
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp> // OpenCV window I/O
+#include <opencv2/features2d.hpp>
+#include <opencv2/objdetect.hpp>
#include <stdio.h>
#include <string>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
#include <iostream>
using namespace cv;
resize( gray, smallImg, Size(), fx, fx, INTER_LINEAR );
equalizeHist( smallImg, smallImg );
- t = (double)cvGetTickCount();
+ t = (double)getTickCount();
cascade.detectMultiScale( smallImg, faces,
1.1, 2, 0
//|CASCADE_FIND_BIGGEST_OBJECT
faces.push_back(Rect(smallImg.cols - r->x - r->width, r->y, r->width, r->height));
}
}
- t = (double)cvGetTickCount() - t;
- printf( "detection time = %g ms\n", t/((double)cvGetTickFrequency()*1000.) );
+ t = (double)getTickCount() - t;
+ printf( "detection time = %g ms\n", t*1000/getTickFrequency());
for ( size_t i = 0; i < faces.size(); i++ )
{
Rect r = faces[i];
*
*/
-#include "opencv2/objdetect/objdetect.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/objdetect.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
#include <cstdio>
#include "opencv2/video/tracking.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
-#include "opencv2/videoio/videoio.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/videoio/videoio.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
* filestorage_sample demonstrate the usage of the opencv serialization functionality
*/
-#include "opencv2/core/core.hpp"
+#include "opencv2/core.hpp"
#include <iostream>
#include <string>
*
*
********************************************************************************/
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
+
using namespace cv;
using namespace std;
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
#include <stdio.h>
#include <iostream>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/highgui.hpp>
#include <opencv2/core/utility.hpp>
using namespace cv; // all the new API is put into "cv" namespace. Export its content
-#include <opencv2/core/core.hpp>
-#include <opencv2/videoio/videoio.hpp>
-#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/core.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
#include <iostream>
/*this creates a yaml or xml list of files from the command line args
*/
-#include "opencv2/core/core.hpp"
+#include "opencv2/core.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include <string>
#include <iostream>
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
-#include "opencv2/photo/photo.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/photo.hpp"
#include <iostream>
// testOpenCVCam.cpp : Defines the entry point for the console application.
//
-#include "opencv2/videoio/videoio.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
#include "opencv2/video/tracking.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include <stdio.h>
-#include "opencv2/videoio/videoio.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <ctype.h>
#include <stdio.h>
-#include "opencv2/core/core.hpp"
-#include "opencv2/ml/ml.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/ml.hpp"
#include <cstdio>
#include <vector>
#include "opencv2/video/tracking.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
-#include "opencv2/videoio/videoio.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
#include <ctype.h>
#include <iostream>
-#include <string>
-#include "opencv2/core/core.hpp"
-#include "opencv2/core/utility.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
using namespace std;
using namespace cv;
Mat image = imread(in, IMREAD_GRAYSCALE);
+ if( image.empty() )
+ { return -1; }
+
#if 0
Canny(image, image, 50, 200, 3); // Apply canny edge
#endif
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include <stdlib.h>
#include <stdio.h>
#include <string>
return 0;
}
std::string filename = parser.get<std::string>("@image");
- if( (src = imread(filename,1)).empty() )
+ if( (src = imread(filename,IMREAD_COLOR)).empty() )
{
help();
return -1;
#include "opencv2/videoio/videoio.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
#include <fstream>
#include <sstream>
-#include <opencv2/core/core.hpp>
+#include <opencv2/core.hpp>
#include "opencv2/imgcodecs.hpp"
-#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/highgui.hpp>
using namespace cv;
using namespace std;
-#include "opencv2/core/core.hpp"
-#include "opencv2/videoio/videoio.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
using namespace cv;
-#include "opencv2/imgproc/imgproc_c.h"
-#include "opencv2/videoio/videoio_c.h"
-#include "opencv2/highgui/highgui_c.h"
-#include "opencv2/core/utility.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include <iostream>
-#include <ctype.h>
-#include <stdio.h>
+using namespace cv;
static void help( void )
{
printf("\nThis program illustrates Linear-Polar and Log-Polar image transforms\n"
"Usage :\n"
- "./polar_transforms [[camera number -- Default 0],[AVI path_filename]]\n\n"
- );
+ "./polar_transforms [[camera number -- Default 0],[path_to_filename]]\n\n");
}
+
int main( int argc, char** argv )
{
- CvCapture* capture = 0;
- IplImage* log_polar_img = 0;
- IplImage* lin_polar_img = 0;
- IplImage* recovered_img = 0;
+ VideoCapture capture;
+ Mat log_polar_img, lin_polar_img, recovered_log_polar, recovered_lin_polar_img;
help();
- cv::CommandLineParser parser(argc, argv, "{help h||}{@input|0|}");
- if (parser.has("help"))
- {
- help();
- return 0;
- }
+
+ CommandLineParser parser(argc, argv, "{@input|0|}");
std::string arg = parser.get<std::string>("@input");
+
if( arg.size() == 1 && isdigit(arg[0]) )
- capture = cvCaptureFromCAM( arg[0] - '0' );
+ capture.open( arg[0] - '0' );
else
- capture = cvCaptureFromAVI( arg.c_str() );
- if( !capture )
+ capture.open( arg.c_str() );
+
+ if( !capture.isOpened() )
{
const char* name = argv[0];
fprintf(stderr,"Could not initialize capturing...\n");
fprintf(stderr,"Usage: %s <CAMERA_NUMBER> , or \n %s <VIDEO_FILE>\n", name, name);
- help();
return -1;
}
- cvNamedWindow( "Linear-Polar", 0 );
- cvNamedWindow( "Log-Polar", 0 );
- cvNamedWindow( "Recovered image", 0 );
+ namedWindow( "Linear-Polar", WINDOW_NORMAL );
+ namedWindow( "Log-Polar", WINDOW_NORMAL );
+ namedWindow( "Recovered Linear-Polar", WINDOW_NORMAL );
+ namedWindow( "Recovered Log-Polar", WINDOW_NORMAL );
- cvMoveWindow( "Linear-Polar", 20,20 );
- cvMoveWindow( "Log-Polar", 700,20 );
- cvMoveWindow( "Recovered image", 20,700 );
+ moveWindow( "Linear-Polar", 20,20 );
+ moveWindow( "Log-Polar", 700,20 );
+ moveWindow( "Recovered Linear-Polar", 20, 350 );
+ moveWindow( "Recovered Log-Polar", 700, 350 );
for(;;)
{
- IplImage* frame = 0;
+ Mat frame;
+ capture >> frame;
- frame = cvQueryFrame( capture );
- if( !frame )
+ if( frame.empty() )
break;
- if( !log_polar_img )
- {
- log_polar_img = cvCreateImage( cvSize(frame->width,frame->height), IPL_DEPTH_8U, frame->nChannels );
- lin_polar_img = cvCreateImage( cvSize(frame->width,frame->height), IPL_DEPTH_8U, frame->nChannels );
- recovered_img = cvCreateImage( cvSize(frame->width,frame->height), IPL_DEPTH_8U, frame->nChannels );
- }
+ Point2f center( (float)frame.cols / 2, (float)frame.rows / 2 );
+ double M = (double)frame.cols / 8;
- cvLogPolar(frame,log_polar_img,cvPoint2D32f(frame->width >> 1,frame->height >> 1),70, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS);
- cvLinearPolar(frame,lin_polar_img,cvPoint2D32f(frame->width >> 1,frame->height >> 1),70, CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS);
+ logPolar(frame,log_polar_img, center, M, INTER_LINEAR + WARP_FILL_OUTLIERS);
+ linearPolar(frame,lin_polar_img, center, M, INTER_LINEAR + WARP_FILL_OUTLIERS);
-#if 0
- cvLogPolar(log_polar_img,recovered_img,cvPoint2D32f(frame->width >> 1,frame->height >> 1),70, CV_WARP_INVERSE_MAP+CV_INTER_LINEAR);
-#else
- cvLinearPolar(lin_polar_img,recovered_img,cvPoint2D32f(frame->width >> 1,frame->height >> 1),70, CV_WARP_INVERSE_MAP+CV_INTER_LINEAR+CV_WARP_FILL_OUTLIERS);
-#endif
+ logPolar(log_polar_img, recovered_log_polar, center, M, WARP_INVERSE_MAP + INTER_LINEAR);
+ linearPolar(lin_polar_img, recovered_lin_polar_img, center, M, WARP_INVERSE_MAP + INTER_LINEAR + WARP_FILL_OUTLIERS);
- cvShowImage("Log-Polar", log_polar_img );
- cvShowImage("Linear-Polar", lin_polar_img );
- cvShowImage("Recovered image", recovered_img );
+ imshow("Log-Polar", log_polar_img );
+ imshow("Linear-Polar", lin_polar_img );
+ imshow("Recovered Linear-Polar", recovered_lin_polar_img );
+ imshow("Recovered Log-Polar", recovered_log_polar );
- if( cvWaitKey(10) >= 0 )
+ if( waitKey(10) >= 0 )
break;
}
- cvReleaseCapture( &capture );
- cvDestroyWindow("Linear-Polar");
- cvDestroyWindow("Log-Polar");
- cvDestroyWindow("Recovered image");
-
+ waitKey(0);
return 0;
}
-
-#ifdef _EiC
-main(1,"laplace.c");
-#endif
-#include "opencv2/imgproc/imgproc.hpp"
-#include "opencv2/videoio/videoio.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
#include "opencv2/video/background_segm.hpp"
#include <stdio.h>
#include <string>
// It loads several images sequentially and tries to find squares in
// each image
-#include "opencv2/core/core.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
#include <math.h>
"Returns sequence of squares detected on the image.\n"
"the sequence is stored in the specified memory storage\n"
"Call:\n"
- "./squares\n"
- "Using OpenCV version %s\n" << CV_VERSION << "\n" << endl;
+ "./squares [file_name (optional)]\n"
+ "Using OpenCV version " << CV_VERSION << "\n" << endl;
}
}
-int main(int /*argc*/, char** /*argv*/)
+int main(int argc, char** argv)
{
static const char* names[] = { "../data/pic1.png", "../data/pic2.png", "../data/pic3.png",
"../data/pic4.png", "../data/pic5.png", "../data/pic6.png", 0 };
help();
+
+ if( argc > 1)
+ {
+ names[0] = argv[1];
+ names[1] = "0";
+ }
+
namedWindow( wndname, 1 );
vector<vector<Point> > squares;
* easy as CV_PI right?
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
#include <vector>
*/
#include <opencv2/imgcodecs.hpp>
-#include <opencv2/videoio/videoio.hpp>
-#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp>
#include <iostream>
#include <stdio.h>
GitHub: https://github.com/Itseez/opencv/
************************************************** */
-#include "opencv2/calib3d/calib3d.hpp"
+#include "opencv2/calib3d.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <vector>
#include <string>
*/
#include "opencv2/calib3d/calib3d.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include "opencv2/core/utility.hpp"
#include <stdio.h>
-#include "opencv2/ml/ml.hpp"
-#include "opencv2/core/core.hpp"
+#include "opencv2/ml.hpp"
+#include "opencv2/core.hpp"
#include "opencv2/core/utility.hpp"
#include <stdio.h>
#include <string>
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include <stdio.h>
using namespace cv;
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
using namespace cv;
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
using namespace cv;
using namespace std;
const char* equalized_window = "Equalized Image";
/// Load image
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
- { cout<<"Usage: ./Histogram_Demo <path_to_image>"<<endl;
+ { cout<<"Usage: ./EqualizeHist_Demo <path_to_image>"<<endl;
return -1;
}
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
using namespace std;
using namespace cv;
/**
* @function main
*/
-int main( int, char** argv )
+int main( int argc, char** argv )
{
+ if (argc < 3)
+ {
+ cout << "Not enough parameters" << endl;
+ cout << "Usage:\n./MatchTemplate_Demo <image_name> <template_name>" << endl;
+ return -1;
+ }
+
/// Load image and template
- img = imread( argv[1], 1 );
- templ = imread( argv[2], 1 );
+ img = imread( argv[1], IMREAD_COLOR );
+ templ = imread( argv[2], IMREAD_COLOR );
+
+ if(img.empty() || templ.empty())
+ {
+ cout << "Can't read one of the images" << endl;
+ return -1;
+ }
/// Create windows
namedWindow( image_window, WINDOW_AUTOSIZE );
* @author OpenCV team
*/
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
int main( int, char** argv )
{
/// Read the image
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
+
+ if( src.empty() )
+ { cout<<"Usage: ./calcBackProject_Demo1 <path_to_image>"<<endl;
+ return -1;
+ }
+
/// Transform it to HSV
cvtColor( src, hsv, COLOR_BGR2HSV );
* @author OpenCV team
*/
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
int main( int, char** argv )
{
/// Read the image
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
/// Transform it to HSV
cvtColor( src, hsv, COLOR_BGR2HSV );
* @author
*/
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
using namespace std;
using namespace cv;
/**
* @function main
*/
-int main( int, char** argv )
+int main(int argc, char** argv)
{
Mat src, dst;
/// Load image
- src = imread( argv[1], 1 );
+ String imageName( "../data/lena.jpg" ); // by default
+
+ if (argc > 1)
+ {
+ imageName = argv[1];
+ }
+
+ src = imread( imageName, IMREAD_COLOR );
if( src.empty() )
{ return -1; }
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
using namespace std;
using namespace cv;
/// Load three images with different environment settings
if( argc < 4 )
{
- printf("** Error. Usage: ./compareHist_Demo <image_settings0> <image_setting1> <image_settings2>\n");
+ printf("** Error. Usage: ./compareHist_Demo <image_settings0> <image_settings1> <image_settings2>\n");
return -1;
}
- src_base = imread( argv[1], 1 );
- src_test1 = imread( argv[2], 1 );
- src_test2 = imread( argv[3], 1 );
+ src_base = imread( argv[1], IMREAD_COLOR );
+ src_test1 = imread( argv[2], IMREAD_COLOR );
+ src_test2 = imread( argv[3], IMREAD_COLOR );
+
+ if(src_base.empty() || src_test1.empty() || src_test2.empty())
+ {
+ cout << "Can't read one of the images" << endl;
+ return -1;
+ }
/// Convert to HSV
cvtColor( src_base, hsv_base, COLOR_BGR2HSV );
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
using namespace cv;
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
using namespace cv;
* @author OpenCV team
*/
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include <stdlib.h>
-#include <stdio.h>
+#include "opencv2/highgui.hpp"
using namespace cv;
int main( int, char** argv )
{
/// Load an image
- src = imread( argv[1] );
+ src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{ return -1; }
* @author OpenCV team
*/
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include <stdlib.h>
-#include <stdio.h>
+#include "opencv2/highgui.hpp"
using namespace cv;
int main( int, char** argv )
{
/// Load an image
- src = imread( argv[1] );
+ src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{ return -1; }
*/
void Morphology_Operations( int, void* )
{
-
// Since MORPH_X : 2,3,4,5 and 6
int operation = morph_operator + 2;
* @author OpenCV team
*/
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include <math.h>
-#include <stdlib.h>
-#include <stdio.h>
+#include "opencv2/highgui.hpp"
using namespace cv;
* brief Sample code for simple filters
* author OpenCV team
*/
-#include <iostream>
-#include <vector>
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/features2d/features2d.hpp"
+#include "opencv2/highgui.hpp"
using namespace std;
using namespace cv;
namedWindow( window_name, WINDOW_AUTOSIZE );
/// Load the source image
- src = imread( "../data/lena.jpg", 1 );
+ src = imread( "../data/lena.jpg", IMREAD_COLOR );
if( display_caption( "Original Image" ) != 0 ) { return 0; }
* @author OpenCV team
*/
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include <stdlib.h>
-#include <stdio.h>
+#include "opencv2/highgui.hpp"
using namespace cv;
int main( int, char** argv )
{
/// Load an image
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
+
+ if( src.empty() )
+ { return -1; }
/// Convert the image to Gray
- cvtColor( src, src_gray, COLOR_RGB2GRAY );
+ cvtColor( src, src_gray, COLOR_BGR2GRAY );
/// Create a window to display results
namedWindow( window_name, WINDOW_AUTOSIZE );
* @author OpenCV team
*/
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include <stdlib.h>
-#include <stdio.h>
+#include "opencv2/highgui.hpp"
using namespace cv;
int main( int, char** argv )
{
/// Load an image
- src = imread( argv[1] );
+ src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{ return -1; }
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
using namespace cv;
using namespace std;
Mat src, warp_dst, warp_rotate_dst;
/// Load the image
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
/// Set the dst image the same type and size as src
warp_dst = Mat::zeros( src.rows, src.cols, src.type() );
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
using namespace std;
}
// Read the image
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
using namespace cv;
using namespace std;
int main( int, char** argv )
{
/// Read the image
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{ help();
* @author OpenCV team
*/
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include <stdlib.h>
-#include <stdio.h>
+#include "opencv2/highgui.hpp"
using namespace cv;
const char* window_name = "Laplace Demo";
/// Load an image
- src = imread( argv[1] );
+ src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{ return -1; }
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
using namespace cv;
int main( int, char** argv )
{
/// Load the image
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
/// Create dst, map_x and map_y with the same size as src:
dst.create( src.size(), src.type() );
* @author OpenCV team
*/
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include <stdlib.h>
-#include <stdio.h>
+#include "opencv2/highgui.hpp"
using namespace cv;
int ddepth = CV_16S;
/// Load an image
- src = imread( argv[1] );
+ src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{ return -1; }
* @author OpenCV team
*/
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include <stdlib.h>
-#include <stdio.h>
+#include "opencv2/highgui.hpp"
using namespace cv;
int c;
/// Load an image
- src = imread( argv[1] );
+ src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{
* @author OpenCV team
*/
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include <stdlib.h>
-#include <stdio.h>
+#include "opencv2/highgui.hpp"
using namespace cv;
int c;
/// Load an image
- src = imread( argv[1] );
+ src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{ return -1; }
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
-#include <stdlib.h>
using namespace cv;
using namespace std;
int main( int, char** argv )
{
/// Load source image
- src = imread(argv[1]);
+ src = imread(argv[1], IMREAD_COLOR);
if (src.empty())
{
cerr << "No image supplied ..." << endl;
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
-#include <stdlib.h>
using namespace cv;
using namespace std;
int main( int, char** argv )
{
/// Load source image and convert it to gray
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
/// Convert image to gray and blur it
cvtColor( src, src_gray, COLOR_BGR2GRAY );
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
-#include <stdlib.h>
using namespace cv;
using namespace std;
int main( int, char** argv )
{
/// Load source image and convert it to gray
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
/// Convert image to gray and blur it
cvtColor( src, src_gray, COLOR_BGR2GRAY );
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
-#include <stdlib.h>
using namespace cv;
using namespace std;
int main( int, char** argv )
{
/// Load source image and convert it to gray
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
/// Convert image to gray and blur it
cvtColor( src, src_gray, COLOR_BGR2GRAY );
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
-#include <stdlib.h>
using namespace cv;
using namespace std;
int main( int, char** argv )
{
/// Load source image and convert it to gray
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
/// Convert image to gray and blur it
cvtColor( src, src_gray, COLOR_BGR2GRAY );
* @author OpenCV team
*/
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
-#include <stdlib.h>
using namespace cv;
using namespace std;
* @brief Demo code for detecting corners using OpenCV built-in functions
* @author OpenCV team
*/
+
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
-#include <stdlib.h>
using namespace cv;
using namespace std;
int main( int, char** argv )
{
/// Load source image and convert it to gray
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
cvtColor( src, src_gray, COLOR_BGR2GRAY );
/// Set some parameters
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
-#include <stdlib.h>
using namespace cv;
using namespace std;
int main( int, char** argv )
{
/// Load source image and convert it to gray
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
cvtColor( src, src_gray, COLOR_BGR2GRAY );
/// Create a window and a trackbar
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
-#include <stdlib.h>
using namespace cv;
using namespace std;
int main( int, char** argv )
{
/// Load source image and convert it to gray
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
cvtColor( src, src_gray, COLOR_BGR2GRAY );
/// Create Window
*/
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include <iostream>
-#include <stdio.h>
-#include <stdlib.h>
using namespace cv;
using namespace std;
int main( int, char** argv )
{
/// Load source image and convert it to gray
- src = imread( argv[1], 1 );
+ src = imread( argv[1], IMREAD_COLOR );
cvtColor( src, src_gray, COLOR_BGR2GRAY );
/// Create Window
static void help()
{
cout << "This is a camera calibration sample." << endl
- << "Usage: calibration configurationFile" << endl
+ << "Usage: camera_calibration [configuration_file -- default ./default.xml]" << endl
<< "Near the sample file you'll find the configuration file, which has detailed help of "
"how to edit it. It may be any OpenCV supported file format XML/YAML." << endl;
}
for(size_t i = 0; i < s.imageList.size(); i++ )
{
- view = imread(s.imageList[i], 1);
+ view = imread(s.imageList[i], IMREAD_COLOR);
if(view.empty())
continue;
remap(view, rview, map1, map2, INTER_LINEAR);
#include "ModelRegistration.h"
#include "Utils.h"
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/calib3d/calib3d.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/calib3d.hpp>
// For text
int fontFace = cv::FONT_ITALIC;
#include <iostream>
#include <time.h>
// OpenCV
-#include <opencv2/core/core.hpp>
+#include <opencv2//core.hpp>
#include <opencv2/core/utility.hpp>
-#include <opencv2/highgui/highgui.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/calib3d/calib3d.hpp>
+#include <opencv2/highgui.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/calib3d.hpp>
#include <opencv2/video/tracking.hpp>
// PnP Tutorial
#include "Mesh.h"
// C++
#include <iostream>
// OpenCV
-#include <opencv2/core/core.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
-#include <opencv2/calib3d/calib3d.hpp>
-#include <opencv2/features2d/features2d.hpp>
+#include <opencv2/core.hpp>
+#include <opencv2/imgproc.hpp>
+#include <opencv2/calib3d.hpp>
+#include <opencv2/features2d.hpp>
// PnP Tutorial
#include "Mesh.h"
#include "Model.h"
* @author A. Huaman
*/
-#include <stdio.h>
#include <iostream>
-#include "opencv2/calib3d/calib3d.hpp"
-#include "opencv2/core/core.hpp"
+#include "opencv2/calib3d.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
using namespace cv;
-#include "opencv2/core/core.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
-#include <opencv2/core/core.hpp>
+#include <opencv2/core.hpp>
#include <iostream>
#include <string>
<< " we take an input image and divide the native color palette (255) with the " << endl
<< "input. Shows C operator[] method, iterators and at function for on-the-fly item address calculation."<< endl
<< "Usage:" << endl
- << "./howToScanImages imageNameToUse divideWith [G]" << endl
+ << "./how_to_scan_images <imageNameToUse> <divideWith> [G]" << endl
<< "if you add a G parameter the image is processed in gray scale" << endl
<< "--------------------------------------------------------------------------" << endl
<< endl;
//! [head]
-#include <stdio.h>
#include <iostream>
-#include <opencv2/core/core.hpp>
-#include <opencv2/imgproc/imgproc.hpp>
+#include <opencv2/imgproc.hpp>
#include "opencv2/imgcodecs.hpp"
-#include <opencv2/highgui/highgui.hpp>
-#include <opencv2/core/utility.hpp>
+#include <opencv2/highgui.hpp>
using namespace cv; // The new C++ interface API is inside this namespace. Import it.
using namespace std;
-#include <opencv2/core.hpp>
-#include <opencv2/core/utility.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
help(argv[0]);
const char* filename = argc >=2 ? argv[1] : "../data/lena.jpg";
- Mat I, J, K;
+ Mat src, dst0, dst1;
if (argc >= 3 && !strcmp("G", argv[2]))
- I = imread( filename, IMREAD_GRAYSCALE);
+ src = imread( filename, IMREAD_GRAYSCALE);
else
- I = imread( filename, IMREAD_COLOR);
+ src = imread( filename, IMREAD_COLOR);
+
+ if (src.empty())
+ {
+ cerr << "Can't open image [" << filename << "]" << endl;
+ return -1;
+ }
namedWindow("Input", WINDOW_AUTOSIZE);
namedWindow("Output", WINDOW_AUTOSIZE);
- imshow("Input", I);
+ imshow( "Input", src );
double t = (double)getTickCount();
- Sharpen(I, J);
+ Sharpen( src, dst0 );
t = ((double)getTickCount() - t)/getTickFrequency();
cout << "Hand written function times passed in seconds: " << t << endl;
- imshow("Output", J);
- waitKey(0);
+ imshow( "Output", dst0 );
+ waitKey();
- Mat kern = (Mat_<char>(3,3) << 0, -1, 0,
+ Mat kernel = (Mat_<char>(3,3) << 0, -1, 0,
-1, 5, -1,
0, -1, 0);
t = (double)getTickCount();
- filter2D(I, K, I.depth(), kern );
+ filter2D( src, dst1, src.depth(), kernel );
t = ((double)getTickCount() - t)/getTickFrequency();
cout << "Built-in filter2D time passed in seconds: " << t << endl;
- imshow("Output", K);
+ imshow( "Output", dst1 );
- waitKey(0);
+ waitKey();
return 0;
}
void Sharpen(const Mat& myImage,Mat& Result)
/* For description look into the help() function. */
-#include "opencv2/core/core.hpp"
+#include "opencv2/core.hpp"
#include <iostream>
using namespace std;
<< "That is, cv::Mat M(...); M.create and cout << M. " << endl
<< "Shows how output can be formated to OpenCV, python, numpy, csv and C styles." << endl
<< "Usage:" << endl
- << "./cvout_sample" << endl
+ << "./mat_the_basic_image_container" << endl
<< "--------------------------------------------------------------------------" << endl
<< endl;
}
*/
// OpenCV Headers
-#include "opencv2/core/core.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/highgui.hpp"
// C++ Standard Libraries
#include <cmath>
* Check input arguments
*/
if( argc < 3 ){
- cout << "usage: " << argv[0] << " <image> <dem>" << endl;
- return 1;
+ cout << "usage: " << argv[0] << " <image_name> <dem_model_name>" << endl;
+ return -1;
}
// load the image (note that we don't have the projection information. You will
//! [includes]
-#include <opencv2/core/core.hpp>
+#include <opencv2/core.hpp>
#include <opencv2/imgcodecs.hpp>
-#include <opencv2/highgui/highgui.hpp>
+#include <opencv2/highgui.hpp>
#include <iostream>
#include <string>
int main( int argc, char** argv )
{
//! [load]
- string imageName("../data/HappyFish.jpg"); // by default
+ String imageName( "../data/HappyFish.jpg" ); // by default
if( argc > 1)
{
imageName = argv[1];
//! [mat]
//! [imread]
- image = imread(imageName.c_str(), IMREAD_COLOR); // Read the file
+ image = imread( imageName, IMREAD_COLOR ); // Read the file
//! [imread]
if( image.empty() ) // Check for invalid input
int main(int argc, char *argv[])
{
CV_Assert(argc == 2);
- Mat I;
- I = imread(argv[1]);
+ Mat src;
+ src = imread(argv[1], IMREAD_COLOR);
- Mat gray = Mat(I.size(),CV_8UC1);
- Mat color_boost = Mat(I.size(),CV_8UC3);
+ Mat gray = Mat(src.size(),CV_8UC1);
+ Mat color_boost = Mat(src.size(),CV_8UC3);
- decolor(I,gray,color_boost);
+ decolor(src,gray,color_boost);
imshow("grayscale",gray);
imshow("color_boost",color_boost);
waitKey(0);
int num,type;
- Mat I = imread(argv[1]);
+ Mat src = imread(argv[1], IMREAD_COLOR);
- if(I.empty())
+ if(src.empty())
{
cout << "Image not found" << endl;
exit(0);
cin >> type;
- edgePreservingFilter(I,img,type);
+ edgePreservingFilter(src,img,type);
imshow("Edge Preserve Smoothing",img);
}
else if(num == 2)
{
- detailEnhance(I,img);
+ detailEnhance(src,img);
imshow("Detail Enhanced",img);
}
else if(num == 3)
{
Mat img1;
- pencilSketch(I,img1, img, 10 , 0.1f, 0.03f);
+ pencilSketch(src,img1, img, 10 , 0.1f, 0.03f);
imshow("Pencil Sketch",img1);
imshow("Color Pencil Sketch",img);
}
else if(num == 4)
{
- stylization(I,img);
+ stylization(src,img);
imshow("Stylization",img);
}
waitKey(0);
<< " OpenCV. You can process both videos (-vid) and images (-img)." << endl
<< endl
<< "Usage:" << endl
- << "./bs {-vid <video filename>|-img <image filename>}" << endl
- << "for example: ./bs -vid video.avi" << endl
- << "or: ./bs -img /data/images/1.png" << endl
+ << "./bg_sub {-vid <video filename>|-img <image filename>}" << endl
+ << "for example: ./bg_sub -vid video.avi" << endl
+ << "or: ./bg_sub -img /data/images/1.png" << endl
<< "--------------------------------------------------------------------------" << endl
<< endl;
}
#include <iomanip> // for controlling float print precision
#include <sstream> // string to number conversion
-#include <opencv2/core/core.hpp> // Basic OpenCV structures (cv::Mat, Scalar)
-#include <opencv2/imgproc/imgproc.hpp> // Gaussian Blur
-#include <opencv2/videoio/videoio.hpp>
-#include <opencv2/highgui/highgui.hpp> // OpenCV window I/O
+#include <opencv2/core.hpp> // Basic OpenCV structures (cv::Mat, Scalar)
+#include <opencv2/imgproc.hpp> // Gaussian Blur
+#include <opencv2/videoio.hpp>
+#include <opencv2/highgui.hpp> // OpenCV window I/O
using namespace std;
using namespace cv;
<< "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
+ << "./video-input-psnr-ssim <referenceVideo> <useCaseTestVideo> <PSNR_Trigger_Value> <Wait_Between_Frames> " << endl
<< "--------------------------------------------------------------------------" << endl
<< endl;
}
#include <iostream> // for standard I/O
#include <string> // for strings
-#include <opencv2/core/core.hpp> // Basic OpenCV structures (cv::Mat)
-#include <opencv2/videoio/videoio.hpp> // Video write
+#include <opencv2/core.hpp> // Basic OpenCV structures (cv::Mat)
+#include <opencv2/videoio.hpp> // Video write
using namespace std;
using namespace cv;
<< "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
+ << "./video-write <input_video_name> [ R | G | B] [Y | N]" << endl
<< "------------------------------------------------------------------------------" << endl
<< endl;
}
#include <iostream>
#include "opencv2/core/opengl.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include "opencv2/cudaimgproc.hpp"
using namespace std;
#include <iostream>
#include <iomanip>
-#include "opencv2/objdetect/objdetect.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/objdetect.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/cudaobjdetect.hpp"
#include "opencv2/cudaimgproc.hpp"
#include "opencv2/cudawarping.hpp"
#include <iostream>
#include "opencv2/cvconfig.h"
-#include "opencv2/core/core.hpp"
+#include "opencv2/core.hpp"
#include "opencv2/cudaarithm.hpp"
#ifdef HAVE_TBB
#include <iostream>
#include "opencv2/cvconfig.h"
-#include "opencv2/core/core.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/highgui.hpp"
#include "opencv2/cudastereo.hpp"
#ifdef HAVE_TBB
#include <iostream>
#include "opencv2/cvconfig.h"
-#include "opencv2/core/core.hpp"
+#include "opencv2/core.hpp"
#include "opencv2/cudaarithm.hpp"
#ifdef HAVE_TBB
#include <GL/glu.h>
#endif
-#include "opencv2/core/core.hpp"
+#include "opencv2/core.hpp"
#include "opencv2/core/opengl.hpp"
#include "opencv2/core/cuda.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
using namespace std;
using namespace cv;
#include <iomanip>
#include "opencv2/core/cuda.hpp"
#include "opencv2/cudalegacy.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/highgui/highgui_c.h"
+#include "opencv2/highgui.hpp"
#if !defined(HAVE_CUDA)
int main( int, const char** )
#ifdef HAVE_OPENCV_XFEATURES2D
-#include "opencv2/core/core.hpp"
-#include "opencv2/features2d/features2d.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/core.hpp"
+#include "opencv2/features2d.hpp"
+#include "opencv2/highgui.hpp"
#include "opencv2/cudafeatures2d.hpp"
#include "opencv2/xfeatures2d/cuda.hpp"
#include "opencv2/core/utility.hpp"
#include "opencv2/core/ocl.hpp"
#include "opencv2/video/tracking.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
-#include "opencv2/videoio/videoio.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/imgproc.hpp"
+#include "opencv2/videoio.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
#include <cctype>
#include <iostream>
-#include "opencv2/core/core.hpp"
+#include "opencv2/core.hpp"
#include "opencv2/core/ocl.hpp"
#include "opencv2/core/utility.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/videoio.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
using namespace cv;
using namespace std;
#include "opencv2/core.hpp"
#include "opencv2/core/ocl.hpp"
#include "opencv2/core/utility.hpp"
-#include "opencv2/imgproc/imgproc.hpp"
+#include "opencv2/imgproc.hpp"
#include "opencv2/imgcodecs.hpp"
-#include "opencv2/highgui/highgui.hpp"
+#include "opencv2/highgui.hpp"
#include <iostream>
#include <string.h>
#include "opencv2/core/utility.hpp"
#include "opencv2/imgcodecs.hpp"
#include "opencv2/videoio.hpp"
-#include "opencv2/highgui/highgui.hpp"
-#include "opencv2/video/video.hpp"
+#include "opencv2/highgui.hpp"
+#include "opencv2/video.hpp"
using namespace std;
using namespace cv;
#include "MainPage.xaml.h"
#include <opencv2\imgproc\types_c.h>
-#include <opencv2\imgcodecs\imgcodecs.hpp>
-#include <opencv2\core\core.hpp>
-#include <opencv2\imgproc\imgproc.hpp>
+#include <opencv2\imgcodecs.hpp>
+#include <opencv2\core.hpp>
+#include <opencv2\imgproc.hpp>
#include <opencv2\highgui.hpp>
#include <opencv2\highgui\highgui_winrt.hpp>
} else {
Windows::UI::Popups::MessageDialog("Initialize image before processing \n").ShowAsync();
}
-}
\ No newline at end of file
+}
#include "OcvTransform.h"
#include "bufferlock.h"
-#include <opencv2\core\core.hpp>
-#include <opencv2\imgproc\imgproc.hpp>
-#include <opencv2\features2d\features2d.hpp>
+#include <opencv2\core.hpp>
+#include <opencv2\imgproc.hpp>
+#include <opencv2\features2d.hpp>
#include <Robuffer.h>
#include <vector>
#include <opencv2\imgproc\types_c.h>
-#include <opencv2\imgcodecs\imgcodecs.hpp>
-#include <opencv2\core\core.hpp>
+#include <opencv2\imgcodecs.hpp>
+#include <opencv2\core.hpp>
#include <windows.storage.h>
#include "MainPage.xaml.h"
#include <opencv2\imgproc\types_c.h>
-#include <opencv2\core\core.hpp>
-#include <opencv2\imgproc\imgproc.hpp>
+#include <opencv2\core.hpp>
+#include <opencv2\imgproc.hpp>
#include <Robuffer.h>
#include <ppl.h>
#include <ppltasks.h>
#include <windows.storage.streams.h>
#include <wrl.h>
#include <robuffer.h>
-#include <opencv2\core\core.hpp>
-#include <opencv2\imgproc\imgproc.hpp>
-#include <opencv2\features2d\features2d.hpp>
+#include <opencv2\core.hpp>
+#include <opencv2\imgproc.hpp>
+#include <opencv2\features2d.hpp>
#include <algorithm>
using namespace Windows::Storage::Streams;
#include "OpenCVComponent.h"
#include <opencv2\imgproc\types_c.h>
-#include <opencv2\core\core.hpp>
-#include <opencv2\imgproc\imgproc.hpp>
+#include <opencv2\core.hpp>
+#include <opencv2\imgproc.hpp>
#include <vector>
#include <algorithm>
{
vector.push_back(data[i]);
}
-
-}
\ No newline at end of file
+}