struct TensorWrapper calcOpticalFlowSF_expanded(
struct TensorWrapper from, struct TensorWrapper to, struct TensorWrapper flow,
int layers, int averaging_block_size, int max_flow,
double sigma_dist, double sigma_color, int postprocess_window,
double sigma_dist_fix, double sigma_color_fix, double occ_thr,
int upscale_averaging_radius, double upscale_sigma_dist,
double upscale_sigma_color, double speed_up_thr)
{
if (flow.isNull()) {
cv::Mat retval;
optflow::calcOpticalFlowSF(
from.toMat(), to.toMat(), retval, layers, averaging_block_size,
max_flow, sigma_dist, sigma_color, postprocess_window, sigma_dist_fix,
sigma_color_fix, occ_thr, upscale_averaging_radius,
upscale_sigma_dist, upscale_sigma_color, speed_up_thr);
return TensorWrapper(retval);
} else {
optflow::calcOpticalFlowSF(
from.toMat(), to.toMat(), flow.toMat(), layers, averaging_block_size,
max_flow, sigma_dist, sigma_color, postprocess_window, sigma_dist_fix,
sigma_color_fix, occ_thr, upscale_averaging_radius,
upscale_sigma_dist, upscale_sigma_color, speed_up_thr);
return flow;
}
}
struct TensorWrapper randMVNormal(
struct TensorWrapper mean, struct TensorWrapper cov, int nsamples, struct TensorWrapper samples)
{
MatT samples_mat = samples.toMatT();
ml::randMVNormal(mean.toMat(), cov.toMat(), nsamples, samples_mat);
return TensorWrapper(samples_mat);
}
struct TensorWrapper FrameSource_nextFrame(struct FrameSourcePtr ptr, struct TensorWrapper frame)
{
MatT frame_mat;
if(!frame.isNull()) frame_mat = frame.toMatT();
ptr->nextFrame(frame_mat);
return TensorWrapper(frame_mat);
}
extern "C" struct TensorWrapper BackgroundSubtractor_apply(struct BackgroundSubtractorPtr ptr,
struct TensorWrapper image, struct TensorWrapper fgmast, double learningRate)
{
MatT fgmast_mat = fgmast.toMatT();
ptr->apply(image.toMat(), fgmast_mat, learningRate);
return TensorWrapper(fgmast_mat);
}
struct TensorWrapper SuperResolution_nextFrame(struct SuperResolutionPtr ptr, struct TensorWrapper frame)
{
MatT frame_mat;
if(!frame.isNull()) frame_mat = frame.toMatT();
ptr->nextFrame(frame_mat);
return TensorWrapper(frame_mat);
}
extern "C" struct TensorWrapper KalmanFilter_predict(struct KalmanFilterPtr ptr,
struct TensorWrapper control)
{
cv::Mat retval = control.toMat();
cv::Mat result = ptr->predict(retval);
return TensorWrapper(MatT(result));
}
struct TensorWrapper xphoto_autowbGrayworld(
struct TensorWrapper src, struct TensorWrapper dst, float thresh)
{
MatT dst_mat = dst.toMatT();
cv::xphoto::autowbGrayworld(src.toMat(), dst_mat, thresh);
return TensorWrapper(dst_mat);
}
struct TensorWrapper imencode(
const char *ext, struct TensorWrapper img, struct TensorWrapper params)
{
std::vector<unsigned char> retval;
cv::imencode(ext, img.toMat(), retval, params.toMat());
return TensorWrapper(cv::Mat(retval, true));
}
struct TensorWrapper xphoto_dctDenoising(
struct TensorWrapper src, struct TensorWrapper dst, double sigma, int psize)
{
MatT dst_mat = dst.toMatT();
cv::xphoto::balanceWhite(src.toMat(), dst_mat.mat, sigma, psize);
return TensorWrapper(dst_mat);
}
struct TensorWrapper convertPointsHomogeneous(
struct TensorWrapper src, struct TensorWrapper dst)
{
MatT dst_mat = dst.toMatT();
cv::convertPointsHomogeneous(src.toMat(), dst_mat);
return TensorWrapper(dst_mat);
}
struct TensorWrapper Feature2DAsync_detectAsyncCuda(
struct cutorchInfo info, struct Feature2DAsyncPtr ptr, struct TensorWrapper image,
struct TensorWrapper keypoints, struct TensorWrapper mask)
{
cuda::GpuMat retval = keypoints.toGpuMat();
ptr->detectAsync(image.toGpuMat(), retval, TO_GPUMAT_OR_NOARRAY(mask), prepareStream(info));
return TensorWrapper(retval, info.state);
}
struct TensorWrapper initCameraMatrix2D(
struct TensorArray objectPoints, struct TensorArray imagePoints,
struct SizeWrapper imageSize, double aspectRatio)
{
return TensorWrapper(MatT(cv::initCameraMatrix2D(
objectPoints.toMatList(), imagePoints.toMatList(),
imageSize, aspectRatio)));
}
extern "C" struct TensorWrapper BackgroundSubtractor_getBackgroundImage(
struct BackgroundSubtractorPtr ptr,
struct TensorWrapper backgroundImage)
{
MatT backgroundImage_mat = backgroundImage.toMatT();
ptr->getBackgroundImage(backgroundImage_mat);
return TensorWrapper(backgroundImage_mat);
}
struct TensorWrapper TrainData_getSample(
struct TrainDataPtr ptr, struct TensorWrapper varIdx, int sidx)
{
cv::Mat varIdxMat = varIdx.toMat();
std::vector<float> output(varIdxMat.rows * varIdxMat.cols);
ptr->getSample(varIdxMat, sidx, output.data());
return TensorWrapper(cv::Mat(output, true));
}
struct TensorWrapper xphoto_inpaint(
struct TensorWrapper src, struct TensorWrapper mask,
struct TensorWrapper dst, int algorithmType)
{
MatT dst_mat = dst.toMatT();
cv::xphoto::inpaint(src.toMat(), mask.toMat(), dst_mat.mat, algorithmType);
return TensorWrapper(dst_mat);
}
struct TensorWrapper xphoto_balanceWhite(
struct TensorWrapper src, struct TensorWrapper dst, int algorithmType,
float inputMin, float inputMax, float outputMin, float outputMax)
{
MatT dst_mat = dst.toMatT();
cv::xphoto::balanceWhite(src.toMat(), dst_mat.mat, algorithmType, inputMin, inputMax, outputMin, outputMax);
return TensorWrapper(dst_mat);
}
struct TensorWrapper StereoMatcher_compute(
struct StereoMatcherPtr ptr, struct TensorWrapper left,
struct TensorWrapper right, struct TensorWrapper disparity)
{
MatT disparity_mat = disparity.toMatT();
ptr->compute(left.toMat(), right.toMat(), disparity_mat);
return TensorWrapper(disparity_mat);
}
struct TensorWrapper computeCorrespondEpilines(
struct TensorWrapper points, int whichImage, struct TensorWrapper F,
struct TensorWrapper lines)
{
MatT lines_mat = lines.toMatT();
cv::computeCorrespondEpilines(points.toMat(), whichImage, F.toMat(),lines_mat);
return TensorWrapper(lines_mat);
}
struct TensorWrapper TrainData_getNormCatValues(
struct TrainDataPtr ptr, int vi, struct TensorWrapper sidx)
{
cv::Mat sidxMat = sidx.toMat();
std::vector<int> output(sidxMat.rows * sidxMat.cols);
ptr->getNormCatValues(vi, sidxMat, output.data());
return TensorWrapper(cv::Mat(output, true));
}
struct TensorWrapper DenseOpticalFlow_calcCuda(struct cutorchInfo info,
struct DenseOpticalFlowPtr ptr, struct TensorWrapper I0, struct TensorWrapper I1,
struct TensorWrapper flow)
{
cuda::GpuMat retval = flow.toGpuMat();
ptr->calc(I0.toGpuMat(), I1.toGpuMat(), retval, prepareStream(info));
return TensorWrapper(retval, info.state);
}
struct TensorWrapper equalizeHist(struct cutorchInfo info,
struct TensorWrapper src, struct TensorWrapper dst)
{
cuda::GpuMat retval;
if (!dst.isNull()) retval = dst.toGpuMat();
cuda::equalizeHist(src.toGpuMat(), retval);
return TensorWrapper(retval, info.state);
}
struct TensorWrapper calcHist(
struct cutorchInfo info, struct TensorWrapper src, struct TensorWrapper hist)
{
cuda::GpuMat retval;
if (!hist.isNull()) retval = hist.toGpuMat();
cuda::calcHist(src.toGpuMat(), retval, prepareStream(info));
return TensorWrapper(retval, info.state);
}
struct TensorWrapper HOG_compute(
struct cutorchInfo info, struct HOGPtr ptr, struct TensorWrapper img,
struct TensorWrapper descriptors)
{
GpuMatT descriptorsMat = descriptors.toGpuMatT();
ptr->compute(img.toGpuMat(), descriptorsMat, prepareStream(info));
return TensorWrapper(descriptorsMat, info.state);
}
struct TensorWrapper gammaCorrection(struct cutorchInfo info,
struct TensorWrapper src, struct TensorWrapper dst, bool forward)
{
cuda::GpuMat retval;
if (!dst.isNull()) retval = dst.toGpuMat();
cuda::gammaCorrection(src.toGpuMat(), retval, forward, prepareStream(info));
return TensorWrapper(retval, info.state);
}
struct TensorWrapper cvtColor(struct cutorchInfo info,
struct TensorWrapper src, struct TensorWrapper dst, int code, int dstCn)
{
cuda::GpuMat retval;
if (!dst.isNull()) retval = dst.toGpuMat();
cuda::cvtColor(src.toGpuMat(), retval, code, dstCn, prepareStream(info));
return TensorWrapper(retval, info.state);
}
struct TensorWrapper alphaComp(struct cutorchInfo info,
struct TensorWrapper img1, struct TensorWrapper img2,
struct TensorWrapper dst, int alpha_op)
{
cuda::GpuMat retval;
if (!dst.isNull()) retval = dst.toGpuMat();
cuda::alphaComp(img1.toGpuMat(), img2.toGpuMat(), retval, alpha_op, prepareStream(info));
return TensorWrapper(retval, info.state);
}
struct TensorWrapper TemplateMatching_match(
struct cutorchInfo info, struct TemplateMatchingPtr ptr, struct TensorWrapper image,
struct TensorWrapper templ, struct TensorWrapper result)
{
cuda::GpuMat retval;
if (!result.isNull()) retval = result.toGpuMat();
ptr->match(image.toGpuMat(), templ.toGpuMat(), retval, prepareStream(info));
return TensorWrapper(retval, info.state);
}
struct TensorWrapper CornersDetector_detect(
struct cutorchInfo info, struct CornersDetectorPtr ptr, struct TensorWrapper image,
struct TensorWrapper corners, struct TensorWrapper mask)
{
cuda::GpuMat retval;
if (!corners.isNull()) retval = corners.toGpuMat();
ptr->detect(image.toGpuMat(), retval, TO_GPUMAT_OR_NOARRAY(mask));
return TensorWrapper(retval, info.state);
}
struct TensorWrapper resizeCuda(struct cutorchInfo info,
struct TensorWrapper src, struct TensorWrapper dst,
struct SizeWrapper dsize, double fx, double fy,
int interpolation)
{
GpuMatT dstMat = dst.toGpuMatT();
cuda::resize(src.toGpuMat(), dstMat, dsize, fx, fy, interpolation, prepareStream(info));
return TensorWrapper(dstMat, info.state);
}
struct TensorWrapper rotateCuda(
struct cutorchInfo info, struct TensorWrapper src, struct TensorWrapper dst,
struct SizeWrapper dsize, double angle, double xShift, double yShift, int interpolation)
{
cuda::GpuMat dstMat = dst.toGpuMat();
cuda::rotate(src.toGpuMat(), dstMat, dsize, angle, xShift, yShift,
interpolation, prepareStream(info));
return TensorWrapper(dstMat, info.state);
}
