Mat initModify::histogramEqualization(Mat & sourceImage) { // change the Mat to IplImage, which can make whole process quicker. IplImage * src; src = &IplImage(sourceImage); IplImage * imgChannel[4] = { 0, 0, 0, 0 }; IplImage * dist = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 3); if (src) { for (int i = 0; i < src->nChannels; i++) { imgChannel[i] = cvCreateImage(cvGetSize(src), IPL_DEPTH_8U, 1); } // split all the channels (R, G, B, A) cvSplit(src, imgChannel[0], imgChannel[1], imgChannel[2], imgChannel[3]); for (int i = 0; i < dist->nChannels; i++) { cvEqualizeHist(imgChannel[i], imgChannel[i]); } // merge all the channels cvMerge(imgChannel[0], imgChannel[1], imgChannel[2], imgChannel[3], dist); Mat resultImage = cvarrToMat(dist, true); cvReleaseImage(&dist); return resultImage; } else { return Mat(); } }
void pix_opencv_patreco :: loadDistMess (t_symbol *filename) { CvMat* distortion_coeffs; if ( filename->s_name[0] == 0 ) { error("no filename passed to loadDist message"); return; } if ( filename == NULL ) { error("NULL pointer passed to function loadDist"); return;} distortion_coeffs = (CvMat*)cvLoad(filename->s_name); // TODO crash when passing non-XML file if (distortion_coeffs == NULL) { distortion_coeffs = cvCreateMat(5, 1, CV_32FC1); error("can't open file %s", filename->s_name); //~ resetCorrectionMatrix(); } else if( distortion_coeffs->rows != 5 || distortion_coeffs->cols != 1 || CV_MAT_TYPE(distortion_coeffs->type) != CV_32FC1 ) { error("%s is not a valid distortions coeffs file", filename->s_name); cvReleaseMat(&distortion_coeffs); distortion_coeffs = cvCreateMat(3, 3, CV_32FC1); //~ resetCorrectionMatrix(); } else post("load distortion coefficients from %s",filename->s_name); m_distortions = cvarrToMat(distortion_coeffs); t_atom dist_out[5]; for ( int i = 0 ; i < 5 ; i++ ){ SETFLOAT(&dist_out[i], CV_MAT_ELEM( *distortion_coeffs, float, i, 0)); } outlet_anything( m_dataout, gensym("distortion_coeffs"), 5, dist_out); }
void pix_opencv_patreco :: loadIntraMess (t_symbol *filename) { CvMat* intrinsic_matrix; if ( filename->s_name[0] == 0 ) { error("no filename passed to loadIntra message"); return; } if ( filename == NULL ) { error("%s is not a valid matrix", filename->s_name); return;} intrinsic_matrix = (CvMat*)cvLoad(filename->s_name, 0, 0, 0);// TODO crash when passing non-XML file if (intrinsic_matrix == NULL) { intrinsic_matrix = cvCreateMat(3, 3, CV_32FC1); error("can't open file %s", filename->s_name); //~ resetCorrectionMatrix(); } else if ( intrinsic_matrix->rows != 3 || intrinsic_matrix->cols != 3 || CV_MAT_TYPE(intrinsic_matrix->type) != CV_32FC1 ) { error("%s is not a valid intrinsic matrix", filename->s_name); cvReleaseMat(&intrinsic_matrix); intrinsic_matrix = cvCreateMat(3, 3, CV_32FC1); //~ resetCorrectionMatrix(); } else post("load transformation matrix from %s",filename->s_name); m_cameraMatrix = cvarrToMat(intrinsic_matrix); t_atom intra_out[9]; for ( int i = 0 ; i < 9 ; i++ ){ SETFLOAT(&intra_out[i], CV_MAT_ELEM( *intrinsic_matrix, float, i%3, i/3)); } outlet_anything( this->m_dataout, gensym("intrinsic_matrix"), 9, intra_out); }
QImage convert_lpl_qimg(IplImage* frame) { Mat img = cvarrToMat(frame); cv::cvtColor(img,img,CV_BGR2RGB); //Qt reads in RGB whereas CV in BGR QImage imdisplay((uchar*)img.data, img.cols, img.rows, img.step, QImage::Format_RGB888); img.release(); return imdisplay; }
Mat AAM::getTextureParamsFromC(Mat c) { Mat ap = this->appearancePCA.backProject(c); CvMat apMat=ap; CvMat textureParams; cvGetCols(&apMat, &textureParams, shapeSet.cols, shapeSet.cols+this->b_g.cols); Mat texture=cvarrToMat(&textureParams); return texture; }
Mat AAM::getShapeParamsFromC(Mat c) { Mat ap = this->appearancePCA.backProject(c); CvMat apMat=ap; CvMat shapeParams; cvGetCols(&apMat, &shapeParams, 0, shapeSet.cols); Mat shape=cvarrToMat(&shapeParams); shape=shape/this->w; return shape; }
void insertImageCOI(InputArray _ch, CvArr* arr, int coi) { Mat ch = _ch.getMat(), mat = cvarrToMat(arr, false, true, 1); if(coi < 0) { CV_Assert( CV_IS_IMAGE(arr) ); coi = cvGetImageCOI((const IplImage*)arr)-1; } CV_Assert(ch.size == mat.size && ch.depth() == mat.depth() && 0 <= coi && coi < mat.channels()); int _pairs[] = { 0, coi }; mixChannels( &ch, 1, &mat, 1, _pairs, 1 ); }
void extractImageCOI(const CvArr* arr, OutputArray _ch, int coi) { Mat mat = cvarrToMat(arr, false, true, 1); _ch.create(mat.dims, mat.size, mat.depth()); Mat ch = _ch.getMat(); if(coi < 0) { CV_Assert( CV_IS_IMAGE(arr) ); coi = cvGetImageCOI((const IplImage*)arr)-1; } CV_Assert(0 <= coi && coi < mat.channels()); int _pairs[] = { coi, 0 }; mixChannels( &mat, 1, &ch, 1, _pairs, 1 ); }
// iterate the EKF double slamStep(Mat u, VideoCapture &cap, VideoWriter &record) { double r_dp = u.at<double>(0); double r_dth = u.at<double>(1); Mat frame; cap >> frame; ml->UpdateMarkers(frame); Mat observations = slam->step(u); // find the closest visible marker double mindist = 99999; for(int i=0; i < observations.rows; i+=2) { if(observations.at<double>(i) < mindist) mindist = observations.at<double>(i); } #ifdef GUI Mat rmap, mcov; if(slam->getMap(rmap, mcov)) { for(int i=0; i < rmap.rows; i+=2) { double g_x = rmap.at<double>(i); double g_y = rmap.at<double>(i+1); disp->setGuess(g_x,g_y,i/2); } } Mat robot = slam->getRobot(); disp->guessRobot(robot.at<double>(0), robot.at<double>(1), robot.at<double>(2)); const IplImage* dispImage = disp->renderMap(); // Make sure our mat can hold all the images int height = (frame.rows > dispImage->height) ? frame.rows : dispImage->height; if(!outFrame.data || outFrame.cols < dispImage->width + frame.cols + 100 || outFrame.rows < height) { outFrame = Mat::zeros(height, dispImage->width + frame.cols + 100, frame.type()); Rect binRoi(100 + dispImage->width, 0, frame.cols, frame.rows); Rect markerRoi(0, 0, 100, height); ml->SetDrawMats(outFrame(binRoi), outFrame(markerRoi)); } Rect iplRoi(100, 0, dispImage->width, dispImage->height); cvarrToMat(dispImage).copyTo(outFrame(iplRoi)); imshow("EKFSlam", outFrame); g_outFrame = outFrame; record << outFrame; waitKey(10); #endif return mindist; }
void EyeCameraFrameReaderThread::run(void) { emit onCameraTextChanged("Loading..."); int frontCamIndex = cameraIndex == 1 ? 2 : 1; EyeTracker *eyeTracker = new EyeTracker(cameraIndex, frontCamIndex); // If camera could not be opened if(!eyeTracker->isOpened()) { qDebug() << "Error: Cannot connect to camera."; emit onCameraTextChanged("Cannot connect to camera"); emit finished(); } for( ; ; ) { // Capture images eyeTracker->captureEyeFrame(); eyeTracker->captureSceneFrame(); Point2f p = eyeTracker->doTrack(); // Set up x and y coordinates char str[50]; sprintf(str, "%.1f", p.x); emit onEyeXChanged(str); sprintf(str, "%.1f", p.y); emit onEyeYChanged(str); // Draw squares to eye image eyeTracker->drawSquares(eyeTracker->findSquares()); // Set eye pixmap emit onCameraPixmapChanged(QPixmap::fromImage(cvMatToQImage(cvarrToMat(eyeTracker->getEyeImage())))); // Release images eyeTracker->releaseGrayEyeImage(); eyeTracker->releaseGraySceneImage(); cvWaitKey(20); } }
int _tmain(int argc, _TCHAR* argv[]) { IplImage* input_img = cvLoadImage("Carol_Niedermayer_0001.jpg",0); Mat input_mat=cvarrToMat(input_img,true); if (input_mat.cols == 0) { cout<<"can not load image"<<endl; return 1; } Rect face_box = face_detect(input_mat); cout<<"here"<<endl; Mat aligned_face(128,128,CV_8UC1); int flag = face_align(input_mat,&aligned_face,face_box); if(flag == 0) { cout<<"can not align the face image"<<endl; return 1; } imwrite("aligned_face.bmp",aligned_face); char* modelPath = "casia_144_ve_id_model_iter_1210000.bin"; const int layer_index =14; const int len = 320*8*8; float* feature = (float*)malloc(320*sizeof(float)); clock_t start, end; double time; start = clock(); cnnFace cnn(modelPath,layer_index,len); if (cnn.cnnFaceInit() != 0) { return 1; } cnn.getFeature(aligned_face, feature); //cnn.getFeature(imgFace2, feat2); //float score = cnn.getScore(feat1, feat2); end = clock(); time = (double)(end - start) / CLOCKS_PER_SEC; cout << "The score is " << "\nTime is " << time << endl; cnn.~cnnFace(); free(feature); return 0; }
static void* imdecode_( const Mat& buf, int flags, int hdrtype, Mat* mat=0 ) { CV_Assert(buf.data && buf.isContinuous()); IplImage* image = 0; CvMat *matrix = 0; Mat temp, *data = &temp; string filename; ImageDecoder decoder = findDecoder(buf); if( decoder.empty() ) return 0; if( !decoder->setSource(buf) ) { filename = tempfile(); FILE* f = fopen( filename.c_str(), "wb" ); if( !f ) return 0; size_t bufSize = buf.cols*buf.rows*buf.elemSize(); fwrite( &buf.data[0], 1, bufSize, f ); fclose(f); decoder->setSource(filename); } if( !decoder->readHeader() ) { if( !filename.empty() ) remove(filename.c_str()); return 0; } CvSize size; size.width = decoder->width(); size.height = decoder->height(); int type = decoder->type(); if( flags != -1 ) { if( (flags & CV_LOAD_IMAGE_ANYDEPTH) == 0 ) type = CV_MAKETYPE(CV_8U, CV_MAT_CN(type)); if( (flags & CV_LOAD_IMAGE_COLOR) != 0 || ((flags & CV_LOAD_IMAGE_ANYCOLOR) != 0 && CV_MAT_CN(type) > 1) ) type = CV_MAKETYPE(CV_MAT_DEPTH(type), 3); else type = CV_MAKETYPE(CV_MAT_DEPTH(type), 1); } if( hdrtype == LOAD_CVMAT || hdrtype == LOAD_MAT ) { if( hdrtype == LOAD_CVMAT ) { matrix = cvCreateMat( size.height, size.width, type ); temp = cvarrToMat(matrix); } else { mat->create( size.height, size.width, type ); data = mat; } } else { image = cvCreateImage( size, cvIplDepth(type), CV_MAT_CN(type) ); temp = cvarrToMat(image); } bool code = decoder->readData( *data ); if( !filename.empty() ) remove(filename.c_str()); if( !code ) { cvReleaseImage( &image ); cvReleaseMat( &matrix ); if( mat ) mat->release(); return 0; } return hdrtype == LOAD_CVMAT ? (void*)matrix : hdrtype == LOAD_IMAGE ? (void*)image : (void*)mat; }
int ns__trainANN(struct soap *soap, char *inputMatFilename, char *neuralFile, char **OutputMatFilename) { double start, end; start = omp_get_wtime(); Mat src; //must be 3ch image if(!readMat(inputMatFilename, src)) { cerr << "trainANN :: can not read bin file" << endl; soap->fault->faultstring = "trainANN :: can not read bin file"; return SOAP_FAULT; } // convert src to CvMat to use an old-school function CvMat tmp = src; CV_Assert(tmp.cols == src.cols && tmp.rows == src.rows && tmp.data.ptr == (uchar*)src.data && tmp.step == src.step); CvMat *input3Ch = cvCreateMat(src.rows, src.cols, CV_32FC3); cvConvert(&tmp, input3Ch); CvMat *output1Ch = cvCreateMat(src.rows, src.cols, CV_32FC1); CvANN_MLP* neuron = NULL ; if (neuron == NULL ) neuron = new CvANN_MLP(); else neuron->clear(); if(!ByteArrayToANN(neuralFile, neuron)){ cerr << "trainANN :: can not load byte array to neural" << endl; return soap_receiver_fault(soap, "trainANN :: can not load byte array to neural", NULL); } CvMat input_nn = cvMat(input3Ch->height*input3Ch->width, 3, CV_32FC1, input3Ch->data.fl); CvMat output_nn = cvMat(output1Ch->height*output1Ch->width, 1, CV_32FC1, output1Ch->data.fl); neuron->predict(&input_nn, &output_nn); Mat resultNN = cvarrToMat(output1Ch, false); /* generate output file name */ *OutputMatFilename = (char*)soap_malloc(soap, FILENAME_SIZE); time_t now = time(0); strftime(*OutputMatFilename, sizeof(OutputMatFilename)*FILENAME_SIZE, "/home/lluu/dir/%Y%m%d_%H%M%S_trainANN", localtime(&now)); /* save to bin */ if(!saveMat(*OutputMatFilename, resultNN)) { cerr << "trainANN :: save mat to binary file" << endl; return soap_receiver_fault(soap, "trainANN :: save mat to binary file", NULL); } src.release(); resultNN.release(); cvReleaseMat(&output1Ch); end = omp_get_wtime(); cerr<<"ns__trainANN "<<"time elapsed "<<end-start<<endl; return SOAP_OK; }
int main( int argc, char** argv ) { // Medida de tiempo inicial clock_t t0, t_load, t_loop, t_loop0; double dtime; t0 = clock(); // Declaration of variables CascadeClassifier face_cascade; // Cascade Classifier Mat captureFrame, grayscaleFrame; // Captured and converted to gray Frames double x_face_pos, y_face_pos, area_face; // Coordinates of the detected face vector< Rect_<int> > faces; // Vector of faces #ifdef RASPBERRY RaspiCamCvCapture * captureDevice; // Video input #else CvCapture * captureDevice; // Video input #endif char sTmp[255]; #ifdef TRACE sprintf(sTmp,"\n Directorio de ejecucion del programa: "); trace (sTmp); cout << get_ProgramDirectory(); #endif #ifdef RECOGNITION // Declaration of variables Face recognition string people[MAX_PEOPLE]; // Each person of the model of face recognition int im_width, im_height; // heigh, witdh of 1st images of the model of face recognition int prediction_seuil; // Prediction limit Ptr<FaceRecognizer> model; // Model of face recognitio // Prediction limit depending on the device #ifdef EIGENFACES prediction_seuil = 10; #else prediction_seuil = 1000; #endif // Model of face recognition #ifdef EIGENFACES model = createEigenFaceRecognizer(); #else model = createFisherFaceRecognizer(); #endif // Read measures file read_measures_file(im_width, im_height, '='); // Read people file read_people_file(people, '(', ')', '='); // Load model load_model_recognition(model); t_load = clock(); #ifdef DEBUG dtime = difftime(t_load,t0); sprintf(sTmp,"\n (Face Tracking) tiempo de carga del modelo = "); debug(sTmp); cout << print_time(dtime); #endif #endif // Video input depending on the device #ifdef RASPBERRY captureDevice = raspiCamCvCreateCameraCapture(0); // Index doesn't really matter #else captureDevice = cvCreateCameraCapture(0); #endif // Load of Haar Cascade if (!load_haar_cascade(face_cascade)) { return -1;} // Create new window SHOW cvNamedWindow("Face tracking", 1); do { t_loop0 = clock(); #ifdef RASPBERRY IplImage* image = raspiCamCvQueryFrame(captureDevice); // Get images from the video input #else IplImage* image = cvQueryFrame(captureDevice); // Get images from the video input #endif captureFrame = cvarrToMat(image); // Convert images to Mat cvtColor(captureFrame, grayscaleFrame, CV_RGB2GRAY); // Convert the image to gray scale // Detection and Face Recognition face_detection(face_cascade, grayscaleFrame, captureFrame, &faces, x_face_pos, y_face_pos, area_face); #ifdef RECOGNITION // Detection and Face Recognition face_recognition(people, grayscaleFrame, captureFrame, &faces, im_width, im_height, model, prediction_seuil, x_face_pos, y_face_pos, area_face); #endif // Display results #ifdef SHOW imshow("Face tracking", captureFrame); #endif t_loop = clock(); #ifdef DEBUG dtime = difftime(t_loop,t_loop0); sprintf(sTmp,"\n (Face Tracking) tiempo del bucle del reconocimiento de cara = "); debug(sTmp); cout << print_time(dtime); #endif } while(cvWaitKey(10) < 0); // Destroy window #ifdef SHOW cvDestroyWindow("Face tracking"); #endif #ifdef TRACE trace ("\n"); #endif #ifdef RASPBERRY raspiCamCvReleaseCapture(&captureDevice); #else cvReleaseCapture(&captureDevice); #endif return 0; }
static void* imread_( const string& filename, int flags, int hdrtype, Mat* mat=0 ) { IplImage* image = 0; CvMat *matrix = 0; Mat temp, *data = &temp; ImageDecoder decoder = findDecoder(filename); if( decoder.empty() ) return 0; decoder->setSource(filename); if( !decoder->readHeader() ) return 0; CvSize size; size.width = decoder->width(); size.height = decoder->height(); int type = decoder->type(); if( flags != -1 ) { if( (flags & CV_LOAD_IMAGE_ANYDEPTH) == 0 ) type = CV_MAKETYPE(CV_8U, CV_MAT_CN(type)); if( (flags & CV_LOAD_IMAGE_COLOR) != 0 || ((flags & CV_LOAD_IMAGE_ANYCOLOR) != 0 && CV_MAT_CN(type) > 1) ) type = CV_MAKETYPE(CV_MAT_DEPTH(type), 3); else type = CV_MAKETYPE(CV_MAT_DEPTH(type), 1); } if( hdrtype == LOAD_CVMAT || hdrtype == LOAD_MAT ) { if( hdrtype == LOAD_CVMAT ) { matrix = cvCreateMat( size.height, size.width, type ); temp = cvarrToMat(matrix); } else { mat->create( size.height, size.width, type ); data = mat; } } else { image = cvCreateImage( size, cvIplDepth(type), CV_MAT_CN(type) ); temp = cvarrToMat(image); } if( !decoder->readData( *data )) { cvReleaseImage( &image ); cvReleaseMat( &matrix ); if( mat ) mat->release(); return 0; } return hdrtype == LOAD_CVMAT ? (void*)matrix : hdrtype == LOAD_IMAGE ? (void*)image : (void*)mat; }
static void* imdecode_( const Vector<uchar>& buf, int flags, int hdrtype, Mat* mat=0 ) { IplImage* image = 0; CvMat *matrix = 0; Mat temp, *data = &temp; char fnamebuf[L_tmpnam]; const char* filename = 0; ImageDecoder decoder = findDecoder(buf); if( !decoder.obj ) return 0; if( !decoder->setSource(buf) ) { filename = tmpnam(fnamebuf); FILE* f = fopen( filename, "wb" ); if( !f ) return 0; fwrite( &buf[0], 1, buf.size(), f ); fclose(f); decoder->setSource(filename); } if( !decoder->readHeader() ) { if( filename ) unlink(filename); return 0; } CvSize size; size.width = decoder->width(); size.height = decoder->height(); int type = decoder->type(); if( flags != -1 ) { if( (flags & CV_LOAD_IMAGE_ANYDEPTH) == 0 ) type = CV_MAKETYPE(CV_8U, CV_MAT_CN(type)); if( (flags & CV_LOAD_IMAGE_COLOR) != 0 || ((flags & CV_LOAD_IMAGE_ANYCOLOR) != 0 && CV_MAT_CN(type) > 1) ) type = CV_MAKETYPE(CV_MAT_DEPTH(type), 3); else type = CV_MAKETYPE(CV_MAT_DEPTH(type), 1); } if( hdrtype == LOAD_CVMAT || hdrtype == LOAD_MAT ) { if( hdrtype == LOAD_CVMAT ) { matrix = cvCreateMat( size.height, size.width, type ); temp = cvarrToMat(matrix); } else { mat->create( size.height, size.width, type ); data = mat; } } else { image = cvCreateImage( size, cvIplDepth(type), CV_MAT_CN(type) ); temp = cvarrToMat(image); } bool code = decoder->readData( *data ); if( filename ) unlink(filename); if( !code ) { cvReleaseImage( &image ); cvReleaseMat( &matrix ); if( mat ) mat->release(); return 0; } return hdrtype == LOAD_CVMAT ? (void*)matrix : hdrtype == LOAD_IMAGE ? (void*)image : (void*)mat; }
//----------------------------------------------------- void ofxSURFTracker::detect(unsigned char *pix, int inputWidth, int inputHeight) { /*** code adapted from http://docs.opencv.org/doc/tutorials/features2d/feature_homography/feature_homography.html ***/ if( inputWidth != inputImg.getWidth() || inputHeight != inputImg.getHeight()) { // this should only happen once inputImg.clear(); inputImg.allocate(inputWidth, inputHeight); cout << "ofxSURFTracker : re-allocated the input image."<<endl; } // create the cvImage from the ofImage inputImg.setFromPixels(pix, inputWidth, inputHeight); inputImg.setROI( ofRectangle((inputWidth-width)/2, (inputHeight-height)/2, width, height ) ); // take out the piece that we want to use. croppedImg.setFromPixels(inputImg.getRoiPixels(), width, height); // make it into a trackable grayscale image trackImg = croppedImg; // do some fancy contrast stuff if(bContrast) { trackImg.contrastStretch(); } // set up the feature detector detector = SurfFeatureDetector(hessianThreshold, octaves, octaveLayers, bUpright); // clear existing keypoints from previous frame keypoints_scene.clear(); // get the Mat to do the feature detection on Mat trackMat = cvarrToMat(trackImg.getCvImage()); detector.detect( trackMat, keypoints_scene); // Calculate descriptors (feature vectors) extractor.compute( trackMat, keypoints_scene, descriptors_scene ); // Matching descriptor vectors using FLANN matcher vector< DMatch > matches; if(!descriptors_object.empty() && !descriptors_scene.empty() ) { flannMatcher.match( descriptors_object, descriptors_scene, matches); } // Quick calculation of max and min distances between keypoints double max_dist = 0; double min_dist = 100; for( int i = 0; i < matches.size(); i++ ) { double dist = matches[i].distance; if( dist < min_dist ) min_dist = dist; if( dist > max_dist ) max_dist = dist; } // Filter matches upon quality : distance is between 0 and 1, lower is better good_matches.clear(); for( int i = 0; i < matches.size(); i++ ) { if(matches[i].distance < 3 * min_dist && matches[i].distance < distanceThreshold) { good_matches.push_back( matches[i]); } } // find the homography // transform the bounding box for this scene vector <Point2f> scene_pts; vector <Point2f> object_pts; object_transformed.clear(); if(good_matches.size() > minMatches) { for( int i = 0; i < good_matches.size(); i++ ) { //-- Get the keypoints from the good matches object_pts.push_back( keypoints_object[ good_matches[i].queryIdx ].pt ); scene_pts.push_back( keypoints_scene[ good_matches[i].trainIdx ].pt ); } if( scene_pts.size() >5 && object_pts.size() > 5) { homography = findHomography( object_pts, scene_pts, CV_RANSAC); perspectiveTransform( object, object_transformed, homography); } // being here means we have found a decent match objectLifeTime += 0.05; } else { // we haven't found a decent match objectLifeTime -= 0.05; } if(objectLifeTime > 1) { objectLifeTime = 1; } else if( objectLifeTime < 0) { objectLifeTime = 0; } }
void AAM::countA() { Mat deltaC; Mat deltaI; for(int i=0; i<this->shapeSet.rows; i++) { for(int j=0; j<100; j++) { Mat ds=randomPointsMat(40, this->shapeSet.cols); cout<<"random ds: "<<ds<<endl; ds.convertTo(ds, this->shapeSet.type()); Mat newShape=ds+this->shapeSet.row(i); newShape.convertTo(newShape, meanShape.type()); Mat newShapeParams=newShape-meanShape; newShapeParams=newShapeParams*this->w; Mat image_grey; cvtColor(this->images[i], image_grey, COLOR_BGR2GRAY); Mat newTexture=this->getTetureInShape(image_grey, newShape); newTexture.convertTo(newTexture, meanTexture.type()); Mat newDeltaTexture=newTexture - meanTexture; Mat newTextureParams=this->textureVariationPCA.project(newDeltaTexture); Mat newAp; newShapeParams.convertTo(newShapeParams, newTextureParams.type()); hconcat(newShapeParams, newTextureParams, newAp); cout<<"new appearance: " <<newAp<<endl; Mat c=this->appearancePCA.project(newAp); cout<<"new c: "<<c<<endl; c.convertTo(c, cSet.type()); Mat dc=this->cSet.row(i)-c; cout<<"dc: "<<dc<<endl; Mat ap = this->appearancePCA.backProject(c); CvMat apMat=ap; cout<<"appearance: "<<ap<<endl; CvMat shapeParams; cvGetCols(&apMat, &shapeParams, 0, shapeSet.cols); cout<<"shape: "<<endl; Mat shape=cvarrToMat(&shapeParams); cout<<"shapeParams: "<<shape<<endl; shape=shape/this->w; cout<<"shapeParams scaled: "<<shape<<endl; CvMat textureParams; cvGetCols(&apMat, &textureParams, shapeSet.cols, shapeSet.cols+this->b_g.cols); Mat texture=cvarrToMat(&textureParams); cout<<"texture Params: "<<texture<<endl; shape.convertTo(shape, meanShape.type()); Mat modelShape=this->meanShape + shape; modelShape=this->cutToRange(modelShape, 0, this->ImageHeight); cout<<"modelShape: "<<modelShape<<endl; Mat backProjectShape=this->textureVariationPCA.backProject(texture); backProjectShape.convertTo(backProjectShape, meanTexture.type()); Mat modelTexture=this->meanTexture + backProjectShape; modelTexture.convertTo(modelTexture, CV_8U); modelTexture.convertTo(modelTexture, CV_32S); //cout<<"modelTexture: "<<modelTexture<<endl; Mat warped=this->warpImage(this->images[i], modelShape); cvtColor(warped, image_grey, COLOR_BGR2GRAY); Mat convHull = this->createConvexHull(this->meanPoints); Mat realTexture=this->getTextureInsideHull(image_grey, convHull); Mat realTextureSampled=this->sampleMat(realTexture, sampling); normalize(realTextureSampled, realTextureSampled, 0, 255, NORM_MINMAX); cout<<realTexture.cols<<" "<<realTextureSampled.cols<<" "<<modelTexture.cols<<endl; realTextureSampled.convertTo(realTextureSampled, modelTexture.type()); Mat dI=realTextureSampled-modelTexture; deltaC.push_back(dc); deltaI.push_back(dI); } } cout<<"deltaI : " <<deltaI<<endl; cout<<"deltaC: "<<deltaC<<endl; this->A=this->findLinearAproximation(deltaI, deltaC); Mat deltaItest; deltaI.row(0).convertTo(deltaItest, A.type()); cout<<"delta I row: "<<deltaItest.row(0)<<endl; cout<<"delta c row: "<<deltaC.row(0)<<endl; //cout<<this->A.type()<<endl; //cout<<deltaI.type()<<endl; Mat result=deltaItest.row(0)*A; cout<<result<<endl; }
vector<Point> AAM::findPoints(Mat image) { float k=10; int i=0; Mat convHull = this->createConvexHull(this->meanPoints); Mat points; cout<<"mean shape"<<this->meanShape<<endl; this->meanShape.copyTo(points); cout<<"initial shape"<<points<<endl; Mat deltaG; double normE0; Mat c; do { cout<<"iteration "<<i<<endl; cout<<"start Points: "<<points<<endl; k=1; //this->drawPoints(image, points, QString::number(i).toStdString()); Mat textureSampled=this->getTetureInShape(image, points); textureSampled.convertTo(textureSampled, CV_32S); this->meanTexture.convertTo(meanTexture, CV_32S); Mat deltaT = textureSampled - this->meanTexture; points.convertTo(points, meanShape.type()); Mat deltaPoint = points-meanShape; // cout<<"deltaPoint: "<<deltaPoint<<endl; deltaPoint=deltaPoint*this->w; // cout<<"deltaPoint: "<<deltaPoint<<endl; Mat b=this->textureVariationPCA.project(deltaT); // cout<<"b for texture: "<<b<<endl; Mat ap; deltaPoint.convertTo(deltaPoint, b.type()); hconcat(deltaPoint, b, ap); // cout<<"appearance: "<<ap<<endl; c= this->appearancePCA.project(ap); // cout<<"c: "<<c<<endl; Mat modelAp=this->appearancePCA.backProject(c); // cout<<"model appearance: "<<modelAp<<endl; CvMat bModelMat; CvMat modelApMat=modelAp; cvGetCols(&modelApMat, &bModelMat, this->shapeSet.cols, this->shapeSet.cols + this->b_g.cols); Mat bModel=cvarrToMat(&bModelMat); bModel.convertTo(bModel, CV_32F); // cout<<"b model"<<bModel<<endl; Mat deltaGModel=this->textureVariationPCA.backProject(bModel); // cout<<"delta g model: "<<deltaGModel<<endl; deltaGModel.convertTo(deltaGModel, this->meanTexture.type()); Mat textureModel=this->meanTexture + deltaGModel; textureModel.convertTo(textureModel, CV_8U); textureModel.convertTo(textureModel, CV_32S); // cout<<"texture model: "<<textureModel<<endl; Mat modelShape=this->getShapeParamsFromC(c); modelShape.convertTo(modelShape, this->meanShape.type()); modelShape=meanShape + modelShape; modelShape=this->cutToRange(modelShape, 0, this->ImageHeight); // cout<<"model shape: "<<modelShape<<endl; Mat realTexture=this->getTetureInShape(image, modelShape); realTexture.convertTo(realTexture, textureModel.type()); // cout<<"real texture"<<realTexture<<endl; Mat deltaI=realTexture-textureModel; // cout<<"deltaI: "<<deltaI<<endl; deltaI.convertTo(deltaI, CV_32F); Mat deltaC=deltaI*this->A; cout<<"delta c"<<deltaC<<endl; c.convertTo(c, deltaC.type()); normE0=this->euqlidesNorm(deltaI); double normE=normE0; Mat newC; while(normE0<=normE && k>0.0001) //sprawdzić, czy deltaG jest mniejsze niż deltaG0 { // cout<<"k "<<k<<endl; newC=c+k*deltaC; cout<<"newc: "<<newC<<endl; Mat shapeParams=this->getShapeParamsFromC(newC); Mat textureParams=this->getTextureParamsFromC(newC); Mat textureDelta=this->textureVariationPCA.backProject(textureParams); textureDelta.convertTo(textureDelta, meanTexture.type()); Mat texture=meanTexture + textureDelta; shapeParams.convertTo(shapeParams, meanShape.type()); points=meanShape + shapeParams; points=this->cutToRange(points, 0, this->ImageHeight); Mat realTexture=this->getTetureInShape(image, points); texture.convertTo(texture, realTexture.type()); deltaI=realTexture - texture; normE=this->euqlidesNorm(deltaI); k=k/2; } i++; newC.copyTo(c); normE0=normE; cout<<"points: "<<points<<endl; cout<<"error: "<<normE0<<endl; } while(i<30); // sprwdzić, czy błąd deltaG jest mniejszy od maxymalnego błędu this->drawPoints(image, points, "final points"); cout<<"final points: "<<points<<endl; cout<<"mean: "<<this->meanShape<<endl; return this->convertMatToPoints(points); }
/** * Read an image into memory and return the information * * @param[in] filename File to load * @param[in] flags Flags * @param[in] hdrtype { LOAD_CVMAT=0, * LOAD_IMAGE=1, * LOAD_MAT=2 * } * @param[in] mat Reference to C++ Mat object (If LOAD_MAT) * @param[in] scale_denom Scale value * */ static void* imread_( const String& filename, int flags, int hdrtype, Mat* mat=0 ) { IplImage* image = 0; CvMat *matrix = 0; Mat temp, *data = &temp; /// Search for the relevant decoder to handle the imagery ImageDecoder decoder; #ifdef HAVE_GDAL if(flags != IMREAD_UNCHANGED && (flags & IMREAD_LOAD_GDAL) == IMREAD_LOAD_GDAL ){ decoder = GdalDecoder().newDecoder(); }else{ #endif decoder = findDecoder( filename ); #ifdef HAVE_GDAL } #endif /// if no decoder was found, return nothing. if( !decoder ){ return 0; } int scale_denom = 1; if( flags > IMREAD_LOAD_GDAL ) { if( flags & IMREAD_REDUCED_GRAYSCALE_2 ) scale_denom = 2; else if( flags & IMREAD_REDUCED_GRAYSCALE_4 ) scale_denom = 4; else if( flags & IMREAD_REDUCED_GRAYSCALE_8 ) scale_denom = 8; } /// set the scale_denom in the driver decoder->setScale( scale_denom ); /// set the filename in the driver decoder->setSource( filename ); // read the header to make sure it succeeds if( !decoder->readHeader() ) return 0; // established the required input image size CvSize size; size.width = decoder->width(); size.height = decoder->height(); // grab the decoded type int type = decoder->type(); if( (flags & IMREAD_LOAD_GDAL) != IMREAD_LOAD_GDAL && flags != IMREAD_UNCHANGED ) { if( (flags & CV_LOAD_IMAGE_ANYDEPTH) == 0 ) type = CV_MAKETYPE(CV_8U, CV_MAT_CN(type)); if( (flags & CV_LOAD_IMAGE_COLOR) != 0 || ((flags & CV_LOAD_IMAGE_ANYCOLOR) != 0 && CV_MAT_CN(type) > 1) ) type = CV_MAKETYPE(CV_MAT_DEPTH(type), 3); else type = CV_MAKETYPE(CV_MAT_DEPTH(type), 1); } if( hdrtype == LOAD_CVMAT || hdrtype == LOAD_MAT ) { if( hdrtype == LOAD_CVMAT ) { matrix = cvCreateMat( size.height, size.width, type ); temp = cvarrToMat( matrix ); } else { mat->create( size.height, size.width, type ); data = mat; } } else { image = cvCreateImage( size, cvIplDepth(type), CV_MAT_CN(type) ); temp = cvarrToMat( image ); } // read the image data if( !decoder->readData( *data )) { cvReleaseImage( &image ); cvReleaseMat( &matrix ); if( mat ) mat->release(); return 0; } if( decoder->setScale( scale_denom ) > 1 ) // if decoder is JpegDecoder then decoder->setScale always returns 1 { resize( *mat, *mat, Size( size.width / scale_denom, size.height / scale_denom ) ); } return hdrtype == LOAD_CVMAT ? (void*)matrix : hdrtype == LOAD_IMAGE ? (void*)image : (void*)mat; }