void imageHist(const Mat& input, Mat& histVector){ Mat input_tmp; unsigned char *input_data; float *hist_data; Size inputSize; // To check data is float or uchar if(input.type() == CV_32FC(1)){ //printf("CV_32FC1 Dectect in imageHist!!\n"); input.convertTo(input_tmp, CV_8UC(1), 255.0); } else if(input.type() == CV_8UC(1)){ //printf("CV_8UC1 Dectect in imageHist!!\n"); input_tmp = input; } else{ printf("Error Type in imageHist!!!\n"); exit(0); } input_data = input_tmp.data; // get input data inputSize = input_tmp.size(); // get input size histVector = Mat::zeros(1, 256, CV_32FC(1)); // get a zero mat //printf("%d\n", histVector.type()==CV_32FC(1)); hist_data = (float*)histVector.data; // calculat histtgram for(int i=0; i<inputSize.width * inputSize.height; i++){ int tmp = (int)input_data[i]; hist_data[tmp]++; } return; }
Mat ColorChannelFilter::applyTo(const Mat& image, Mat& filtered) const { if (image.type() != CV_8UC3) throw invalid_argument("ColorChannelFilter: the image must be of type CV_8UC3"); int rows = image.rows; int cols = image.cols; float normalizer = 1.f / 255.f; if (magnitude) { // include magnitude filtered.create(rows, cols, CV_8UC(bins + 1)); if (image.isContinuous() && filtered.isContinuous()) { cols *= rows; rows = 1; } for (int row = 0; row < rows; ++row) { const Vec3b* colorCode = image.ptr<Vec3b>(row); uchar* values = filtered.data + filtered.step[0] * row; for (int col = 0; col < cols; ++col) { for (unsigned int bin = 0; bin <= bins; ++bin) values[bin] = 0; uchar hue = colorCode[col][0]; uchar saturation = colorCode[col][1]; uchar value = colorCode[col][2]; float magnitude = normalizer * saturation * value; // magnitude is between 0 and 255 BinData binData = color2bin[hue]; values[binData.bin1] += cv::saturate_cast<uchar>(cvRound(binData.weight1 * magnitude)); values[binData.bin2] += cv::saturate_cast<uchar>(cvRound(binData.weight2 * magnitude)); values[bins] += binData.weight1 + binData.weight2; values += bins + 1; } } } else { // do not include magnitude filtered.create(rows, cols, CV_8UC(bins)); if (image.isContinuous() && filtered.isContinuous()) { cols *= rows; rows = 1; } for (int row = 0; row < rows; ++row) { const Vec3b* colorCode = image.ptr<Vec3b>(row); uchar* values = filtered.data + filtered.step[0] * row; for (int col = 0; col < cols; ++col) { for (unsigned int bin = 0; bin < bins; ++bin) values[bin] = 0; uchar hue = colorCode[col][0]; uchar saturation = colorCode[col][1]; uchar value = colorCode[col][2]; float magnitude = normalizer * saturation * value; // magnitude is between 0 and 255 BinData binData = color2bin[hue]; values[binData.bin1] += cv::saturate_cast<uchar>(cvRound(binData.weight1 * magnitude)); values[binData.bin2] += cv::saturate_cast<uchar>(cvRound(binData.weight2 * magnitude)); values += bins; } } } return filtered; }
void histEqualization(const Mat& input, Mat& output, Mat& T){ Mat input_tmp; Mat histVector; unsigned char* input_data; unsigned char* output_data; unsigned char* T_data; float* hist_data; Size inputSize; double time_count; // To check input data is float or uchar if(input.type() == CV_32FC(1)){ //printf("CV_32FC1 Dectect in histEqualization!!\n"); input.convertTo(input_tmp, CV_8UC(1), 255.0); } else if(input.type() == CV_8UC(1)){ //printf("CV_8UC1 Dectect in histEqualization!!\n"); input_tmp = input; } else{ printf("Error Type in histEqualization!!!\n"); exit(0); } time_count = (double)getTickCount(); T.create(1,256,CV_8UC(1)); T_data = (unsigned char*)T.data; output.create(input.size(), CV_8UC(1)); input_data = (unsigned char*)input_tmp.data; inputSize = input_tmp.size(); output_data = (unsigned char*)output.data; imageHist(input, histVector); // get the image hist hist_data = (float*)histVector.data; float accum = 0; // get the accumadata amount int height = inputSize.height; int width = inputSize.width; // To get the transform function for(int i=0; i<256; i++){ T_data[i] = (unsigned char)((255.0/(height*width))* (accum + hist_data[i]) + 0.5); accum += hist_data[i]; } // To write the output by T for(int i=0; i<inputSize.width*inputSize.height; i++){ output_data[i] = T_data[(int)input_data[i]]; } time_count = (double)getTickCount() - time_count; printf("histEqualization Total consume %gms\n", time_count*1000/getTickFrequency());// get processing time return; }
void BackgroundSubtractorLOBSTER_<ParallelUtils::eGLSL>::getBackgroundImage(cv::OutputArray oBGImg) const { lvDbgExceptionWatch; CV_Assert(m_bInitialized); glAssert(m_bGLInitialized && !m_vnBGModelData.empty()); oBGImg.create(m_oFrameSize,CV_8UC(int(m_nImgChannels))); cv::Mat oOutputImg = oBGImg.getMatRef(); glBindBuffer(GL_SHADER_STORAGE_BUFFER,getSSBOId(BackgroundSubtractorLOBSTER_::eLOBSTERStorageBuffer_BGModelBinding)); glGetBufferSubData(GL_SHADER_STORAGE_BUFFER,0,m_nBGModelSize*sizeof(uint),(void*)m_vnBGModelData.data()); glErrorCheck; for(size_t nRowIdx=0; nRowIdx<(size_t)m_oFrameSize.height; ++nRowIdx) { const size_t nModelRowOffset = nRowIdx*m_nRowStepSize; const size_t nImgRowOffset = nRowIdx*oOutputImg.step.p[0]; for(size_t nColIdx=0; nColIdx<(size_t)m_oFrameSize.width; ++nColIdx) { const size_t nModelColOffset = nColIdx*m_nColStepSize+nModelRowOffset; const size_t nImgColOffset = nColIdx*oOutputImg.step.p[1]+nImgRowOffset; std::array<float,4> afCurrPxSum = {0.0f,0.0f,0.0f,0.0f}; for(size_t nSampleIdx=0; nSampleIdx<m_nBGSamples; ++nSampleIdx) { const size_t nModelPxOffset = nSampleIdx*m_nSampleStepSize+nModelColOffset; for(size_t nChannelIdx=0; nChannelIdx<m_nImgChannels; ++nChannelIdx) { const size_t nModelTotOffset = nChannelIdx+nModelPxOffset; afCurrPxSum[nChannelIdx] += m_vnBGModelData[nModelTotOffset]; } } for(size_t nChannelIdx=0; nChannelIdx<m_nImgChannels; ++nChannelIdx) { const size_t nSampleChannelIdx = ((nChannelIdx==3||m_nImgChannels==1)?nChannelIdx:2-nChannelIdx); const size_t nImgTotOffset = nSampleChannelIdx+nImgColOffset; oOutputImg.data[nImgTotOffset] = (uchar)(afCurrPxSum[nChannelIdx]/m_nBGSamples); } } } }
// public cv::Mat RFeatures::loadTGA( const std::string& fname) { cv::Mat m; FILE *bstream = fopen( fname.c_str(), "rb"); if ( !bstream) { std::cerr << "[ERROR] RFeatures::loadTGA(" << fname << "): Unable to open file for reading!" << std::endl; return m; } // end if // Read the header TGAHeader tga; if ( fread( tga.barray, 1, 18, bstream) != 18) { std::cerr << "[ERROR] RFeatures::loadTGA: Failed to read TGA header!" << std::endl; return m; } // end if tga.setFromArray(); // Read the image bytes row by row (BGA order) int bread = 0; m = cv::Mat( tga.height, tga.width, CV_8UC(tga.bitsperpixel/8)); const int nc = m.cols * m.channels(); for ( int i = int(m.rows-1); i >= 0; --i) // Read bottom to top bread += (int)fread( (void*)m.ptr(i), 1, nc, bstream); if ( bread != int(nc * m.rows)) { std::cerr << "[ERROR] RFeatures::loadTGA: Failed to read all " << (nc * m.rows) << " bytes of the image!" << std::endl; return cv::Mat(); } // end if fclose(bstream); return m; } // end loadTGA
int ns__MatToJPG (struct soap *soap, char *InputMatFilename, char **OutputMatFilename) { double start, end; start = omp_get_wtime(); Mat src; /* check if it is not 8U then convert to 8UC(n) */ int chan = src.channels(); if( src.type() != 0 || src.type() != 8 || src.type() != 16 ) { src.convertTo(src, CV_8UC(chan)); } /* generate output file name */ *OutputMatFilename = (char*)soap_malloc(soap, FILENAME_SIZE); getOutputFilename(OutputMatFilename,".jpg"); if(!imwrite(*OutputMatFilename, src)) { cerr<< "MatToJPG:: can not save mat to jpg file" << endl; return soap_receiver_fault(soap, "MatToJPG:: can not save mat to jpg file", NULL); } src.release(); end = omp_get_wtime(); cerr<<"ns__MatToJPG "<<"time elapsed "<<end-start<<endl; return SOAP_OK; }
bool Camera::Iterate() { AppCastingMOOSApp::Iterate(); Mat m_capture_frame(LARGEUR_IMAGE_CAMERA, HAUTEUR_IMAGE_CAMERA, CV_8UC(3)); if(m_vc_v4l2.read(m_capture_frame)) { if(m_inverser_image) flip(m_capture_frame, m_capture_frame, -1); Notify((char*)(m_image_name).c_str(), (void*)m_capture_frame.data, 3 * LARGEUR_IMAGE_CAMERA * HAUTEUR_IMAGE_CAMERA, MOOSLocalTime()); //imwrite("test.jpeg", m_capture_frame); if(m_affichage_image) { imshow(m_display_name, m_capture_frame); waitKey(1); } retractRunWarning("No frame grabbed."); } else reportRunWarning("No frame grabbed."); // MOOSDebugWrite("No frame grabbed."); AppCastingMOOSApp::PostReport(); return(true); }
void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) { // default parameters int ksize = 3; double sigma = 2.0; //validate input if (nrhs == 0) { mexErrMsgTxt("An image is required!"); } if (nlhs != 1) { mexErrMsgTxt("Only one output is provided."); } if(!mxIsDouble(prhs[0]) || ((mxGetNumberOfDimensions(prhs[0]) != 3) && (mxGetNumberOfDimensions(prhs[0]) != 2))) { mexErrMsgTxt("Type of the image has to be double."); } if((nrhs >= 2) && ((!mxIsDouble(prhs[1])) || (mxGetScalar(prhs[1]) <= 0))) { mexErrMsgTxt("ksize has to be a positive integer."); } else if (nrhs >= 2) { ksize = (int) mxGetScalar(prhs[1]); } if((nrhs >= 3) && ((!mxIsDouble(prhs[2])) || (mxGetScalar(prhs[2]) <= 0))) { mexErrMsgTxt("sigma has to be a positive value."); } else if (nrhs >= 3) { sigma = (double) mxGetScalar(prhs[2]); } // determine input/output image properties const int *dims = mxGetDimensions(prhs[0]); const int nDims = mxGetNumberOfDimensions(prhs[0]); const int rows = dims[0]; const int cols = dims[1]; const int channels = (nDims == 3 ? dims[2] : 1); // Allocate, copy, and convert the input image // @note: input is double cv::Mat image = cv::Mat::zeros(cv::Size(cols, rows), CV_64FC(channels)); om::copyMatrixToOpencv(mxGetPr(prhs[0]), image); image.convertTo(image, CV_8U, 255); // Call OpenCV functions here and do the magic cv::Mat out = cv::Mat::zeros(cv::Size(cols, rows), CV_8UC(channels)); cv::GaussianBlur(image,out,cv::Size(ksize,ksize),sigma); // Convert opencv to Matlab and set as output // @note: output is uint8 plhs[0] = mxCreateNumericArray(nDims, dims, mxUINT8_CLASS, mxREAL); om::copyMatrixToMatlab<unsigned char>(out, (unsigned char*)mxGetPr(plhs[0])); }
Mat apply(Image& img,int type){ int dim(256); Mat lut(1, &dim, CV_8UC(img.dst.channels())); switch (type) { case 0: if (img.dst.channels()==1) { for (int i = 0; i < 256; i++) lut.at<uchar>(i) = uchar(255*log2(i+1)/8); } else { for (int i = 0; i < 256; i++) { lut.at<Vec3b>(i)[0] = uchar(255 * log2(i + 1) / 8); lut.at<Vec3b>(i)[1] = uchar(255 * log2(i + 1) / 8); lut.at<Vec3b>(i)[2] = uchar(255 * log2(i + 1) / 8); } } break; case 1: if (img.dst.channels()==1) { for (int i = 0; i < 256; i++) lut.at<uchar>(i) = uchar(16 * sqrt(i + 1)); } else { for (int i = 0; i < 256; i++) { lut.at<Vec3b>(i)[0] = uchar(16*sqrt(i+1)); lut.at<Vec3b>(i)[1] = uchar(16*sqrt(i+1)); lut.at<Vec3b>(i)[2] = uchar(16*sqrt(i+1)); } } break; case 2: if (img.dst.channels()==1) { for (int i = 0; i < 256; i++) lut.at<uchar>(i) = uchar(84*pow(i,0.2)); } else { for (int i = 0; i < 256; i++) { lut.at<Vec3b>(i)[0] = uchar(48*pow(i,0.3)); lut.at<Vec3b>(i)[1] = uchar(48*pow(i,0.3)); lut.at<Vec3b>(i)[2] = uchar(48*pow(i,0.3)); } } break; default: break; } LUT(img.original, lut, img.dst); return img.dst; }
/** * Convert gdal type to opencv type */ int KGDAL2CV::gdal2opencv(const GDALDataType& gdalType, const int& channels){ switch (gdalType){ /// UInt8 case GDT_Byte: if (channels == 1){ return CV_8UC1; } if (channels == 3){ return CV_8UC3; } if (channels == 4){ return CV_8UC4; } else { return CV_8UC(channels); } return -1; /// UInt16 case GDT_UInt16: if (channels == 1){ return CV_16UC1; } if (channels == 3){ return CV_16UC3; } if (channels == 4){ return CV_16UC4; } else { return CV_16UC(channels); } return -1; /// Int16 case GDT_Int16: if (channels == 1){ return CV_16SC1; } if (channels == 3){ return CV_16SC3; } if (channels == 4){ return CV_16SC4; } else { return CV_16SC(channels); } return -1; /// UInt32 case GDT_UInt32: case GDT_Int32: if (channels == 1){ return CV_32SC1; } if (channels == 3){ return CV_32SC3; } if (channels == 4){ return CV_32SC4; } else { return CV_32SC(channels); } return -1; case GDT_Float32: if (channels == 1){ return CV_32FC1; } if (channels == 3){ return CV_32FC3; } if (channels == 4){ return CV_32FC4; } else { return CV_32FC(channels); } return -1; case GDT_Float64: if (channels == 1){ return CV_64FC1; } if (channels == 3){ return CV_64FC3; } if (channels == 4){ return CV_64FC4; } else { return CV_64FC(channels); } return -1; default: std::cout << "Unknown GDAL Data Type" << std::endl; std::cout << "Type: " << GDALGetDataTypeName(gdalType) << std::endl; return -1; } return -1; }
CV_IMPL void cvConvertScaleAbs( const void* srcarr, void* dstarr, double scale, double shift ) { cv::Mat src = cv::cvarrToMat(srcarr), dst = cv::cvarrToMat(dstarr); CV_Assert( src.size == dst.size && dst.type() == CV_8UC(src.channels())); cv::convertScaleAbs( src, dst, scale, shift ); }
void AffineTransformation::transformImage( const cv::Mat& inputImage, cv::Mat** transformedImage, cv::Mat** transformMatrix) { cv::Point2d leftTop; leftTop.x = 0; leftTop.y = 0; cv::Point2d leftTopImage = multiplyMatrixWithVector(leftTop); cv::Point2d rightTop; rightTop.x = inputImage.cols - 1; rightTop.y = 0; cv::Point2d rightTopImage = multiplyMatrixWithVector(rightTop); cv::Point2d leftBottom; leftBottom.x = 0; leftBottom.y = inputImage.rows - 1; cv::Point2d leftBottomImage = multiplyMatrixWithVector(leftBottom); cv::Point2d rightBottom; rightBottom.x = inputImage.cols - 1; rightBottom.y = inputImage.rows - 1; cv::Point2d rightBottomImage = multiplyMatrixWithVector(rightBottom); cv::Point2d maxPoint; maxPoint.x = std::max(leftTopImage.x, std::max(rightTopImage.x, std::max(leftBottomImage.x, rightBottomImage.x))); maxPoint.y = std::max(leftTopImage.y, std::max(rightTopImage.y, std::max(leftBottomImage.y, rightBottomImage.y))); cv::Point2d minPoint; minPoint.x = std::min(leftTopImage.x, std::min(rightTopImage.x, std::min(leftBottomImage.x, rightBottomImage.x))); minPoint.y = std::min(leftTopImage.y, std::min(rightTopImage.y, std::min(leftBottomImage.y, rightBottomImage.y))); cv::Size transformedImageSize; transformedImageSize.width = static_cast<int>(std::ceil(maxPoint.x - minPoint.x)); transformedImageSize.height = static_cast<int>(std::ceil(maxPoint.y - minPoint.y)); *transformMatrix = new cv::Mat(2, 3, CV_64FC1); *transformedImage = new cv::Mat(inputImage.size(), CV_8UC(inputImage.channels())); (*transformMatrix)->at<double>(0, 0) = transformationMatrix.at<double>(0, 0); (*transformMatrix)->at<double>(0, 1) = transformationMatrix.at<double>(0, 1); (*transformMatrix)->at<double>(0, 2) = transformationMatrix.at<double>(0, 2) - minPoint.x; (*transformMatrix)->at<double>(1, 0) = transformationMatrix.at<double>(1, 0); (*transformMatrix)->at<double>(1, 1) = transformationMatrix.at<double>(1, 1); (*transformMatrix)->at<double>(1, 2) = transformationMatrix.at<double>(1, 2) - minPoint.y; cv::warpAffine(inputImage, **transformedImage, **transformMatrix, inputImage.size()); }
int colorLMap( const cv::Mat& lmap, cv::Mat& cmap ) { if( lmap.depth() != CV_8U ) return -1; if( lmap.channels() != 1 ) return -1; int W = lmap.size().width; int H = lmap.size().height; cmap.create( H, W, CV_8UC(3) ); colorLMap( W,H, (const Tree::Label*)lmap.data, (unsigned char*)cmap.data); return 0; }
void PacketReceiver::frame2mat(const AVFrame& frameBGR, cv::Mat& matBGR) { matBGR.create(codecCtx->height, codecCtx->width, CV_8UC(3)); for (int y = 0; y < codecCtx->height; y++) { for (int x = 0; x < codecCtx->width; x++) { matBGR.at<cv::Vec3b>(y, x)[0] = frameBGR.data[0][y * frameBGR.linesize[0] + x * 3 + 0]; matBGR.at<cv::Vec3b>(y, x)[1] = frameBGR.data[0][y * frameBGR.linesize[0] + x * 3 + 1]; matBGR.at<cv::Vec3b>(y, x)[2] = frameBGR.data[0][y * frameBGR.linesize[0] + x * 3 + 2]; } } }
PERF_TEST_P(Size_CvtMode_Bayer, cvtColorBayer8u, testing::Combine( testing::Values(::perf::szODD, ::perf::szVGA), CvtModeBayer::all() ) ) { Size sz = get<0>(GetParam()); int mode = get<1>(GetParam()); ChPair ch = getConversionInfo(mode); mode %= COLOR_COLORCVT_MAX; Mat src(sz, CV_8UC(ch.scn)); Mat dst(sz, CV_8UC(ch.dcn)); declare.time(100); declare.in(src, WARMUP_RNG).out(dst); TEST_CYCLE() cvtColor(src, dst, mode, ch.dcn); SANITY_CHECK(dst, 1); }
void Proc3DSCropper::find_colors(const cv::Mat &frame, const std::vector<float> &hues, cv::Mat &colors, const float sigma, const int nouse_s_thresh, const int nouse_v_thresh) { // convert to HSV image cv::cvtColor(frame, this->hsv_cache, CV_BGR2HSV); cv::medianBlur(this->hsv_cache, this->hsv_cache, 7); std::vector<float> color_diffs; this->adjust_colors(this->hsv_cache, hues, color_diffs, sigma); int nrows = frame.rows; int ncols = frame.cols; int r, c; cv::Mat color_mat = cv::Mat::zeros(nrows, ncols, CV_8UC(COLOR_NUM)); for (r = 0; r < nrows; ++r) { for (c = 0; c < ncols; ++c) { cv::Vec3b pix = this->hsv_cache.at<cv::Vec3b>(r, c); int pix_hue = pix[0]; int pix_s = pix[1]; int pix_v = pix[2]; int index = 0; cv::Vec<uchar, COLOR_NUM> vec; bool pix_active = true; if (pix_s < nouse_s_thresh || pix_v < nouse_v_thresh) { pix_active = false; } for (const float &hue: hues) { if (!pix_active) { vec[index] = 0; continue; } const float diff1 = hue - pix_hue; const float diff2 = diff1 + 180; const float diff3 = diff1 - 180; const float abs1 = std::abs(diff1); const float abs2 = std::abs(diff2); const float abs3 = std::abs(diff3); const float _min_diff = std::min(abs1, abs2); const float min_diff = std::min(_min_diff, abs3); const float allowable_abs_diff = color_diffs[index]; if (allowable_abs_diff >= min_diff) { vec[index] = 255; } else { vec[index] = 0; } ++index; } color_mat.at<cv::Vec<uchar, COLOR_NUM>>(r, c) = vec; } } color_mat.copyTo(colors); };
void BackgroundSubtractorLOBSTER_<ParallelUtils::eNonParallel>::initialize(const cv::Mat& oInitImg, const cv::Mat& oROI) { lvDbgExceptionWatch; // == init BackgroundSubtractorLBSP::initialize(oInitImg,oROI); m_voBGColorSamples.resize(m_nBGSamples); m_voBGDescSamples.resize(m_nBGSamples); for(size_t s=0; s<m_nBGSamples; ++s) { m_voBGColorSamples[s].create(m_oImgSize,CV_8UC((int)m_nImgChannels)); m_voBGColorSamples[s] = cv::Scalar_<uchar>::all(0); m_voBGDescSamples[s].create(m_oImgSize,CV_16UC((int)m_nImgChannels)); m_voBGDescSamples[s] = cv::Scalar_<ushort>::all(0); } m_bInitialized = true; refreshModel(1.0f,true); m_bModelInitialized = true; }
Mat toImage(const vector<chain_code*>& codes,int row,int col){ Mat dest(row,col, CV_8UC(1),Scalar(BACKGROUND)); for (int i=0; i<codes.size(); i++) { chain_code* c=codes[i]; int p1=c->x; int p2=c->y; dest.at<uchar>(p1,p2)=FOREGROUND; for (int j=0; j<c->nodes.size(); j++) { int nodeDirect=c->nodes[j]; if(nodeDirect==0){ p2++; } else if(nodeDirect==1){ p1--; p2++; } else if(nodeDirect==2){ p1--; } else if(nodeDirect==3){ p1--; p2--; } else if(nodeDirect==4){ p2--; } else if(nodeDirect==5){ p1++; p2--; } else if(nodeDirect==6){ p1++; } else if(nodeDirect==7){ p1++; p2++; } dest.at<uchar>(p1,p2)=FOREGROUND; } } return dest; }
void unsharpFiltering(const Mat& input, const Mat& boxMask, float scale, Mat& output, Mat& scaledUnsharp, Mat& blurredInput){ Mat input_tmp; float* input_data; float* blur_data; float* scaled_data; float* output_data; Size inputSize; double t = (double)getTickCount(); // To check the input data type is float or uchar if(input.type() == CV_8UC(1)){ input.convertTo(input_tmp, CV_32FC(1), 1/255.0); } else if(input.type() == CV_32FC(1)){ input_tmp = input; } else{ printf("Error Type in unsharpFiltering!!!\n"); exit(0); } // blur the input spatialFiltering(input_tmp, boxMask, blurredInput); inputSize = input.size(); output.create(inputSize, CV_32FC(1)); scaledUnsharp.create(inputSize, CV_32FC(1)); input_data = (float*)input_tmp.data; blur_data = (float*)blurredInput.data; output_data = (float*)output.data; scaled_data = (float*)scaledUnsharp.data; // start doing unsharp for(int i=0; i<inputSize.width*inputSize.height; i++){ float buf; scaled_data[i] = scale * (input_data[i] - blur_data[i]);// get scaledUnsharp buf = input_data[i] + scaled_data[i]; if(buf > 255) // pix > 255 buf = 255; else if(buf < 0)// pix < 0 buf = 0; output_data[i] = buf; //write output data } t = ((double)getTickCount() - t)*1000/getTickFrequency(); printf("unsharpFiltering total consume %gms\n", t);// get the processing time return; }
void powerlawTransform(const Mat& input, float r, Mat& output){ double C; double t; Mat tmp_input; Mat tmp_output; unsigned char max_val; unsigned char* input_data; unsigned char* output_data; // Check the Mat data type if(input.type() == CV_32FC1){ // if it is float //printf("CV_32FC1 Mat Dectect in powerlawTransform!!\n"); input.convertTo(tmp_input, CV_8UC1, 255.0); } else if(input.type() == CV_8UC1){ // if it is uchar //printf("CV_8UC1 Mat Dectect in powerlawTransform!!\n"); tmp_input = input; } else{ // if it is unknown type printf("Type Error in powerlawTransform!!!!\n"); exit(0); } Size inputSize = tmp_input.size(); // get input size tmp_output.create(inputSize, CV_8UC(1)); input_data = tmp_input.data; output_data = tmp_output.data; t = (double)getTickCount(); max_val = 0; // fine the max value for(int index=0; index<inputSize.height*inputSize.width; index++) if(input_data[index] > max_val) max_val = input_data[index]; C = 255.0/pow((double)max_val, (double)r); // calculate the constant C // do power operation for(int index=0; index<inputSize.height*inputSize.width; index++){ output_data[index] = (unsigned char)(C * pow((double)input_data[index], (double)r)+0.5); } t = (double)getTickCount() - t; printf("powerlawTransform Total consume %gms\n", t*1000/getTickFrequency());// get processing time tmp_output.convertTo(output, CV_32FC1, 1/255.0); //write output data return; }
////////////////////////////////////////////////////////////////////////////////// // ID: 102061149 Wang Fu-En // // For successfully compile this code you should include the following header // // <cstdlib> // // <stdlib.h> // // <stdio.h> // // <iostream> // // <math.h> // // <opencv2/highgui/highgui.hpp> // // <opencv2/core/core.hpp> // // All the function in the file will compute the processing time // // automatically to get the efficiency of the code, and functions will check // // whether the input data is valid or not; normally, input should be grayscale // // image. // ////////////////////////////////////////////////////////////////////////////////// void logTransform(const Mat& input, Mat &output){ double C; double t; unsigned char max_val; Mat tmp_input; Mat tmp_output; //The folowing is to check Mat type if(input.type() == CV_32FC1){ // if it is float type input.convertTo(tmp_input, CV_8UC1, 255.0); //printf("CV_32FC1 Mat Detect in logTransform\n"); } else if(input.type() == CV_8UC1){ // if it is uchar type //printf("CV_8UC1 Mat Detect in logTransform!!\n"); tmp_input = input; } else{ // if the type is unknown //printf("Type Error in logTransform!!!\n"); exit(0); } Size size_of_input = tmp_input.size(); //get input size unsigned char* data = tmp_input.data; t = (double)getTickCount(); max_val = 0; // find the max value to determin C for(int index=0; index < size_of_input.height * size_of_input.width; index++) if(data[index] > max_val) max_val = data[index]; C = 255.0/(log(1.0+max_val)); // calculate the C value tmp_output.create(size_of_input.height, size_of_input.width, CV_8UC(1)); unsigned char* out_data = tmp_output.data; // Do log operation to every point for(int index=0; index < size_of_input.height * size_of_input.width; index++){ out_data[index] = (unsigned char)(C * log(1.0 + data[index]) + 0.5); } t = (double)getTickCount() - t; printf("logTransform Total consume %gms\n", t*1000/getTickFrequency());// get processing time tmp_output.convertTo(output, CV_32FC1, 1/255.0); // write output data return; }
void laplacianFiltering(const Mat& input, const Mat& laplacianMask, float scale, Mat& output, Mat& scaledLaplacian){ Mat input_tmp,tmp; float* input_data; float* output_data; float* scaleLap_data; double t = (double)getTickCount(); Size inputSize; spatialFiltering(input, laplacianMask, scaledLaplacian); //get scaledLaplacian(haven't multiple scale) // To check input data is float or uchar if(input.type() == CV_8UC(1)){ input.convertTo(input_tmp, CV_32FC(1), 1/255.0); } else if(input.type() == CV_32FC(1)){ input_tmp = input; } else{ printf("Error Type in laplacianFiltering!!!\n"); exit(0); } inputSize = input.size(); output.create(inputSize, CV_32FC(1)); scaleLap_data = (float*)scaledLaplacian.data; input_data = (float*)input_tmp.data; output_data = (float*)output.data; // start doing laplace transform for(int p=0; p<inputSize.width*inputSize.height; p++){ float buf; scaleLap_data[p] = scaleLap_data[p]*scale;//multiple scale buf = input_data[p] + scaleLap_data[p]; // add to origin input if(buf>1) // if value > 1 buf = 1; else if(buf<0)// if value <0 buf = 0; output_data[p] = buf; } t = (double)getTickCount()-t; printf("Laplacian total consume %gms\n", t*1000/getTickFrequency());// get processing time return; }
/* Convert QImage to cv::Mat without data copy */ cv::Mat image2Mat_shared(const QImage &img, MatColorOrder *order) { if (img.isNull()) return cv::Mat(); switch (img.format()) { case QImage::Format_Indexed8: break; #if QT_VERSION >= 0x040400 case QImage::Format_RGB888: if (order) *order = MCO_RGB; break; #endif case QImage::Format_RGB32: case QImage::Format_ARGB32: case QImage::Format_ARGB32_Premultiplied: if (order) *order = getColorOrderOfRGB32Format(); break; #if QT_VERSION >= 0x050200 case QImage::Format_RGBX8888: case QImage::Format_RGBA8888: case QImage::Format_RGBA8888_Premultiplied: if (order) *order = MCO_RGBA; break; #endif #if QT_VERSION >= 0x050500 case QImage::Format_Alpha8: case QImage::Format_Grayscale8: break; #endif default: return cv::Mat(); } return cv::Mat(img.height(), img.width(), CV_8UC(img.depth()/8), (uchar*)img.bits(), img.bytesPerLine()); }
Mat Histogram::likeyhoodImage(Mat image) { Mat out; int *c=(int *)calloc(sizeof(int),_channels.size()); for(int i=0;i<_channels.size();i++) { c[i]=_channels[i]; } int *h=(int *)calloc(sizeof(int),_channels.size()); for(int i=0;i<_channels.size();i++) { h[i]=_histSize[_channels[i]]; } float **ranges=(float **)calloc(sizeof(float*),_channels.size()); int size=_channels.size(); for(int i=0;i<size;i++) { float *x=(float *)calloc(sizeof(float),2); int index=2*_channels[i]; x[0]=_histRange[index]; x[1]=_histRange[index+1]; ranges[i]=x; //cerr << x[0] << ":" <<x[1] <<endl; } image.copyTo(out); out.convertTo(out,CV_32FC(1),1,0); out.setTo(cv::Scalar::all(0)); Mat i2; cv::normalize(_histMat,i2,0,255,NORM_MINMAX); cv::calcBackProject(&image,1,c,i2,out,(const float **)ranges,1,true); out.convertTo(out,CV_8UC(1),1.0,0); return out; }
int main(int argc, char *argv[]) { if(argc<2) cerr << "Usage : ColorConstancy filename " << endl; Mat image=imread(argv[1]); cerr << "reading image " << argv[2] << endl; color_correction::contrast_stretching a; color_correction::gray_world b1; color_correction::gray_edge b2; color_correction::maxRGB b3; color_correction::max_edge b4; Mat input; input.create(240,320,CV_8UC(3)); resize(image,input, input.size(), 0, 0, INTER_NEAREST); imshow("original",input); imshow("contrast stretching",a.run(input)); imshow("gray world RGB",b1.run2(input,1,2)); imshow("gray world Lab",b1.run1(input,1)); imshow("Shades of gray",b1.run2(input,6,2)); imshow("maxRGB",b3.run(input,6,0)); imshow("gray edge",b2.run(input,1,0)); imshow("max edge",b4.run(input,1,0)); cv::waitKey(0); }
vector<chain_code*> extractChainCodesLevel(const Mat& src,int level){ vector<chain_code*> chainCodes; Mat I; threshold(src, I, THRESHOLDVALUE, 255, CV_THRESH_BINARY); Mat PNH=Mat(3,3, CV_8UC(1),Scalar(BACKGROUND)); chain_segment* actchain_ptr=NULL; bool actchain_isLeft=true; node* frame=new node(NULL,NULL,NULL,"frame"); node* CurrentHole=frame; node* CurrentObject=NULL; int isMinPoint = 0; int currentCoordinateI; int currentCoordinateJ; vector<coordinates*> savedCoordinates; if(level==-1) level=INT_MAX; for (int i=0; i<I.rows; i++) { for (int j=0; j<I.cols; j++) { currentCoordinateI=i; currentCoordinateJ=j; for( int di = 0; di < 3; di++) { for(int dj = 0; dj < 3; dj ++ ) { PNH.at<uchar>(di, dj) = getPixel(I, i + di - 1, j + dj - 1); } } if (!isInvalid(PNH)) { if(getPixel(PNH, 1, 1)==BACKGROUND) continue; if(isMin0(PNH)&&isMax0(PNH)){ chain_code* ch=new chain_code(i,j); chainCodes.push_back(ch); continue; } searchDirections(PNH,actchain_isLeft,actchain_ptr,CurrentHole,CurrentObject,isMinPoint); searchMinPoints(PNH,actchain_isLeft,actchain_ptr,CurrentHole,CurrentObject,isMinPoint,currentCoordinateI,currentCoordinateJ,savedCoordinates); searchMaxPoints(PNH,actchain_isLeft,actchain_ptr,CurrentHole,CurrentObject,currentCoordinateI,currentCoordinateJ); } } } int parentSize=1, childSize=0,le=0; node * temp; queue<node *> q; q.push(frame); do { temp = q.front(); if(temp!=frame&&temp->coord!=NULL){ coordinates* c = temp->coord; chain_code* newChain=new chain_code(c->x,c->y); chain_segment* moveChain; if(c->typeMin) moveChain=c->whichNode->right; else moveChain=c->whichNode->left; chain_segment* copyFirst=moveChain; while(true){ vector<int>& vecs=moveChain->chainCodes->nodes; if(moveChain->isLeft) reverse(vecs.begin(), vecs.end()); for (int m=0; m<vecs.size(); m++) { newChain->nodes.push_back(vecs[m]); } chain_segment* tobeDeleted = moveChain; moveChain=moveChain->connectNext; delete tobeDeleted->chainCodes; delete tobeDeleted; if(moveChain==copyFirst) break; } delete c; chainCodes.push_back(newChain); } q.pop(); for(int i=0; i<temp->children.size(); i++){ if(temp->children[i]) q.push(temp->children[i]); childSize ++; } delete temp; parentSize--; if(parentSize == 0){ parentSize = childSize; childSize = 0; le++; } } while(!q.empty()&&le<level); return chainCodes; }
vector<chain_code*> extractChainCodes(const Mat& src){ vector<chain_code*> chainCodes; Mat I; threshold(src, I, THRESHOLDVALUE, 255, CV_THRESH_BINARY); Mat PNH=Mat(3,3, CV_8UC(1),Scalar(BACKGROUND)); chain_segment* actchain_ptr=NULL; bool actchain_isLeft=true; node* frame=new node(NULL,NULL,NULL,"frame"); node* CurrentHole=frame; node* CurrentObject=NULL; int isMinPoint=0; int currentCoordinateI; int currentCoordinateJ; vector<coordinates*> savedCoordinates; for (int i=0; i<I.rows; i++) { for (int j=0; j<I.cols; j++) { currentCoordinateI=i; currentCoordinateJ=j; for( int di = 0; di < 3; di++) { for(int dj = 0; dj < 3; dj ++ ) { PNH.at<uchar>(di, dj) = getPixel(I, i + di - 1, j + dj - 1); } } if (!isInvalid(PNH)) { if(getPixel(PNH, 1, 1)==BACKGROUND) continue; if(isMin0(PNH)&&isMax0(PNH)){ chain_code* ch=new chain_code(i,j); chainCodes.push_back(ch); continue; } searchDirections(PNH,actchain_isLeft,actchain_ptr,CurrentHole,CurrentObject,isMinPoint); searchMinPoints(PNH,actchain_isLeft,actchain_ptr,CurrentHole,CurrentObject,isMinPoint,currentCoordinateI,currentCoordinateJ,savedCoordinates); searchMaxPoints(PNH,actchain_isLeft,actchain_ptr,CurrentHole,CurrentObject,currentCoordinateI,currentCoordinateJ); } } } for(int n=0;n<savedCoordinates.size();n++){ coordinates* c = savedCoordinates[n]; chain_code* newChain=new chain_code(c->x,c->y); chain_segment* moveChain; if(c->typeMin) moveChain=c->whichNode->right; else moveChain=c->whichNode->left; chain_segment* copyFirst=moveChain; while(true){ vector<int>& vecs=moveChain->chainCodes->nodes; if(moveChain->isLeft) reverse(vecs.begin(), vecs.end()); for (int m=0; m<vecs.size(); m++) { newChain->nodes.push_back(vecs[m]); } chain_segment* tobeDeleted = moveChain; moveChain=moveChain->connectNext; delete tobeDeleted->chainCodes; delete tobeDeleted; if(moveChain==copyFirst) break; //if(moveChain==NULL) break; } delete c->whichNode; delete c; chainCodes.push_back(newChain); } delete frame; return chainCodes; }
void blobfinder::FindWindow(Image* input, Mat output,ColorFilter *m_redFilter, ColorFilter *m_greenFilter, ColorFilter *m_yellowFilter) { //convert from Image* to Mat Mat img = input->asIplImage(); //output = input; //White balance image Mat img_whitebalance = cv::Mat::zeros(img.rows,img.cols,CV_8UC(3)); img_whitebalance = WhiteBalance(img); imshow("White Balance",img_whitebalance); Mat img_hsv; Mat img_temp; Mat img_red, img_green, img_yellow; //thresholded for these colors CvPoint point; unsigned int i; //Color Thresholding //Step 1: Convert to HSV space, HSV space is less susceptible to lighting changes //HSV stands for Hue, saturation and value. In theory, we can do 'color thresholding' just based on Hue cvtColor(img_whitebalance,img_hsv,CV_BGR2HSV); //Step 2:Threshold with pre-defined levels //Hue range from 0 to 180 in OpenCV //int red_minH, green_minH, green_maxH, yellow_minH, yellow_maxH; //yellow_minH = 0; //10 //yellow_maxH =60; //40 //red_minH =60; //15 works well //green_minH = 120;//30 //green_maxH = 180; //60 //hsv - from 120-180 seems to be a good red filter //these levels should be defined in an XML file and not just loaded here int red_minH= m_redFilter->getChannel3Low(); int red_maxH= m_redFilter->getChannel3High(); int yellow_minH= m_yellowFilter->getChannel3Low(); int yellow_maxH= m_yellowFilter->getChannel3High(); int green_minH= m_greenFilter->getChannel3Low(); int green_maxH= m_greenFilter->getChannel3High(); vector<Mat> hsv_planes; split(img_hsv,hsv_planes); //first take any value higher than max and converts it to 0 //red is a special case because the hue value for red are 0-10 and 170-1980 //same filter as the other cases followed by an invert threshold(hsv_planes[0],img_red,red_minH,255,THRESH_TOZERO); threshold(img_red,img_red,red_maxH,0,THRESH_TOZERO_INV); threshold(img_red,img_red,1,255,THRESH_BINARY_INV); threshold(hsv_planes[0],img_yellow,yellow_maxH,0,THRESH_TOZERO_INV); threshold(img_yellow,img_yellow,yellow_minH,255,THRESH_TOZERO); threshold(hsv_planes[0],img_green,green_maxH,0,THRESH_TOZERO_INV); threshold(img_green,img_green,green_minH,255,THRESH_TOZERO); threshold(img_red,img_red,1,255,THRESH_BINARY); threshold(img_green,img_green,1,255,THRESH_BINARY); threshold(img_yellow,img_yellow,1,255,THRESH_BINARY); //imshow("Red Single Plane",img_red); //imshow("Yellow Plane",img_yellow); //imshow("Green Plane",img_green); hsv_planes[2] = img_red; hsv_planes[0] = img_yellow; hsv_planes[1] = img_green; merge(hsv_planes,img_whitebalance); //Step 3: Blob detection! On the thresheld (thresholded?) image //Attempt 2: //creation //SimpleBlobDetector* blob_detector; //blob_detector = new SimpleBlobDetector(); //blob_detector->creat("SimpleBlobDetector"); //change params, first move it tp public SimpleBlobDetector::Params params; params.minDistBetweenBlobs =0; //params.minThreshold =100; //params.maxThreshold =256; //params.thresholdStep = 200; //params.filterByArea=false; params.filterByInertia = true; params.filterByConvexity = false; params.filterByColor=false; params.filterByArea = true; params.filterByCircularity = true; params.minArea =100.0f; params.maxArea = 20000.0f; params.minCircularity = 0.3; params.maxCircularity = 1.5; params.filterByColor = false; params.minInertiaRatio =.2; params.maxInertiaRatio = 1.3; //create SimpleBlobDetector blob_red(params); SimpleBlobDetector blob_yellow(params); SimpleBlobDetector blob_green(params); blob_red.create("SimpleBlob"); blob_green.create("SimpleBlob"); blob_yellow.create("SimpleBlob"); //detect //vector<KeyPoint> keypoints_red; //vector<KeyPoint> keypoints_green; //vector<KeyPoint> keypoints_yellow; blob_red.detect(img_red,_keypoints_red); blob_yellow.detect(img_yellow,_keypoints_yellow); blob_green.detect(img_green,_keypoints_green); //extract x y coordinates of the keypoints printf("\n Red"); for (i=0;i<_keypoints_red.size();i++) { point.x = _keypoints_red[i].pt.x; point.y= _keypoints_red[i].pt.y; printf("\n Size: %f,angle %f, response = %f",_keypoints_red[i].size,_keypoints_red[i].angle, _keypoints_red[i].response); circle(img_whitebalance,point,5,Scalar(0,0,150),1,8,0); printf("\n Keypoint = %d, (%d, %d)",i,point.x,point.y); } printf("\n Yellow"); for (i=0;i<_keypoints_yellow.size();i++) { point.x = _keypoints_yellow[i].pt.x; point.y= _keypoints_yellow[i].pt.y; printf("\n Size: %f,angle %f, response = %f",_keypoints_yellow[i].size,_keypoints_yellow[i].angle, _keypoints_yellow[i].response); circle(img_whitebalance,point,5,Scalar(0,255,255),1,8,0); printf("\n Keypoint = %d, (%d, %d)",i,point.x,point.y); } printf("\n Green"); for (i=0;i<_keypoints_green.size();i++) { point.x = _keypoints_green[i].pt.x; point.y= _keypoints_green[i].pt.y; printf("\n Size: %f,angle %f, response = %f",_keypoints_green[i].size,_keypoints_green[i].angle, _keypoints_green[i].response); circle(img_whitebalance,point,5,Scalar(0,150,0),1,8,0); printf("\n Keypoint = %d, (%d, %d)",i,point.x,point.y); } imshow("Found Blobs",img_whitebalance); //imshow("img_red",img_red); //cvWaitKey(0); //convert back to Imatg* //output->setData(img_whitebalance.data,false); //output = img_whitebalance; };
void BackgroundSubtractorLOBSTER::initialize(const cv::Mat& oInitImg, const cv::Mat& oROI) { CV_Assert(!oInitImg.empty() && oInitImg.cols>0 && oInitImg.rows>0); CV_Assert(oInitImg.isContinuous()); CV_Assert(oInitImg.type()==CV_8UC1 || oInitImg.type()==CV_8UC3); if(oInitImg.type()==CV_8UC3) { std::vector<cv::Mat> voInitImgChannels; cv::split(oInitImg,voInitImgChannels); if(!cv::countNonZero((voInitImgChannels[0]!=voInitImgChannels[1])|(voInitImgChannels[2]!=voInitImgChannels[1]))) std::cout << std::endl << "\tBackgroundSubtractorLOBSTER : Warning, grayscale images should always be passed in CV_8UC1 format for optimal performance." << std::endl; } cv::Mat oNewBGROI; if(oROI.empty() && (m_oROI.empty() || oROI.size()!=oInitImg.size())) { oNewBGROI.create(oInitImg.size(),CV_8UC1); oNewBGROI = cv::Scalar_<uchar>(UCHAR_MAX); } else if(oROI.empty()) oNewBGROI = m_oROI; else { CV_Assert(oROI.size()==oInitImg.size() && oROI.type()==CV_8UC1); CV_Assert(cv::countNonZero((oROI<UCHAR_MAX)&(oROI>0))==0); oNewBGROI = oROI.clone(); } LBSP::validateROI(oNewBGROI); const size_t nROIPxCount = (size_t)cv::countNonZero(oNewBGROI); CV_Assert(nROIPxCount>0); m_oROI = oNewBGROI; m_oImgSize = oInitImg.size(); m_nImgType = oInitImg.type(); m_nImgChannels = oInitImg.channels(); m_nTotPxCount = m_oImgSize.area(); m_nTotRelevantPxCount = nROIPxCount; m_nFrameIndex = 0; m_nFramesSinceLastReset = 0; m_nModelResetCooldown = 0; m_oLastFGMask.create(m_oImgSize,CV_8UC1); m_oLastFGMask = cv::Scalar_<uchar>(0); m_oLastColorFrame.create(m_oImgSize,CV_8UC((int)m_nImgChannels)); m_oLastColorFrame = cv::Scalar_<uchar>::all(0); m_oLastDescFrame.create(m_oImgSize,CV_16UC((int)m_nImgChannels)); m_oLastDescFrame = cv::Scalar_<ushort>::all(0); m_voBGColorSamples.resize(m_nBGSamples); m_voBGDescSamples.resize(m_nBGSamples); for(size_t s=0; s<m_nBGSamples; ++s) { m_voBGColorSamples[s].create(m_oImgSize,CV_8UC((int)m_nImgChannels)); m_voBGColorSamples[s] = cv::Scalar_<uchar>::all(0); m_voBGDescSamples[s].create(m_oImgSize,CV_16UC((int)m_nImgChannels)); m_voBGDescSamples[s] = cv::Scalar_<ushort>::all(0); } if(m_aPxIdxLUT) delete[] m_aPxIdxLUT; if(m_aPxInfoLUT) delete[] m_aPxInfoLUT; m_aPxIdxLUT = new size_t[m_nTotRelevantPxCount]; m_aPxInfoLUT = new PxInfoBase[m_nTotPxCount]; if(m_nImgChannels==1) { CV_Assert(m_oLastColorFrame.step.p[0]==(size_t)m_oImgSize.width && m_oLastColorFrame.step.p[1]==1); CV_Assert(m_oLastDescFrame.step.p[0]==m_oLastColorFrame.step.p[0]*2 && m_oLastDescFrame.step.p[1]==m_oLastColorFrame.step.p[1]*2); for(size_t t=0; t<=UCHAR_MAX; ++t) m_anLBSPThreshold_8bitLUT[t] = cv::saturate_cast<uchar>((t*m_fRelLBSPThreshold+m_nLBSPThresholdOffset)/2); for(size_t nPxIter=0, nModelIter=0; nPxIter<m_nTotPxCount; ++nPxIter) { if(m_oROI.data[nPxIter]) { m_aPxIdxLUT[nModelIter] = nPxIter; m_aPxInfoLUT[nPxIter].nImgCoord_Y = (int)nPxIter/m_oImgSize.width; m_aPxInfoLUT[nPxIter].nImgCoord_X = (int)nPxIter%m_oImgSize.width; m_aPxInfoLUT[nPxIter].nModelIdx = nModelIter; m_oLastColorFrame.data[nPxIter] = oInitImg.data[nPxIter]; const size_t nDescIter = nPxIter*2; LBSP::computeGrayscaleDescriptor(oInitImg,oInitImg.data[nPxIter],m_aPxInfoLUT[nPxIter].nImgCoord_X,m_aPxInfoLUT[nPxIter].nImgCoord_Y,m_anLBSPThreshold_8bitLUT[oInitImg.data[nPxIter]],*((ushort*)(m_oLastDescFrame.data+nDescIter))); ++nModelIter; } } } else { //m_nImgChannels==3 CV_Assert(m_oLastColorFrame.step.p[0]==(size_t)m_oImgSize.width*3 && m_oLastColorFrame.step.p[1]==3); CV_Assert(m_oLastDescFrame.step.p[0]==m_oLastColorFrame.step.p[0]*2 && m_oLastDescFrame.step.p[1]==m_oLastColorFrame.step.p[1]*2); for(size_t t=0; t<=UCHAR_MAX; ++t) m_anLBSPThreshold_8bitLUT[t] = cv::saturate_cast<uchar>(t*m_fRelLBSPThreshold+m_nLBSPThresholdOffset); for(size_t nPxIter=0, nModelIter=0; nPxIter<m_nTotPxCount; ++nPxIter) { if(m_oROI.data[nPxIter]) { m_aPxIdxLUT[nModelIter] = nPxIter; m_aPxInfoLUT[nPxIter].nImgCoord_Y = (int)nPxIter/m_oImgSize.width; m_aPxInfoLUT[nPxIter].nImgCoord_X = (int)nPxIter%m_oImgSize.width; m_aPxInfoLUT[nPxIter].nModelIdx = nModelIter; const size_t nPxRGBIter = nPxIter*3; const size_t nDescRGBIter = nPxRGBIter*2; for(size_t c=0; c<3; ++c) { m_oLastColorFrame.data[nPxRGBIter+c] = oInitImg.data[nPxRGBIter+c]; LBSP::computeSingleRGBDescriptor(oInitImg,oInitImg.data[nPxRGBIter+c],m_aPxInfoLUT[nPxIter].nImgCoord_X,m_aPxInfoLUT[nPxIter].nImgCoord_Y,c,m_anLBSPThreshold_8bitLUT[oInitImg.data[nPxRGBIter+c]],((ushort*)(m_oLastDescFrame.data+nDescRGBIter))[c]); } ++nModelIter; } } } m_bInitialized = true; refreshModel(1.0f); }
int Train(ToolParam &tool_param, CommonSettings &settings) { if (tool_param.train_size() <= settings.param_index) { LOG(FATAL)<< "Train parameter index does not exist."; } TrainParam train_param = tool_param.train(settings.param_index); InputParam input_param = train_param.input(); if(!(input_param.has_patch_size() && input_param.has_padding_size() && input_param.has_labels() && input_param.has_channels())) { LOG(FATAL) << "Patch size, padding size, label count or channel count parameter missing."; } int patch_size = input_param.patch_size(); int padding_size = input_param.padding_size(); unsigned int nr_labels = input_param.labels(); unsigned int nr_channels = input_param.channels(); std::string proto_solver = ""; if(!train_param.has_solver()) { LOG(FATAL) << "Solver prototxt file argument missing"; } proto_solver = train_param.solver(); caffe::SolverParameter solver_param; caffe::ReadProtoFromTextFileOrDie(proto_solver, &solver_param); int test_interval = solver_param.has_test_interval()?solver_param.test_interval():-1; shared_ptr<caffe::Solver<float> > solver( caffe::GetSolver<float>(solver_param)); if(train_param.has_solverstate()) { // Continue from previous solverstate const char* solver_state_c = train_param.solverstate().c_str(); solver->Restore(solver_state_c); } // Get handles to the test and train network of the Caffe solver boost::shared_ptr<caffe::Net<float>> train_net = solver->net(); boost::shared_ptr<caffe::Net<float>> test_net; if(solver->test_nets().size() > 0) { test_net = solver->test_nets()[0]; } // Overwrite label count from the desired count to the pre-consolidation count if(input_param.has_preprocessor()) { PreprocessorParam preprocessor_param = input_param.preprocessor(); if(preprocessor_param.has_label_consolidate()) { nr_labels = preprocessor_param.label_consolidate().label_size(); } } TrainImageProcessor image_processor(patch_size, nr_labels); if(input_param.has_preprocessor()) { PreprocessorParam preprocessor_param = input_param.preprocessor(); image_processor.SetBorderParams(input_param.has_padding_size(), padding_size / 2); image_processor.SetRotationParams(preprocessor_param.has_rotation() && preprocessor_param.rotation()); image_processor.SetPatchMirrorParams(preprocessor_param.has_mirror() && preprocessor_param.mirror()); image_processor.SetNormalizationParams(preprocessor_param.has_normalization() && preprocessor_param.normalization()); if(preprocessor_param.has_label_consolidate()) { LabelConsolidateParam label_consolidate_param = preprocessor_param.label_consolidate(); std::vector<int> con_labels; for(int cl = 0; cl < label_consolidate_param.label_size(); ++ cl) { con_labels.push_back(label_consolidate_param.label(cl)); } image_processor.SetLabelConsolidateParams(preprocessor_param.has_label_consolidate(), con_labels); } if(preprocessor_param.has_histeq()) { PrepHistEqParam histeq_param = preprocessor_param.histeq(); std::vector<float> label_boost(nr_labels, 1.0); for(int i = 0; i < histeq_param.label_boost().size(); ++i) { label_boost[i] = histeq_param.label_boost().Get(i); } image_processor.SetLabelHistEqParams(true, histeq_param.has_patch_prior()&&histeq_param.patch_prior(), histeq_param.has_masking()&&histeq_param.masking(), label_boost); } if(preprocessor_param.has_crop()) { PrepCropParam crop_param = preprocessor_param.crop(); image_processor.SetCropParams(crop_param.has_imagecrop()?crop_param.imagecrop():0, crop_param.has_labelcrop()?crop_param.labelcrop():0); } if(preprocessor_param.has_clahe()) { PrepClaheParam clahe_param = preprocessor_param.clahe(); image_processor.SetClaheParams(true, clahe_param.has_clip()?clahe_param.clip():4.0); } if(preprocessor_param.has_blur()) { PrepBlurParam blur_param = preprocessor_param.blur(); image_processor.SetBlurParams(true, blur_param.has_mean()?blur_param.mean():0.0, blur_param.has_std()?blur_param.std():0.1, blur_param.has_ksize()?blur_param.ksize():5); } } if(!(input_param.has_raw_images() && input_param.has_label_images())) { LOG(FATAL) << "Raw images or label images folder missing."; } std::set<std::string> filetypes = CreateImageTypesSet(); int error; std::vector<std::vector<bofs::path>> training_set = LoadTrainingSetItems(filetypes, input_param.raw_images(),input_param.label_images(),&error); unsigned int ijsum = 0; // Preload and preprocess all images for (unsigned int i = 0; i < training_set.size(); ++i) { std::vector<bofs::path> training_item = training_set[i]; std::vector<cv::Mat> raw_stack; std::vector<std::vector<cv::Mat>> labels_stack(training_item.size() - 1); std::string type = bofs::extension(training_item[0]); std::transform(type.begin(), type.end(), type.begin(), ::tolower); if(type == ".tif" || type == ".tiff") { // TIFF and multipage TIFF mode raw_stack = LoadTiff(training_item[0].string(), nr_channels); } else { // All other image types cv::Mat raw_image = cv::imread(training_item[0].string(), nr_channels == 1 ? CV_LOAD_IMAGE_GRAYSCALE : CV_LOAD_IMAGE_COLOR); raw_stack.push_back(raw_image); } for(unsigned int k = 0; k < training_item.size() - 1; ++k) { std::string type = bofs::extension(training_item[k+1]); std::transform(type.begin(), type.end(), type.begin(), ::tolower); if(type == ".tif" || type == ".tiff") { std::vector<cv::Mat> label_stack = LoadTiff(training_item[k+1].string(), 1); labels_stack[k] = label_stack; } else { std::vector<cv::Mat> label_stack; cv::Mat label_image = cv::imread(training_item[k+1].string(), CV_LOAD_IMAGE_GRAYSCALE); label_stack.push_back(label_image); labels_stack[k] = label_stack; } } for (unsigned int j = 0; j < raw_stack.size(); ++j) { std::vector<cv::Mat> label_images; for(unsigned int k = 0; k < labels_stack.size(); ++k) { label_images.push_back(labels_stack[k][j]); } if(label_images.size() > 1 && nr_labels != 2 && label_images.size() < nr_labels) { // Generate complement label cv::Mat clabel(label_images[0].rows, label_images[0].cols, CV_8UC(1), 255.0); for(unsigned int k = 0; k < label_images.size(); ++k) { cv::subtract(clabel,label_images[k],clabel); } label_images.push_back(clabel); } image_processor.SubmitImage(raw_stack[j], ijsum, label_images); ++ijsum; } } image_processor.Init(); std::vector<long> labelcounter(nr_labels + 1); int train_iters = solver_param.has_max_iter()?solver_param.max_iter():0; // Do the training for (int i = 0; i < train_iters; ++i) { std::vector<cv::Mat> patch = image_processor.DrawPatchRandom(); std::vector<cv::Mat> images; std::vector<cv::Mat> labels; images.push_back(patch[0]); labels.push_back(patch[1]); // TODO: Only enable in debug or statistics mode for (int y = 0; y < patch_size; ++y) { for (int x = 0; x < patch_size; ++x) { labelcounter[patch[1].at<float>(y, x) + 1] += 1; } } if(settings.debug) { for (unsigned int k = 0; k < nr_labels + 1; ++k) { std::cout << "Label: " << k << ", " << labelcounter[k] << std::endl; } } if(settings.graphic) { cv::Mat test; double minVal, maxVal; cv::minMaxLoc(patch[1], &minVal, &maxVal); patch[1].convertTo(test, CV_32FC1, 1.0 / (maxVal - minVal), -minVal * 1.0 / (maxVal - minVal)); std::vector<cv::Mat> tv; tv.push_back(test); tv.push_back(test); tv.push_back(test); cv::Mat tvl; cv::merge(tv, tvl); cv::Mat patchclone = patch[0].clone(); tvl.copyTo( patchclone( cv::Rect(padding_size / 2, padding_size / 2, patch_size, patch_size))); cv::imshow(OCVDBGW, patchclone); cv::waitKey(10); } // The labels std::vector<int> lalabels; lalabels.push_back(0); boost::dynamic_pointer_cast<caffe::MemoryDataLayer<float>>( train_net->layers()[0])->AddMatVector(labels, lalabels); // The images std::vector<int> imlabels; imlabels.push_back(0); boost::dynamic_pointer_cast<caffe::MemoryDataLayer<float>>( train_net->layers()[1])->AddMatVector(images, imlabels); solver->Step(1); if(test_interval > -1 && i % test_interval == 0) { // TODO: Run tests with the testset and testnet // TODO: Apply ISBI and other quality measures (cross, rand, pixel, warp, loss) // TODO: Write out statistics to file } } LOG(INFO) << "Training done!"; return 0; }