void Feature2D::compute( InputArrayOfArrays _images, std::vector<std::vector<KeyPoint> >& keypoints, OutputArrayOfArrays _descriptors ) { CV_INSTRUMENT_REGION(); if( !_descriptors.needed() ) return; vector<Mat> images; _images.getMatVector(images); size_t i, nimages = images.size(); CV_Assert( keypoints.size() == nimages ); CV_Assert( _descriptors.kind() == _InputArray::STD_VECTOR_MAT ); vector<Mat>& descriptors = *(vector<Mat>*)_descriptors.getObj(); descriptors.resize(nimages); for( i = 0; i < nimages; i++ ) { compute(images[i], keypoints[i], descriptors[i]); } }
// Reconstruction function for API void reconstruct(const InputArrayOfArrays points2d, OutputArrayOfArrays projection_matrices, OutputArray points3d, bool is_projective, bool has_outliers, bool is_sequence) { int nviews = points2d.total(); cv::Mat F; // OpenCV data types std::vector<cv::Mat> pts2d; points2d.getMatVector(pts2d); int depth = pts2d[0].depth(); // Projective reconstruction if (is_projective) { // Two view reconstruction if (nviews == 2) { // Get fundamental matrix fundamental8Point(pts2d[0], pts2d[1], F, has_outliers); // Get Projection matrices cv::Mat P, Pp; projectionsFromFundamental(F, P, Pp); projection_matrices.create(2, 1, depth); P.copyTo(projection_matrices.getMatRef(0)); Pp.copyTo(projection_matrices.getMatRef(1)); // Triangulate and find 3D points using inliers triangulatePoints(points2d, projection_matrices, points3d); } } // Affine reconstruction else { // Two view reconstruction if (nviews == 2) { } else { } } }
void cv::split(InputArray _m, OutputArrayOfArrays _mv) { Mat m = _m.getMat(); if( m.empty() ) { _mv.release(); return; } CV_Assert( !_mv.fixedType() || CV_MAT_TYPE(_mv.flags) == m.depth() ); _mv.create(m.channels(), 1, m.depth()); Mat* dst = &_mv.getMatRef(0); split(m, dst); }
// Computes the shadows occlusion where we cannot reconstruct the model void GrayCodePattern_Impl::computeShadowMasks( InputArrayOfArrays blackImages, InputArrayOfArrays whiteImages, OutputArrayOfArrays shadowMasks ) const { std::vector<Mat>& whiteImages_ = *( std::vector<Mat>* ) whiteImages.getObj(); std::vector<Mat>& blackImages_ = *( std::vector<Mat>* ) blackImages.getObj(); std::vector<Mat>& shadowMasks_ = *( std::vector<Mat>* ) shadowMasks.getObj(); shadowMasks_.resize( whiteImages_.size() ); int cam_width = whiteImages_[0].cols; int cam_height = whiteImages_[0].rows; // TODO: parallelize for for( int k = 0; k < (int) shadowMasks_.size(); k++ ) { shadowMasks_[k] = Mat( cam_height, cam_width, CV_8U ); for( int i = 0; i < cam_width; i++ ) { for( int j = 0; j < cam_height; j++ ) { double white = whiteImages_[k].at<uchar>( Point( i, j ) ); double black = blackImages_[k].at<uchar>( Point( i, j ) ); if( abs(white - black) > blackThreshold ) { shadowMasks_[k].at<uchar>( Point( i, j ) ) = ( uchar ) 1; } else { shadowMasks_[k].at<uchar>( Point( i, j ) ) = ( uchar ) 0; } } } } }
double mycalibrateCamera( InputArrayOfArrays _objectPoints, InputArrayOfArrays _imagePoints, Size imageSize, InputOutputArray _cameraMatrix, InputOutputArray _distCoeffs, OutputArrayOfArrays _rvecs, OutputArrayOfArrays _tvecs, int flags, TermCriteria criteria ) { int rtype = CV_64F; Mat cameraMatrix = _cameraMatrix.getMat(); cameraMatrix = prepareCameraMatrix(cameraMatrix, rtype); Mat distCoeffs = _distCoeffs.getMat(); distCoeffs = prepareDistCoeffs(distCoeffs, rtype); if( !(flags & CALIB_RATIONAL_MODEL) ) distCoeffs = distCoeffs.rows == 1 ? distCoeffs.colRange(0, 5) : distCoeffs.rowRange(0, 5); int i; size_t nimages = _objectPoints.total(); CV_Assert( nimages > 0 ); Mat objPt, imgPt, npoints, rvecM((int)nimages, 3, CV_64FC1), tvecM((int)nimages, 3, CV_64FC1); collectCalibrationData( _objectPoints, _imagePoints, noArray(), objPt, imgPt, 0, npoints ); CvMat c_objPt = objPt, c_imgPt = imgPt, c_npoints = npoints; CvMat c_cameraMatrix = cameraMatrix, c_distCoeffs = distCoeffs; CvMat c_rvecM = rvecM, c_tvecM = tvecM; double reprojErr = cvCalibrateCamera2(&c_objPt, &c_imgPt, &c_npoints, imageSize, &c_cameraMatrix, &c_distCoeffs, &c_rvecM, &c_tvecM, flags, criteria ); bool rvecs_needed = _rvecs.needed(), tvecs_needed = _tvecs.needed(); if( rvecs_needed ) _rvecs.create((int)nimages, 1, CV_64FC3); if( tvecs_needed ) _tvecs.create((int)nimages, 1, CV_64FC3); for( i = 0; i < (int)nimages; i++ ) { if( rvecs_needed ) { _rvecs.create(3, 1, CV_64F, i, true); Mat rv = _rvecs.getMat(i); memcpy(rv.data, rvecM.ptr<double>(i), 3*sizeof(double)); } if( tvecs_needed ) { _tvecs.create(3, 1, CV_64F, i, true); Mat tv = _tvecs.getMat(i); memcpy(tv.data, tvecM.ptr<double>(i), 3*sizeof(double)); } } cameraMatrix.copyTo(_cameraMatrix); distCoeffs.copyTo(_distCoeffs); return reprojErr; }
void DescriptorExtractor::compute( InputArrayOfArrays _imageCollection, std::vector<std::vector<KeyPoint> >& pointCollection, OutputArrayOfArrays _descCollection ) const { std::vector<Mat> imageCollection, descCollection; _imageCollection.getMatVector(imageCollection); _descCollection.getMatVector(descCollection); CV_Assert( imageCollection.size() == pointCollection.size() ); descCollection.resize( imageCollection.size() ); for( size_t i = 0; i < imageCollection.size(); i++ ) compute( imageCollection[i], pointCollection[i], descCollection[i] ); }
bool forward_ocl(InputArrayOfArrays inps, OutputArrayOfArrays outs, OutputArrayOfArrays internals) { std::vector<UMat> inputs; std::vector<UMat> outputs; inps.getUMatVector(inputs); outs.getUMatVector(outputs); for (size_t i = 0; i < inputs.size(); i++) { UMat srcBlob = inputs[i]; void *src_handle = inputs[i].handle(ACCESS_READ); void *dst_handle = outputs[i].handle(ACCESS_WRITE); if (src_handle != dst_handle) { MatShape outShape = shape(outputs[i]); UMat umat = srcBlob.reshape(1, (int)outShape.size(), &outShape[0]); umat.copyTo(outputs[i]); } } outs.assign(outputs); return true; }
int solveP3P( InputArray _opoints, InputArray _ipoints, InputArray _cameraMatrix, InputArray _distCoeffs, OutputArrayOfArrays _rvecs, OutputArrayOfArrays _tvecs, int flags) { CV_INSTRUMENT_REGION(); Mat opoints = _opoints.getMat(), ipoints = _ipoints.getMat(); int npoints = std::max(opoints.checkVector(3, CV_32F), opoints.checkVector(3, CV_64F)); CV_Assert( npoints == 3 && npoints == std::max(ipoints.checkVector(2, CV_32F), ipoints.checkVector(2, CV_64F)) ); CV_Assert( flags == SOLVEPNP_P3P || flags == SOLVEPNP_AP3P ); Mat cameraMatrix0 = _cameraMatrix.getMat(); Mat distCoeffs0 = _distCoeffs.getMat(); Mat cameraMatrix = Mat_<double>(cameraMatrix0); Mat distCoeffs = Mat_<double>(distCoeffs0); Mat undistortedPoints; undistortPoints(ipoints, undistortedPoints, cameraMatrix, distCoeffs); std::vector<Mat> Rs, ts; int solutions = 0; if (flags == SOLVEPNP_P3P) { p3p P3Psolver(cameraMatrix); solutions = P3Psolver.solve(Rs, ts, opoints, undistortedPoints); } else if (flags == SOLVEPNP_AP3P) { ap3p P3Psolver(cameraMatrix); solutions = P3Psolver.solve(Rs, ts, opoints, undistortedPoints); } if (solutions == 0) { return 0; } if (_rvecs.needed()) { _rvecs.create(solutions, 1, CV_64F); } if (_tvecs.needed()) { _tvecs.create(solutions, 1, CV_64F); } for (int i = 0; i < solutions; i++) { Mat rvec; Rodrigues(Rs[i], rvec); _tvecs.getMatRef(i) = ts[i]; _rvecs.getMatRef(i) = rvec; } return solutions; }
bool forward_ocl(InputArrayOfArrays inps, OutputArrayOfArrays outs, OutputArrayOfArrays internals) { std::vector<UMat> inputs; std::vector<UMat> outputs; inps.getUMatVector(inputs); outs.getUMatVector(outputs); int _layerWidth = inputs[0].size[3]; int _layerHeight = inputs[0].size[2]; int _imageWidth = inputs[1].size[3]; int _imageHeight = inputs[1].size[2]; float stepX, stepY; if (_stepX == 0 || _stepY == 0) { stepX = static_cast<float>(_imageWidth) / _layerWidth; stepY = static_cast<float>(_imageHeight) / _layerHeight; } else { stepX = _stepX; stepY = _stepY; } if (umat_offsetsX.empty()) { Mat offsetsX(1, _offsetsX.size(), CV_32FC1, &_offsetsX[0]); Mat offsetsY(1, _offsetsX.size(), CV_32FC1, &_offsetsY[0]); Mat aspectRatios(1, _aspectRatios.size(), CV_32FC1, &_aspectRatios[0]); Mat variance(1, _variance.size(), CV_32FC1, &_variance[0]); offsetsX.copyTo(umat_offsetsX); offsetsY.copyTo(umat_offsetsY); aspectRatios.copyTo(umat_aspectRatios); variance.copyTo(umat_variance); int real_numPriors = _numPriors >> (_offsetsX.size() - 1); umat_scales = UMat(1, &real_numPriors, CV_32F, 1.0f); }
bool forward_ocl(InputArrayOfArrays inps, OutputArrayOfArrays outs, OutputArrayOfArrays internals) { std::vector<UMat> inputs; std::vector<UMat> outputs; inps.getUMatVector(inputs); outs.getUMatVector(outputs); if (useSoftmaxTree) { // Yolo 9000 CV_Error(cv::Error::StsNotImplemented, "Yolo9000 is not implemented"); return false; } CV_Assert(inputs.size() >= 1); int const cell_size = classes + coords + 1; UMat blob_umat = blobs[0].getUMat(ACCESS_READ); for (size_t ii = 0; ii < outputs.size(); ii++) { UMat& inpBlob = inputs[ii]; UMat& outBlob = outputs[ii]; int rows = inpBlob.size[1]; int cols = inpBlob.size[2]; ocl::Kernel logistic_kernel("logistic_activ", ocl::dnn::region_oclsrc); size_t global = rows*cols*anchors; logistic_kernel.set(0, (int)global); logistic_kernel.set(1, ocl::KernelArg::PtrReadOnly(inpBlob)); logistic_kernel.set(2, (int)cell_size); logistic_kernel.set(3, ocl::KernelArg::PtrWriteOnly(outBlob)); logistic_kernel.run(1, &global, NULL, false); if (useSoftmax) { // Yolo v2 // softmax activation for Probability, for each grid cell (X x Y x Anchor-index) ocl::Kernel softmax_kernel("softmax_activ", ocl::dnn::region_oclsrc); size_t nthreads = rows*cols*anchors; softmax_kernel.set(0, (int)nthreads); softmax_kernel.set(1, ocl::KernelArg::PtrReadOnly(inpBlob)); softmax_kernel.set(2, ocl::KernelArg::PtrReadOnly(blob_umat)); softmax_kernel.set(3, (int)cell_size); softmax_kernel.set(4, (int)classes); softmax_kernel.set(5, (int)classfix); softmax_kernel.set(6, (int)rows); softmax_kernel.set(7, (int)cols); softmax_kernel.set(8, (int)anchors); softmax_kernel.set(9, (float)thresh); softmax_kernel.set(10, ocl::KernelArg::PtrWriteOnly(outBlob)); if (!softmax_kernel.run(1, &nthreads, NULL, false)) return false; } if (nmsThreshold > 0) { Mat mat = outBlob.getMat(ACCESS_WRITE); float *dstData = mat.ptr<float>(); do_nms_sort(dstData, rows*cols*anchors, thresh, nmsThreshold); } } return true; }
bool GrayCodePattern_Impl::generate( OutputArrayOfArrays pattern ) { std::vector<Mat>& pattern_ = *( std::vector<Mat>* ) pattern.getObj(); pattern_.resize( numOfPatternImages ); for( size_t i = 0; i < numOfPatternImages; i++ ) { pattern_[i] = Mat( params.height, params.width, CV_8U ); } uchar flag = 0; for( int j = 0; j < params.width; j++ ) // rows loop { int rem = 0, num = j, prevRem = j % 2; for( size_t k = 0; k < numOfColImgs; k++ ) // images loop { num = num / 2; rem = num % 2; if( ( rem == 0 && prevRem == 1 ) || ( rem == 1 && prevRem == 0) ) { flag = 1; } else { flag = 0; } for( int i = 0; i < params.height; i++ ) // rows loop { uchar pixel_color = ( uchar ) flag * 255; pattern_[2 * numOfColImgs - 2 * k - 2].at<uchar>( i, j ) = pixel_color; if( pixel_color > 0 ) pixel_color = ( uchar ) 0; else pixel_color = ( uchar ) 255; pattern_[2 * numOfColImgs - 2 * k - 1].at<uchar>( i, j ) = pixel_color; // inverse } prevRem = rem; } } for( int i = 0; i < params.height; i++ ) // rows loop { int rem = 0, num = i, prevRem = i % 2; for( size_t k = 0; k < numOfRowImgs; k++ ) { num = num / 2; rem = num % 2; if( (rem == 0 && prevRem == 1) || (rem == 1 && prevRem == 0) ) { flag = 1; } else { flag = 0; } for( int j = 0; j < params.width; j++ ) { uchar pixel_color = ( uchar ) flag * 255; pattern_[2 * numOfRowImgs - 2 * k + 2 * numOfColImgs - 2].at<uchar>( i, j ) = pixel_color; if( pixel_color > 0 ) pixel_color = ( uchar ) 0; else pixel_color = ( uchar ) 255; pattern_[2 * numOfRowImgs - 2 * k + 2 * numOfColImgs - 1].at<uchar>( i, j ) = pixel_color; } prevRem = rem; } } return true; }
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; }
bool forward_ocl(InputArrayOfArrays inps, OutputArrayOfArrays outs, OutputArrayOfArrays internals) { std::vector<UMat> inputs; std::vector<UMat> outputs; bool use_half = (inps.depth() == CV_16S); inps.getUMatVector(inputs); outs.getUMatVector(outputs); int _layerWidth = inputs[0].size[3]; int _layerHeight = inputs[0].size[2]; int _imageWidth = inputs[1].size[3]; int _imageHeight = inputs[1].size[2]; if (umat_offsetsX.empty()) { Mat offsetsX(1, _offsetsX.size(), CV_32FC1, &_offsetsX[0]); Mat offsetsY(1, _offsetsY.size(), CV_32FC1, &_offsetsY[0]); Mat variance(1, _variance.size(), CV_32FC1, &_variance[0]); Mat widths(1, _boxWidths.size(), CV_32FC1, &_boxWidths[0]); Mat heights(1, _boxHeights.size(), CV_32FC1, &_boxHeights[0]); offsetsX.copyTo(umat_offsetsX); offsetsY.copyTo(umat_offsetsY); variance.copyTo(umat_variance); widths.copyTo(umat_widths); heights.copyTo(umat_heights); } String opts; if (use_half) opts = "-DDtype=half -DDtype4=half4 -Dconvert_T=convert_half4"; else opts = "-DDtype=float -DDtype4=float4 -Dconvert_T=convert_float4"; size_t nthreads = _layerHeight * _layerWidth; ocl::Kernel kernel("prior_box", ocl::dnn::prior_box_oclsrc, opts); kernel.set(0, (int)nthreads); kernel.set(1, (float)_stepX); kernel.set(2, (float)_stepY); kernel.set(3, ocl::KernelArg::PtrReadOnly(umat_offsetsX)); kernel.set(4, ocl::KernelArg::PtrReadOnly(umat_offsetsY)); kernel.set(5, (int)_offsetsX.size()); kernel.set(6, ocl::KernelArg::PtrReadOnly(umat_widths)); kernel.set(7, ocl::KernelArg::PtrReadOnly(umat_heights)); kernel.set(8, (int)_boxWidths.size()); kernel.set(9, ocl::KernelArg::PtrWriteOnly(outputs[0])); kernel.set(10, (int)_layerHeight); kernel.set(11, (int)_layerWidth); kernel.set(12, (int)_imageHeight); kernel.set(13, (int)_imageWidth); kernel.run(1, &nthreads, NULL, false); // clip the prior's coordidate such that it is within [0, 1] if (_clip) { Mat mat = outputs[0].getMat(ACCESS_READ); int aspect_count = (_maxSize > 0) ? 1 : 0; int offset = nthreads * 4 * _offsetsX.size() * (1 + aspect_count + _aspectRatios.size()); float* outputPtr = mat.ptr<float>() + offset; int _outChannelSize = _layerHeight * _layerWidth * _numPriors * 4; for (size_t d = 0; d < _outChannelSize; ++d) { outputPtr[d] = std::min<float>(std::max<float>(outputPtr[d], 0.), 1.); } } // set the variance. { ocl::Kernel kernel("set_variance", ocl::dnn::prior_box_oclsrc, opts); int offset = total(shape(outputs[0]), 2); size_t nthreads = _layerHeight * _layerWidth * _numPriors; kernel.set(0, (int)nthreads); kernel.set(1, (int)offset); kernel.set(2, (int)_variance.size()); kernel.set(3, ocl::KernelArg::PtrReadOnly(umat_variance)); kernel.set(4, ocl::KernelArg::PtrWriteOnly(outputs[0])); if (!kernel.run(1, &nthreads, NULL, false)) return false; } return true; }
bool forward_ocl(InputArrayOfArrays inputs_, OutputArrayOfArrays outputs_, OutputArrayOfArrays internals_) { std::vector<UMat> inputs; std::vector<UMat> outputs; std::vector<UMat> internals; inputs_.getUMatVector(inputs); outputs_.getUMatVector(outputs); internals_.getUMatVector(internals); CV_Assert(inputs.size() == 1 && outputs.size() == 1); CV_Assert(inputs[0].total() == outputs[0].total()); const UMat& inp0 = inputs[0]; UMat& buffer = internals[0]; size_t num = inp0.size[0]; size_t channels = inp0.size[1]; size_t channelSize = inp0.total() / (num * channels); for (size_t i = 0; i < num; ++i) { MatShape s = shape(channels, channelSize); UMat src = inputs[i].reshape(1, s.size(), &s[0]); UMat dst = outputs[i].reshape(1, s.size(), &s[0]); UMat abs_mat; absdiff(src, cv::Scalar::all(0), abs_mat); pow(abs_mat, pnorm, buffer); if (acrossSpatial) { // add eps to avoid overflow float absSum = sum(buffer)[0] + epsilon; float norm = pow(absSum, 1.0f / pnorm); multiply(src, 1.0f / norm, dst); } else { Mat norm; reduce(buffer, norm, 0, REDUCE_SUM); norm += epsilon; // compute inverted norm to call multiply instead divide cv::pow(norm, -1.0f / pnorm, norm); repeat(norm, channels, 1, buffer); multiply(src, buffer, dst); } if (!blobs.empty()) { // scale the output Mat scale = blobs[0]; if (scale.total() == 1) { // _scale: 1 x 1 multiply(dst, scale.at<float>(0, 0), dst); } else { // _scale: _channels x 1 CV_Assert(scale.total() == channels); repeat(scale, 1, dst.cols, buffer); multiply(dst, buffer, dst); } } } return true; }