void AdaptiveManifoldFilterN::initSrcAndJoint(InputArray src_, InputArray joint_) { srcSize = src_.size(); smallSize = getSmallSize(); srcCnNum = src_.channels(); split(src_, srcCn); if (src_.depth() != CV_32F) { for (int i = 0; i < srcCnNum; i++) srcCn[i].convertTo(srcCn[i], CV_32F); } if (joint_.empty() || joint_.getObj() == src_.getObj()) { jointCnNum = srcCnNum; if (src_.depth() == CV_32F) { jointCn = srcCn; } else { jointCn.resize(jointCnNum); for (int i = 0; i < jointCnNum; i++) srcCn[i].convertTo(jointCn[i], CV_32F, getNormalizer(src_.depth())); } } else { splitChannels(joint_, jointCn); jointCnNum = (int)jointCn.size(); int jointDepth = jointCn[0].depth(); Size jointSize = jointCn[0].size(); CV_Assert( jointSize == srcSize && (jointDepth == CV_8U || jointDepth == CV_16U || jointDepth == CV_32F) ); if (jointDepth != CV_32F) { for (int i = 0; i < jointCnNum; i++) jointCn[i].convertTo(jointCn[i], CV_32F, getNormalizer(jointDepth)); } } }
static std::vector<Mat> extractMatVector(InputArray in) { if (in.isMat() || in.isUMat()) { return std::vector<Mat>(1, in.getMat()); } else if (in.isMatVector()) { return *static_cast<const std::vector<Mat>*>(in.getObj()); } else if (in.isUMatVector()) { std::vector<Mat> vmat; in.getMatVector(vmat); return vmat; } else { CV_Assert(in.isMat() || in.isMatVector() || in.isUMat() || in.isUMatVector()); return std::vector<Mat>(); } }
void cv::viz::writeTrajectory(InputArray _traj, const String& files_format, int start, const String& tag) { if (_traj.kind() == _InputArray::STD_VECTOR_MAT) { #if CV_MAJOR_VERSION < 3 std::vector<Mat>& v = *(std::vector<Mat>*)_traj.obj; #else std::vector<Mat>& v = *(std::vector<Mat>*)_traj.getObj(); #endif for(size_t i = 0, index = max(0, start); i < v.size(); ++i, ++index) { Affine3d affine; Mat pose = v[i]; CV_Assert(pose.type() == CV_32FC(16) || pose.type() == CV_64FC(16)); pose.copyTo(affine.matrix); writePose(cv::format(files_format.c_str(), index), affine, tag); } return; } if (_traj.kind() == _InputArray::STD_VECTOR || _traj.kind() == _InputArray::MAT) { CV_Assert(_traj.type() == CV_32FC(16) || _traj.type() == CV_64FC(16)); Mat traj = _traj.getMat(); if (traj.depth() == CV_32F) for(size_t i = 0, index = max(0, start); i < traj.total(); ++i, ++index) writePose(cv::format(files_format.c_str(), index), traj.at<Affine3f>((int)i), tag); if (traj.depth() == CV_64F) for(size_t i = 0, index = max(0, start); i < traj.total(); ++i, ++index) writePose(cv::format(files_format.c_str(), index), traj.at<Affine3d>((int)i), tag); return; } CV_Error(Error::StsError, "Unsupported array kind"); }
bool FacemarkKazemiImpl::fit(InputArray img, InputArray roi, OutputArrayOfArrays landmarks){ if(!isModelLoaded){ String error_message = "No model loaded. Aborting...."; CV_Error(Error::StsBadArg, error_message); return false; } Mat image = img.getMat(); std::vector<Rect> & faces = *(std::vector<Rect>*)roi.getObj(); std::vector<std::vector<Point2f> > & shapes = *(std::vector<std::vector<Point2f> >*) landmarks.getObj(); shapes.resize(faces.size()); if(image.empty()){ String error_message = "No image found.Aborting.."; CV_Error(Error::StsBadArg, error_message); return false; } if(faces.empty()){ String error_message = "No faces found.Aborting.."; CV_Error(Error::StsBadArg, error_message); return false; } if(meanshape.empty()||loaded_forests.empty()||loaded_pixel_coordinates.empty()){ String error_message = "Model not loaded properly.Aborting..."; CV_Error(Error::StsBadArg, error_message); return false; } if(loaded_forests.size()==0){ String error_message = "Model not loaded properly.Aboerting..."; CV_Error(Error::StsBadArg, error_message); return false; } if(loaded_pixel_coordinates.size()==0){ String error_message = "Model not loaded properly.Aboerting..."; CV_Error(Error::StsBadArg, error_message); return false; } vector< vector<int> > nearest_landmarks; findNearestLandmarks(nearest_landmarks); tree_node curr_node; vector<Point2f> pixel_relative; vector<int> pixel_intensity; Mat warp_mat; for(size_t e=0;e<faces.size();e++){ shapes[e]=meanshape; convertToActual(faces[e],warp_mat); for(size_t i=0;i<loaded_forests.size();i++){ pixel_intensity.clear(); pixel_relative = loaded_pixel_coordinates[i]; getRelativePixels(shapes[e],pixel_relative,nearest_landmarks[i]); getPixelIntensities(image,pixel_relative,pixel_intensity,faces[e]); for(size_t j=0;j<loaded_forests[i].size();j++){ regtree tree = loaded_forests[i][j]; curr_node = tree.nodes[0]; unsigned long curr_node_index = 0; while(curr_node.leaf.size()==0) { if ((float)pixel_intensity[(unsigned long)curr_node.split.index1] - (float)pixel_intensity[(unsigned long)curr_node.split.index2] > curr_node.split.thresh) { curr_node_index=left(curr_node_index); } else curr_node_index=right(curr_node_index); curr_node = tree.nodes[curr_node_index]; } for(size_t p=0;p<curr_node.leaf.size();p++){ shapes[e][p]=shapes[e][p] + curr_node.leaf[p]; } } } for(unsigned long j=0;j<shapes[e].size();j++){ Mat C = (Mat_<double>(3,1) << shapes[e][j].x, shapes[e][j].y, 1); Mat D = warp_mat*C; shapes[e][j].x=float(D.at<double>(0,0)); shapes[e][j].y=float(D.at<double>(1,0)); } } return true; }
void convexHull( InputArray _points, OutputArray _hull, bool clockwise, bool returnPoints ) { CV_INSTRUMENT_REGION() CV_Assert(_points.getObj() != _hull.getObj()); Mat points = _points.getMat(); int i, total = points.checkVector(2), depth = points.depth(), nout = 0; int miny_ind = 0, maxy_ind = 0; CV_Assert(total >= 0 && (depth == CV_32F || depth == CV_32S)); if( total == 0 ) { _hull.release(); return; } returnPoints = !_hull.fixedType() ? returnPoints : _hull.type() != CV_32S; bool is_float = depth == CV_32F; AutoBuffer<Point*> _pointer(total); AutoBuffer<int> _stack(total + 2), _hullbuf(total); Point** pointer = _pointer; Point2f** pointerf = (Point2f**)pointer; Point* data0 = points.ptr<Point>(); int* stack = _stack; int* hullbuf = _hullbuf; CV_Assert(points.isContinuous()); for( i = 0; i < total; i++ ) pointer[i] = &data0[i]; // sort the point set by x-coordinate, find min and max y if( !is_float ) { std::sort(pointer, pointer + total, CHullCmpPoints<int>()); for( i = 1; i < total; i++ ) { int y = pointer[i]->y; if( pointer[miny_ind]->y > y ) miny_ind = i; if( pointer[maxy_ind]->y < y ) maxy_ind = i; } } else { std::sort(pointerf, pointerf + total, CHullCmpPoints<float>()); for( i = 1; i < total; i++ ) { float y = pointerf[i]->y; if( pointerf[miny_ind]->y > y ) miny_ind = i; if( pointerf[maxy_ind]->y < y ) maxy_ind = i; } } if( pointer[0]->x == pointer[total-1]->x && pointer[0]->y == pointer[total-1]->y ) { hullbuf[nout++] = 0; } else { // upper half int *tl_stack = stack; int tl_count = !is_float ? Sklansky_( pointer, 0, maxy_ind, tl_stack, -1, 1) : Sklansky_( pointerf, 0, maxy_ind, tl_stack, -1, 1); int *tr_stack = stack + tl_count; int tr_count = !is_float ? Sklansky_( pointer, total-1, maxy_ind, tr_stack, -1, -1) : Sklansky_( pointerf, total-1, maxy_ind, tr_stack, -1, -1); // gather upper part of convex hull to output if( !clockwise ) { std::swap( tl_stack, tr_stack ); std::swap( tl_count, tr_count ); } for( i = 0; i < tl_count-1; i++ ) hullbuf[nout++] = int(pointer[tl_stack[i]] - data0); for( i = tr_count - 1; i > 0; i-- ) hullbuf[nout++] = int(pointer[tr_stack[i]] - data0); int stop_idx = tr_count > 2 ? tr_stack[1] : tl_count > 2 ? tl_stack[tl_count - 2] : -1; // lower half int *bl_stack = stack; int bl_count = !is_float ? Sklansky_( pointer, 0, miny_ind, bl_stack, 1, -1) : Sklansky_( pointerf, 0, miny_ind, bl_stack, 1, -1); int *br_stack = stack + bl_count; int br_count = !is_float ? Sklansky_( pointer, total-1, miny_ind, br_stack, 1, 1) : Sklansky_( pointerf, total-1, miny_ind, br_stack, 1, 1); if( clockwise ) { std::swap( bl_stack, br_stack ); std::swap( bl_count, br_count ); } if( stop_idx >= 0 ) { int check_idx = bl_count > 2 ? bl_stack[1] : bl_count + br_count > 2 ? br_stack[2-bl_count] : -1; if( check_idx == stop_idx || (check_idx >= 0 && pointer[check_idx]->x == pointer[stop_idx]->x && pointer[check_idx]->y == pointer[stop_idx]->y) ) { // if all the points lie on the same line, then // the bottom part of the convex hull is the mirrored top part // (except the exteme points). bl_count = MIN( bl_count, 2 ); br_count = MIN( br_count, 2 ); } } for( i = 0; i < bl_count-1; i++ ) hullbuf[nout++] = int(pointer[bl_stack[i]] - data0); for( i = br_count-1; i > 0; i-- ) hullbuf[nout++] = int(pointer[br_stack[i]] - data0); } if( !returnPoints ) Mat(nout, 1, CV_32S, hullbuf).copyTo(_hull); else { _hull.create(nout, 1, CV_MAKETYPE(depth, 2)); Mat hull = _hull.getMat(); size_t step = !hull.isContinuous() ? hull.step[0] : sizeof(Point); for( i = 0; i < nout; i++ ) *(Point*)(hull.ptr() + i*step) = data0[hullbuf[i]]; } }