C++ Mat::fl方法代码示例

//=============================================================================
vector<Point2f> 
patch_models::
apply_simil(const Mat &S,
        const vector<Point2f> &points)
{
  int n = points.size();
  vector<Point2f> p(n);
  for(int i = 0; i < n; i++){
    p[i].x = S.fl(0,0)*points[i].x + S.fl(0,1)*points[i].y + S.fl(0,2);
    p[i].y = S.fl(1,0)*points[i].x + S.fl(1,1)*points[i].y + S.fl(1,2);
  }return p;
}

//==============================================================================
bool
face_detector::
enough_bounded_points(const Mat &pts,
              const Rect R,
              const float frac)
{
  int n = pts.rows/2,m = 0;
  for(int i = 0; i < n; i++){
    if((pts.fl(2*i  ) >= R.x) && (pts.fl(2*i  ) <= R.x + R.width) &&
       (pts.fl(2*i+1) >= R.y) && (pts.fl(2*i+1) <= R.y + R.height))m++;
  }
  if(float(m)/n >= frac)return true; else return false;
}

//==============================================================================
Mat
shape_model::
center_shape(const Mat &pts)
{
    int n = pts.rows/2; float mx = 0,my = 0;
    for(int i = 0; i < n; i++){
        mx += pts.fl(2*i); my += pts.fl(2*i+1);
    }
    Mat p(2*n,1,CV_32F); mx /= n; my /= n;
    for(int i = 0; i < n; i++){
        p.fl(2*i) = pts.fl(2*i) - mx; p.fl(2*i+1) = pts.fl(2*i+1) - my;
    }return p;
}

//==============================================================================
void
shape_model::
train(const vector<vector<Point2f> > &points,
      const vector<Vec2i> &con,
      const float frac,
      const int kmax)
{
    //vectorize points
    // 把N张图片中的n个点的坐标排成一个N*2n的矩阵
    Mat X = this->pts2mat(points);
    int N = X.cols,n = X.rows/2;
    
    //align shapes
    // 把这些shape先用procustes方法对齐
    Y = this->procrustes(X);
    
    
    //compute rigid transformation
    Mat R = this->calc_rigid_basis(Y);
    
    //compute non-rigid transformation
    Mat P = R.t()*Y; Mat dY = Y - R*P; SVD svd(dY*dY.t());
    int m = min(min(kmax,N-1),n-1);
    float vsum = 0; for(int i = 0; i < m; i++)vsum += svd.w.fl(i);
    float v = 0; int k = 0;
    for(k = 0; k < m; k++){v += svd.w.fl(k); if(v/vsum >= frac){k++; break;}}
    if(k > m)k = m;
    Mat D = svd.u(Rect(0,0,k,2*n));
    
    //combine bases
    V.create(2*n,4+k,CV_32F);
    Mat Vr = V(Rect(0,0,4,2*n)); R.copyTo(Vr);
    Mat Vd = V(Rect(4,0,k,2*n)); D.copyTo(Vd);
    
    //compute variance (normalized wrt scale)
    Mat Q = V.t()*X;
    for(int i = 0; i < N; i++){
        float v = Q.fl(0,i); Mat q = Q.col(i); q /= v;
    }
    e.create(4+k,1,CV_32F);
    pow(Q,2,Q);
    for(int i = 0; i < 4+k; i++){
        if(i < 4)e.fl(i) = -1;
        else e.fl(i) = Q.row(i).dot(Mat::ones(1,N,CV_32F))/(N-1);
    }
    //store connectivity
    if(con.size() > 0){ //default connectivity
        int m = con.size();
        C.create(m,2,CV_32F);
        for(int i = 0; i < m; i++){
            C.at<int>(i,0) = con[i][0]; C.at<int>(i,1) = con[i][1];
        }
    }else{              //user-specified connectivity
        C.create(n,2,CV_32S);
        for(int i = 0; i < n-1; i++){
            C.at<int>(i,0) = i; C.at<int>(i,1) = i+1;
        }
        C.at<int>(n-1,0) = n-1; C.at<int>(n-1,1) = 0;
    }
}

//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================
//==============================================================================
void 
patch_models::
train(ft_data &data,
      const vector<Point2f> &ref,
      const Size psize,
      const Size ssize,
      const bool mirror,
      const float var,
      const float lambda,
      const float mu_init,
      const int nsamples,
      const bool visi)
{
  //set reference shape
  int n = ref.size(); reference = Mat(ref).reshape(1,2*n);
  Size wsize = psize + ssize;

  //train each patch model in turn
  patches.resize(n);
  for(int i = 0; i < n; i++){
    if(visi)cout << "training patch " << i << "..." << endl;
    vector<Mat> images(0);
    for(int j = 0; j < data.n_images(); j++){
      Mat im = data.get_image(j,0);
//        imshow("im",im);
      vector<Point2f> p = data.get_points(j,false);
      Mat pt = Mat(p).reshape(1,2*n);
      Mat S = this->calc_simil(pt),A(2,3,CV_32F); 
      A.fl(0,0) = S.fl(0,0); A.fl(0,1) = S.fl(0,1);
      A.fl(1,0) = S.fl(1,0); A.fl(1,1) = S.fl(1,1);
      A.fl(0,2) = pt.fl(2*i  ) - 
    (A.fl(0,0) * (wsize.width-1)/2 + A.fl(0,1)*(wsize.height-1)/2);
      A.fl(1,2) = pt.fl(2*i+1) - 
    (A.fl(1,0) * (wsize.width-1)/2 + A.fl(1,1)*(wsize.height-1)/2);
      Mat I; warpAffine(im,I,A,wsize,INTER_LINEAR+WARP_INVERSE_MAP);
      images.push_back(I);
      if(mirror){
    im = data.get_image(j,1); 
    p = data.get_points(j,true);
    pt = Mat(p).reshape(1,2*n);
    S = this->calc_simil(pt);
    A.fl(0,0) = S.fl(0,0); A.fl(0,1) = S.fl(0,1);
    A.fl(1,0) = S.fl(1,0); A.fl(1,1) = S.fl(1,1);
    A.fl(0,2) = pt.fl(2*i  ) - 
      (A.fl(0,0) * (wsize.width-1)/2 + A.fl(0,1)*(wsize.height-1)/2);
    A.fl(1,2) = pt.fl(2*i+1) - 
      (A.fl(1,0) * (wsize.width-1)/2 + A.fl(1,1)*(wsize.height-1)/2);
    warpAffine(im,I,A,wsize,INTER_LINEAR+WARP_INVERSE_MAP);
    images.push_back(I);
      }
    }
    patches[i].train(images,psize,var,lambda,mu_init,nsamples,visi);
  }
}

//==============================================================================
float 
face_detector::
calc_scale(const Mat &pts)
{
  Point2f c = this->center_of_mass(pts); int n = pts.rows/2;
  Mat p(2*n,1,CV_32F);
  for(int i = 0; i < n; i++){
    p.fl(2*i  ) = pts.fl(2*i  ) - c.x;
    p.fl(2*i+1) = pts.fl(2*i+1) - c.y;
  }return reference.dot(p)/reference.dot(reference);
}

//=============================================================================
Mat
shape_model::
rot_scale_align(const Mat &src,
                const Mat &dst)
{
    //construct linear system
    int n = src.rows/2; float a=0,b=0,d=0;
    for(int i = 0; i < n; i++){
        d += src.fl(2*i) * src.fl(2*i  ) + src.fl(2*i+1) * src.fl(2*i+1);
        a += src.fl(2*i) * dst.fl(2*i  ) + src.fl(2*i+1) * dst.fl(2*i+1);
        b += src.fl(2*i) * dst.fl(2*i+1) - src.fl(2*i+1) * dst.fl(2*i  );
    }
    a /= d; b /= d;//solved linear system
    return (Mat_<float>(2,2) << a,-b,b,a);
}

//=============================================================================
Mat 
patch_models::
inv_simil(const Mat &S)
{
  Mat Si(2,3,CV_32F);
  float d = S.fl(0,0)*S.fl(1,1) - S.fl(1,0)*S.fl(0,1);
  Si.fl(0,0) = S.fl(1,1)/d; Si.fl(0,1) = -S.fl(0,1)/d;
  Si.fl(1,1) = S.fl(0,0)/d; Si.fl(1,0) = -S.fl(1,0)/d;
  Mat Ri = Si(Rect(0,0,2,2));
  Mat t = -Ri*S.col(2),St = Si.col(2); t.copyTo(St); return Si; 
}

//==============================================================================
void
shape_model::
calc_params(const vector<Point2f> &pts,const Mat weight,const float c_factor)
{
    int n = pts.size(); assert(V.rows == 2*n);
    Mat s = Mat(pts).reshape(1,2*n); //point set to vector format
    if(weight.empty())p = V.t()*s;   //simple projection
    else{                            //scaled projection
        if(weight.rows != n){cout << "Invalid weighting matrix" << endl; abort();}
        int K = V.cols; Mat H = Mat::zeros(K,K,CV_32F),g = Mat::zeros(K,1,CV_32F);
        for(int i = 0; i < n; i++){
            Mat v = V(Rect(0,2*i,K,2)); float w = weight.fl(i);
            H += w*v.t()*v; g += w*v.t()*Mat(pts[i]);
        }
        solve(H,g,p,DECOMP_SVD);
    }this->clamp(c_factor);          //clamp resulting parameters
}