struct TensorArray EM_getCovs(struct EMPtr ptr)
{
std::vector<cv::Mat> vec;
ptr->getCovs(vec);
std::vector<MatT> retval = get_vec_MatT(vec);
return TensorArray(retval);
}
struct TensorArray Rodrigues(
struct TensorWrapper src, struct TensorWrapper dst, struct TensorWrapper jacobian)
{
std::vector<MatT> result;
result[0] = dst.toMatT();
result[1] = jacobian.toMatT();
cv::Rodrigues(src.toMat(), result[0], result[1]);
return TensorArray(result);
}
struct TensorArray calcMotionGradient(
struct TensorWrapper mhi, struct TensorWrapper mask, struct TensorWrapper orientation,
double delta1, double delta2, int apertureSize)
{
std::vector<MatT> retval(2);
if (!mask.isNull()) retval[0] = mask.toMatT();
if (!orientation.isNull()) retval[1] = orientation.toMatT();
motempl::calcMotionGradient(mhi.toMat(), retval[0], retval[1], delta1, delta2, apertureSize);
return TensorArray(retval);
}
struct TensorArray Feature2DAsync_computeAsyncCuda(
struct cutorchInfo info, struct Feature2DAsyncPtr ptr, struct TensorWrapper image,
struct TensorWrapper keypoints, struct TensorWrapper descriptors)
{
std::vector<cuda::GpuMat> retval(2);
retval[0] = keypoints.toGpuMat();
retval[1] = descriptors.toGpuMat();
ptr->computeAsync(image.toGpuMat(), retval[0], retval[1], prepareStream(info));
return TensorArray(retval, info.state);
}
struct TensorArray createConcentricSpheresTestSet(
int nsamples, int nfeatures, int nclasses, struct TensorWrapper samples, struct TensorWrapper responses)
{
std::vector<MatT> retval(2);
retval[0] = samples.toMatT();
retval[1] = responses.toMatT();
ml::createConcentricSpheresTestSet(nsamples, nfeatures, nclasses, retval[0], retval[1]);
return TensorArray(retval);
}
struct TensorArray matMulDeriv(
struct TensorWrapper A, struct TensorWrapper B,
struct TensorWrapper dABdA, struct TensorWrapper dABdB)
{
std::vector<MatT> result(2);
result[0] = dABdA.toMatT();
result[1] = dABdB.toMatT();
cv::matMulDeriv(A.toMat(), B.toMat(), result[0], result[1]);
return TensorArray(result);
}
struct TensorArray findHomography2(
struct TensorWrapper srcPoints, struct TensorWrapper dstPoints,
struct TensorWrapper mask, int method, double ransacReprojThreshold)
{
std::vector<MatT> vec(2);
vec[1] = mask.toMatT();
vec[0] = MatT(cv::findHomography(srcPoints.toMat(), dstPoints.toMat(),
vec[1], method, ransacReprojThreshold));
return TensorArray(vec);
}
struct TensorArray findFundamentalMat2(
struct TensorWrapper points1, struct TensorWrapper points2,
struct TensorWrapper mask, int method, double param1, double param2)
{
std::vector<MatT> vec(2);
vec[1] = mask.toMatT();
vec[0] = MatT(cv::findFundamentalMat(points1.toMat(), points2.toMat(),
vec[1], method, param1, param2));
return TensorArray(vec);
}
struct TensorArray DenseOpticalFlowExt_calc(
struct DenseOpticalFlowExtPtr ptr, struct TensorWrapper frame0, struct TensorWrapper frame1,
struct TensorWrapper flow1, struct TensorWrapper flow2)
{
std::vector<cv::Mat> retval(2);
if (!flow1.isNull()) retval[0] = flow1;
if (!flow2.isNull()) retval[1] = flow2;
ptr->calc(frame0.toMat(), frame1.toMat(), retval[0], retval[1]);
return TensorArray(retval);
}
struct TensorArray decomposeEssentialMat(
struct TensorWrapper E, struct TensorWrapper R1,
struct TensorWrapper R2, struct TensorWrapper t)
{
std::vector<MatT> vec(3);
vec[0] = R1.toMatT();
vec[1] = R2.toMatT();
vec[2] = t.toMatT();
cv::decomposeEssentialMat(E.toMat(), vec[0], vec[1], vec[2]);
return TensorArray(vec);
}
struct TensorArray Index_knnSearch(
struct IndexPtr ptr, struct TensorWrapper query, int knn, struct TensorWrapper indices,
struct TensorWrapper dists, struct SearchParamsPtr params)
{
std::vector<cv::Mat> retval(2);
if (!indices.isNull()) retval[0] = indices;
if (!dists.isNull()) retval[1] = dists;
ptr->knnSearch(query.toMat(), retval[0], retval[1], knn, params);
return TensorArray(retval);
}
struct TensorArray correctMatches(
struct TensorWrapper F, struct TensorWrapper points1,
struct TensorWrapper points2, struct TensorWrapper newPoints1,
struct TensorWrapper newPoints2)
{
std::vector<MatT> vec(2);
vec[0] = newPoints1.toMatT();
vec[1] = newPoints2.toMatT();
cv::correctMatches(F.toMat(),
points1.toMat(), points2.toMat(), vec[0], vec[1]);
return TensorArray(vec);
}
struct TensorArray buildWarpPerspectiveMapsCuda(
struct cutorchInfo info, struct TensorWrapper M, bool inverse,
struct SizeWrapper dsize, struct TensorWrapper xmap, struct TensorWrapper ymap)
{
std::vector<cuda::GpuMat> retval(2);
retval[0] = xmap.toGpuMat();
retval[1] = ymap.toGpuMat();
cuda::buildWarpPerspectiveMaps(M.toGpuMat(), inverse, dsize,
retval[0], retval[1], prepareStream(info));
return TensorArray(retval, info.state);
}
struct TensorArray projectPoints(
struct TensorWrapper objectPoints, struct TensorWrapper rvec,
struct TensorWrapper tvec, struct TensorWrapper cameraMatrix,
struct TensorWrapper distCoeffs, struct TensorWrapper imagePoints,
struct TensorWrapper jacobian, double aspectRatio)
{
std::vector<MatT> result(2);
result[0] = imagePoints.toMatT();
result[1] = jacobian.toMatT();
cv::projectPoints(objectPoints.toMat(), rvec.toMat(), tvec.toMat(),
cameraMatrix.toMat(), distCoeffs.toMat(), result[0],
result[1], aspectRatio);
return TensorArray(result);
}
struct TensorArray fisheye_initUndistortRectifyMap(
struct TensorWrapper K, struct TensorWrapper D,
struct TensorWrapper R, struct TensorWrapper P,
struct SizeWrapper size, int m1type,
struct TensorWrapper map1, struct TensorWrapper map2)
{
std::vector<MatT> vec(2);
vec[0] = map1.toMatT();
vec[1] = map2.toMatT();
fisheye::initUndistortRectifyMap(K.toMat(), D.toMat(), R.toMat(), P.toMat(),
size, m1type, vec[0], vec[1]);
return TensorArray(vec);
}
struct TensorArray fisheye_projectPoints2(
struct TensorWrapper objectPoints, struct TensorWrapper imagePoints,
struct TensorWrapper rvec, struct TensorWrapper tvec,
struct TensorWrapper K, struct TensorWrapper D, double alpha,
struct TensorWrapper jacobian)
{
std::vector<MatT> vec(2);
vec[0] = imagePoints.toMatT();
vec[1] = jacobian.toMatT();
fisheye::projectPoints(objectPoints.toMat(), vec[0], rvec.toMat(),
tvec.toMat(), K.toMat(), D.toMat(), alpha, vec[1]);
return TensorArray(vec);
}
extern "C" struct TensorArray AlignMTB_process2(struct AlignMTBPtr ptr, struct TensorArray src, struct TensorArray dst)
{
if (dst.isNull()) {
auto retval = new std::vector<cv::Mat>(src);
ptr->process(src.toMatList(), *retval);
return TensorArray(*retval);
} else {
auto retval = new std::vector<cv::Mat>(dst);
ptr->process(src.toMatList(), *retval);
dst = *retval;
}
return dst;
}
extern "C" struct TensorArray AlignMTB_process1(struct AlignMTBPtr ptr, struct TensorArray src, struct TensorArray dst,
struct TensorWrapper times, struct TensorWrapper response)
{
if (dst.isNull()) {
auto retval = new std::vector<cv::Mat>(src);
ptr->process(src.toMatList(), *retval, times.toMat(), response.toMat());
return TensorArray(*retval);
} else {
auto retval = new std::vector<cv::Mat>(dst);
ptr->process(src.toMatList(), *retval, times.toMat(), response.toMat());
dst = *retval;
}
return dst;
}
struct TensorArray SparseOpticalFlow_calcCuda(struct cutorchInfo info,
struct SparseOpticalFlowPtr ptr, struct TensorWrapper prevImg, struct TensorWrapper nextImg,
struct TensorWrapper prevPts, struct TensorWrapper nextPts, struct TensorWrapper status,
bool outputErr, struct TensorWrapper err)
{
std::vector<cuda::GpuMat> retval(3);
retval[0] = nextPts.toGpuMat();
retval[1] = status.toGpuMat();
retval[2] = err.toGpuMat();
ptr->calc(prevImg.toGpuMat(), nextImg.toGpuMat(), prevPts.toGpuMat(),
retval[0], retval[1], outputErr ? retval[2] : cv::noArray(), prepareStream(info));
return TensorArray(retval, info.state);
}
extern "C" struct TensorArray calcOpticalFlowPyrLK(struct TensorWrapper prevImg,
struct TensorWrapper nextImg, struct TensorWrapper prevPts,
struct TensorWrapper nextPts, struct TensorWrapper status,
struct TensorWrapper err, struct SizeWrapper winSize, int maxLevel,
struct TermCriteriaWrapper criteria, int flags, double minEigThreshold)
{
std::vector<MatT> retval(3);
retval[1] = status.toMatT();
retval[2] = err.toMatT();
cv::calcOpticalFlowPyrLK(prevImg.toMat(), nextImg.toMat(), prevPts.toMat(), nextPts.toMat(), retval[1],
retval[2], winSize, maxLevel, criteria, flags, minEigThreshold);
retval[0] = MatT(nextPts);
return TensorArray(retval);
}
struct TensorArray KalmanFilter_getFields(struct KalmanFilterPtr ptr)
{
std::vector<MatT> retval(10);
retval[0] = MatT(ptr->statePre);
retval[1] = MatT(ptr->statePost);
retval[2] = MatT(ptr->transitionMatrix);
retval[3] = MatT(ptr->controlMatrix);
retval[4] = MatT(ptr->measurementMatrix);
retval[5] = MatT(ptr->processNoiseCov);
retval[6] = MatT(ptr->measurementNoiseCov);
retval[7] = MatT(ptr->errorCovPre);
retval[8] = MatT(ptr->gain);
retval[9] = MatT(ptr->errorCovPost);
return TensorArray(retval);
}
struct TensorArray decomposeProjectionMatrix(
struct TensorWrapper projMatrix, struct TensorWrapper cameraMatrix,
struct TensorWrapper rotMatrix, struct TensorWrapper transVect,
struct TensorWrapper rotMatrixX, struct TensorWrapper rotMatrixY,
struct TensorWrapper rotMatrixZ, struct TensorWrapper eulerAngles)
{
std::vector<MatT> vec(7);
vec[0] = cameraMatrix.toMatT();
vec[1] = rotMatrix.toMatT();
vec[2] = transVect.toMatT();
vec[3] = rotMatrixX.toMatT();
vec[4] = rotMatrixY.toMatT();
vec[5] = rotMatrixZ.toMatT();
vec[6] = eulerAngles.toMatT();
cv::decomposeProjectionMatrix(projMatrix.toMat(),
vec[0], vec[1], vec[2], vec[3], vec[4], vec[5], vec[6]);
return TensorArray(vec);
}
struct TensorArray fisheye_stereoRectify(
struct TensorWrapper K1, struct TensorWrapper D1,
struct TensorWrapper K2, struct TensorWrapper D2,
struct SizeWrapper imageSize, struct TensorWrapper R,
struct TensorWrapper tvec, struct TensorWrapper R1,
struct TensorWrapper R2, struct TensorWrapper P1,
struct TensorWrapper P2, struct TensorWrapper Q,
int flags, struct SizeWrapper newImageSize,
double balance, double fov_scale)
{
std::vector<MatT> vec(5);
vec[0] = R1.toMatT();
vec[1] = R2.toMatT();
vec[2] = P1.toMatT();
vec[3] = P2.toMatT();
vec[4] = Q.toMatT();
fisheye::stereoRectify(K1.toMat(), D1.toMat(), K2.toMat(), D2.toMat(),
imageSize, R.toMat(), tvec.toMat(), vec[0],
vec[1], vec[2], vec[3], vec[4], flags,
newImageSize, balance, fov_scale);
return TensorArray(vec);
}
struct TensorArray composeRT(
struct TensorWrapper rvec1, struct TensorWrapper tvec1, struct TensorWrapper rvec2,
struct TensorWrapper tvec2, struct TensorWrapper rvec3, struct TensorWrapper tvec3,
struct TensorWrapper dr3dr1, struct TensorWrapper dr3dt1, struct TensorWrapper dr3dr2,
struct TensorWrapper dr3dt2, struct TensorWrapper dt3dr1, struct TensorWrapper dt3dt1,
struct TensorWrapper dt3dr2, struct TensorWrapper dt3dt2)
{
std::vector<MatT> vec(10);
vec[0] = rvec3.toMatT();
vec[1] = tvec3.toMatT();
vec[2] = dr3dr1.toMatT();
vec[3] = dr3dt1.toMatT();
vec[4] = dr3dr2.toMatT();
vec[5] = dr3dt2.toMatT();
vec[6] = dt3dr1.toMatT();
vec[7] = dt3dt1.toMatT();
vec[8] = dt3dr2.toMatT();
vec[9] = dt3dt2.toMatT();
cv::composeRT(rvec1.toMat(),tvec1.toMat(), rvec2.toMat(),
tvec2.toMat(), vec[0], vec[1], vec[2], vec[3],
vec[4], vec[5], vec[6], vec[7], vec[8], vec[9]);
return TensorArray(vec);
}
struct TensorArray DescriptorMatcher_getTrainDescriptorsCuda(
struct cutorchInfo info, struct DescriptorMatcherPtr ptr) {
std::vector<cuda::GpuMat> retval = ptr->getTrainDescriptors();
return TensorArray(retval, info.state);
}