void GaborFilter<_Tp>::generateFilter(Mat_<complex<_Tp> > & result,
int scale, int orientation, int filterSizeX, int filterSizeY,
_Tp kMax, _Tp sigma)
{
_Tp offsetX = filterSizeX/2.0;
_Tp offsetY = filterSizeY/2.0;
_Tp psi = ((orientation*M_PI)/8);
_Tp f = sqrt(2);
_Tp fV = pow(f, scale);
_Tp kReal = (kMax/fV)*cos(psi);
_Tp kImag = (kMax/fV)*sin(psi);
_Tp kSquare = pow(sqrt(pow(kReal, 2) + pow(kImag, 2)), 2);
_Tp sSquare = pow(sigma,2);
_Tp sSquareHalf = -0.5 * sSquare;
_Tp kS = kSquare/sSquare;
_Tp kSHalf = -0.5f * kSquare / sSquare;
result.create(filterSizeX, filterSizeY);
int numberColumns = filterSizeY*filterSizeX;
complex<_Tp>* data = ((Mat)result).ptr<complex<_Tp> >(0);
GaborFilterBody<_Tp> gaborFilterBody(mFilterSizeX, mFilterSizeY,
offsetX, offsetY, kS, kSHalf, kReal, kImag, sSquare, data);
parallel_for(BlockedRange(0, numberColumns), gaborFilterBody);
}
//===========================================================================
void Multi_SVR_patch_expert::Response(const Mat_<float> &area_of_interest, Mat_<double> &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);
Mat_<double> 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 BackgroundSubtractorGMGImpl::initialize(Size frameSize, double minVal, double maxVal)
{
CV_Assert(minVal < maxVal);
CV_Assert(maxFeatures > 0);
CV_Assert(learningRate >= 0.0 && learningRate <= 1.0);
CV_Assert(numInitializationFrames >= 1);
CV_Assert(quantizationLevels >= 1 && quantizationLevels <= 255);
CV_Assert(backgroundPrior >= 0.0 && backgroundPrior <= 1.0);
minVal_ = minVal;
maxVal_ = maxVal;
frameSize_ = frameSize;
frameNum_ = 0;
nfeatures_.create(frameSize_);
colors_.create(frameSize_.area(), maxFeatures);
weights_.create(frameSize_.area(), maxFeatures);
nfeatures_.setTo(Scalar::all(0));
}
void Multi_SVR_patch_expert::ResponseDepth(const Mat_<float>& area_of_interest, Mat_<double>& 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);
}
// With depth patch experts only do raw data modality
svr_patch_experts[0].ResponseDepth(area_of_interest, response);
}
int main()
{
Mat_<Vec3b> srcImage;
srcImage.create(512, 512);
for (int i = 0; i < srcImage.rows; i++)
for (int j = 0; j < srcImage.cols; j++)
srcImage(i, j) = Vec3f(255, 255, 255);
imshow("srcImage", srcImage);
waitKey();
return 0;
}
double ConjGradSolverImpl::minimize(InputOutputArray x){
CV_Assert(_Function.empty()==false);
dprintf(("termcrit:\n\ttype: %d\n\tmaxCount: %d\n\tEPS: %g\n",_termcrit.type,_termcrit.maxCount,_termcrit.epsilon));
Mat x_mat=x.getMat();
CV_Assert(MIN(x_mat.rows,x_mat.cols)==1);
int ndim=MAX(x_mat.rows,x_mat.cols);
CV_Assert(x_mat.type()==CV_64FC1);
if(d.cols!=ndim){
d.create(1,ndim);
r.create(1,ndim);
r_old.create(1,ndim);
minimizeOnTheLine_buf1.create(1,ndim);
minimizeOnTheLine_buf2.create(1,ndim);
}
Mat_<double> proxy_x;
if(x_mat.rows>1){
buf_x.create(1,ndim);
Mat_<double> proxy(ndim,1,buf_x.ptr<double>());
x_mat.copyTo(proxy);
proxy_x=buf_x;
}else{
proxy_x=x_mat;
}
_Function->getGradient(proxy_x.ptr<double>(),d.ptr<double>());
d*=-1.0;
d.copyTo(r);
//here everything goes. check that everything is setted properly
dprintf(("proxy_x\n"));print_matrix(proxy_x);
dprintf(("d first time\n"));print_matrix(d);
dprintf(("r\n"));print_matrix(r);
for(int count=0;count<_termcrit.maxCount;count++){
minimizeOnTheLine(_Function,proxy_x,d,minimizeOnTheLine_buf1,minimizeOnTheLine_buf2);
r.copyTo(r_old);
_Function->getGradient(proxy_x.ptr<double>(),r.ptr<double>());
r*=-1.0;
double r_norm_sq=norm(r);
if(_termcrit.type==(TermCriteria::MAX_ITER+TermCriteria::EPS) && r_norm_sq<_termcrit.epsilon){
break;
}
r_norm_sq=r_norm_sq*r_norm_sq;
double beta=MAX(0.0,(r_norm_sq-r.dot(r_old))/r_norm_sq);
d=r+beta*d;
}
if(x_mat.rows>1){
Mat(ndim, 1, CV_64F, proxy_x.ptr<double>()).copyTo(x);
}
return _Function->calc(proxy_x.ptr<double>());
}
void myaccumarray(Mat & subs,Mat & val,Mat_<T> & accumM,cv::Size size){
accumM.create(size);
accumM.setTo(Scalar::all(0));
cout<<"channels: "<<val.channels()<<endl;
for (int i=0;i<subs.rows;i++)
{
for (int c=0;c<val.channels();c++)
{
//cout<<(subs.at<int>(i,0))<<","<<(subs.at<int>(i,1))<<" "<<endl;
//cout<<val.at<T>(i,0)[c]<<endl;
accumM.at<T>((subs.at<int>(i,0)),(subs.at<int>(i,1)))[c] += val.at<T>(i,0)[c];
//cout<<(subs.at<int>(i,0))<<","<<(subs.at<int>(i,1))<<" "<<accumM.at<T>((subs.at<int>(i,0)),(subs.at<int>(i,1)))[c]<<endl;
}
}
}
/**
* @brief Util::convertQImageToMat
* @brief 转换QImage到CV::Mat
* @param img_qt QImage类型
* @param img_cv cv::Mat类型
* @return 没有返回值
*/
void Util::convertQImageToMat( QImage &img_qt, Mat_<Vec3b>& img_cv){
img_cv.create(img_qt.height(), img_qt.width());
img_qt.convertToFormat(QImage::Format_RGB32);
int lineNum = 0;
int height = img_qt.height();
int width = img_qt.width();
uchar *imgBits = img_qt.bits();
for(int i=0; i<height; i++){
lineNum = i* width *4;
for(int j=0; j<width; j++){
img_cv(i, j)[2] = imgBits[lineNum + j*4 + 2];
img_cv(i, j)[1] = imgBits[lineNum + j*4 + 1];
img_cv(i, j)[0] = imgBits[lineNum + j*4 + 0];
}
}
}
static inline void linearizeHomographyAt( const Mat_<double>& H, const Point2f& pt, Mat_<double>& A )
{
A.create(2,2);
double p1 = H(0,0)*pt.x + H(0,1)*pt.y + H(0,2),
p2 = H(1,0)*pt.x + H(1,1)*pt.y + H(1,2),
p3 = H(2,0)*pt.x + H(2,1)*pt.y + H(2,2),
p3_2 = p3*p3;
if( p3 )
{
A(0,0) = H(0,0)/p3 - p1*H(2,0)/p3_2; // fxdx
A(0,1) = H(0,1)/p3 - p1*H(2,1)/p3_2; // fxdy
A(1,0) = H(1,0)/p3 - p2*H(2,0)/p3_2; // fydx
A(1,1) = H(1,1)/p3 - p2*H(2,1)/p3_2; // fydx
}
else
A.setTo(Scalar::all(numeric_limits<double>::max()));
}
void ShapeModel::viewShapeModelUpdate(ModelViewInfo *pInfo)
{
Mat_< double > paramV;
paramV.create(this->nShapeParams, 1);
for (int i=0;i<nShapeParams;i++){
paramV(i, 0) = (pInfo->vList[i]/30.0 - 0.5)*6*
sqrt(pcaShape->eigenvalues.at<double>(i, 0));
}
Mat_<cv::Vec3b> img;
ModelImage s;
s.setShapeInfo(&shapeInfo);
s.loadTrainImage(Mat_<unsigned char>::ones(190*2, 160*2)*255);
projectParamToShape(paramV, s.shapeVec);
SimilarityTrans st = s.shapeVec.getShapeTransformFitingSize(
Size(320, 380));
s.buildFromShapeVec(st, 1000);
img = s.show(0, -1, false);
imshow("Viewing Shape Model", img);
}
void EnhancedStereo::computeDistance(Mat_<float> & distance)
{
distance.create(smallHeight(), smallWidth());
for (int v = 0; v < smallHeight(); v++)
{
for (int u = 0; u < smallWidth(); u++)
{
if (smallDisparity(v, u) == 0)
{
distance(v, u) = 100;
continue;
}
int idx = getLinearIdx(vBig(v), uBig(u));
Point pinf = pinfPxVec[idx];
CurveRasterizer<Polynomial2> raster(pinf.x, pinf.y, epipolePx.x, epipolePx.y, epipolarVec[idx]);
raster.step(smallDisparity(v, u));
Vector3d X = triangulate(uBig(u), vBig(v), raster.x, raster.y);
distance(v, u) = X.norm();
}
}
}
void EnhancedStereo::generatePlane(Transformation<double> TcameraPlane,
Mat_<float> & distance, const vector<Vector3d> & polygonVec)
{
distance.create(smallHeight(), smallWidth());
Vector3d t = TcameraPlane.trans();
Vector3d z = TcameraPlane.rotMat().col(2);
vector<Vector3d> polygonCamVec;
TcameraPlane.transform(polygonVec, polygonCamVec);
for (int v = 0; v < smallHeight(); v++)
{
for (int u = 0; u < smallWidth(); u++)
{
distance(v, u) = 0;
Vector3d vec; // the direction vector
if (not cam1.reconstructPoint(Vector2d(uBig(u), vBig(v)), vec)) continue;
double zvec = z.dot(vec);
if (zvec < 1e-3)
{
continue;
}
bool inside = true;
for (int i = 0; i < polygonCamVec.size(); i++)
{
int j = (i + 1) % polygonCamVec.size();
Vector3d normal = polygonCamVec[i].cross(polygonCamVec[j]);
if (vec.dot(normal) < 0)
{
inside = false;
break;
}
}
if (not inside) continue;
double tz = t.dot(z);
double alpha = tz / zvec;
vec *= alpha;
distance(v, u) = vec.norm();
}
}
}
void SegmenterHumanSimple::segment(const cv::Mat& img, Mat_<uchar>& mask)
{
Mat imgBGR;
Mat imgLAB;
Mat imgBGRo;
float rate = 500.0f/img.cols;
GaussianBlur(img,imgBGRo,Size(),0.8,0.8);
vector<Rect> faces;
resize(imgBGRo,imgBGRo,Size(),rate,rate);
cv::CascadeClassifier faceModel(this->_m_filenameFaceModel);
faceModel.detectMultiScale(imgBGRo,faces);
imgBGRo.convertTo( imgBGR, CV_32F, 1.0/255. );
cvtColor( imgBGR, imgLAB, CV_BGR2Lab );
Superpixel sp(1000,1,5);
Mat_<int> segmentation = sp.segment(imgLAB);
vector<SuperpixelStatistic> stat = sp.stat(imgLAB,imgBGR,segmentation);
Mat_<float> prob;
this->getPixelProbability(imgBGRo,prob,faces);
Mat_<float> sprob;
UtilsSuperpixel::Stat(segmentation,prob,stat,sprob);
Mat_<int> initial(int(stat.size()),1);
initial.setTo(1,sprob>0.5);
initial.setTo(0,sprob<=0.5);
Mat_<float> probaColor;
int myx = cv::countNonZero(initial);
this->_getColorProba(stat,initial,probaColor);
Mat_<float> fgdInit,bgdInit,fgdColor,bgdColor;
this->_prob2energy(sprob,fgdInit,bgdInit);
this->_prob2energy(probaColor,fgdColor,bgdColor);
Mat_<float> fgdEnergy, bgdEnergy;
fgdEnergy = fgdInit + fgdColor;
bgdEnergy = bgdInit + bgdColor;
Mat_<int> label;
mask.create(imgBGRo.rows,imgBGRo.cols);
UtilsSegmentation::MaxFlowSuperpixel(stat,fgdEnergy,bgdEnergy,50.0,label);
for( int i=0;i<mask.rows;i++)
{
for(int j=0;j<mask.cols;j++)
{
if ( label(segmentation(i,j)) > 0.5)
{
mask(i,j) = 255;
}
else
{
mask(i,j) = 0;
}
}
}
cv::resize(mask,mask,Size(img.cols,img.rows));
mask.setTo(255,mask>128);
mask.setTo(0,mask<=128);
}
void UtilsSegmentation::MaxFlowSuperpixel(std::vector<SuperpixelStatistic>& spstat, const Mat_<float>& fgdEnergy,
const Mat_<float>& bgdEnergy, float gamma, Mat_<int>& label)
{
//::Graph<float,float,float> graph(nNode,nEdge,errfunc);
//graph
int nEdge = UtilsSuperpixel::CountEdge(spstat);
Mat_<int> edgeVertex(nEdge,2);
Mat_<float> edgeWeight(nEdge,1);
Mat_<float> edgeLen(nEdge,1);
int idx = 0;
for(int i=0;i<spstat.size();i++)
{
SuperpixelStatistic& sp = spstat[i];
for( set<int>::iterator j=sp.conn.begin();
j!= sp.conn.end();
j++)
{
int d = (*j);
SuperpixelStatistic& dsp = spstat[d];
if ( i != d)
{
edgeVertex(idx,0) = min(i,d);
edgeVertex(idx,1) = max(i,d);
float diff = (float) norm(sp.mean_color_ - dsp.mean_color_);
edgeWeight(idx) = diff*diff;
edgeLen(idx) = (float) cv::norm(sp.mean_position_-dsp.mean_position_);
idx++;
}
}
}
float beta = (float) cv::mean(edgeWeight)[0];
Graph<float,float,float> graph((int)spstat.size(), nEdge, errfunc);
graph.add_node((int)spstat.size());
for(int i=0;i<fgdEnergy.total();i++)
{
graph.add_tweights(i,bgdEnergy(i),fgdEnergy(i));
}
edgeWeight = - edgeWeight / beta;
cv::exp(edgeWeight,edgeWeight);
edgeWeight *= gamma;
cv::divide(edgeWeight, edgeLen,edgeWeight);
for(int i=0;i<nEdge;i++)
{
float w = edgeWeight(i);
graph.add_edge(edgeVertex(i,0),edgeVertex(i,1),w,w);
}
graph.maxflow();
label.create((int)spstat.size(),1);
for(int i=0;i<spstat.size();i++)
{
if ( graph.what_segment(i) == Graph<float,float,float>::SOURCE)
{
label(i) = 1;
}
else
{
label(i) = 0;
}
}
}
void spm_bp::init_label_super(Mat_<Vec2f>& label_super_k, Mat_<float>& dCost_super_k) //, vector<vector<Vec2f> > &label_saved, vector<vector<Mat_<float> > > &dcost_saved)
{
printf("==================================================\n");
printf("Initiating particles...Done!\n");
vector<Vec2f> label_vec;
Mat_<float> localDataCost;
for (int sp = 0; sp < numOfSP1; ++sp) {
int id = repPixels1[sp];
int y = subRange1[id][0];
int x = subRange1[id][1];
int h = subRange1[id][3] - subRange1[id][1] + 1;
int w = subRange1[id][2] - subRange1[id][0] + 1;
label_vec.clear();
int k = 0;
while (k < NUM_TOP_K) {
float du = (float(rand()) / RAND_MAX - 0.5) * 2 * (float)disp_range_u;
float dv = (float(rand()) / RAND_MAX - 0.5) * 2 * (float)disp_range_v;
du = floor(du * upScale + 0.5) / upScale;
dv = floor(dv * upScale + 0.5) / upScale;
if (du >= -disp_range_u && du <= disp_range_u && dv >= -disp_range_v && dv <= disp_range_v) {
int index_tp = 1;
for (int k1 = 0; k1 < k; ++k1) {
if (checkEqual_PMF_PMBP(label_super_k[repPixels1[sp]][k1], Vec2f(du, dv)))
index_tp = 0;
}
if (index_tp == 1) {
for (int ii = 0; ii < superpixelsList1[sp].size(); ++ii)
label_super_k[superpixelsList1[sp][ii]][k] = Vec2f(du, dv);
label_vec.push_back(Vec2f(du, dv));
++k;
}
}
}
#if USE_CLMF0_TO_AGGREGATE_COST
cv::Mat_<cv::Vec4b> leftCombinedCrossMap;
leftCombinedCrossMap.create(h, w);
subCrossMap1[sp].copyTo(leftCombinedCrossMap);
CFFilter cff;
#endif
int vec_size = label_vec.size();
localDataCost.create(h, w * vec_size);
localDataCost.setTo(0);
#pragma omp parallel for num_threads(NTHREADS)
for (int i = 0; i < vec_size; ++i) {
int kx = i * w;
Mat_<float> rawCost;
getLocalDataCostPerlabel(sp, label_vec[i], rawCost);
#if USE_CLMF0_TO_AGGREGATE_COST
cff.FastCLMF0FloatFilterPointer(leftCombinedCrossMap, rawCost, rawCost);
#endif
rawCost.copyTo(localDataCost(cv::Rect(kx, 0, w, h)));
}
//getLocalDataCost( sp, label_vec, localDataCost);
int pt, px, py, kx;
for (int ii = 0; ii < superpixelsList1[sp].size(); ++ii) {
//cout<<ii<<endl;
pt = superpixelsList1[sp][ii];
px = pt / width1;
py = pt % width1;
for (int kk = 0; kk < NUM_TOP_K; kk++) {
kx = kk * w;
const Mat_<float>& local = localDataCost(cv::Rect(kx, 0, w, h));
dCost_super_k[pt][kk] = local[px - x][py - y];
}
}
}
printf("==================================================\n");
}
void spm_bp::getLocalDataCost(int sp, vector<Vec2f>& flowList, Mat_<float>& localDataCost) //, vector<vector<Vec2f> > &label_saved, vector<vector<Mat_<float> > > &dcost_saved)
{
int dSize = flowList.size();
//USE_COLOR_FEATURES
cv::Mat_<cv::Vec3f> subLt = subImage1[sp];
#if USE_CENSUS
vector<vector<bitset<CENSUS_SIZE_OF> > > subLt_css = subCensusBS1[sp];
//cv::Mat_<Vec_css> subLt_css = subCensus1[sp];
//cv::Mat_<Vec_css_bit> subLt_css_bit = subCensus_bit1[sp];
#endif
int upHeight, upWidth;
upHeight = im1Up.rows;
upWidth = im1Up.cols;
// extract sub-image from subrange
int p1 = repPixels1[sp];
int w = subRange1[p1][2] - subRange1[p1][0] + 1;
int h = subRange1[p1][3] - subRange1[p1][1] + 1;
int x = subRange1[p1][0];
int y = subRange1[p1][1];
#if USE_CLMF0_TO_AGGREGATE_COST
cv::Mat_<cv::Vec4b> leftCombinedCrossMap;
leftCombinedCrossMap.create(h, w);
subCrossMap1[sp].copyTo(leftCombinedCrossMap);
CFFilter cff;
#endif
Mat_<float> rawCost(h, w);
cv::Mat_<Vec3f> subRt(h, w);
cv::Mat_<Vec2f> subRt_g(h, w);
#if USE_CENSUS
vector<vector<bitset<CENSUS_SIZE_OF> > > subRt_css(h, vector<bitset<CENSUS_SIZE_OF> >(w));
#endif
cv::Mat_<float> tmpCost(h, w);
// localDataCost.release();
localDataCost.create(h, w * dSize);
int kx;
for (int kd = 0; kd < dSize; ++kd) {
kx = kd * w;
clock_t start = clock();
clock_t end;
//int check_id = isNewLabel_PMF_PMBP(label_saved[sp],flowList[kd]);
#if SAVE_DCOST
if (check_id >= 0) {
cout << "hit" << endl;
//dcost_saved[sp][check_id].copyTo(localDataCost(cv::Rect(kx, 0, w, h)));
//cout<<"hit"<<end-start<<endl;
//continue;
}
#endif
start = clock();
Vec2f fl = flowList[kd];
Vec3f* subLtPtr = (cv::Vec3f*)(subLt.ptr(0));
Vec3f* subRtPtr = (cv::Vec3f*)(subRt.ptr(0));
float* rawCostPtr = (float*)(rawCost.ptr(0));
int cy, cx, oy, ox;
oy = y;
for (cy = 0; cy < h; ++cy, ++oy) {
ox = x;
for (cx = 0; cx < w; ++cx, ++ox) {
int oyUp, oxUp;
oyUp = (oy + fl[0]) * upScale;
oxUp = (ox + fl[1]) * upScale;
if (oyUp < 0)
oyUp = 0;
if (oyUp >= upHeight)
oyUp = upHeight - 1;
if (oxUp < 0)
oxUp = 0;
if (oxUp >= upWidth)
oxUp = upWidth - 1;
#if USE_POINTER_WISE
*subRtPtr++ = im2Up[oyUp][oxUp];
#else
subRt[cy][cx] = im2Up[oyUp][oxUp];
#endif
#if USE_CENSUS
subRt_css[cy][cx] = censusBS2[oyUp][oxUp];
#endif
}
}
// calculate raw cost
subLtPtr = (cv::Vec3f*)(subLt.ptr(0));
subRtPtr = (cv::Vec3f*)(subRt.ptr(0));
rawCostPtr = (float*)(rawCost.ptr(0));
int iy, ix;
for (iy = 0; iy < h; ++iy) {
for (ix = 0; ix < w; ++ix) {
#if DATA_COST_ADCENSUS
bitset<CENSUS_SIZE_OF> tmpBS = subRt_css[iy][ix] ^ subLt_css[iy][ix];
#if USE_POINTER_WISE
float dist_c = fabs((float)(*subLtPtr)[0] - (*subRtPtr)[0])
+ fabs((float)(*subLtPtr)[1] - (*subRtPtr)[1])
+ fabs((float)(*subLtPtr++)[2] - (*subRtPtr++)[2]);
#else
float dist_c = std::abs(subLt[iy][ix][0] - subRt[iy][ix][0])
+ std::abs(subLt[iy][ix][1] - subRt[iy][ix][1])
+ std::abs(subLt[iy][ix][2] - subRt[iy][ix][2]);
#endif
float dist_css = expCensusDiffTable[tmpBS.count()];
//cout<<dist_c/3<<endl;
float dist_ce = expColorDiffTable[int(dist_c / 3)];
//cout<<dist_css<<"and "<<dist_c1<<endl;
//float dist_css = 1-std::exp( - float(HammingDis_bit(subLt_css_bit[iy][ix],subRt_css_bit[iy][ix]))/miu);
#if USE_POINTER_WISE
*rawCostPtr++ = 255 * (dist_css + dist_ce);
#else
rawCost[iy][ix] = 255 * (dist_css + dist_ce); //beta*min(dist_c/3,tau_c);//beta*min(dist_c/3,tau_c);//*255 + beta*min(dist_c/3,tau_c);
#endif
#endif
}
}
#if USE_CLMF0_TO_AGGREGATE_COST
cff.FastCLMF0FloatFilterPointer(leftCombinedCrossMap, rawCost, tmpCost);
//cout<<"filtering"<<clock()-end<<endl;
#endif
#if SAVE_DCOST
label_saved[sp].push_back(fl);
//dcost_saved[sp].push_back(tmpCost);
#endif
tmpCost.copyTo(localDataCost(cv::Rect(kx, 0, w, h)));
end = clock();
//cout<<"not hit"<<end-start<<endl;
}
//cout<<label_saved[sp].size()<<endl;
}
void spm_bp::getLocalDataCostPerlabel(int sp, const Vec2f& fl, Mat_<float>& localDataCost)
{
//USE_COLOR_FEATURES
cv::Mat_<cv::Vec3f> subLt = subImage1[sp];
#if USE_CENSUS
vector<vector<bitset<CENSUS_SIZE_OF> > > subLt_css = subCensusBS1[sp];
#endif
int upHeight, upWidth;
upHeight = im1Up.rows;
upWidth = im1Up.cols;
// extract sub-image from subrange
int p1 = repPixels1[sp];
int w = subRange1[p1][2] - subRange1[p1][0] + 1;
int h = subRange1[p1][3] - subRange1[p1][1] + 1;
int x = subRange1[p1][0];
int y = subRange1[p1][1];
// localDataCost.release();
localDataCost.create(h, w);
//Mat_<float> rawCost(h, w);
Mat_<Vec3f> subRt(h, w);
vector<vector<bitset<CENSUS_SIZE_OF> > > subRt_css(h, vector<bitset<CENSUS_SIZE_OF> >(w));
#if SAVE_DCOST
if (check_id >= 0) {
cout << "hit" << endl;
}
#endif
Vec3f* subLtPtr = (cv::Vec3f*)(subLt.ptr(0));
Vec3f* subRtPtr = (cv::Vec3f*)(subRt.ptr(0));
float* rawCostPtr = (float*)(localDataCost.ptr(0));
cv::Vec3f *im2UpPtr = (cv::Vec3f*) im2Up.ptr(0);
int im2UpWidth = im2Up.cols;
int maxHeight = upHeight - 1;
int maxWidth = upWidth - 1;
int cy, cx, oy, ox;
float fl0 = fl[0], fl1 = fl[1];
#pragma omp parallel for
for (cy = 0; cy < h; ++cy) {
oy = y + cy;
int oyUp = (oy + fl0) * upScale;
if (oyUp < 0)
oyUp = 0;
if (oyUp >= upHeight)
oyUp = maxHeight;
for (cx = 0; cx < w; ++cx) {
ox = x + cx;
int oxUp = (ox + fl1) * upScale;
if (oxUp < 0)
oxUp = 0;
if (oxUp >= upWidth)
oxUp = maxWidth;
#if USE_POINTER_WISE
// *subRtPtr++ = im2Up[oyUp][oxUp];
subRtPtr[cy * w + cx] = im2UpPtr[oyUp * im2UpWidth + oxUp];
#else
subRt[cy][cx] = im2Up[oyUp][oxUp];
#endif
#if USE_CENSUS
subRt_css[cy][cx] = censusBS2[oyUp][oxUp];
#endif
}
}
// calculate raw cost
subLtPtr = (cv::Vec3f*)(subLt.ptr(0));
subRtPtr = (cv::Vec3f*)(subRt.ptr(0));
rawCostPtr = (float*)(localDataCost.ptr(0));
int iy, ix;
for (iy = 0; iy < h; ++iy) {
for (ix = 0; ix < w; ++ix) {
#if DATA_COST_ADCENSUS
bitset<CENSUS_SIZE_OF> tmpBS = subRt_css[iy][ix] ^ subLt_css[iy][ix];
#if USE_POINTER_WISE
float dist_c = fabsf((*subLtPtr)[0] - (*subRtPtr)[0])
+ fabsf((*subLtPtr)[1] - (*subRtPtr)[1])
+ fabsf((*subLtPtr)[2] - (*subRtPtr)[2]);
++subLtPtr;
++subRtPtr;
#else
float dist_c = std::abs(subLt[iy][ix][0] - subRt[iy][ix][0])
+ std::abs(subLt[iy][ix][1] - subRt[iy][ix][1])
+ std::abs(subLt[iy][ix][2] - subRt[iy][ix][2]);
#endif
float dist_css = expCensusDiffTable[tmpBS.count()];
float dist_ce = expColorDiffTable[int(dist_c / 3)];
#if USE_POINTER_WISE
*rawCostPtr++ = 255 * (dist_css + dist_ce);
#else
localDataCost[iy][ix] = 255 * (dist_css + dist_ce); //beta*min(dist_c/3,tau_c);//beta*min(dist_c/3,tau_c);//*255 + beta*min(dist_c/3,tau_c);
#endif
#endif
}
}
#if SAVE_DCOST
label_saved[sp].push_back(fl);
#endif
}
//===========================================================================
void SVR_patch_expert::Response(const Mat_<float>& area_of_interest, Mat_<double>& response)
{
int response_height = area_of_interest.rows - weights.rows + 1;
int response_width = area_of_interest.cols - weights.cols + 1;
// the patch area on which we will calculate reponses
cv::Mat_<float> normalised_area_of_interest;
if(response.rows != response_height || response.cols != response_width)
{
response.create(response_height, response_width);
}
// If type is raw just normalise mean and standard deviation
if(type == 0)
{
// Perform normalisation across whole patch
cv::Scalar mean;
cv::Scalar std;
cv::meanStdDev(area_of_interest, mean, std);
// Avoid division by zero
if(std[0] == 0)
{
std[0] = 1;
}
normalised_area_of_interest = (area_of_interest - mean[0]) / std[0];
}
// If type is gradient, perform the image gradient computation
else if(type == 1)
{
Grad(area_of_interest, normalised_area_of_interest);
}
else
{
printf("ERROR(%s,%d): Unsupported patch type %d!\n", __FILE__,__LINE__, type);
abort();
}
Mat_<float> svr_response;
// The empty matrix as we don't pass precomputed dft's of image
Mat_<double> empty_matrix_0(0,0,0.0);
Mat_<float> empty_matrix_1(0,0,0.0);
Mat_<float> empty_matrix_2(0,0,0.0);
// Efficient calc of patch expert SVR response across the area of interest
matchTemplate_m(normalised_area_of_interest, empty_matrix_0, empty_matrix_1, empty_matrix_2, weights, weights_dfts, svr_response, CV_TM_CCOEFF_NORMED);
response.create(svr_response.size());
MatIterator_<double> p = response.begin();
cv::MatIterator_<float> q1 = svr_response.begin(); // respone for each pixel
cv::MatIterator_<float> q2 = svr_response.end();
while(q1 != q2)
{
// the SVR response passed into logistic regressor
*p++ = 1.0/(1.0 + exp( -(*q1++ * scaling + bias )));
}
}