C++ UMat::empty方法代码示例

TEST_P(UMatBasicTests, base)
{
    const int align_mask = 3;
    roi.x &= ~align_mask;
    roi.y &= ~align_mask;
    roi.width = (roi.width + align_mask) & ~align_mask;
    roi &= Rect(0, 0, ua.cols, ua.rows);

    if(useRoi)
    {
        ua = UMat(ua,roi);
    }
    UMat ub = ua.clone();
    EXPECT_MAT_NEAR(ub,ua,0);

    ASSERT_EQ(ua.channels(), cn);
    ASSERT_EQ(ua.depth(), depth);
    ASSERT_EQ(ua.type(), type);
    ASSERT_EQ(ua.elemSize(), a.elemSize());
    ASSERT_EQ(ua.elemSize1(), a.elemSize1());
    ASSERT_EQ(ub.empty(), ub.cols*ub.rows == 0);
    ub.release();
    ASSERT_TRUE( ub.empty() );
    if(useRoi && a.size() != ua.size())
    {
        ASSERT_EQ(ua.isSubmatrix(), true);
    }
    else
    {
        ASSERT_EQ(ua.isSubmatrix(), false);
    }

    int dims = randomInt(2,6);
    int sz[CV_MAX_DIM];
    size_t total = 1;
    for(int i = 0; i<dims; i++)
    {
        sz[i] = randomInt(1,45);
        total *= (size_t)sz[i];
    }
    int new_type = CV_MAKE_TYPE(randomInt(CV_8S,CV_64F),randomInt(1,4));
    ub = UMat(dims, sz, new_type);
    ASSERT_EQ(ub.total(), total);
}

OCL_PERF_TEST(HOGFixture, HOG)
{
    UMat src;
    imread(getDataPath("gpu/hog/road.png"), cv::IMREAD_GRAYSCALE).copyTo(src);
    ASSERT_FALSE(src.empty());

    vector<cv::Rect> found_locations;
    declare.in(src);

    HOGDescriptor hog;
    hog.setSVMDetector(hog.getDefaultPeopleDetector());

    OCL_TEST_CYCLE() hog.detectMultiScale(src, found_locations);

    std::sort(found_locations.begin(), found_locations.end(), RectLess());
    SANITY_CHECK(found_locations, 3);
}

int main(int argc, char* argv[])
{
    if (argc==2)
        imread(argv[1]).copyTo(img);
    if (img.empty())
    {
        cout << "File not found or empty image\n";
    }
    imshow("Original",img);
    namedWindow( window_name, WINDOW_AUTOSIZE );

    /// Create a Trackbar for user to enter threshold
    createTrackbar( "a:",window_name, &aa, 400, PaillouFilter );
    createTrackbar( "w:", window_name, &ww, 400, PaillouFilter );
    PaillouFilter(0,NULL);
    waitKey();
    return 0;
}

int main(int argc, char** argv)
{
    const char* keys =
        "{ i input    | ../data/pic1.png   | specify input image }"
        "{ o output   | squares_output.jpg | specify output save path}"
        "{ h help     |                    | print help message }"
        "{ m cpu_mode |                    | run without OpenCL }";

    CommandLineParser cmd(argc, argv, keys);

    if(cmd.has("help"))
    {
        cout << "Usage : squares [options]" << endl;
        cout << "Available options:" << endl;
        cmd.printMessage();
        return EXIT_SUCCESS;
    }
    if (cmd.has("cpu_mode"))
    {
        ocl::setUseOpenCL(false);
        std::cout << "OpenCL was disabled" << std::endl;
    }

    string inputName = cmd.get<string>("i");
    string outfile = cmd.get<string>("o");

    int iterations = 10;
    namedWindow( wndname, WINDOW_AUTOSIZE );
    vector<vector<Point> > squares;

    UMat image;
    imread(inputName, 1).copyTo(image);
    if( image.empty() )
    {
        cout << "Couldn't load " << inputName << endl;
        cmd.printMessage();
        return EXIT_FAILURE;
    }

    int j = iterations;
    int64 t_cpp = 0;
    //warm-ups
    cout << "warming up ..." << endl;
    findSquares(image, squares);

    do
    {
        int64 t_start = cv::getTickCount();
        findSquares(image, squares);
        t_cpp += cv::getTickCount() - t_start;

        t_start  = cv::getTickCount();

        cout << "run loop: " << j << endl;
    }
    while(--j);
    cout << "average time: " << 1000.0f * (double)t_cpp / getTickFrequency() / iterations << "ms" << endl;

    UMat result = drawSquaresBoth(image, squares);
    imshow(wndname, result);
    imwrite(outfile, result);
    waitKey(0);

    return EXIT_SUCCESS;
}

int main(int argc, const char** argv)
{
    // declare capture engine that can read images from camera or file
    VideoCapture cap;

    // if no cmd-line arguments other than the app name then camera flag is raised
    bool camera = (1==argc);

    if(camera)
        // call open(int) method to init capture engine to read from camera
        // In case of many cameras the index of camera can be passed as argument.
        cap.open(0);
    else
        // call open(char*) method to init capture engine to read images from file
        // the argument is file name that will be opened for reading
        // it can be name of video file or still image
        cap.open(argv[1]);
    
    // check that capture engine open source (camera or file) successfully
    if (!cap.isOpened())
    {
        printf("can not open %s\n",camera?"camera":argv[1]);
        printf("trying to open test.jpg\n");
        // in case of fail try to open simple test file to be able check pipeline working
        cap.open("test.jpg");
        if (!cap.isOpened())
        {
            printf("can not open test.jpg\n");
            return EXIT_FAILURE;
        }
    }

    // prepare for processing images
    // declare mat objects to store input, intermediate and output images


    // this is main loop over all input frames
    for (;;)
    {
        // get next frame from input stream
        //cap >> imgInp;
		imgInp = imread(cap, CV_LOAD_IMAGE_ANYDEPTH);

        // check read result
        // in case of reading from file the loop will be break after last frame is read and processed
        // in case of camera this condition is always false until something wrong with camera 
        if (imgInp.empty())
        {
            // wait until user press any key and the break the loop
            // we need to wait to ge
            waitKey(0);
            break;
        }

        // show the input image on the screen using opencv function
        // this call creates window named "Input" and draws imgInp inside the window
        imshow("Input", imgInp);

        // convert input image into intermediate grayscale image
		if (imgInp.channels() > 1)
		{
			printf("Preceding with blanks: %10d \n", imgInp.channels());
              cvtColor(imgInp, imgGray, COLOR_BGR2GRAY);
			  Mat spl;
			  split(imgInp, spl);
			  imshow("spl1", spl[0]);//b
			  imshow("spl2", spl[1]);//g
			  imshow("spl3", spl[2]);//r

		}
		else{ imgGray = imgInp; }
        
        
		/// Initialize values
		alpha_slider = 0;
		p2_slider = 0;
		// run canny processing on grayscale image
        //Canny(imgGray, imgOut, 50, 150);

        // show the result on the screen using opencv function
        // this call creates window named "Canny" and draw imgOut inside the window
        //imshow("Canny", imgOut);
		/// Create Windows
		namedWindow("Linear Blend",WINDOW_NORMAL);

		/// Create Trackbars
		char TrackbarName[50];
		char TrackbarName2[50];
		sprintf(TrackbarName, "Thresh#1 /n x %d", alpha_slider_max);
		sprintf(TrackbarName2, "Thresh#2 /n 2 x %d", alpha_slider_max);
		//createTrackbar(TrackbarName, "Linear Blend", &alpha_slider, alpha_slider_max, on_trackbar);
		createTrackbar(TrackbarName, "Linear Blend", &alpha_slider, alpha_slider_max, on_trackbar_Canny);
		createTrackbar(TrackbarName2, "Linear Blend", &p2_slider, p2_slider_max, on_trackbar_Canny);

		ps_array[0] = alpha_slider;
		ps_array[1] = p2_slider;

		/// Show some stuff
		on_trackbar_Canny(0,0);
		//on_trackbar(alpha_slider, 0);
//.........这里部分代码省略.........

bool OCL4DNNPool<Dtype>::Forward(const UMat& bottom,
                                 UMat& top,
                                 UMat& top_mask)
{
    bool ret = true;
    size_t global[] = { 128 * 128 };
    size_t local[] = { 128 };

    // support 2D case
    switch (pool_method_)
    {
    case LIBDNN_POOLING_METHOD_MAX:
        {
            bool haveMask = !top_mask.empty();
            ocl::Kernel oclk_max_pool_forward(
                haveMask ? CL_KERNEL_SELECT("max_pool_forward_mask") : CL_KERNEL_SELECT("max_pool_forward"),
                ocl::dnn::ocl4dnn_pooling_oclsrc,
                format("-D KERNEL_MAX_POOL=1 -D KERNEL_W=%d -D KERNEL_H=%d"
                       " -D STRIDE_W=%d -D STRIDE_H=%d"
                       " -D PAD_W=%d -D PAD_H=%d%s",
                       kernel_w_, kernel_h_,
                       stride_w_, stride_h_,
                       pad_w_, pad_h_,
                       haveMask ? " -D HAVE_MASK=1" : ""
                ));

            if (oclk_max_pool_forward.empty())
                return false;

            oclk_max_pool_forward.args(
                count_,
                ocl::KernelArg::PtrReadOnly(bottom),
                channels_,
                height_,
                width_,
                pooled_height_,
                pooled_width_,
                ocl::KernelArg::PtrWriteOnly(top),
                ocl::KernelArg::PtrWriteOnly(top_mask)
            );

            ret = oclk_max_pool_forward.run(1, global, local, false);
        }
        break;
    case LIBDNN_POOLING_METHOD_AVE:
        {
            CV_Assert(top_mask.empty());

            ocl::Kernel oclk_ave_pool_forward(CL_KERNEL_SELECT("ave_pool_forward"),
                ocl::dnn::ocl4dnn_pooling_oclsrc,
                format("-D KERNEL_AVE_POOL=1 -D KERNEL_W=%d -D KERNEL_H=%d"
                       " -D STRIDE_W=%d -D STRIDE_H=%d"
                       " -D PAD_W=%d -D PAD_H=%d%s",
                       kernel_w_, kernel_h_,
                       stride_w_, stride_h_,
                       pad_w_, pad_h_,
                       avePoolPaddedArea ? " -D AVE_POOL_PADDING_AREA" : ""
                ));

            if (oclk_ave_pool_forward.empty())
                return false;

            oclk_ave_pool_forward.args(
                count_,
                ocl::KernelArg::PtrReadOnly(bottom),
                channels_,
                height_,
                width_,
                pooled_height_,
                pooled_width_,
                ocl::KernelArg::PtrWriteOnly(top)
            );

            ret = oclk_ave_pool_forward.run(1, global, local, false);
        }
        break;
    case LIBDNN_POOLING_METHOD_STO:
        {
            CV_Assert(top_mask.empty());

            ocl::Kernel oclk_sto_pool_forward(CL_KERNEL_SELECT("sto_pool_forward_test"),
                ocl::dnn::ocl4dnn_pooling_oclsrc,
                format("-D KERNEL_STO_POOL=1 -D KERNEL_W=%d -D KERNEL_H=%d"
                       " -D STRIDE_W=%d -D STRIDE_H=%d",
                       kernel_w_, kernel_h_,
                       stride_w_, stride_h_
                ));


            if (oclk_sto_pool_forward.empty())
                return false;

            oclk_sto_pool_forward.args(
                count_,
                ocl::KernelArg::PtrReadOnly(bottom),
                channels_,
                height_,
                width_,
                pooled_height_,
                pooled_width_,
//.........这里部分代码省略.........

int main(int argc, char** argv)
{
    CV_TRACE_FUNCTION();

    cv::CommandLineParser parser(argc, argv,
        "{help h ? |     | help message}"
        "{n        | 100 | number of frames to process }"
        "{@video   | 0   | video filename or cameraID }"
    );
    if (parser.has("help"))
    {
        parser.printMessage();
        return 0;
    }

    VideoCapture capture;
    std::string video = parser.get<string>("@video");
    if (video.size() == 1 && isdigit(video[0]))
        capture.open(parser.get<int>("@video"));
    else
        capture.open(video);
    int nframes = 0;
    if (capture.isOpened())
    {
        nframes = (int)capture.get(CAP_PROP_FRAME_COUNT);
        cout << "Video " << video <<
            ": width=" << capture.get(CAP_PROP_FRAME_WIDTH) <<
            ", height=" << capture.get(CAP_PROP_FRAME_HEIGHT) <<
            ", nframes=" << nframes << endl;
    }
    else
    {
        cout << "Could not initialize video capturing...\n";
        return -1;
    }

    int N = parser.get<int>("n");
    if (nframes > 0 && N > nframes)
        N = nframes;

    cout << "Start processing..." << endl
        << "Press ESC key to terminate" << endl;

    UMat frame;
    for (int i = 0; N > 0 ? (i < N) : true; i++)
    {
        CV_TRACE_REGION("FRAME"); // OpenCV Trace macro for named "scope" region
        {
            CV_TRACE_REGION("read");
            capture.read(frame);

            if (frame.empty())
            {
                cerr << "Can't capture frame: " << i << std::endl;
                break;
            }

            // OpenCV Trace macro for NEXT named region in the same C++ scope
            // Previous "read" region will be marked complete on this line.
            // Use this to eliminate unnecessary curly braces.
            CV_TRACE_REGION_NEXT("process");
            process_frame(frame);

            CV_TRACE_REGION_NEXT("delay");
            if (waitKey(1) == 27/*ESC*/)
                break;
        }
    }

    return 0;
}