void EncoderBoFSoft::encode(const cv::Mat_<float>& descriptors, cv::Mat_<float>& encoded) { int ndata = descriptors.rows; int ndim = descriptors.cols; if ( ndim != this->_m_nDim) { throw std::runtime_error("dimension not match when encode"); } encoded.create(ndata,this->_m_nCode); encoded.setTo(0.0f); //encoded.zeros(ndata,this->_m_nCode); #pragma omp parallel for for(int i=0;i<ndata;i++) { Mat index,dist; this->_m_pTree->findNearest(descriptors.row(i),_m_nz,INT_MAX,index,noArray(),dist); Scalar mean,std; cv::meanStdDev(dist,mean,std); cv::divide(std(0),dist,dist); for(int j=0;j<_m_nz;j++) { encoded(i,index.at<int>(j)) = dist.at<float>(j); } } }
void paste_images_gallery(const std::vector<cv::Mat_<T> > & in, cv::Mat_<T> & out, int gallerycols, T background_color, bool draw_borders = false, cv::Scalar border_color = CV_RGB(0,0,0)) { if (in.size() == 0) { out.create(0, 0); return; } int cols1 = in[0].cols, rows1 = in[0].rows, nimgs = in.size(); // prepare output int galleryrows = std::ceil(1. * nimgs / gallerycols); out.create(rows1 * galleryrows, cols1 * gallerycols); // printf("nimgs:%i, gallerycols:%i, galleryrows:%i\n", nimgs, gallerycols, galleryrows); out.setTo(background_color); // paste images for (int img_idx = 0; img_idx < nimgs; ++img_idx) { int galleryx = img_idx % gallerycols, galleryy = img_idx / gallerycols; cv::Rect roi(galleryx * cols1, galleryy * rows1, cols1, rows1); // printf("### out:%ix%i, roi %i:'%s'\n", out.cols, out.rows, img_idx, geometry_utils::print_rect(roi).c_str()); if (cols1 != in[img_idx].cols || rows1 != in[img_idx].rows) { printf("Image %i of size (%ix%i), different from (%ix%i), skipping it.\n", img_idx, in[img_idx].cols, in[img_idx].rows, cols1, rows1); cv::line(out, roi.tl(), roi.br(), border_color, 2); cv::line(out, roi.br(), roi.tl(), border_color, 2); } else in[img_idx].copyTo( out(roi) ); if (draw_borders) cv::rectangle(out, roi, border_color, 1); } // end loop img_idx } // end paste_images_gallery<_T>
//=========================================================================== void Multi_SVR_patch_expert::Response(const cv::Mat_<float> &area_of_interest, cv::Mat_<float> &response) { int response_height = area_of_interest.rows - height + 1; int response_width = area_of_interest.cols - width + 1; if(response.rows != response_height || response.cols != response_width) { response.create(response_height, response_width); } // For the purposes of the experiment only use the response of normal intensity, for fair comparison if(svr_patch_experts.size() == 1) { svr_patch_experts[0].Response(area_of_interest, response); } else { // responses from multiple patch experts these can be gradients, LBPs etc. response.setTo(1.0); cv::Mat_<float> modality_resp(response_height, response_width); for(size_t i = 0; i < svr_patch_experts.size(); i++) { svr_patch_experts[i].Response(area_of_interest, modality_resp); response = response.mul(modality_resp); } } }
//=========================================================================== void CCNF_patch_expert::Response(cv::Mat_<float> &area_of_interest, cv::Mat_<float> &response) { int response_height = area_of_interest.rows - height + 1; int response_width = area_of_interest.cols - width + 1; if(response.rows != response_height || response.cols != response_width) { response.create(response_height, response_width); } response.setTo(0); // the placeholder for the DFT of the image, the integral image, and squared integral image so they don't get recalculated for every response cv::Mat_<double> area_of_interest_dft; cv::Mat integral_image, integral_image_sq; cv::Mat_<float> neuron_response; // responses from the neural layers for(size_t i = 0; i < neurons.size(); i++) { // Do not bother with neuron response if the alpha is tiny and will not contribute much to overall result if(neurons[i].alpha > 1e-4) { neurons[i].Response(area_of_interest, area_of_interest_dft, integral_image, integral_image_sq, neuron_response); response = response + neuron_response; } } int s_to_use = -1; // Find the matching sigma for(size_t i=0; i < window_sizes.size(); ++i) { if(window_sizes[i] == response_height) { // Found the correct sigma s_to_use = i; break; } } cv::Mat_<float> resp_vec_f = response.reshape(1, response_height * response_width); cv::Mat out = Sigmas[s_to_use] * resp_vec_f; response = out.reshape(1, response_height); // Making sure the response does not have negative numbers double min; minMaxIdx(response, &min, 0); if(min < 0) { response = response - min; } }
void OvershootClusterer::drawTo(cv::Mat_<cv::Vec3b> &out) const { out.setTo(0); out.setTo(Scalar(255,255,255), img > 0); Mat_<Vec3b>::iterator itOut = out.begin(), itOutEnd = out.end(); Mat_<unsigned char>::const_iterator it = smallestOvershootVisit.begin(), itEnd = smallestOvershootVisit.end(); for (; itOut != itOutEnd && it != itEnd; ++it, ++itOut) { if ((*it) < CLUSTERER_OVERSHOOTS) { unsigned char nonRed = (*it)*(255/CLUSTERER_OVERSHOOTS); *itOut = Vec3b(nonRed,nonRed,255); } } }
void SegmenterHumanSimple::getPixelProbability(const cv::Mat& img, cv::Mat_<float>& prob, vector<Rect> faces) { prob.create(img.rows,img.cols); prob.setTo(0.3f); for(int i=0;i<faces.size();i++) { Rect rect = faces[i]; rect = UtilsOpencv::ScaleRect(rect,Rect(0,0,img.cols,img.rows),1.2,1.5,1.2,1.2); prob(Rect(rect.x,rect.y,rect.width,img.rows-rect.y)) = 0.7f; } }
int ExtractSubImageDaisyDescriptors(daisy *desc, cv::Mat_<float> &descOut, float py, float px, float step, int ori, int h, int w, float limH, float limW) { //printf("here 0 %d %d py = %f px = %f\n", w, h, py, px); descOut.create(w*h, DAISY_FEATURE_LENGTH); //printf("here 0-1\n"); descOut.setTo(cv::Scalar(0.0)); //printf("here 0-2\n"); int iy, ix; float cy, cx, ssinOri, scosOri; ssinOri = step*sin((float)ori/180.0*M_PI); scosOri = step*cos((float)ori/180.0*M_PI); float ry, rx; // the first pos of each row ry = py; rx = px; //printf("here 1\n"); //float *thor = new float [DAISY_FEATURE_LENGTH]; for (iy=0; iy<h; ++iy) { cy = ry; cx = rx; float *ptr = (float *)(descOut.ptr(iy*w)); //printf("here 2 %f %f %f %f\n", cy, cx, ssinOri, scosOri); for (ix=0; ix<w; ++ix) { //memset(thor, 0, sizeof(float)*desc->descriptor_size()); //desc->get_descriptor(std::min<double>(limH-1.0, std::max<double>(cy, 0.0)), std::min<double>(limW-1.0, std::max<double>(cx, 0.0)), ori, ptr); desc->ExtractDescriptorFromNormalizedHistogram(ptr, std::min<double>(limH-1.0, std::max<double>(cy, 0.0)), std::min<double>(limW-1.0, std::max<double>(cx, 0.0)), ori); ptr += DAISY_FEATURE_LENGTH; //printf("here 2-1\n"); //memcpy(ptr, thor, sizeof(float)*DAISY_FEATURE_LENGTH); //printf("here 2-2\n"); //printf("here 2-3\n"); cy = cy+ssinOri; cx = cx+scosOri; } ry = ry+scosOri; rx = rx-ssinOri; //printf("here 2\n"); } //delete [] thor; //printf("here 3\n"); return 1; }
KalmanFilter( cv::Point initialPt ) { mKF = cv::KalmanFilter( 4, 2, 0 ); mKF.transitionMatrix = ( cv::Mat_<float>(4, 4) << 1,0,1,0, 0,1,0,1, 0,0,1,0, 0,0,0,1 ); mMeasurement = cv::Mat_<float>( 2, 1 ); mMeasurement.setTo( cv::Scalar( 0 ) ); // init... mKF.statePre.at<float>( 0 ) = initialPt.x; mKF.statePre.at<float>( 1 ) = initialPt.y; mKF.statePre.at<float>( 2 ) = 0; mKF.statePre.at<float>( 3 ) = 0; setIdentity( mKF.measurementMatrix ); setIdentity( mKF.processNoiseCov, cv::Scalar::all( 1e-4 ) ); setIdentity( mKF.measurementNoiseCov, cv::Scalar::all( 1e-1 ) ); setIdentity( mKF.errorCovPost, cv::Scalar::all( .1 )); mPrediction = initialPt; // prime the filter, otherwise it thinks it's at 0,0 correct( initialPt ); }
void generate_gabor_filter(cv::Mat_<T>& image, double peakFreq, double theta, double sigma_x, double sigma_y) { const size_t w = image.size().width; const size_t h = image.size().height; const double step_u = 1.0 / static_cast<double>(w); const double step_v = 1.0 / static_cast<double>(h); const double cos_theta = std::cos(theta); const double sin_theta = std::sin(theta); const double sigmaXSquared = sigma_x*sigma_x; const double sigmaYSquared = sigma_y*sigma_y; image.setTo(cv::Scalar(0)); for (int ny = -1; ny <= 1; ny++) for (int nx = -1; nx <= 1; nx++) { double v = ny; for (size_t y = 0; y < h; y++) { double u = nx; for (size_t x = 0; x < w; x++) { double ur = u * cos_theta - v * sin_theta; double vr = u * sin_theta + v * cos_theta; double tmp = ur-peakFreq; double value = std::exp(-2*M_PI*M_PI * (tmp*tmp*sigmaXSquared + vr*vr*sigmaYSquared)); image(y, x) += value; u += step_u; } v += step_v; } } }