C++ (Cpp) fgMask Examples

Example #1

File: simpleraycaster.cpp Project: aurelw/libfhc

std::tuple<cv::Mat, cv::Mat> SimpleRayCaster::renderZMasks() {
    cv::Mat fgMask(_res_y, _res_x, CV_32F);
    cv::Mat bgMask(_res_y, _res_x, CV_32F);

    for (int y=0; y<_res_y; y++) {
        for (int x=0; x<_res_x; x++) {

            Eigen::Vector2f co((float)x/(float)_res_x,(float)y/(float)_res_y);
            auto zvalues = castRay(co);
            float fgPixel = 0.0f;
            float bgPixel = 0.0f;

            /* only valid masks if there were 2 intersections */
            if (zvalues.size() == 2) {
                if (zvalues[0] < zvalues[1]) {
                    fgPixel = zvalues[0];
                    bgPixel = zvalues[1];
                } else {
                    fgPixel = zvalues[1];
                    bgPixel = zvalues[0];
                }
            }

            fgMask.at<float>(y,x) = fgPixel;
            bgMask.at<float>(y,x) = bgPixel;
        }
    } 

    return std::make_tuple(fgMask, bgMask);
}

Example #2

File: DrawingCanvas.cpp Project: AlexTape/OpenCV-Tutorial

//! Processes a frame and returns output image
bool DrawingCanvasSample::processFrame(const cv::Mat& inputFrame, cv::Mat& outputFrame)
{
    cv::cvtColor(inputFrame,
                 m_grayImage,
                 cv::COLOR_BGRA2GRAY);
    
    cv::bilateralFilter(m_grayImage,
                        m_filtered,
                        m_bilateralD,
                        m_bilateralSigmaThreshold,
                        m_bilateralColorThreshold);
    
    cv::Mat grayImage3channes;
    cv::Mat a[] = { m_filtered, m_filtered, m_filtered };
    cv::merge(a, 3, grayImage3channes);
    
    cv::adaptiveThreshold(m_grayImage, bgMask, 255, cv::ADAPTIVE_THRESH_GAUSSIAN_C , cv::THRESH_BINARY, 1 + 2*m_thresholdBlockSize, m_thresholdC);
    
    cv::Mat fgMask(bgMask.size(), bgMask.type());
    fgMask = cv::Scalar(255);
    fgMask ^= bgMask;
    
    cv::Mat b[] = { bgMask, bgMask, bgMask };
    cv::merge(b, 3, bgMask3channels);
    
    cv::Mat c[] = { fgMask, fgMask, fgMask};
    cv::merge(c, 3, fgMask3channels);
    
    cv::Scalar backgroundColor = cv::Scalar(56, 138, 239);
    cv::Scalar foregroundColor = cv::Scalar(255,255,255);
    
    cv::multiply(grayImage3channes, backgroundColor, bgColor, 1.0f / 255.f);
    cv::multiply(grayImage3channes, foregroundColor, fgColor, 100.0f / 255.0f);
    
    if (m_currentView == kStageGrayscale)
    {
        cv::cvtColor(m_grayImage, outputFrame, cv::COLOR_GRAY2BGRA);        
    }
    else if (m_currentView == kStageBilateralFilter)
    {
        cv::cvtColor(m_filtered, outputFrame, cv::COLOR_GRAY2BGRA);        
    }
    else if (m_currentView == kStageThreshold)
    {
        cv::cvtColor(bgMask, outputFrame, cv::COLOR_GRAY2BGRA);
    }
    else
    {
        cv::Mat resul = (bgColor & bgMask3channels) + (fgColor & fgMask3channels);
        cv::cvtColor(resul, outputFrame, cv::COLOR_BGR2BGRA);
    }
    
    return true;
}