C++ TensorWrapper函数代码示例

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);
}