update cpp samples and tutorials

pull/6029/head
Suleyman TURKMEN 9 years ago
parent 1aeff45631
commit 11ca1c95f8
  1. 2
      samples/android/face-detection/jni/DetectionBasedTracker_jni.cpp
  2. 6
      samples/android/tutorial-2-mixedprocessing/jni/jni_part.cpp
  3. 8
      samples/cpp/3calibration.cpp
  4. 4
      samples/cpp/contours2.cpp
  5. 5
      samples/cpp/convexhull.cpp
  6. 2
      samples/cpp/cout_mat.cpp
  7. 12
      samples/cpp/dbt_face_detection.cpp
  8. 4
      samples/cpp/delaunay2.cpp
  9. 6
      samples/cpp/facedetect.cpp
  10. 6
      samples/cpp/facial_features.cpp
  11. 6
      samples/cpp/fback.cpp
  12. 6
      samples/cpp/ffilldemo.cpp
  13. 2
      samples/cpp/filestorage.cpp
  14. 5
      samples/cpp/fitellipse.cpp
  15. 4
      samples/cpp/grabcut.cpp
  16. 4
      samples/cpp/houghcircles.cpp
  17. 4
      samples/cpp/houghlines.cpp
  18. 4
      samples/cpp/image.cpp
  19. 6
      samples/cpp/image_sequence.cpp
  20. 4
      samples/cpp/imagelist_creator.cpp
  21. 6
      samples/cpp/inpaint.cpp
  22. 4
      samples/cpp/intelperc_capture.cpp
  23. 2
      samples/cpp/kalman.cpp
  24. 6
      samples/cpp/laplace.cpp
  25. 4
      samples/cpp/letter_recog.cpp
  26. 6
      samples/cpp/lkdemo.cpp
  27. 10
      samples/cpp/lsd_lines.cpp
  28. 4
      samples/cpp/minarea.cpp
  29. 6
      samples/cpp/morphology2.cpp
  30. 4
      samples/cpp/openni_capture.cpp
  31. 4
      samples/cpp/pca.cpp
  32. 8
      samples/cpp/phase_corr.cpp
  33. 95
      samples/cpp/polar_transforms.cpp
  34. 6
      samples/cpp/segment_objects.cpp
  35. 19
      samples/cpp/squares.cpp
  36. 2
      samples/cpp/starter_imagelist.cpp
  37. 4
      samples/cpp/starter_video.cpp
  38. 6
      samples/cpp/stereo_calib.cpp
  39. 4
      samples/cpp/stereo_match.cpp
  40. 4
      samples/cpp/tree_engine.cpp
  41. 2
      samples/cpp/tutorial_code/HighGUI/AddingImagesTrackbar.cpp
  42. 2
      samples/cpp/tutorial_code/HighGUI/BasicLinearTransformsTrackbar.cpp
  43. 9
      samples/cpp/tutorial_code/Histograms_Matching/EqualizeHist_Demo.cpp
  44. 24
      samples/cpp/tutorial_code/Histograms_Matching/MatchTemplate_Demo.cpp
  45. 12
      samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo1.cpp
  46. 6
      samples/cpp/tutorial_code/Histograms_Matching/calcBackProject_Demo2.cpp
  47. 16
      samples/cpp/tutorial_code/Histograms_Matching/calcHist_Demo.cpp
  48. 19
      samples/cpp/tutorial_code/Histograms_Matching/compareHist_Demo.cpp
  49. 2
      samples/cpp/tutorial_code/ImgProc/AddingImages.cpp
  50. 2
      samples/cpp/tutorial_code/ImgProc/BasicLinearTransforms.cpp
  51. 8
      samples/cpp/tutorial_code/ImgProc/Morphology_1.cpp
  52. 9
      samples/cpp/tutorial_code/ImgProc/Morphology_2.cpp
  53. 7
      samples/cpp/tutorial_code/ImgProc/Pyramids.cpp
  54. 9
      samples/cpp/tutorial_code/ImgProc/Smoothing.cpp
  55. 13
      samples/cpp/tutorial_code/ImgProc/Threshold.cpp
  56. 8
      samples/cpp/tutorial_code/ImgTrans/CannyDetector_Demo.cpp
  57. 7
      samples/cpp/tutorial_code/ImgTrans/Geometric_Transforms_Demo.cpp
  58. 6
      samples/cpp/tutorial_code/ImgTrans/HoughCircle_Demo.cpp
  59. 7
      samples/cpp/tutorial_code/ImgTrans/HoughLines_Demo.cpp
  60. 8
      samples/cpp/tutorial_code/ImgTrans/Laplace_Demo.cpp
  61. 7
      samples/cpp/tutorial_code/ImgTrans/Remap_Demo.cpp
  62. 8
      samples/cpp/tutorial_code/ImgTrans/Sobel_Demo.cpp
  63. 8
      samples/cpp/tutorial_code/ImgTrans/copyMakeBorder_demo.cpp
  64. 8
      samples/cpp/tutorial_code/ImgTrans/filter2D_demo.cpp
  65. 8
      samples/cpp/tutorial_code/ShapeDescriptors/findContours_demo.cpp
  66. 8
      samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo1.cpp
  67. 8
      samples/cpp/tutorial_code/ShapeDescriptors/generalContours_demo2.cpp
  68. 8
      samples/cpp/tutorial_code/ShapeDescriptors/hull_demo.cpp
  69. 8
      samples/cpp/tutorial_code/ShapeDescriptors/moments_demo.cpp
  70. 6
      samples/cpp/tutorial_code/ShapeDescriptors/pointPolygonTest_demo.cpp
  71. 9
      samples/cpp/tutorial_code/TrackingMotion/cornerDetector_Demo.cpp
  72. 8
      samples/cpp/tutorial_code/TrackingMotion/cornerHarris_Demo.cpp
  73. 8
      samples/cpp/tutorial_code/TrackingMotion/cornerSubPix_Demo.cpp
  74. 8
      samples/cpp/tutorial_code/TrackingMotion/goodFeaturesToTrack_Demo.cpp
  75. 4
      samples/cpp/tutorial_code/calib3d/camera_calibration/camera_calibration.cpp
  76. 4
      samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/Utils.cpp
  77. 8
      samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_detection.cpp
  78. 8
      samples/cpp/tutorial_code/calib3d/real_time_pose_estimation/src/main_registration.cpp
  79. 6
      samples/cpp/tutorial_code/calib3d/stereoBM/SBM_Sample.cpp
  80. 6
      samples/cpp/tutorial_code/core/discrete_fourier_transform/discrete_fourier_transform.cpp
  81. 2
      samples/cpp/tutorial_code/core/file_input_output/file_input_output.cpp
  82. 2
      samples/cpp/tutorial_code/core/how_to_scan_images/how_to_scan_images.cpp
  83. 7
      samples/cpp/tutorial_code/core/interoperability_with_OpenCV_1/interoperability_with_OpenCV_1.cpp
  84. 30
      samples/cpp/tutorial_code/core/mat_mask_operations/mat_mask_operations.cpp
  85. 4
      samples/cpp/tutorial_code/core/mat_the_basic_image_container/mat_the_basic_image_container.cpp
  86. 10
      samples/cpp/tutorial_code/imgcodecs/GDAL_IO/gdal-image.cpp
  87. 8
      samples/cpp/tutorial_code/introduction/display_image/display_image.cpp
  88. 10
      samples/cpp/tutorial_code/photo/decolorization/decolor.cpp
  89. 12
      samples/cpp/tutorial_code/photo/non_photorealistic_rendering/npr_demo.cpp
  90. 6
      samples/cpp/tutorial_code/video/bg_sub.cpp
  91. 10
      samples/cpp/tutorial_code/videoio/video-input-psnr-ssim/video-input-psnr-ssim.cpp
  92. 6
      samples/cpp/tutorial_code/videoio/video-write/video-write.cpp
  93. 2
      samples/gpu/alpha_comp.cpp
  94. 6
      samples/gpu/cascadeclassifier.cpp
  95. 2
      samples/gpu/driver_api_multi.cpp
  96. 4
      samples/gpu/driver_api_stereo_multi.cpp
  97. 2
      samples/gpu/multi.cpp
  98. 4
      samples/gpu/opengl.cpp
  99. 3
      samples/gpu/opticalflow_nvidia_api.cpp
  100. 6
      samples/gpu/surf_keypoint_matcher.cpp
  101. Some files were not shown because too many files have changed in this diff Show More

@ -1,5 +1,5 @@
#include <DetectionBasedTracker_jni.h>
#include <opencv2/core/core.hpp>
#include <opencv2/core.hpp>
#include <opencv2/objdetect.hpp>
#include <string>

@ -1,7 +1,7 @@
#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;

@ -2,10 +2,10 @@
* 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>

@ -1,5 +1,5 @@
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc.hpp"
#include "opencv2/highgui.hpp"
#include <math.h>
#include <iostream>

@ -1,6 +1,5 @@
#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;

@ -5,7 +5,7 @@
*
*/
#include "opencv2/core/core.hpp"
#include "opencv2/core.hpp"
#include <iostream>
using namespace std;

@ -1,11 +1,11 @@
#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>

@ -1,5 +1,5 @@
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc.hpp>
#include <opencv2/highgui.hpp>
#include <iostream>
using namespace cv;

@ -177,7 +177,7 @@ void detectAndDraw( Mat& img, CascadeClassifier& cascade,
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
@ -198,8 +198,8 @@ void detectAndDraw( Mat& img, CascadeClassifier& cascade,
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];

@ -6,9 +6,9 @@
*
*/
#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>

@ -1,7 +1,7 @@
#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>

@ -1,7 +1,7 @@
#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>

@ -2,7 +2,7 @@
* filestorage_sample demonstrate the usage of the opencv serialization functionality
*/
#include "opencv2/core/core.hpp"
#include "opencv2/core.hpp"
#include <iostream>
#include <string>

@ -14,10 +14,11 @@
*
*
********************************************************************************/
#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;

@ -1,6 +1,6 @@
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/imgproc.hpp"
#include <iostream>

@ -1,6 +1,6 @@
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/imgproc.hpp"
#include <iostream>

@ -1,6 +1,6 @@
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/imgproc.hpp"
#include <iostream>

@ -1,7 +1,7 @@
#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

@ -1,6 +1,6 @@
#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>

@ -1,9 +1,9 @@
/*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>

@ -1,7 +1,7 @@
#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>

@ -1,8 +1,8 @@
// 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>

@ -1,5 +1,5 @@
#include "opencv2/video/tracking.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/highgui.hpp"
#include <stdio.h>

@ -1,6 +1,6 @@
#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>

@ -1,5 +1,5 @@
#include "opencv2/core/core.hpp"
#include "opencv2/ml/ml.hpp"
#include "opencv2/core.hpp"
#include "opencv2/ml.hpp"
#include <cstdio>
#include <vector>

@ -1,7 +1,7 @@
#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>

@ -1,11 +1,8 @@
#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;
@ -23,6 +20,9 @@ int main(int argc, char** argv)
Mat image = imread(in, IMREAD_GRAYSCALE);
if( image.empty() )
{ return -1; }
#if 0
Canny(image, image, 50, 200, 3); // Apply canny edge
#endif

@ -1,5 +1,5 @@
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/imgproc.hpp"
#include <iostream>

@ -1,6 +1,6 @@
#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>
@ -66,7 +66,7 @@ int main( int argc, char** argv )
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;

@ -1,6 +1,6 @@
#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>

@ -42,9 +42,9 @@
#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;

@ -1,7 +1,7 @@
#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;

@ -1,94 +1,75 @@
#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

@ -1,6 +1,6 @@
#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>

@ -2,10 +2,10 @@
// 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>
@ -23,8 +23,8 @@ static void help()
"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;
}
@ -140,11 +140,18 @@ static void drawSquares( Mat& image, const vector<vector<Point> >& squares )
}
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;

@ -9,7 +9,7 @@
* easy as CV_PI right?
*/
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/highgui.hpp"
#include <iostream>
#include <vector>

@ -12,8 +12,8 @@
*/
#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>

@ -22,10 +22,10 @@
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>

@ -8,9 +8,9 @@
*/
#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>

@ -1,5 +1,5 @@
#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>

@ -5,7 +5,7 @@
*/
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/highgui.hpp"
#include <stdio.h>
using namespace cv;

@ -6,7 +6,7 @@
*/
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/highgui.hpp"
using namespace cv;

@ -5,10 +5,9 @@
*/
#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;
@ -24,10 +23,10 @@ int main( int, char** argv )
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;
}

@ -5,10 +5,9 @@
*/
#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;
@ -27,11 +26,24 @@ void MatchingMethod( int, void* );
/**
* @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 );

@ -4,9 +4,9 @@
* @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>
@ -27,7 +27,13 @@ void Hist_and_Backproj(int, void* );
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 );

@ -4,9 +4,9 @@
* @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>
@ -30,7 +30,7 @@ void pickPoint (int event, int x, int y, int, void* );
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 );

@ -4,11 +4,10 @@
* @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;
@ -16,12 +15,19 @@ 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; }

@ -5,10 +5,9 @@
*/
#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;
@ -26,13 +25,19 @@ int main( int argc, char** argv )
/// 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 );

@ -5,7 +5,7 @@
*/
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/highgui.hpp"
#include <iostream>
using namespace cv;

@ -5,7 +5,7 @@
*/
#include "opencv2/imgcodecs.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/highgui.hpp"
#include <iostream>
using namespace cv;

@ -4,11 +4,9 @@
* @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;
@ -32,7 +30,7 @@ void Dilation( int, void* );
int main( int, char** argv )
{
/// Load an image
src = imread( argv[1] );
src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{ return -1; }

@ -4,11 +4,9 @@
* @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;
@ -34,7 +32,7 @@ void Morphology_Operations( int, void* );
int main( int, char** argv )
{
/// Load an image
src = imread( argv[1] );
src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{ return -1; }
@ -67,7 +65,6 @@ int main( int, char** argv )
*/
void Morphology_Operations( int, void* )
{
// Since MORPH_X : 2,3,4,5 and 6
int operation = morph_operator + 2;

@ -4,12 +4,9 @@
* @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;

@ -3,13 +3,10 @@
* 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;
@ -35,7 +32,7 @@ int main( void )
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; }

@ -4,11 +4,9 @@
* @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;
@ -35,10 +33,13 @@ void Threshold_Demo( int, void* );
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 );

@ -4,11 +4,9 @@
* @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;
@ -50,7 +48,7 @@ static void CannyThreshold(int, void*)
int main( int, char** argv )
{
/// Load an image
src = imread( argv[1] );
src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{ return -1; }

@ -5,10 +5,9 @@
*/
#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;
@ -31,7 +30,7 @@ int main( int, char** argv )
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() );

@ -5,8 +5,8 @@
*/
#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;
@ -63,7 +63,7 @@ int main(int argc, char** argv)
}
// Read the image
src = imread( argv[1], 1 );
src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{

@ -5,10 +5,9 @@
*/
#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;
@ -39,7 +38,7 @@ void Probabilistic_Hough( int, void* );
int main( int, char** argv )
{
/// Read the image
src = imread( argv[1], 1 );
src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{ help();

@ -4,11 +4,9 @@
* @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;
@ -26,7 +24,7 @@ int main( int, char** argv )
const char* window_name = "Laplace Demo";
/// Load an image
src = imread( argv[1] );
src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{ return -1; }

@ -5,10 +5,9 @@
*/
#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;
@ -27,7 +26,7 @@ void update_map( void );
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() );

@ -4,11 +4,9 @@
* @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;
@ -26,7 +24,7 @@ int main( int, char** argv )
int ddepth = CV_16S;
/// Load an image
src = imread( argv[1] );
src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{ return -1; }

@ -4,11 +4,9 @@
* @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;
@ -28,7 +26,7 @@ int main( int, char** argv )
int c;
/// Load an image
src = imread( argv[1] );
src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{

@ -4,11 +4,9 @@
* @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;
@ -30,7 +28,7 @@ int main ( int, char** argv )
int c;
/// Load an image
src = imread( argv[1] );
src = imread( argv[1], IMREAD_COLOR );
if( src.empty() )
{ return -1; }

@ -5,11 +5,9 @@
*/
#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;
@ -28,7 +26,7 @@ void thresh_callback(int, void* );
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;

@ -5,11 +5,9 @@
*/
#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;
@ -28,7 +26,7 @@ void thresh_callback(int, void* );
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 );

@ -5,11 +5,9 @@
*/
#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;
@ -28,7 +26,7 @@ void thresh_callback(int, void* );
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 );

@ -5,11 +5,9 @@
*/
#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;
@ -28,7 +26,7 @@ void thresh_callback(int, void* );
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 );

@ -5,11 +5,9 @@
*/
#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;
@ -28,7 +26,7 @@ void thresh_callback(int, void* );
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 );

@ -4,11 +4,9 @@
* @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;

@ -3,12 +3,11 @@
* @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;
@ -40,7 +39,7 @@ void myHarris_function( int, void* );
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

@ -5,11 +5,9 @@
*/
#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;
@ -31,7 +29,7 @@ void cornerHarris_demo( int, void* );
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

@ -5,11 +5,9 @@
*/
#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;
@ -32,7 +30,7 @@ void goodFeaturesToTrack_Demo( int, void* );
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

@ -5,11 +5,9 @@
*/
#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;
@ -32,7 +30,7 @@ void goodFeaturesToTrack_Demo( int, void* );
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

@ -21,7 +21,7 @@ using namespace std;
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;
}
@ -415,7 +415,7 @@ int main(int argc, char* argv[])
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);

@ -11,8 +11,8 @@
#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;

@ -2,11 +2,11 @@
#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"

@ -1,10 +1,10 @@
// 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"

@ -4,12 +4,10 @@
* @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;

@ -1,7 +1,7 @@
#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>

@ -1,4 +1,4 @@
#include <opencv2/core/core.hpp>
#include <opencv2/core.hpp>
#include <iostream>
#include <string>

@ -16,7 +16,7 @@ static void help()
<< " 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;

@ -1,12 +1,9 @@
//! [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;

@ -1,5 +1,3 @@
#include <opencv2/core.hpp>
#include <opencv2/core/utility.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/highgui.hpp>
#include <opencv2/imgproc.hpp>
@ -25,38 +23,44 @@ int main( int argc, char* argv[])
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)

@ -1,6 +1,6 @@
/* For description look into the help() function. */
#include "opencv2/core/core.hpp"
#include "opencv2/core.hpp"
#include <iostream>
using namespace std;
@ -15,7 +15,7 @@ static void help()
<< "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;
}

@ -3,9 +3,9 @@
*/
// 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>
@ -159,8 +159,8 @@ int main( int argc, char* argv[] ){
* 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

@ -1,7 +1,7 @@
//! [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>
@ -16,7 +16,7 @@ using namespace std;
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];
@ -28,7 +28,7 @@ int main( int argc, char** argv )
//! [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

@ -27,13 +27,13 @@ using namespace cv;
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);

@ -35,9 +35,9 @@ int main(int argc, char* argv[])
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);
@ -71,25 +71,25 @@ int main(int argc, char* argv[])
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);

@ -38,9 +38,9 @@ void help()
<< " 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;
}

@ -3,10 +3,10 @@
#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;
@ -22,7 +22,7 @@ static void help()
<< "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;
}

@ -1,8 +1,8 @@
#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;
@ -14,7 +14,7 @@ static void help()
<< "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;
}

@ -1,7 +1,7 @@
#include <iostream>
#include "opencv2/core/opengl.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/highgui.hpp"
#include "opencv2/cudaimgproc.hpp"
using namespace std;

@ -6,9 +6,9 @@
#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"

@ -8,7 +8,7 @@
#include <iostream>
#include "opencv2/cvconfig.h"
#include "opencv2/core/core.hpp"
#include "opencv2/core.hpp"
#include "opencv2/cudaarithm.hpp"
#ifdef HAVE_TBB

@ -9,8 +9,8 @@
#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

@ -8,7 +8,7 @@
#include <iostream>
#include "opencv2/cvconfig.h"
#include "opencv2/core/core.hpp"
#include "opencv2/core.hpp"
#include "opencv2/cudaarithm.hpp"
#ifdef HAVE_TBB

@ -17,10 +17,10 @@
#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;

@ -14,8 +14,7 @@
#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** )

@ -4,9 +4,9 @@
#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"

Some files were not shown because too many files have changed in this diff Show More

Loading…
Cancel
Save