예제 #1
0
struct TensorWrapper pyrUpCuda(struct cutorchInfo info,
        struct TensorWrapper src, struct TensorWrapper dst)
{
    if (dst.isNull()) {
        cuda::GpuMat retval;
        cuda::pyrUp(src.toGpuMat(), retval, prepareStream(info));
        return TensorWrapper(retval, info.state);
    } else if (dst.tensorPtr == src.tensorPtr) {
        // in-place
        cuda::GpuMat source = src.toGpuMat();
        cuda::pyrUp(source, source, prepareStream(info));
    } else {
        cuda::pyrUp(src.toGpuMat(), dst.toGpuMat(), prepareStream(info));
    }
    return dst;
}
bool RtspStreamWorker::setup()
{
    ASSERT_WORKER_THREAD();

    m_ctx = avformat_alloc_context();
    m_ctx->interrupt_callback.callback = rtspStreamInterruptCallback;
    m_ctx->interrupt_callback.opaque = this;

    AVDictionary *options = createOptions();
    bool prepared = prepareStream(&m_ctx, options);
    av_dict_free(&options);

    if (prepared)
    {
        m_frameFormatter.reset(new RtspStreamFrameFormatter(m_ctx->streams[m_videoStreamIndex]));
        m_frameFormatter->setAutoDeinterlacing(m_autoDeinterlacing);
    }
    else if (m_ctx)
    {
        avformat_close_input(&m_ctx);
        m_ctx = 0;
    }

    return prepared;
}
예제 #3
0
struct TensorWrapper evenLevels(struct cutorchInfo info,
        struct TensorWrapper levels, int nLevels, int lowerLevel, int upperLevel)
{
    cuda::GpuMat retval;
    if (!levels.isNull()) retval = levels.toGpuMat();
    cuda::evenLevels(retval, nLevels, lowerLevel, upperLevel, prepareStream(info));
}
예제 #4
0
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);
}
예제 #5
0
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);
}
예제 #6
0
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);
}
예제 #7
0
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);
}
예제 #8
0
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);
}
예제 #9
0
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);
}
예제 #10
0
struct TensorWrapper CornernessCriteria_compute(
        struct cutorchInfo info, struct CornernessCriteriaPtr ptr,
        struct TensorWrapper src, struct TensorWrapper dst)
{
    cuda::GpuMat retval;
    if (!dst.isNull()) retval = dst.toGpuMat();
    ptr->compute(src.toGpuMat(), retval, prepareStream(info));
}
예제 #11
0
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);
}
예제 #12
0
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);
}
예제 #13
0
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);
}
예제 #14
0
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);
}
예제 #15
0
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);
}
예제 #16
0
struct TensorWrapper blendLinear(struct cutorchInfo info,
        struct TensorWrapper img1, struct TensorWrapper img2, struct TensorWrapper weights1, 
        struct TensorWrapper weights2, struct TensorWrapper result)
{
    cuda::GpuMat retval;
    if (!result.isNull()) retval = result.toGpuMat();
    cuda::blendLinear(
            img1.toGpuMat(), img2.toGpuMat(), weights1.toGpuMat(), weights2.toGpuMat(),
            retval, prepareStream(info));
    return TensorWrapper(retval, info.state);
}
예제 #17
0
struct TensorWrapper bilateralFilter(struct cutorchInfo info,
        struct TensorWrapper src, struct TensorWrapper dst, int kernel_size,
        float sigma_color, float sigma_spatial, int borderMode)
{
    cuda::GpuMat retval;
    if (!dst.isNull()) retval = dst.toGpuMat();
    cuda::bilateralFilter(
            src.toGpuMat(), retval, kernel_size, sigma_color,
            sigma_color, borderMode, prepareStream(info));
    return TensorWrapper(retval, info.state);
}
예제 #18
0
struct TensorWrapper CascadeClassifier_detectMultiScale(
        struct cutorchInfo info, struct CascadeClassifierPtr ptr,
        struct TensorWrapper image, struct TensorWrapper objects)
{
    GpuMatT objectsMat = objects.toGpuMatT();
    cuda::GpuMat imageMat = image.toGpuMat();
    cuda::GpuMat imageByte;
    imageMat.convertTo(imageByte, CV_8U, 255.0); // Sorry guys :(
    ptr->detectMultiScale(imageByte, objectsMat, prepareStream(info));
    return TensorWrapper(objectsMat, info.state);
}
예제 #19
0
struct TensorWrapper DescriptorMatcher_knnMatch_masksCuda(
    struct cutorchInfo info, struct DescriptorMatcherPtr ptr,
    struct TensorWrapper queryDescriptors, struct TensorWrapper trainDescriptors,
    struct TensorWrapper matches, int k, struct TensorArray masks)
{
    cuda::GpuMat retval = matches.toGpuMat();
    ptr->knnMatchAsync(
        queryDescriptors.toGpuMat(), trainDescriptors.toGpuMat(), retval,
        k, TO_GPUMAT_LIST_OR_NOARRAY(masks), prepareStream(info));
    return TensorWrapper(retval, info.state);
}
예제 #20
0
struct TensorWrapper DescriptorMatcher_radiusMatchCuda(
    struct cutorchInfo info, struct DescriptorMatcherPtr ptr,
    struct TensorWrapper queryDescriptors, struct TensorWrapper trainDescriptors,
    struct TensorWrapper matches, float maxDistance, struct TensorWrapper mask)
{
    cuda::GpuMat retval = matches.toGpuMat();
    ptr->radiusMatchAsync(
        queryDescriptors.toGpuMat(), trainDescriptors.toGpuMat(),
        retval, maxDistance, TO_GPUMAT_OR_NOARRAY(mask), prepareStream(info));
    return TensorWrapper(retval, info.state);
}
예제 #21
0
struct TensorWrapper remapCuda(struct cutorchInfo info,
        struct TensorWrapper src, struct TensorWrapper map1,
        struct TensorWrapper map2, int interpolation, struct TensorWrapper dst,
        int borderMode, struct ScalarWrapper borderValue)
{
    if (dst.isNull()) {
        cuda::GpuMat retval;
        cuda::remap(src.toGpuMat(), retval, map1.toGpuMat(), map2.toGpuMat(),
                    interpolation, borderMode, borderValue, prepareStream(info));
        return TensorWrapper(retval, info.state);
    } else if (dst.tensorPtr == src.tensorPtr) {
        // in-place
        cuda::GpuMat source = src.toGpuMat();
        cuda::remap(source, source, map1.toGpuMat(), map2.toGpuMat(), interpolation,
                    borderMode, borderValue, prepareStream(info));
    } else {
        cuda::remap(src.toGpuMat(), dst.toGpuMat(), map1.toGpuMat(), map2.toGpuMat(),
                    interpolation, borderMode, borderValue, prepareStream(info));
    }
    return dst;
}
예제 #22
0
struct TensorWrapper warpPerspectiveCuda(struct cutorchInfo info,
        struct TensorWrapper src, struct TensorWrapper dst,
        struct TensorWrapper M, struct SizeWrapper dsize,
        int flags, int borderMode, struct ScalarWrapper borderValue)
{
    if (dst.isNull()) {
        cuda::GpuMat retval;
        cuda::warpPerspective(src.toGpuMat(), retval, M.toGpuMat(), dsize,
                              flags, borderMode, borderValue, prepareStream(info));
        return TensorWrapper(retval, info.state);
    } else if (dst.tensorPtr == src.tensorPtr) {
        // in-place
        cuda::GpuMat source = src.toGpuMat();
        cuda::warpPerspective(source, source, M.toGpuMat(), dsize, flags,
                              borderMode, borderValue, prepareStream(info));
    } else {
        cuda::warpPerspective(src.toGpuMat(), dst.toGpuMat(), M.toGpuMat(),
                              dsize, flags, borderMode, borderValue, prepareStream(info));
    }
    return dst;
}
예제 #23
0
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);
}
예제 #24
0
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);
}
예제 #25
0
void swapChannels(
        struct cutorchInfo info, struct TensorWrapper image,
        struct Vec4iWrapper dstOrder)
{
    cuda::swapChannels(image.toGpuMat(), &dstOrder.v0, prepareStream(info));
}