opencv/opencv_contrib
1
0
Fork 0
mirror of https://github.com/opencv/opencv_contrib.git synced 2025-10-20 21:40:49 +08:00
Code Issues Releases Wiki Activity

minor changes

Browse Source
This commit is contained in:
Suleyman TURKMEN
2018-10-31 19:38:19 +03:00
parent 6703cddd93
commit 2074cc48e5
24 changed files with 72 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
modules/aruco/src/aruco.cpp
View File

@@ -103,13 +103,12 @@ Ptr<DetectorParameters> DetectorParameters::create() {
*/ */
static void _convertToGrey(InputArray _in, OutputArray _out) { static void _convertToGrey(InputArray _in, OutputArray _out) {
CV_Assert(_in.getMat().channels() == 1 || _in.getMat().channels() == 3); CV_Assert(_in.type() == CV_8UC1 || _in.type() == CV_8UC3);
_out.create(_in.getMat().size(), CV_8UC1); if(_in.type() == CV_8UC3)
if(_in.getMat().type() == CV_8UC3) cvtColor(_in, _out, COLOR_BGR2GRAY);
cvtColor(_in.getMat(), _out.getMat(), COLOR_BGR2GRAY);
else else
_in.getMat().copyTo(_out); _in.copyTo(_out);
} }

12
modules/aruco/src/charuco.cpp
View File

@@ -345,10 +345,10 @@ static int _selectAndRefineChessboardCorners(InputArray _allCorners, InputArray
// corner refinement, first convert input image to grey // corner refinement, first convert input image to grey
Mat grey; Mat grey;
if(_image.getMat().type() == CV_8UC3) if(_image.type() == CV_8UC3)
cvtColor(_image.getMat(), grey, COLOR_BGR2GRAY); cvtColor(_image, grey, COLOR_BGR2GRAY);
else else
_image.getMat().copyTo(grey); _image.copyTo(grey);
const Ptr<DetectorParameters> params = DetectorParameters::create(); // use default params for corner refinement const Ptr<DetectorParameters> params = DetectorParameters::create(); // use default params for corner refinement
@@ -754,10 +754,10 @@ void detectCharucoDiamond(InputArray _image, InputArrayOfArrays _markerCorners,
// convert input image to grey // convert input image to grey
Mat grey; Mat grey;
if(_image.getMat().type() == CV_8UC3) if(_image.type() == CV_8UC3)
cvtColor(_image.getMat(), grey, COLOR_BGR2GRAY); cvtColor(_image, grey, COLOR_BGR2GRAY);
else else
_image.getMat().copyTo(grey); _image.copyTo(grey);
// for each of the detected markers, try to find a diamond // for each of the detected markers, try to find a diamond
for(unsigned int i = 0; i < _markerIds.total(); i++) { for(unsigned int i = 0; i < _markerIds.total(); i++) {

18
modules/cnn_3dobj/src/cnn_feature.cpp
View File

@@ -222,26 +222,24 @@ namespace cnn_3dobj
{ {
/* Convert the input image to the input image format of the network. */ /* Convert the input image to the input image format of the network. */
cv::Mat sample; cv::Mat sample;
if (img.channels() == 3 && num_channels == 1) if (num_channels == 1)
cv::cvtColor(img, sample, CV_BGR2GRAY); cv::cvtColor(img, sample, COLOR_BGR2GRAY);
else if (img.channels() == 4 && num_channels == 1)
cv::cvtColor(img, sample, CV_BGRA2GRAY);
else if (img.channels() == 4 && num_channels == 3) else if (img.channels() == 4 && num_channels == 3)
cv::cvtColor(img, sample, CV_BGRA2BGR); cv::cvtColor(img, sample, COLOR_BGRA2BGR);
else if (img.channels() == 1 && num_channels == 3) else if (img.channels() == 1 && num_channels == 3)
cv::cvtColor(img, sample, CV_GRAY2BGR); cv::cvtColor(img, sample, COLOR_GRAY2BGR);
else else
sample = img; sample = img;
cv::Mat sample_resized; cv::Mat sample_resized;
if (sample.size() != input_geometry) if (sample.size() != input_geometry)
cv::resize(sample, sample_resized, input_geometry); cv::resize(sample, sample_resized, input_geometry);
else else
sample_resized = sample; sample_resized = sample;
cv::Mat sample_float; cv::Mat sample_float;
if (num_channels == 3) sample_resized.convertTo(sample_float, CV_32F);
sample_resized.convertTo(sample_float, CV_32FC3);
else
sample_resized.convertTo(sample_float, CV_32FC1);
cv::Mat sample_normalized; cv::Mat sample_normalized;
if (net_ready == 2) if (net_ready == 2)
cv::subtract(sample_float, mean_, sample_normalized); cv::subtract(sample_float, mean_, sample_normalized);

2
modules/cvv/samples/cvv_demo.cpp
View File

@@ -84,7 +84,7 @@ main(int argc, char** argv)
// convert to grayscale // convert to grayscale
cv::Mat imgGray; cv::Mat imgGray;
cv::cvtColor(imgRead, imgGray, CV_BGR2GRAY); cv::cvtColor(imgRead, imgGray, COLOR_BGR2GRAY);
cvv::debugFilter(imgRead, imgGray, CVVISUAL_LOCATION, "to gray"); cvv::debugFilter(imgRead, imgGray, CVVISUAL_LOCATION, "to gray");
// detect ORB features // detect ORB features

4
modules/cvv/src/qtutil/filter/diffFilterWidget.cpp
View File

@@ -69,8 +69,8 @@ void DiffFilterFunction::applyFilter(InputArray in, OutputArray out) const
} }
cv::Mat originalHSV, filteredHSV; cv::Mat originalHSV, filteredHSV;
cv::cvtColor(in.at(0).get(), originalHSV, CV_BGR2HSV); cv::cvtColor(in.at(0).get(), originalHSV, COLOR_BGR2HSV);
cv::cvtColor(in.at(1).get(), filteredHSV, CV_BGR2HSV); cv::cvtColor(in.at(1).get(), filteredHSV, COLOR_BGR2HSV);
auto diffHSV = cv::abs(originalHSV - filteredHSV); auto diffHSV = cv::abs(originalHSV - filteredHSV);
std::array<cv::Mat, 3> splitVector; std::array<cv::Mat, 3> splitVector;

2
modules/face/tutorials/face_landmark/face_landmark_detection.markdown
View File

@@ -46,7 +46,7 @@ resize(img,img,Size(460,460),0,0,INTER_LINEAR_EXACT);
Mat gray; Mat gray;
std::vector<Rect> faces; std::vector<Rect> faces;
if(img.channels()>1){ if(img.channels()>1){
cvtColor(img.getMat(),gray,CV_BGR2GRAY); cvtColor(img.getMat(),gray,COLOR_BGR2GRAY);
} }
else{ else{
gray = img.getMat().clone(); gray = img.getMat().clone();

2
modules/face/tutorials/face_landmark/face_landmark_trainer.markdown
View File

@@ -65,7 +65,7 @@ bool myDetector( InputArray image, OutputArray ROIs ){
Mat gray; Mat gray;
std::vector<Rect> faces; std::vector<Rect> faces;
if(image.channels()>1){ if(image.channels()>1){
cvtColor(image.getMat(),gray,CV_BGR2GRAY); cvtColor(image.getMat(),gray,COLOR_BGR2GRAY);
} }
else{ else{
gray = image.getMat().clone(); gray = image.getMat().clone();

2
modules/face/tutorials/face_landmark/face_landmark_video.markdown
View File

@@ -26,7 +26,7 @@ bool myDetector( InputArray image, OutputArray ROIs ){
Mat gray; Mat gray;
std::vector<Rect> faces; std::vector<Rect> faces;
if(image.channels()>1){ if(image.channels()>1){
cvtColor(image.getMat(),gray,CV_BGR2GRAY); cvtColor(image.getMat(),gray,COLOR_BGR2GRAY);
} }
else{ else{
gray = image.getMat().clone(); gray = image.getMat().clone();

2
modules/face/tutorials/face_landmark/sample_face_swapping.markdown
View File

@@ -25,7 +25,7 @@ bool myDetector( InputArray image, OutputArray ROIs ){
Mat gray; Mat gray;
std::vector<Rect> faces; std::vector<Rect> faces;
if(image.channels()>1){ if(image.channels()>1){
cvtColor(image.getMat(),gray,CV_BGR2GRAY); cvtColor(image.getMat(),gray,COLOR_BGR2GRAY);
} }
else{ else{
gray = image.getMat().clone(); gray = image.getMat().clone();

12
modules/img_hash/src/average_hash.cpp
View File

@@ -27,18 +27,10 @@ public:
input.type() == CV_8U); input.type() == CV_8U);
cv::resize(input, resizeImg, cv::Size(8,8), 0, 0, INTER_LINEAR_EXACT); cv::resize(input, resizeImg, cv::Size(8,8), 0, 0, INTER_LINEAR_EXACT);
if(input.type() == CV_8UC3) if(input.channels() > 1)
{ cv::cvtColor(resizeImg, grayImg, COLOR_BGR2GRAY);
cv::cvtColor(resizeImg, grayImg, CV_BGR2GRAY);
}
else if(input.type() == CV_8UC4)
{
cv::cvtColor(resizeImg, grayImg, CV_BGRA2GRAY);
}
else else
{
grayImg = resizeImg; grayImg = resizeImg;
}
uchar const imgMean = static_cast<uchar>(cvRound(cv::mean(grayImg)[0])); uchar const imgMean = static_cast<uchar>(cvRound(cv::mean(grayImg)[0]));
cv::compare(grayImg, imgMean, bitsImg, CMP_GT); cv::compare(grayImg, imgMean, bitsImg, CMP_GT);

12
modules/img_hash/src/block_mean_hash.cpp
View File

@@ -40,18 +40,10 @@ public:
input.type() == CV_8U); input.type() == CV_8U);
cv::resize(input, resizeImg_, cv::Size(imgWidth,imgHeight), 0, 0, INTER_LINEAR_EXACT); cv::resize(input, resizeImg_, cv::Size(imgWidth,imgHeight), 0, 0, INTER_LINEAR_EXACT);
if(input.type() == CV_8UC3) if(input.channels() > 1)
{ cv::cvtColor(resizeImg_, grayImg_, COLOR_BGR2GRAY);
cv::cvtColor(resizeImg_, grayImg_, CV_BGR2GRAY);
}
else if(input.type() == CV_8UC4)
{
cv::cvtColor(resizeImg_, grayImg_, CV_BGRA2GRAY);
}
else else
{
grayImg_ = resizeImg_; grayImg_ = resizeImg_;
}
int pixColStep = blockWidth; int pixColStep = blockWidth;
int pixRowStep = blockHeigth; int pixRowStep = blockHeigth;

11
modules/img_hash/src/color_moment_hash.cpp
View File

@@ -28,25 +28,24 @@ public:
} }
else if(input.type() == CV_8UC4) else if(input.type() == CV_8UC4)
{ {
cv::cvtColor(input, colorImg_, CV_BGRA2BGR); cv::cvtColor(input, colorImg_, COLOR_BGRA2BGR);
} }
else else
{ {
cv::cvtColor(input, colorImg_, CV_GRAY2BGR); cv::cvtColor(input, colorImg_, COLOR_GRAY2BGR);
} }
cv::resize(colorImg_, resizeImg_, cv::Size(512,512), 0, 0, cv::resize(colorImg_, resizeImg_, cv::Size(512,512), 0, 0, INTER_CUBIC);
INTER_CUBIC);
cv::GaussianBlur(resizeImg_, blurImg_, cv::Size(3,3), 0, 0); cv::GaussianBlur(resizeImg_, blurImg_, cv::Size(3,3), 0, 0);
cv::cvtColor(blurImg_, colorSpace_, CV_BGR2HSV); cv::cvtColor(blurImg_, colorSpace_, COLOR_BGR2HSV);
cv::split(colorSpace_, channels_); cv::split(colorSpace_, channels_);
outputArr.create(1, 42, CV_64F); outputArr.create(1, 42, CV_64F);
cv::Mat hash = outputArr.getMat(); cv::Mat hash = outputArr.getMat();
hash.setTo(0); hash.setTo(0);
computeMoments(hash.ptr<double>(0)); computeMoments(hash.ptr<double>(0));
cv::cvtColor(blurImg_, colorSpace_, CV_BGR2YCrCb); cv::cvtColor(blurImg_, colorSpace_, COLOR_BGR2YCrCb);
cv::split(colorSpace_, channels_); cv::split(colorSpace_, channels_);
computeMoments(hash.ptr<double>(0) + 21); computeMoments(hash.ptr<double>(0) + 21);
} }

13
modules/img_hash/src/marr_hildreth_hash.cpp
View File

@@ -105,18 +105,11 @@ public:
input.type() == CV_8UC3 || input.type() == CV_8UC3 ||
input.type() == CV_8U); input.type() == CV_8U);
if(input.type() == CV_8UC3) if(input.channels() > 1)
{ cv::cvtColor(input, grayImg, COLOR_BGR2GRAY);
cv::cvtColor(input, grayImg, CV_BGR2GRAY);
}
else if(input.type() == CV_8UC4)
{
cv::cvtColor(input, grayImg, CV_BGRA2GRAY);
}
else else
{
grayImg = input; grayImg = input;
}
//pHash use Canny-deritch filter to blur the image //pHash use Canny-deritch filter to blur the image
cv::GaussianBlur(grayImg, blurImg, cv::Size(7, 7), 0); cv::GaussianBlur(grayImg, blurImg, cv::Size(7, 7), 0);
cv::resize(blurImg, resizeImg, cv::Size(512, 512), 0, 0, INTER_CUBIC); cv::resize(blurImg, resizeImg, cv::Size(512, 512), 0, 0, INTER_CUBIC);

12
modules/img_hash/src/phash.cpp
View File

@@ -21,18 +21,10 @@ public:
input.type() == CV_8U); input.type() == CV_8U);
cv::resize(input, resizeImg, cv::Size(32,32), 0, 0, INTER_LINEAR_EXACT); cv::resize(input, resizeImg, cv::Size(32,32), 0, 0, INTER_LINEAR_EXACT);
if(input.type() == CV_8UC3) if(input.channels() > 1)
{ cv::cvtColor(resizeImg, grayImg, COLOR_BGR2GRAY);
cv::cvtColor(resizeImg, grayImg, CV_BGR2GRAY);
}
else if(input.type() == CV_8UC4)
{
cv::cvtColor(resizeImg, grayImg, CV_BGRA2GRAY);
}
else else
{
grayImg = resizeImg; grayImg = resizeImg;
}
grayImg.convertTo(grayFImg, CV_32F); grayImg.convertTo(grayFImg, CV_32F);
cv::dct(grayFImg, dctImg); cv::dct(grayFImg, dctImg);

4
modules/img_hash/src/radial_variance_hash.cpp
View File

@@ -53,11 +53,11 @@ public:
if(input.type() == CV_8UC3) if(input.type() == CV_8UC3)
{ {
cv::cvtColor(input, grayImg_, CV_BGR2GRAY); cv::cvtColor(input, grayImg_, COLOR_BGR2GRAY);
} }
else if(input.type() == CV_8UC4) else if(input.type() == CV_8UC4)
{ {
cv::cvtColor(input, grayImg_, CV_BGRA2GRAY); cv::cvtColor(input, grayImg_, COLOR_BGRA2GRAY);
} }
else else
{ {

3
modules/line_descriptor/src/binary_descriptor.cpp
View File

@@ -548,7 +548,7 @@ void BinaryDescriptor::computeImpl( const Mat& imageSrc, std::vector<KeyLine>& k
if( imageSrc.channels() != 1 ) if( imageSrc.channels() != 1 )
cvtColor( imageSrc, image, COLOR_BGR2GRAY ); cvtColor( imageSrc, image, COLOR_BGR2GRAY );
else else
image = imageSrc.clone(); image = imageSrc;
/*check whether image's depth is different from 0 */ /*check whether image's depth is different from 0 */
if( image.depth() != 0 ) if( image.depth() != 0 )
@@ -627,7 +627,6 @@ void BinaryDescriptor::computeImpl( const Mat& imageSrc, std::vector<KeyLine>& k
{ {
for ( size_t j = 0; j < sl[i].size(); ) for ( size_t j = 0; j < sl[i].size(); )
{ {
//if( (int) ( sl[i][j] ).octaveCount > params.numOfOctave_ )
if( (int) ( sl[i][j] ).octaveCount > octaveIndex ) if( (int) ( sl[i][j] ).octaveCount > octaveIndex )
( sl[i] ).erase( ( sl[i] ).begin() + j ); ( sl[i] ).erase( ( sl[i] ).begin() + j );
else j++; else j++;

16
modules/reg/samples/map_test.cpp
View File

@@ -73,9 +73,9 @@ static void showDifference(const Mat& image1, const Mat& image2, const char* tit
image1.convertTo(img1, CV_32FC3); image1.convertTo(img1, CV_32FC3);
image2.convertTo(img2, CV_32FC3); image2.convertTo(img2, CV_32FC3);
if(img1.channels() != 1) if(img1.channels() != 1)
cvtColor(img1, img1, CV_RGB2GRAY); cvtColor(img1, img1, COLOR_BGR2GRAY);
if(img2.channels() != 1) if(img2.channels() != 1)
cvtColor(img2, img2, CV_RGB2GRAY); cvtColor(img2, img2, COLOR_BGR2GRAY);
Mat imgDiff; Mat imgDiff;
img1.copyTo(imgDiff); img1.copyTo(imgDiff);
@@ -273,11 +273,11 @@ static void calcHomographyFeature(const Mat& image1, const Mat& image2)
Mat gray_image2; Mat gray_image2;
// Convert to Grayscale // Convert to Grayscale
if(image1.channels() != 1) if(image1.channels() != 1)
cvtColor(image1, gray_image1, CV_RGB2GRAY); cvtColor(image1, gray_image1, COLOR_BGR2GRAY);
else else
image1.copyTo(gray_image1); image1.copyTo(gray_image1);
if(image2.channels() != 1) if(image2.channels() != 1)
cvtColor(image2, gray_image2, CV_RGB2GRAY); cvtColor(image2, gray_image2, COLOR_BGR2GRAY);
else else
image2.copyTo(gray_image2); image2.copyTo(gray_image2);
@@ -335,7 +335,7 @@ static void calcHomographyFeature(const Mat& image1, const Mat& image2)
} }
// Find the Homography Matrix // Find the Homography Matrix
Mat H = findHomography( obj, scene, CV_RANSAC ); Mat H = findHomography( obj, scene, RANSAC );
// Use the Homography Matrix to warp the images // Use the Homography Matrix to warp the images
Mat result; Mat result;
Mat Hinv = H.inv(); Mat Hinv = H.inv();
@@ -393,7 +393,7 @@ static void comparePixelVsFeature(const Mat& img1_8b, const Mat& img2_8b)
int main(void) int main(void)
{ {
Mat img1; Mat img1;
img1 = imread("home.png", CV_LOAD_IMAGE_UNCHANGED); img1 = imread("home.png", IMREAD_UNCHANGED);
if(!img1.data) { if(!img1.data) {
cout << "Could not open or find file" << endl; cout << "Could not open or find file" << endl;
return -1; return -1;
@@ -408,13 +408,13 @@ int main(void)
testProjective(img1); testProjective(img1);
#ifdef COMPARE_FEATURES #ifdef COMPARE_FEATURES
Mat imgcmp1 = imread("LR_05.png", CV_LOAD_IMAGE_UNCHANGED); Mat imgcmp1 = imread("LR_05.png", IMREAD_UNCHANGED);
if(!imgcmp1.data) { if(!imgcmp1.data) {
cout << "Could not open or find file" << endl; cout << "Could not open or find file" << endl;
return -1; return -1;
} }
Mat imgcmp2 = imread("LR_06.png", CV_LOAD_IMAGE_UNCHANGED); Mat imgcmp2 = imread("LR_06.png", IMREAD_UNCHANGED);
if(!imgcmp2.data) { if(!imgcmp2.data) {
cout << "Could not open or find file" << endl; cout << "Could not open or find file" << endl;
return -1; return -1;

2
modules/tracking/samples/tutorial_customizing_cn_tracker.cpp
View File

@@ -102,7 +102,7 @@ void sobelExtractor(const Mat img, const Rect roi, Mat& feat){
//! [insideimage] //! [insideimage]
patch=img(region).clone(); patch=img(region).clone();
cvtColor(patch,patch, CV_BGR2GRAY); cvtColor(patch,patch, COLOR_BGR2GRAY);
//! [padding] //! [padding]
// add some padding to compensate when the patch is outside image border // add some padding to compensate when the patch is outside image border

2
modules/tracking/src/TrackingFunctionPF.hpp
View File

@@ -31,7 +31,7 @@ namespace cv{
Mat hsv; Mat hsv;
img.convertTo(hsv,CV_32F,1.0/255.0); img.convertTo(hsv,CV_32F,1.0/255.0);
cvtColor(hsv,hsv,CV_BGR2HSV); cvtColor(hsv,hsv,COLOR_BGR2HSV);
HShist=Mat_<double>(nh,ns,0.0); HShist=Mat_<double>(nh,ns,0.0);
Vhist=Mat_<double>(1,nv,0.0); Vhist=Mat_<double>(1,nv,0.0);

4
modules/tracking/src/trackerBoosting.cpp
View File

@@ -126,7 +126,7 @@ bool TrackerBoostingImpl::initImpl( const Mat& image, const Rect2d& boundingBox
Mat_<int> intImage; Mat_<int> intImage;
Mat_<double> intSqImage; Mat_<double> intSqImage;
Mat image_; Mat image_;
cvtColor( image, image_, CV_RGB2GRAY ); cvtColor( image, image_, COLOR_BGR2GRAY );
integral( image_, intImage, intSqImage, CV_32S ); integral( image_, intImage, intSqImage, CV_32S );
TrackerSamplerCS::Params CSparameters; TrackerSamplerCS::Params CSparameters;
CSparameters.overlap = params.samplerOverlap; CSparameters.overlap = params.samplerOverlap;
@@ -208,7 +208,7 @@ bool TrackerBoostingImpl::updateImpl( const Mat& image, Rect2d& boundingBox )
Mat_<int> intImage; Mat_<int> intImage;
Mat_<double> intSqImage; Mat_<double> intSqImage;
Mat image_; Mat image_;
cvtColor( image, image_, CV_RGB2GRAY ); cvtColor( image, image_, COLOR_BGR2GRAY );
integral( image_, intImage, intSqImage, CV_32S ); integral( image_, intImage, intSqImage, CV_32S );
//get the last location [AAM] X(k-1) //get the last location [AAM] X(k-1)
Ptr<TrackerTargetState> lastLocation = model->getLastTargetState(); Ptr<TrackerTargetState> lastLocation = model->getLastTargetState();

22
modules/tracking/src/trackerCSRT.cpp
View File

@@ -201,7 +201,7 @@ std::vector<Mat> TrackerCSRTImpl::get_features(const Mat &patch, const Size2i &f
} }
if(params.use_gray) { if(params.use_gray) {
Mat gray_m; Mat gray_m;
cvtColor(patch, gray_m, CV_BGR2GRAY); cvtColor(patch, gray_m, COLOR_BGR2GRAY);
resize(gray_m, gray_m, feature_size, 0, 0, INTER_CUBIC); resize(gray_m, gray_m, feature_size, 0, 0, INTER_CUBIC);
gray_m.convertTo(gray_m, CV_32FC1, 1.0/255.0, -0.5); gray_m.convertTo(gray_m, CV_32FC1, 1.0/255.0, -0.5);
features.push_back(gray_m); features.push_back(gray_m);
@@ -465,15 +465,11 @@ Point2f TrackerCSRTImpl::estimate_new_position(const Mat &image)
// ********************************************************************* // *********************************************************************
bool TrackerCSRTImpl::updateImpl(const Mat& image_, Rect2d& boundingBox) bool TrackerCSRTImpl::updateImpl(const Mat& image_, Rect2d& boundingBox)
{ {
//treat gray image as color image
Mat image; Mat image;
if(image_.channels() == 1) { if(image_.channels() == 1) //treat gray image as color image
std::vector<Mat> channels(3); cvtColor(image_, image, COLOR_GRAY2BGR);
channels[0] = channels[1] = channels[2] = image_; else
merge(channels, image);
} else {
image = image_; image = image_;
}
object_center = estimate_new_position(image); object_center = estimate_new_position(image);
if (object_center.x < 0 && object_center.y < 0) if (object_center.x < 0 && object_center.y < 0)
@@ -512,15 +508,11 @@ bool TrackerCSRTImpl::updateImpl(const Mat& image_, Rect2d& boundingBox)
// ********************************************************************* // *********************************************************************
bool TrackerCSRTImpl::initImpl(const Mat& image_, const Rect2d& boundingBox) bool TrackerCSRTImpl::initImpl(const Mat& image_, const Rect2d& boundingBox)
{ {
//treat gray image as color image
Mat image; Mat image;
if(image_.channels() == 1) { if(image_.channels() == 1) //treat gray image as color image
std::vector<Mat> channels(3); cvtColor(image_, image, COLOR_GRAY2BGR);
channels[0] = channels[1] = channels[2] = image_; else
merge(channels, image);
} else {
image = image_; image = image_;
}
current_scale_factor = 1.0; current_scale_factor = 1.0;
image_size = image.size(); image_size = image.size();

2
modules/tracking/src/trackerCSRTUtils.cpp
View File

@@ -552,7 +552,7 @@ double get_min(const Mat &m)
Mat bgr2hsv(const Mat &img) Mat bgr2hsv(const Mat &img)
{ {
Mat hsv_img; Mat hsv_img;
cvtColor(img, hsv_img, CV_BGR2HSV); cvtColor(img, hsv_img, COLOR_BGR2HSV);
std::vector<Mat> hsv_img_channels; std::vector<Mat> hsv_img_channels;
split(hsv_img, hsv_img_channels); split(hsv_img, hsv_img_channels);
hsv_img_channels.at(0).convertTo(hsv_img_channels.at(0), CV_8UC1, 255.0 / 180.0); hsv_img_channels.at(0).convertTo(hsv_img_channels.at(0), CV_8UC1, 255.0 / 180.0);

2
modules/tracking/src/trackerKCF.cpp
View File

@@ -700,7 +700,7 @@ namespace cv{
break; break;
default: // GRAY default: // GRAY
if(img.channels()>1) if(img.channels()>1)
cvtColor(patch,feat, CV_BGR2GRAY); cvtColor(patch,feat, COLOR_BGR2GRAY);
else else
feat=patch; feat=patch;
//feat.convertTo(feat,CV_32F); //feat.convertTo(feat,CV_32F);

13
modules/xphoto/samples/inpainting.cpp
View File

@@ -3,9 +3,6 @@
#include "opencv2/imgproc.hpp" #include "opencv2/imgproc.hpp"
#include "opencv2/highgui.hpp" #include "opencv2/highgui.hpp"
#include "opencv2/core/utility.hpp"
#include "opencv2/imgproc/types_c.h"
#include <ctime> #include <ctime>
#include <iostream> #include <iostream>
@@ -41,22 +38,22 @@ int main( int argc, const char** argv )
std::string maskFilename = parser.get<std::string>("m"); std::string maskFilename = parser.get<std::string>("m");
std::string outFilename = parser.get<std::string>("o"); std::string outFilename = parser.get<std::string>("o");
cv::Mat src = cv::imread(inFilename, -1); cv::Mat src = cv::imread(inFilename, cv::IMREAD_UNCHANGED);
if ( src.empty() ) if ( src.empty() )
{ {
printf( "Cannot read image file: %s\n", inFilename.c_str() ); printf( "Cannot read image file: %s\n", inFilename.c_str() );
return -1; return -1;
} }
cv::cvtColor(src, src, CV_RGB2Lab); cv::cvtColor(src, src, cv::COLOR_BGR2Lab);
cv::Mat mask = cv::imread(maskFilename, 0); cv::Mat mask = cv::imread(maskFilename, cv::IMREAD_GRAYSCALE);
if ( mask.empty() ) if ( mask.empty() )
{ {
printf( "Cannot read image file: %s\n", maskFilename.c_str() ); printf( "Cannot read image file: %s\n", maskFilename.c_str() );
return -1; return -1;
} }
cv::threshold(mask, mask, 128, 255, CV_THRESH_BINARY | CV_THRESH_OTSU); cv::threshold(mask, mask, 128, 255, cv::THRESH_BINARY | cv::THRESH_OTSU);
cv::Mat res(src.size(), src.type()); cv::Mat res(src.size(), src.type());
@@ -65,7 +62,7 @@ int main( int argc, const char** argv )
std::cout << "time = " << (clock() - time) std::cout << "time = " << (clock() - time)
/ double(CLOCKS_PER_SEC) << std::endl; / double(CLOCKS_PER_SEC) << std::endl;
cv::cvtColor(res, res, CV_Lab2RGB); cv::cvtColor(res, res, cv::COLOR_Lab2BGR);
if ( outFilename == "" ) if ( outFilename == "" )
{ {