void writeMat(cv::Mat_<T>& mat, char* file){ ofstream* ofile = new ofstream(file,ofstream::out|ofstream::binary); (*ofile)<<mat.rows<<" "; (*ofile)<<mat.cols<<" "; (*ofile)<<mat.type()<<" "; (*ofile)<<mat.total()*mat.elemSize(); ofile->write((char*) mat.data,mat.total()*mat.elemSize()); ofile->close(); }
cv::Mat_<cv::Vec3b> getWrongColorSegmentationImage(cv::Mat_<int>& labels, int labelcount) { std::vector<cv::Vec3b> colors; colors.reserve(labelcount); std::srand(0); for(int i = 0; i < labelcount; ++i) { cv::Vec3b ccolor; ccolor[0] = std::rand() % 256; ccolor[1] = std::rand() % 256; ccolor[2] = std::rand() % 256; colors.push_back(ccolor); } cv::Mat result(labels.size(), CV_8UC3); cv::Vec3b *dst_ptr = result.ptr<cv::Vec3b>(0); int *src_ptr = labels[0]; for(std::size_t i = 0; i < labels.total(); ++i) { int label = *src_ptr++; assert(label < (int)colors.size()); *dst_ptr++ = colors[label]; } return result; }
float SVMClassifier::predict( const cv::Mat_<float>& z) const { if ( svmp.isLinear()) return (z.dot(linx) - b)/linx.total(); // Normalise by the vector length double result = -b; KernelThreadFunc ktf( as, kernel, xs); ktf.calcResult( 0, numSVs, &z); result += ktf.getResult(); return result / z.total(); /* static const int nthreads = boost::thread::hardware_concurrency(); // CPU threads available const int segSz = numSVs / nthreads; int rem = numSVs % nthreads; boost::thread_group tgroup; vector<KernelThreadFunc*> tobjs(nthreads); int segOffset = 0; for ( int i = 0; i < nthreads; ++i) { int ssz = segSz; if ( rem > 0) { ssz++; rem--; } // end if tobjs[i] = new KernelThreadFunc( as, kernel, xs); tgroup.create_thread( boost::bind( &KernelThreadFunc::calcResult, tobjs[i], segOffset, ssz, &z)); // Start thread segOffset += ssz; // Offset for next thread } // end for tgroup.join_all(); // All processing done // Collect the result for return for ( int i = 0; i < nthreads; ++i) { result += tobjs[i]->getResult(); delete tobjs[i]; } // end for return result / z.total(); // Normalise by the vector length */ } // end predict
void convolve(cv::Mat_<float> &im, const int axis, const float* kernel) { if(axis >= im.dims) throw std::invalid_argument("Matrix dimension is too small to convolve along this axis"); assert(im.isContinuous()); Convolver co(im.size[axis]); unsigned long int step = im.step1(axis); //whatever the real dimension, we fall back to a 3d situation where the axis of interest is y //and either x or z can be of size 1 int nbplanes = 1; for(int d=0; d<axis; ++d) nbplanes *= im.size[d]; int planestep = im.total()/nbplanes; //for each plane for(int i=0; i<nbplanes; ++i) //for each line for(size_t j=0; j<step; ++j) co(reinterpret_cast<float*>(im.data) + i*planestep + j, step, kernel); }
std::vector<float> get_spectrum_1d(const cv::Mat_<float> &im, const int axis, const bool windowing) { if(axis >= im.dims) throw std::invalid_argument("Matrix dimension is too small to compute the spectrum along this axis"); assert(im.isContinuous()); Convolver co(im.size[axis]); if(windowing) co.set_hanning(); std::vector<float> spectrum(co.fourier_size()); std::vector<double> tot(co.fourier_size(), 0.0); std::vector<std::complex<double> > totf(co.fourier_size(), 0.0); unsigned long int step = im.step1(axis); //whatever the real dimension, we fall back to a 3d situation where the axis of interest is y //and either x or z can be of size 1 int nbplanes = 1; for(int d=0; d<axis; ++d) nbplanes *= im.size[d]; int planestep = im.total()/nbplanes; //for each plane for(int i=0; i<nbplanes; ++i) { //for each line for(size_t j=0; j<step; ++j) { co.spectrum(reinterpret_cast<float* const>(im.data) + i*planestep + j, step, &spectrum[0]); for(size_t u=0; u<spectrum.size(); ++u) tot[u] += spectrum[u]; for(size_t u=0; u<spectrum.size(); ++u) totf[u] += co.get_fourier()[u]; } } const double icount = 1.0 / (nbplanes * step); for(size_t i=0; i<tot.size(); ++i) spectrum[i] = tot[i]*icount - std::norm(totf[i]*icount); return spectrum; }
float singleeyefitter::cvx::histKmeans(const cv::Mat_<float>& hist, int bin_min, int bin_max, int K, float init_centres[], cv::Mat_<uchar>& labels, cv::TermCriteria termCriteria) { using namespace math; CV_Assert( hist.rows == 1 || hist.cols == 1 && K > 0 ); labels = cv::Mat_<uchar>::zeros(hist.size()); int nbins = hist.total(); float binWidth = (bin_max - bin_min)/nbins; float binStart = bin_min + binWidth/2; cv::Mat_<float> centres(K, 1, init_centres, 4); int iters = 0; bool finalRun = false; while (true) { ++iters; cv::Mat_<float> old_centres = centres.clone(); int i_bin; cv::Mat_<float>::const_iterator i_hist; cv::Mat_<uchar>::iterator i_labels; cv::Mat_<float>::iterator i_centres; uchar label; float sumDist = 0; int movedCount = 0; // Step 1. Assign each element a label for (i_bin = 0, i_labels = labels.begin(), i_hist = hist.begin(); i_bin < nbins; ++i_bin, ++i_labels, ++i_hist) { float bin_val = binStart + i_bin*binWidth; float minDist = sq(bin_val - centres(*i_labels)); int curLabel = *i_labels; for (label = 0; label < K; ++label) { float dist = sq(bin_val - centres(label)); if (dist < minDist) { minDist = dist; *i_labels = label; } } if (*i_labels != curLabel) movedCount++; sumDist += (*i_hist) * std::sqrt(minDist); } if (finalRun) return sumDist; // Step 2. Recalculate centres cv::Mat_<float> counts(K, 1, 0.0f); for (i_bin = 0, i_labels = labels.begin(), i_hist = hist.begin(); i_bin < nbins; ++i_bin, ++i_labels, ++i_hist) { float bin_val = binStart + i_bin*binWidth; centres(*i_labels) += (*i_hist) * bin_val; counts(*i_labels) += *i_hist; } for (label = 0; label < K; ++label) { if (counts(label) == 0) return std::numeric_limits<float>::infinity(); centres(label) /= counts(label); } // Step 3. Detect termination criteria if (movedCount == 0) finalRun = true; else if (termCriteria.type | cv::TermCriteria::COUNT && iters >= termCriteria.maxCount) finalRun = true; else if (termCriteria.type | cv::TermCriteria::EPS) { float max_movement = 0; for (label = 0; label < K; ++label) { max_movement = std::max(max_movement, sq(centres(label) - old_centres(label))); } if (sqrt(max_movement) < termCriteria.epsilon) finalRun = true; } } return std::numeric_limits<float>::infinity(); }
static void randomIndex(cv::Mat_<int> &randIdx) { for (size_t i=0; i<randIdx.total(); i++) randIdx(i) = i; cv::randShuffle(randIdx); }