{
vector<Point2f> ptvec;
imageSize = view.size();
- cvtColor(view, viewGray, CV_BGR2GRAY);
+ cvtColor(view, viewGray, COLOR_BGR2GRAY);
bool found = findChessboardCorners( view, boardSize, ptvec, CV_CALIB_CB_ADAPTIVE_THRESH );
drawChessboardCorners( view, boardSize, Mat(ptvec), found );
//============================================================================
-// Name : HighDynamicRange_RetinaCompression.cpp
+// Name : OpenEXRimages_HDR_Retina_toneMapping.cpp
// Author : Alexandre Benoit (benoit.alexandre.vision@gmail.com)
// Version : 0.1
// Copyright : Alexandre Benoit, LISTIC Lab, july 2011
-// Description : HighDynamicRange compression (tone mapping) with the help of the Gipsa/Listic's retina in C++, Ansi-style
+// Description : HighDynamicRange retina tone mapping with the help of the Gipsa/Listic's retina in C++, Ansi-style
//============================================================================
#include <iostream>
{
cv::Mat rgbIntImg;
outputMat.convertTo(rgbIntImg, CV_8UC3);
- cvtColor(rgbIntImg, intGrayImage, CV_BGR2GRAY);
+ cvtColor(rgbIntImg, intGrayImage, cv::COLOR_BGR2GRAY);
}
// get histogram density probability in order to cut values under above edges limits (here 5-95%)... usefull for HDR pixel errors cancellation
// Author : Alexandre Benoit (benoit.alexandre.vision@gmail.com)
// Version : 0.2
// Copyright : Alexandre Benoit, LISTIC Lab, december 2011
-// Description : HighDynamicRange compression (tone mapping) for image sequences with the help of the Gipsa/Listic's retina in C++, Ansi-style
+// Description : HighDynamicRange retina tone mapping for image sequences with the help of the Gipsa/Listic's retina in C++, Ansi-style
// Known issues: the input OpenEXR sequences can have bad computed pixels that should be removed
// => a simple method consists of cutting histogram edges (a slider for this on the UI is provided)
// => however, in image sequences, this histogramm cut must be done in an elegant way from frame to frame... still not done...
{
cv::Mat rgbIntImg;
normalisedImage.convertTo(rgbIntImg, CV_8UC3);
- cvtColor(rgbIntImg, intGrayImage, CV_BGR2GRAY);
+ cvtColor(rgbIntImg, intGrayImage, cv::COLOR_BGR2GRAY);
}
// get histogram density probability in order to cut values under above edges limits (here 5-95%)... usefull for HDR pixel errors cancellation
#include <iostream>
#include <vector>
-#include <opencv/highgui.h>
+#include <opencv2/highgui/highgui.hpp>
#if defined WIN32 || defined _WIN32 || defined WINCE
#include <windows.h>
#include <GL/gl.h>
#endif
-#include <opencv/cxcore.h>
-#include <opencv/cv.h>
+#include <opencv2/core/core.hpp>
using namespace std;
using namespace cv;
modelPoints->push_back(cvPoint3D32f(0.0f, CUBE_SIZE, 0.0f));
}
-static void foundCorners(vector<CvPoint2D32f> *srcImagePoints,IplImage* source, IplImage* grayImage)
+static void foundCorners(vector<CvPoint2D32f> *srcImagePoints, const Mat& source, Mat& grayImage)
{
- cvCvtColor(source,grayImage,CV_RGB2GRAY);
- cvSmooth( grayImage, grayImage,CV_GAUSSIAN,11);
- cvNormalize(grayImage, grayImage, 0, 255, CV_MINMAX);
- cvThreshold( grayImage, grayImage, 26, 255, CV_THRESH_BINARY_INV);//25
+ cvtColor(source, grayImage, COLOR_RGB2GRAY);
+ GaussianBlur(grayImage, grayImage, Size(11,11), 0, 0);
+ normalize(grayImage, grayImage, 0, 255, NORM_MINMAX);
+ threshold(grayImage, grayImage, 26, 255, THRESH_BINARY_INV); //25
Mat MgrayImage = grayImage;
//For debug
for(size_t i = 0 ; i<srcImagePoints_temp.size(); i++ )
{
ss<<i;
- circle(Msource,srcImagePoints->at(i),5,CV_RGB(255,0,0));
- putText( Msource, ss.str(), srcImagePoints->at(i),CV_FONT_HERSHEY_SIMPLEX,1,CV_RGB(255,0,0));
+ circle(Msource,srcImagePoints->at(i),5,Scalar(0,0,255));
+ putText(Msource,ss.str(),srcImagePoints->at(i),FONT_HERSHEY_SIMPLEX,1,Scalar(0,0,255));
ss.str("");
//new coordinate system in the middle of the frame and reversed (camera coordinate system)
int main(void)
{
help();
- CvCapture* video = cvCaptureFromFile("cube4.avi");
- CV_Assert(video);
+ VideoCapture video("cube4.avi");
+ CV_Assert(video.isOpened());
- IplImage* source = cvCreateImage(cvGetSize(cvQueryFrame(video)),8,3);
- IplImage* grayImage = cvCreateImage(cvGetSize(cvQueryFrame(video)),8,1);
+ Mat source, grayImage;
- cvNamedWindow("original",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);
- cvNamedWindow("POSIT",CV_WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);
+ video >> source;
+
+ namedWindow("original", WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);
+ namedWindow("POSIT", WINDOW_AUTOSIZE | CV_WINDOW_FREERATIO);
displayOverlay("POSIT", "We lost the 4 corners' detection quite often (the red circles disappear). This demo is only to illustrate how to use OpenGL callback.\n -- Press ESC to exit.", 10000);
- //For debug
- //cvNamedWindow("tempGray",CV_WINDOW_AUTOSIZE);
+
float OpenGLMatrix[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
- cvSetOpenGlDrawCallback("POSIT",on_opengl,OpenGLMatrix);
+ setOpenGlDrawCallback("POSIT",on_opengl,OpenGLMatrix);
vector<CvPoint3D32f> modelPoints;
initPOSIT(&modelPoints);
vector<CvPoint2D32f> srcImagePoints(4,cvPoint2D32f(0,0));
- while(cvWaitKey(33) != 27)
+ while(waitKey(33) != 27)
{
- source=cvQueryFrame(video);
- cvShowImage("original",source);
+ video >> source;
+ imshow("original",source);
foundCorners(&srcImagePoints,source,grayImage);
cvPOSIT( positObject, &srcImagePoints[0], FOCAL_LENGTH, criteria, rotation_matrix, translation_vector );
createOpenGLMatrixFrom(OpenGLMatrix,rotation_matrix,translation_vector);
- cvShowImage("POSIT",source);
- //For debug
- //cvShowImage("tempGray",grayImage);
+ imshow("POSIT",source);
- if (cvGetCaptureProperty(video,CV_CAP_PROP_POS_AVI_RATIO)>0.99)
- cvSetCaptureProperty(video,CV_CAP_PROP_POS_AVI_RATIO,0);
+ if (VideoCapture::get(video,CV_CAP_PROP_POS_AVI_RATIO)>0.99)
+ VideoCapture::get(video,CV_CAP_PROP_POS_AVI_RATIO,0);
}
- cvDestroyAllWindows();
- cvReleaseImage(&grayImage);
- cvReleaseCapture(&video);
+ destroyAllWindows();
cvReleasePOSITObject(&positObject);
return 0;
<< "\n";
}
-
-
-
-
static void makeDir( const string& dir )
{
#if defined WIN32 || defined _WIN32
return -1;
}
- namedWindow("image", CV_WINDOW_NORMAL);
- namedWindow("foreground mask", CV_WINDOW_NORMAL);
- namedWindow("foreground image", CV_WINDOW_NORMAL);
- namedWindow("mean background image", CV_WINDOW_NORMAL);
+ namedWindow("image", WINDOW_NORMAL);
+ namedWindow("foreground mask", WINDOW_NORMAL);
+ namedWindow("foreground image", WINDOW_NORMAL);
+ namedWindow("mean background image", WINDOW_NORMAL);
BackgroundSubtractorMOG2 bg_model;//(100, 3, 0.3, 5);
for( size_t i = 0; i < nimages; i++ )
{
Mat img = imread(imageList[i], 1), gray;
- cvtColor(img, gray, CV_BGR2GRAY);
+ cvtColor(img, gray, COLOR_BGR2GRAY);
vector<KeyPoint> keypoints;
detector->detect(gray, keypoints);
flip( view, view, 0 );
vector<Point2f> pointbuf;
- cvtColor(view, viewGray, CV_BGR2GRAY);
+ cvtColor(view, viewGray, COLOR_BGR2GRAY);
bool found;
switch( pattern )
if( !paused )
{
- cvtColor(image, hsv, CV_BGR2HSV);
+ cvtColor(image, hsv, COLOR_BGR2HSV);
if( trackObject )
{
}
if( backprojMode )
- cvtColor( backproj, image, CV_GRAY2BGR );
+ cvtColor( backproj, image, COLOR_GRAY2BGR );
ellipse( image, trackBox, Scalar(0,0,255), 3, CV_AA );
}
}
return -1;
}
Mat cimg;
- cvtColor(img, cimg, CV_GRAY2BGR);
+ cvtColor(img, cimg, COLOR_GRAY2BGR);
// if the image and the template are not edge maps but normal grayscale images,
// you might want to uncomment the lines below to produce the maps. You can also
matchesMask[i1] = 1;
}
// draw inliers
- drawMatches( img1, keypoints1, img2, keypoints2, filteredMatches, drawImg, CV_RGB(0, 255, 0), CV_RGB(0, 0, 255), matchesMask
+ drawMatches( img1, keypoints1, img2, keypoints2, filteredMatches, drawImg, Scalar(0, 255, 0), Scalar(255, 0, 0), matchesMask
#if DRAW_RICH_KEYPOINTS_MODE
, DrawMatchesFlags::DRAW_RICH_KEYPOINTS
#endif
// draw outliers
for( size_t i1 = 0; i1 < matchesMask.size(); i1++ )
matchesMask[i1] = !matchesMask[i1];
- drawMatches( img1, keypoints1, img2, keypoints2, filteredMatches, drawImg, CV_RGB(0, 0, 255), CV_RGB(255, 0, 0), matchesMask,
+ drawMatches( img1, keypoints1, img2, keypoints2, filteredMatches, drawImg, Scalar(255, 0, 0), Scalar(0, 0, 255), matchesMask,
DrawMatchesFlags::DRAW_OVER_OUTIMG | DrawMatchesFlags::NOT_DRAW_SINGLE_POINTS );
#endif
LOGD("\n\nSTEP n=%d from prev step %f ms\n\n", n, t_ms);
m=images[n-1];
CV_Assert(! m.empty());
- cvtColor(m, gray, CV_BGR2GRAY);
+ cvtColor(m, gray, COLOR_BGR2GRAY);
fd.process(gray);
// Call to update the view
onTrackbar(0, 0);
- int c = cvWaitKey(0) & 255;
+ int c = waitKey(0) & 255;
if( c == 27 )
break;
return 0;
}
- Size textsize = getTextSize("OpenCV forever!", CV_FONT_HERSHEY_COMPLEX, 3, 5, 0);
+ Size textsize = getTextSize("OpenCV forever!", FONT_HERSHEY_COMPLEX, 3, 5, 0);
Point org((width - textsize.width)/2, (height - textsize.height)/2);
Mat image2;
for( i = 0; i < 255; i += 2 )
{
image2 = image - Scalar::all(i);
- putText(image2, "OpenCV forever!", org, CV_FONT_HERSHEY_COMPLEX, 3,
+ putText(image2, "OpenCV forever!", org, FONT_HERSHEY_COMPLEX, 3,
Scalar(i, i, 255), 5, lineType);
imshow(wndname, image2);
return -1;
}
cedge.create(image.size(), image.type());
- cvtColor(image, gray, CV_BGR2GRAY);
+ cvtColor(image, gray, COLOR_BGR2GRAY);
// Create a window
namedWindow("Edge map", 1);
params.cov_mat_type = CvEM::COV_MAT_DIAGONAL;
params.start_step = CvEM::START_E_STEP;
params.means = em_model.get_means();
- params.covs = (const CvMat**)em_model.get_covs();
+ params.covs = em_model.get_covs();
params.weights = em_model.get_weights();
em_model2.train( samples, Mat(), params, &labels );
for(;;)
{
cap >> frame;
- cvtColor(frame, gray, CV_BGR2GRAY);
+ cvtColor(frame, gray, COLOR_BGR2GRAY);
if( prevgray.data )
{
calcOpticalFlowFarneback(prevgray, gray, flow, 0.5, 3, 15, 3, 5, 1.2, 0);
- cvtColor(prevgray, cflow, CV_GRAY2BGR);
- drawOptFlowMap(flow, cflow, 16, 1.5, CV_RGB(0, 255, 0));
+ cvtColor(prevgray, cflow, COLOR_GRAY2BGR);
+ drawOptFlowMap(flow, cflow, 16, 1.5, Scalar(0, 255, 0));
imshow("flow", cflow);
}
if(waitKey(30)>=0)
}
help();
image0.copyTo(image);
- cvtColor(image0, gray, CV_BGR2GRAY);
+ cvtColor(image0, gray, COLOR_BGR2GRAY);
mask.create(image0.rows+2, image0.cols+2, CV_8UC1);
namedWindow( "image", 0 );
if( isColor )
{
cout << "Grayscale mode is set\n";
- cvtColor(image0, gray, CV_BGR2GRAY);
+ cvtColor(image0, gray, COLOR_BGR2GRAY);
mask = Scalar::all(0);
isColor = false;
}
case 'r':
cout << "Original image is restored\n";
image0.copyTo(image);
- cvtColor(image, gray, CV_BGR2GRAY);
+ cvtColor(image, gray, COLOR_BGR2GRAY);
mask = Scalar::all(0);
break;
case 's':
for (size_t i = 0; i < features1.size(); i++)
{
- circle(img_corr, features1[i].pt, 3, CV_RGB(255, 0, 0));
+ circle(img_corr, features1[i].pt, 3, Scalar(0, 0, 255));
}
for (size_t i = 0; i < features2.size(); i++)
help();
const string winName = "image";
- cvNamedWindow( winName.c_str(), CV_WINDOW_AUTOSIZE );
- cvSetMouseCallback( winName.c_str(), on_mouse, 0 );
+ namedWindow( winName, WINDOW_AUTOSIZE );
+ setMouseCallback( winName, on_mouse, 0 );
gcapp.setImageAndWinName( image, winName );
gcapp.showImage();
for(;;)
{
- int c = cvWaitKey(0);
+ int c = waitKey(0);
switch( (char) c )
{
case '\x1b':
}
exit_main:
- cvDestroyWindow( winName.c_str() );
+ destroyWindow( winName );
return 0;
}
Mat cimg;
medianBlur(img, img, 5);
- cvtColor(img, cimg, CV_GRAY2BGR);
+ cvtColor(img, cimg, COLOR_GRAY2BGR);
vector<Vec3f> circles;
HoughCircles(img, circles, CV_HOUGH_GRADIENT, 1, 10,
Mat dst, cdst;
Canny(src, dst, 50, 200, 3);
- cvtColor(dst, cdst, CV_GRAY2BGR);
+ cvtColor(dst, cdst, COLOR_GRAY2BGR);
#if 0
vector<Vec2f> lines;
cvtColor(img_yuv, img, CV_YCrCb2BGR);
// this is counterpart for cvNamedWindow
- namedWindow("image with grain", CV_WINDOW_AUTOSIZE);
+ namedWindow("image with grain", WINDOW_AUTOSIZE);
#if DEMO_MIXED_API_USE
// this is to demonstrate that img and iplimg really share the data - the result of the above
// processing is stored in img and thus in iplimg too.
break;
frame.copyTo(image);
- cvtColor(image, gray, CV_BGR2GRAY);
+ cvtColor(image, gray, COLOR_BGR2GRAY);
if( nightMode )
image = Scalar::all(0);
colorRad = 10;
maxPyrLevel = 1;
- namedWindow( winName, CV_WINDOW_AUTOSIZE );
+ namedWindow( winName, WINDOW_AUTOSIZE );
createTrackbar( "spatialRad", winName, &spatialRad, 80, meanShiftSegmentation );
createTrackbar( "colorRad", winName, &colorRad, 60, meanShiftSegmentation );
imshow( "rect & circle", img );
- char key = (char)cvWaitKey();
+ char key = (char)waitKey();
if( key == 27 || key == 'q' || key == 'Q' ) // 'ESC'
break;
}
OpenClose(open_close_pos, 0);
ErodeDilate(erode_dilate_pos, 0);
- c = cvWaitKey(0);
+ c = waitKey(0);
if( (char)c == 27 )
break;
// init highgui window
string winName = "Reconstruction | press 'q' to quit";
- namedWindow(winName, CV_WINDOW_NORMAL);
+ namedWindow(winName, WINDOW_NORMAL);
// params struct to pass to the trackbar handler
params p;
do
{
video >> frame;
- cvtColor(frame, curr, CV_RGB2GRAY);
+ cvtColor(frame, curr, COLOR_RGB2GRAY);
if(prev.empty())
{
using namespace std;
using namespace cv;
-const Scalar WHITE_COLOR = CV_RGB(255,255,255);
+const Scalar WHITE_COLOR = Scalar(255,255,255);
const string winName = "points";
const int testStep = 5;
// put the text
stringstream text;
text << "current class " << classColors.size()-1;
- putText( img, text.str(), Point(10,25), CV_FONT_HERSHEY_SIMPLEX, 0.8f, WHITE_COLOR, 2 );
+ putText( img, text.str(), Point(10,25), FONT_HERSHEY_SIMPLEX, 0.8f, WHITE_COLOR, 2 );
text.str("");
text << "total classes " << classColors.size();
- putText( img, text.str(), Point(10,50), CV_FONT_HERSHEY_SIMPLEX, 0.8f, WHITE_COLOR, 2 );
+ putText( img, text.str(), Point(10,50), FONT_HERSHEY_SIMPLEX, 0.8f, WHITE_COLOR, 2 );
text.str("");
text << "total points " << trainedPoints.size();
- putText(img, text.str(), cvPoint(10,75), CV_FONT_HERSHEY_SIMPLEX, 0.8f, WHITE_COLOR, 2 );
+ putText(img, text.str(), Point(10,75), FONT_HERSHEY_SIMPLEX, 0.8f, WHITE_COLOR, 2 );
// draw points
for( size_t i = 0; i < trainedPoints.size(); i++ )
for( int i = 0; i < svmClassifier.get_support_vector_count(); i++ )
{
const float* supportVector = svmClassifier.get_support_vector(i);
- circle( imgDst, Point(supportVector[0],supportVector[1]), 5, CV_RGB(255,255,255), -1 );
+ circle( imgDst, Point(supportVector[0],supportVector[1]), 5, Scalar(255,255,255), -1 );
}
}
{
#if _NBC_
find_decision_boundary_NBC();
- cvNamedWindow( "NormalBayesClassifier", WINDOW_AUTOSIZE );
+ namedWindow( "NormalBayesClassifier", WINDOW_AUTOSIZE );
imshow( "NormalBayesClassifier", imgDst );
#endif
#if _KNN_
params.C = 10;
find_decision_boundary_SVM( params );
- cvNamedWindow( "classificationSVM2", WINDOW_AUTOSIZE );
+ namedWindow( "classificationSVM2", WINDOW_AUTOSIZE );
imshow( "classificationSVM2", imgDst );
#endif
}
Mat grayImage0, grayImage1, depthFlt0, depthFlt1/*in meters*/;
- cvtColor( colorImage0, grayImage0, CV_BGR2GRAY );
- cvtColor( colorImage1, grayImage1, CV_BGR2GRAY );
+ cvtColor( colorImage0, grayImage0, COLOR_BGR2GRAY );
+ cvtColor( colorImage1, grayImage1, COLOR_BGR2GRAY );
depth0.convertTo( depthFlt0, CV_32FC1, 1./1000 );
depth1.convertTo( depthFlt1, CV_32FC1, 1./1000 );
if( !tmp_frame.data )
break;
bgsubtractor(tmp_frame, bgmask, update_bg_model ? -1 : 0);
- //CvMat _bgmask = bgmask;
- //cvSegmentFGMask(&_bgmask);
refineSegments(tmp_frame, bgmask, out_frame);
imshow("video", tmp_frame);
imshow("segmented", out_frame);
{
cout << filename << endl;
Mat cimg, cimg1;
- cvtColor(img, cimg, CV_GRAY2BGR);
+ cvtColor(img, cimg, COLOR_GRAY2BGR);
drawChessboardCorners(cimg, boardSize, corners, found);
double sf = 640./MAX(img.rows, img.cols);
resize(cimg, cimg1, Size(), sf, sf);
{
Mat img = imread(goodImageList[i*2+k], 0), rimg, cimg;
remap(img, rimg, rmap[k][0], rmap[k][1], CV_INTER_LINEAR);
- cvtColor(rimg, cimg, CV_GRAY2BGR);
+ cvtColor(rimg, cimg, COLOR_GRAY2BGR);
Mat canvasPart = !isVerticalStereo ? canvas(Rect(w*k, 0, w, h)) : canvas(Rect(0, h*k, w, h));
resize(cimg, canvasPart, canvasPart.size(), 0, 0, CV_INTER_AREA);
if( useCalibrated )
*/
static void on_trackbar( int, void* )
{
- Mat new_image = Mat::zeros( image.size(), image.type() );
+ Mat new_image = Mat::zeros( image.size(), image.type() );
- for( int y = 0; y < image.rows; y++ )
- { for( int x = 0; x < image.cols; x++ )
- { for( int c = 0; c < 3; c++ )
- {
- new_image.at<Vec3b>(y,x)[c] = saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta );
- }
- }
- }
- imshow("New Image", new_image);
+ for( int y = 0; y < image.rows; y++ )
+ for( int x = 0; x < image.cols; x++ )
+ for( int c = 0; c < 3; c++ )
+ new_image.at<Vec3b>(y,x)[c] = saturate_cast<uchar>( alpha*( image.at<Vec3b>(y,x)[c] ) + beta );
+
+ imshow("New Image", new_image);
}
}
/// Convert to grayscale
- cvtColor( src, src, CV_BGR2GRAY );
+ cvtColor( src, src, COLOR_BGR2GRAY );
/// Apply Histogram Equalization
equalizeHist( src, dst );
/// Display results
- namedWindow( source_window, CV_WINDOW_AUTOSIZE );
- namedWindow( equalized_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( source_window, WINDOW_AUTOSIZE );
+ namedWindow( equalized_window, WINDOW_AUTOSIZE );
imshow( source_window, src );
imshow( equalized_window, dst );
templ = imread( argv[2], 1 );
/// Create windows
- namedWindow( image_window, CV_WINDOW_AUTOSIZE );
- namedWindow( result_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( image_window, WINDOW_AUTOSIZE );
+ namedWindow( result_window, WINDOW_AUTOSIZE );
/// Create Trackbar
const char* trackbar_label = "Method: \n 0: SQDIFF \n 1: SQDIFF NORMED \n 2: TM CCORR \n 3: TM CCORR NORMED \n 4: TM COEFF \n 5: TM COEFF NORMED";
/// Read the image
src = imread( argv[1], 1 );
/// Transform it to HSV
- cvtColor( src, hsv, CV_BGR2HSV );
+ cvtColor( src, hsv, COLOR_BGR2HSV );
/// Use only the Hue value
hue.create( hsv.size(), hsv.depth() );
/// Create Trackbar to enter the number of bins
const char* window_image = "Source image";
- namedWindow( window_image, CV_WINDOW_AUTOSIZE );
+ namedWindow( window_image, WINDOW_AUTOSIZE );
createTrackbar("* Hue bins: ", window_image, &bins, 180, Hist_and_Backproj );
Hist_and_Backproj(0, 0);
/// Read the image
src = imread( argv[1], 1 );
/// Transform it to HSV
- cvtColor( src, hsv, CV_BGR2HSV );
+ cvtColor( src, hsv, COLOR_BGR2HSV );
/// Show the image
- namedWindow( window_image, CV_WINDOW_AUTOSIZE );
+ namedWindow( window_image, WINDOW_AUTOSIZE );
imshow( window_image, src );
/// Set Trackbars for floodfill thresholds
}
/// Display
- namedWindow("calcHist Demo", CV_WINDOW_AUTOSIZE );
+ namedWindow("calcHist Demo", WINDOW_AUTOSIZE );
imshow("calcHist Demo", histImage );
waitKey(0);
Mat src_test2, hsv_test2;
Mat hsv_half_down;
- /// Load three images with different environment settings
- if( argc < 4 )
- { printf("** Error. Usage: ./compareHist_Demo <image_settings0> <image_setting1> <image_settings2>\n");
- return -1;
- }
+ /// Load three images with different environment settings
+ if( argc < 4 )
+ {
+ printf("** Error. Usage: ./compareHist_Demo <image_settings0> <image_setting1> <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], 1 );
+ src_test1 = imread( argv[2], 1 );
+ src_test2 = imread( argv[3], 1 );
- /// Convert to HSV
- cvtColor( src_base, hsv_base, CV_BGR2HSV );
- cvtColor( src_test1, hsv_test1, CV_BGR2HSV );
- cvtColor( src_test2, hsv_test2, CV_BGR2HSV );
+ /// Convert to HSV
+ cvtColor( src_base, hsv_base, COLOR_BGR2HSV );
+ cvtColor( src_test1, hsv_test1, COLOR_BGR2HSV );
+ cvtColor( src_test2, hsv_test2, COLOR_BGR2HSV );
- hsv_half_down = hsv_base( Range( hsv_base.rows/2, hsv_base.rows - 1 ), Range( 0, hsv_base.cols - 1 ) );
+ hsv_half_down = hsv_base( Range( hsv_base.rows/2, hsv_base.rows - 1 ), Range( 0, hsv_base.cols - 1 ) );
- /// Using 30 bins for hue and 32 for saturation
+ /// Using 30 bins for hue and 32 for saturation
int h_bins = 50; int s_bins = 60;
int histSize[] = { h_bins, s_bins };
/// Apply the histogram comparison methods
for( int i = 0; i < 4; i++ )
- { int compare_method = i;
- double base_base = compareHist( hist_base, hist_base, compare_method );
- double base_half = compareHist( hist_base, hist_half_down, compare_method );
- double base_test1 = compareHist( hist_base, hist_test1, compare_method );
- double base_test2 = compareHist( hist_base, hist_test2, compare_method );
-
- printf( " Method [%d] Perfect, Base-Half, Base-Test(1), Base-Test(2) : %f, %f, %f, %f \n", i, base_base, base_half , base_test1, base_test2 );
- }
+ {
+ int compare_method = i;
+ double base_base = compareHist( hist_base, hist_base, compare_method );
+ double base_half = compareHist( hist_base, hist_half_down, compare_method );
+ double base_test1 = compareHist( hist_base, hist_test1, compare_method );
+ double base_test2 = compareHist( hist_base, hist_test2, compare_method );
+
+ printf( " Method [%d] Perfect, Base-Half, Base-Test(1), Base-Test(2) : %f, %f, %f, %f \n", i, base_base, base_half , base_test1, base_test2 );
+ }
printf( "Done \n" );
{ return -1; }
/// Create windows
- namedWindow( "Erosion Demo", CV_WINDOW_AUTOSIZE );
- namedWindow( "Dilation Demo", CV_WINDOW_AUTOSIZE );
- cvMoveWindow( "Dilation Demo", src.cols, 0 );
+ namedWindow( "Erosion Demo", WINDOW_AUTOSIZE );
+ namedWindow( "Dilation Demo", WINDOW_AUTOSIZE );
+ moveWindow( "Dilation Demo", src.cols, 0 );
/// Create Erosion Trackbar
createTrackbar( "Element:\n 0: Rect \n 1: Cross \n 2: Ellipse", "Erosion Demo",
{ return -1; }
/// Create window
- namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+ namedWindow( window_name, WINDOW_AUTOSIZE );
/// Create Trackbar to select Morphology operation
createTrackbar("Operator:\n 0: Opening - 1: Closing \n 2: Gradient - 3: Top Hat \n 4: Black Hat", window_name, &morph_operator, max_operator, Morphology_Operations );
/// Create Trackbar to select kernel type
createTrackbar( "Element:\n 0: Rect - 1: Cross - 2: Ellipse", window_name,
- &morph_elem, max_elem,
- Morphology_Operations );
+ &morph_elem, max_elem,
+ Morphology_Operations );
/// Create Trackbar to choose kernel size
createTrackbar( "Kernel size:\n 2n +1", window_name,
- &morph_size, max_kernel_size,
- Morphology_Operations );
+ &morph_size, max_kernel_size,
+ Morphology_Operations );
/// Default start
Morphology_Operations( 0, 0 );
dst = tmp;
/// Create window
- namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+ namedWindow( window_name, WINDOW_AUTOSIZE );
imshow( window_name, dst );
/// Loop
*/
int main( void )
{
- namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+ namedWindow( window_name, WINDOW_AUTOSIZE );
/// Load the source image
src = imread( "../images/lena.png", 1 );
dst = Mat::zeros( src.size(), src.type() );
putText( dst, caption,
Point( src.cols/4, src.rows/2),
- CV_FONT_HERSHEY_COMPLEX, 1, Scalar(255, 255, 255) );
+ FONT_HERSHEY_COMPLEX, 1, Scalar(255, 255, 255) );
imshow( window_name, dst );
int c = waitKey( DELAY_CAPTION );
src = imread( argv[1], 1 );
/// Convert the image to Gray
- cvtColor( src, src_gray, CV_RGB2GRAY );
+ cvtColor( src, src_gray, COLOR_RGB2GRAY );
/// Create a window to display results
- namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+ namedWindow( window_name, WINDOW_AUTOSIZE );
/// Create Trackbar to choose type of Threshold
createTrackbar( trackbar_type,
- window_name, &threshold_type,
- max_type, Threshold_Demo );
+ window_name, &threshold_type,
+ max_type, Threshold_Demo );
createTrackbar( trackbar_value,
- window_name, &threshold_value,
- max_value, Threshold_Demo );
+ window_name, &threshold_value,
+ max_value, Threshold_Demo );
/// Call the function to initialize
Threshold_Demo( 0, 0 );
dst.create( src.size(), src.type() );
/// Convert the image to grayscale
- cvtColor( src, src_gray, CV_BGR2GRAY );
+ cvtColor( src, src_gray, COLOR_BGR2GRAY );
/// Create a window
- namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+ namedWindow( window_name, WINDOW_AUTOSIZE );
/// Create a Trackbar for user to enter threshold
createTrackbar( "Min Threshold:", window_name, &lowThreshold, max_lowThreshold, CannyThreshold );
/// Show what you got
- namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( source_window, WINDOW_AUTOSIZE );
imshow( source_window, src );
- namedWindow( warp_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( warp_window, WINDOW_AUTOSIZE );
imshow( warp_window, warp_dst );
- namedWindow( warp_rotate_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( warp_rotate_window, WINDOW_AUTOSIZE );
imshow( warp_rotate_window, warp_rotate_dst );
/// Wait until user exits the program
{ return -1; }
/// Convert it to gray
- cvtColor( src, src_gray, CV_BGR2GRAY );
+ cvtColor( src, src_gray, COLOR_BGR2GRAY );
/// Reduce the noise so we avoid false circle detection
GaussianBlur( src_gray, src_gray, Size(9, 9), 2, 2 );
}
/// Show your results
- namedWindow( "Hough Circle Transform Demo", CV_WINDOW_AUTOSIZE );
+ namedWindow( "Hough Circle Transform Demo", WINDOW_AUTOSIZE );
imshow( "Hough Circle Transform Demo", src );
waitKey(0);
}
/// Pass the image to gray
- cvtColor( src, src_gray, CV_RGB2GRAY );
+ cvtColor( src, src_gray, COLOR_RGB2GRAY );
/// Apply Canny edge detector
Canny( src_gray, edges, 50, 200, 3 );
char thresh_label[50];
sprintf( thresh_label, "Thres: %d + input", min_threshold );
- namedWindow( standard_name, CV_WINDOW_AUTOSIZE );
+ namedWindow( standard_name, WINDOW_AUTOSIZE );
createTrackbar( thresh_label, standard_name, &s_trackbar, max_trackbar, Standard_Hough);
- namedWindow( probabilistic_name, CV_WINDOW_AUTOSIZE );
+ namedWindow( probabilistic_name, WINDOW_AUTOSIZE );
createTrackbar( thresh_label, probabilistic_name, &p_trackbar, max_trackbar, Probabilistic_Hough);
/// Initialize
GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
/// Convert the image to grayscale
- cvtColor( src, src_gray, CV_RGB2GRAY );
+ cvtColor( src, src_gray, COLOR_RGB2GRAY );
/// Create window
- namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+ namedWindow( window_name, WINDOW_AUTOSIZE );
/// Apply Laplace function
Mat abs_dst;
map_y.create( src.size(), CV_32FC1 );
/// Create window
- namedWindow( remap_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( remap_window, WINDOW_AUTOSIZE );
/// Loop
for(;;)
GaussianBlur( src, src, Size(3,3), 0, 0, BORDER_DEFAULT );
/// Convert it to gray
- cvtColor( src, src_gray, CV_RGB2GRAY );
+ cvtColor( src, src_gray, COLOR_RGB2GRAY );
/// Create window
- namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+ namedWindow( window_name, WINDOW_AUTOSIZE );
/// Generate grad_x and grad_y
Mat grad_x, grad_y;
printf( " ** Press 'ESC' to exit the program \n");
/// Create window
- namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+ namedWindow( window_name, WINDOW_AUTOSIZE );
/// Initialize arguments for the filter
top = (int) (0.05*src.rows); bottom = (int) (0.05*src.rows);
{ return -1; }
/// Create window
- namedWindow( window_name, CV_WINDOW_AUTOSIZE );
+ namedWindow( window_name, WINDOW_AUTOSIZE );
/// Initialize arguments for the filter
anchor = Point( -1, -1 );
src = imread( argv[1], 1 );
/// Convert image to gray and blur it
- cvtColor( src, src_gray, CV_BGR2GRAY );
+ cvtColor( src, src_gray, COLOR_BGR2GRAY );
blur( src_gray, src_gray, Size(3,3) );
/// Create Window
const char* source_window = "Source";
- namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( source_window, WINDOW_AUTOSIZE );
imshow( source_window, src );
createTrackbar( " Canny thresh:", "Source", &thresh, max_thresh, thresh_callback );
}
/// Show in a window
- namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
+ namedWindow( "Contours", WINDOW_AUTOSIZE );
imshow( "Contours", drawing );
}
src = imread( argv[1], 1 );
/// Convert image to gray and blur it
- cvtColor( src, src_gray, CV_BGR2GRAY );
+ cvtColor( src, src_gray, COLOR_BGR2GRAY );
blur( src_gray, src_gray, Size(3,3) );
/// Create Window
const char* source_window = "Source";
- namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( source_window, WINDOW_AUTOSIZE );
imshow( source_window, src );
createTrackbar( " Threshold:", "Source", &thresh, max_thresh, thresh_callback );
}
/// Show in a window
- namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
+ namedWindow( "Contours", WINDOW_AUTOSIZE );
imshow( "Contours", drawing );
}
src = imread( argv[1], 1 );
/// Convert image to gray and blur it
- cvtColor( src, src_gray, CV_BGR2GRAY );
+ cvtColor( src, src_gray, COLOR_BGR2GRAY );
blur( src_gray, src_gray, Size(3,3) );
/// Create Window
const char* source_window = "Source";
- namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( source_window, WINDOW_AUTOSIZE );
imshow( source_window, src );
createTrackbar( " Threshold:", "Source", &thresh, max_thresh, thresh_callback );
}
/// Show in a window
- namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
+ namedWindow( "Contours", WINDOW_AUTOSIZE );
imshow( "Contours", drawing );
}
src = imread( argv[1], 1 );
/// Convert image to gray and blur it
- cvtColor( src, src_gray, CV_BGR2GRAY );
+ cvtColor( src, src_gray, COLOR_BGR2GRAY );
blur( src_gray, src_gray, Size(3,3) );
/// Create Window
const char* source_window = "Source";
- namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( source_window, WINDOW_AUTOSIZE );
imshow( source_window, src );
createTrackbar( " Threshold:", "Source", &thresh, max_thresh, thresh_callback );
findContours( threshold_output, contours, hierarchy, CV_RETR_TREE, CV_CHAIN_APPROX_SIMPLE, Point(0, 0) );
/// Find the convex hull object for each contour
- vector<vector<Point> >hull( contours.size() );
+ vector<vector<Point> >hull( contours.size() );
for( size_t i = 0; i < contours.size(); i++ )
{ convexHull( Mat(contours[i]), hull[i], false ); }
}
/// Show in a window
- namedWindow( "Hull demo", CV_WINDOW_AUTOSIZE );
+ namedWindow( "Hull demo", WINDOW_AUTOSIZE );
imshow( "Hull demo", drawing );
}
src = imread( argv[1], 1 );
/// Convert image to gray and blur it
- cvtColor( src, src_gray, CV_BGR2GRAY );
+ cvtColor( src, src_gray, COLOR_BGR2GRAY );
blur( src_gray, src_gray, Size(3,3) );
/// Create Window
const char* source_window = "Source";
- namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( source_window, WINDOW_AUTOSIZE );
imshow( source_window, src );
createTrackbar( " Canny thresh:", "Source", &thresh, max_thresh, thresh_callback );
}
/// Show in a window
- namedWindow( "Contours", CV_WINDOW_AUTOSIZE );
+ namedWindow( "Contours", WINDOW_AUTOSIZE );
imshow( "Contours", drawing );
/// Calculate the area with the moments 00 and compare with the result of the OpenCV function
/// Create Window and show your results
const char* source_window = "Source";
- namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( source_window, WINDOW_AUTOSIZE );
imshow( source_window, src );
- namedWindow( "Distance", CV_WINDOW_AUTOSIZE );
+ namedWindow( "Distance", WINDOW_AUTOSIZE );
imshow( "Distance", drawing );
waitKey(0);
{
/// Load source image and convert it to gray
src = imread( argv[1], 1 );
- cvtColor( src, src_gray, CV_BGR2GRAY );
+ cvtColor( src, src_gray, COLOR_BGR2GRAY );
/// Set some parameters
int blockSize = 3; int apertureSize = 3;
minMaxLoc( Mc, &myHarris_minVal, &myHarris_maxVal, 0, 0, Mat() );
/* Create Window and Trackbar */
- namedWindow( myHarris_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( myHarris_window, WINDOW_AUTOSIZE );
createTrackbar( " Quality Level:", myHarris_window, &myHarris_qualityLevel, max_qualityLevel, myHarris_function );
myHarris_function( 0, 0 );
minMaxLoc( myShiTomasi_dst, &myShiTomasi_minVal, &myShiTomasi_maxVal, 0, 0, Mat() );
/* Create Window and Trackbar */
- namedWindow( myShiTomasi_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( myShiTomasi_window, WINDOW_AUTOSIZE );
createTrackbar( " Quality Level:", myShiTomasi_window, &myShiTomasi_qualityLevel, max_qualityLevel, myShiTomasi_function );
myShiTomasi_function( 0, 0 );
{
/// Load source image and convert it to gray
src = imread( argv[1], 1 );
- cvtColor( src, src_gray, CV_BGR2GRAY );
+ cvtColor( src, src_gray, COLOR_BGR2GRAY );
/// Create a window and a trackbar
- namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( source_window, WINDOW_AUTOSIZE );
createTrackbar( "Threshold: ", source_window, &thresh, max_thresh, cornerHarris_demo );
imshow( source_window, src );
}
}
/// Showing the result
- namedWindow( corners_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( corners_window, WINDOW_AUTOSIZE );
imshow( corners_window, dst_norm_scaled );
}
{
/// Load source image and convert it to gray
src = imread( argv[1], 1 );
- cvtColor( src, src_gray, CV_BGR2GRAY );
+ cvtColor( src, src_gray, COLOR_BGR2GRAY );
/// Create Window
- namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( source_window, WINDOW_AUTOSIZE );
/// Create Trackbar to set the number of corners
createTrackbar( "Max corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );
{ circle( copy, corners[i], r, Scalar(rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255)), -1, 8, 0 ); }
/// Show what you got
- namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( source_window, WINDOW_AUTOSIZE );
imshow( source_window, copy );
/// Set the neeed parameters to find the refined corners
{
/// Load source image and convert it to gray
src = imread( argv[1], 1 );
- cvtColor( src, src_gray, CV_BGR2GRAY );
+ cvtColor( src, src_gray, COLOR_BGR2GRAY );
/// Create Window
- namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( source_window, WINDOW_AUTOSIZE );
/// Create Trackbar to set the number of corners
createTrackbar( "Max corners:", source_window, &maxCorners, maxTrackbar, goodFeaturesToTrack_Demo );
{ circle( copy, corners[i], r, Scalar(rng.uniform(0,255), rng.uniform(0,255), rng.uniform(0,255)), -1, 8, 0 ); }
/// Show what you got
- namedWindow( source_window, CV_WINDOW_AUTOSIZE );
+ namedWindow( source_window, WINDOW_AUTOSIZE );
imshow( source_window, copy );
}
if( s.calibrationPattern == Settings::CHESSBOARD)
{
Mat viewGray;
- cvtColor(view, viewGray, CV_BGR2GRAY);
+ cvtColor(view, viewGray, COLOR_BGR2GRAY);
cornerSubPix( viewGray, pointBuf, Size(11,11),
Size(-1,-1), TermCriteria( CV_TERMCRIT_EPS+CV_TERMCRIT_ITER, 30, 0.1 ));
}
//-- 4. Display it as a CV_8UC1 image
imgDisparity16S.convertTo( imgDisparity8U, CV_8UC1, 255/(maxVal - minVal));
- namedWindow( windowDisparity, CV_WINDOW_NORMAL );
+ namedWindow( windowDisparity, WINDOW_NORMAL );
imshow( windowDisparity, imgDisparity8U );
//-- 5. Save the image
/// 3. Display your stuff!
imshow( atom_window, atom_image );
- cvMoveWindow( atom_window, 0, 200 );
+ moveWindow( atom_window, 0, 200 );
imshow( rook_window, rook_image );
- cvMoveWindow( rook_window, w, 200 );
+ moveWindow( rook_window, w, 200 );
waitKey( 0 );
return(0);
*/
int Displaying_Big_End( Mat image, char* window_name, RNG )
{
- Size textsize = getTextSize("OpenCV forever!", CV_FONT_HERSHEY_COMPLEX, 3, 5, 0);
+ Size textsize = getTextSize("OpenCV forever!", FONT_HERSHEY_COMPLEX, 3, 5, 0);
Point org((window_width - textsize.width)/2, (window_height - textsize.height)/2);
int lineType = 8;
for( int i = 0; i < 255; i += 2 )
{
image2 = image - Scalar::all(i);
- putText( image2, "OpenCV forever!", org, CV_FONT_HERSHEY_COMPLEX, 3,
+ putText( image2, "OpenCV forever!", org, FONT_HERSHEY_COMPLEX, 3,
Scalar(i, i, 255), 5, lineType );
imshow( window_name, image2 );
// convert image to YUV color space. The output image will be created automatically.
Mat I_YUV;
- cvtColor(I, I_YUV, CV_BGR2YCrCb);
+ cvtColor(I, I_YUV, COLOR_BGR2YCrCb);
vector<Mat> planes; // Use the STL's vector structure to store multiple Mat objects
split(I_YUV, planes); // split the image into separate color planes (Y U V)
cvtColor(I_YUV, I, CV_YCrCb2BGR); // and produce the output RGB image
- namedWindow("image with grain", CV_WINDOW_AUTOSIZE); // use this to create images
+ namedWindow("image with grain", WINDOW_AUTOSIZE); // use this to create images
#ifdef DEMO_MIXED_API_USE
// this is to demonstrate that I and IplI really share the data - the result of the above
else
I = imread( filename, CV_LOAD_IMAGE_COLOR);
- namedWindow("Input", CV_WINDOW_AUTOSIZE);
- namedWindow("Output", CV_WINDOW_AUTOSIZE);
+ namedWindow("Input", WINDOW_AUTOSIZE);
+ namedWindow("Output", WINDOW_AUTOSIZE);
imshow("Input", I);
double t = (double)getTickCount();
cout << "Hand written function times passed in seconds: " << t << endl;
imshow("Output", J);
- cvWaitKey(0);
+ waitKey(0);
Mat kern = (Mat_<char>(3,3) << 0, -1, 0,
-1, 5, -1,
imshow("Output", K);
- cvWaitKey(0);
+ waitKey(0);
return 0;
}
void Sharpen(const Mat& myImage,Mat& Result)
//-- Get the corners from the image_1 ( the object to be "detected" )
std::vector<Point2f> obj_corners(4);
- obj_corners[0] = cvPoint(0,0); obj_corners[1] = cvPoint( img_object.cols, 0 );
- obj_corners[2] = cvPoint( img_object.cols, img_object.rows ); obj_corners[3] = cvPoint( 0, img_object.rows );
+ obj_corners[0] = Point(0,0); obj_corners[1] = Point( img_object.cols, 0 );
+ obj_corners[2] = Point( img_object.cols, img_object.rows ); obj_corners[3] = Point( 0, img_object.rows );
std::vector<Point2f> scene_corners(4);
perspectiveTransform( obj_corners, scene_corners, H);
return -1;
}
- namedWindow( "Display window", CV_WINDOW_AUTOSIZE );// Create a window for display.
+ namedWindow( "Display window", WINDOW_AUTOSIZE );// Create a window for display.
imshow( "Display window", image ); // Show our image inside it.
waitKey(0); // Wait for a keystroke in the window
const char* WIN_RF = "Reference";
// Windows
- namedWindow(WIN_RF, CV_WINDOW_AUTOSIZE );
- namedWindow(WIN_UT, CV_WINDOW_AUTOSIZE );
- cvMoveWindow(WIN_RF, 400 , 0); //750, 2 (bernat =0)
- cvMoveWindow(WIN_UT, refS.width, 0); //1500, 2
+ namedWindow(WIN_RF, WINDOW_AUTOSIZE );
+ namedWindow(WIN_UT, WINDOW_AUTOSIZE );
+ moveWindow(WIN_RF, 400 , 0); //750, 2 (bernat =0)
+ moveWindow(WIN_UT, refS.width, 0); //1500, 2
cout << "Frame resolution: Width=" << refS.width << " Height=" << refS.height
<< " of nr#: " << captRefrnc.get(CV_CAP_PROP_FRAME_COUNT) << endl;
imshow( WIN_RF, frameReference);
imshow( WIN_UT, frameUnderTest);
- c = (char)cvWaitKey(delay);
+ c = (char)waitKey(delay);
if (c == 27) break;
}
*/
int main( void )
{
- CvCapture* capture;
+ VideoCapture capture;
Mat frame;
//-- 1. Load the cascades
if( !eyes_cascade.load( eyes_cascade_name ) ){ printf("--(!)Error loading\n"); return -1; };
//-- 2. Read the video stream
- capture = cvCaptureFromCAM( -1 );
- if( capture )
+ capture.open( -1 );
+ if( capture.isOpened() )
{
for(;;)
{
- frame = cvQueryFrame( capture );
+ capture >> frame;
//-- 3. Apply the classifier to the frame
if( !frame.empty() )
std::vector<Rect> faces;
Mat frame_gray;
- cvtColor( frame, frame_gray, CV_BGR2GRAY );
+ cvtColor( frame, frame_gray, COLOR_BGR2GRAY );
equalizeHist( frame_gray, frame_gray );
//-- Detect faces
face_cascade.detectMultiScale( frame_gray, faces, 1.1, 2, 0|CV_HAAR_SCALE_IMAGE, Size(30, 30) );
*/
int main( void )
{
- CvCapture* capture;
+ VideoCapture capture;
Mat frame;
//-- 1. Load the cascade
if( !eyes_cascade.load( eyes_cascade_name ) ){ printf("--(!)Error loading\n"); return -1; };
//-- 2. Read the video stream
- capture = cvCaptureFromCAM( -1 );
- if( capture )
+ capture.open( -1 );
+ if( capture.isOpened() )
{
for(;;)
{
- frame = cvQueryFrame( capture );
+ capture >> frame;
//-- 3. Apply the classifier to the frame
if( !frame.empty() )
std::vector<Rect> faces;
Mat frame_gray;
- cvtColor( frame, frame_gray, CV_BGR2GRAY );
+ cvtColor( frame, frame_gray, COLOR_BGR2GRAY );
equalizeHist( frame_gray, frame_gray );
//-- Detect faces
if (frame.empty())
break;
cv::Mat gray;
- cv::cvtColor(frame,gray,CV_RGB2GRAY);
+ cv::cvtColor(frame,gray,COLOR_RGB2GRAY);
vector<string> codes;
Mat corners;
findDataMatrix(gray, codes, corners);
if (frame.empty())
break;
- cvtColor(frame, gray, CV_RGB2GRAY);
+ cvtColor(frame, gray, COLOR_RGB2GRAY);
detector.detect(gray, query_kpts); //Find interest points
namedWindow( "image", 1 );
img0.copyTo(img);
- cvtColor(img, markerMask, CV_BGR2GRAY);
- cvtColor(markerMask, imgGray, CV_GRAY2BGR);
+ cvtColor(img, markerMask, COLOR_BGR2GRAY);
+ cvtColor(markerMask, imgGray, COLOR_GRAY2BGR);
markerMask = Scalar::all(0);
imshow( "image", img );
setMouseCallback( "image", onMouse, 0 );