C++ Mat::copyTo方法代码示例

//general processing function of UVDisparity based function
cv::Mat UVDisparity::Process(cv::Mat& img_L, cv::Mat& disp_sgbm,
                             VisualOdometryStereo& vo, cv::Mat& xyz,
                             cv::Mat& roi_mask, cv::Mat& ground_mask,
                             double& pitch1, double& pitch2)
{
    cv::Mat mask_moving;
    calVDisparity(disp_sgbm,xyz);

    //sequentially estimate pitch angles by Kalman Filter
    vector<cv::Mat> pitch_measures;

    pitch_measures = Pitch_Classify(xyz,ground_mask);
    pitch1_KF->predict();
    pitch1_KF->correct(pitch_measures[0]);

    pitch2_KF->predict();
    pitch2_KF->correct(pitch_measures[1]);

    pitch1 = pitch_measures[0].at<float>(0);
    pitch2 = pitch_measures[1].at<float>(0);


    //Improve 3D reconstruction results by pitch angles
    correct3DPoints(xyz,roi_,pitch1_KF->statePost.at<float>(0),pitch2_KF->statePost.at<float>(0));

    //set image ROI according to ROI3D (ROI within a 3D space)
    setImageROI(xyz, roi_mask);

    //filter inliers and outliers
    filterInOut(img_L,roi_mask,disp_sgbm,vo,pitch1);

    //calculate Udisparity image
    calUDisparity(disp_sgbm,xyz,roi_mask,ground_mask);

    //using sigmoid function to adjust Udisparity image for segmentation
    double scale = 0.02, range = 32;
    adjustUdisIntense(scale,range);

     //Find all possible segmentation
     findAllMasks(vo,img_L,xyz,roi_mask);

    if(masks_.size()>0)
    {
       //merge overlapped masks
       mergeMasks();

       //improve the segments by inliers
       verifyByInliers(vo,img_L);
     }

   //perform segmentation in disparity image
   segmentation(disp_sgbm,img_L,roi_mask,mask_moving);

   //demonstration
   cv::Mat img_show;
   img_L.copyTo(img_show,mask_moving);
   cv::imshow("moving",img_show);
   cv::waitKey(1);

   masks_.clear();
   return mask_moving;
}

PowertfDialog::PowertfDialog(cv::Mat& img, QWidget *parent)
    : QDialog(parent)
{
    r = 1;
    c = 1;
    b = 0;
    img.copyTo(image);
    pimage = &img;

    rSlider = new QSlider(Qt::Horizontal);
    rSlider->setRange(0,10);
    rSlider->setValue(r);
    cSlider = new QSlider(Qt::Horizontal);
    cSlider->setRange(0,10);
    cSlider->setValue(c);
    bSlider = new QSlider(Qt::Horizontal);
    bSlider->setRange(0,10);
    bSlider->setValue(b);

    rSBx = new QSpinBox();
    rSBx->setRange(0,10);
    rSBx->setValue(r);
    cSBx = new QSpinBox();
    cSBx->setRange(0,10);
    cSBx->setValue(c);
    bSBx = new QSpinBox();
    bSBx->setRange(0,10);
    bSBx->setValue(b);

    connect(rSlider,SIGNAL(valueChanged(int)),this,SLOT(rChanged(int)));
    connect(cSlider,SIGNAL(valueChanged(int)),this,SLOT(cChanged(int)));
    connect(bSlider,SIGNAL(valueChanged(int)),this,SLOT(bChanged(int)));
    connect(rSlider,SIGNAL(valueChanged(int)),rSBx,SLOT(setValue(int)));
    connect(cSlider,SIGNAL(valueChanged(int)),cSBx,SLOT(setValue(int)));
    connect(bSlider,SIGNAL(valueChanged(int)),bSBx,SLOT(setValue(int)));

    connect(rSBx,SIGNAL(valueChanged(int)),this,SLOT(rChanged(int)));
    connect(cSBx,SIGNAL(valueChanged(int)),this,SLOT(cChanged(int)));
    connect(bSBx,SIGNAL(valueChanged(int)),this,SLOT(bChanged(int)));
    connect(rSBx,SIGNAL(valueChanged(int)),rSlider,SLOT(setValue(int)));
    connect(cSBx,SIGNAL(valueChanged(int)),cSlider,SLOT(setValue(int)));
    connect(bSBx,SIGNAL(valueChanged(int)),bSlider,SLOT(setValue(int)));

    rLabel = new QLabel(tr("r"));
    cLabel = new QLabel(tr("c"));
    bLabel = new QLabel(tr("b"));

    okButton = new QPushButton(tr("&OK"));
    okButton->setDefault(true);
    okButton->setEnabled(true);
    connect(okButton, SIGNAL(clicked()), this, SLOT(okClicked()));

    closeButton = new QPushButton(tr("&Close"));
    connect(closeButton, SIGNAL(clicked()), this, SLOT(closePowertf()));

    QHBoxLayout *rLayout = new QHBoxLayout;
    rLayout->addWidget(rLabel);
    rLayout->addWidget(rSlider);
    rLayout->addWidget(rSBx);
    QHBoxLayout *cLayout = new QHBoxLayout;
    cLayout->addWidget(cLabel);
    cLayout->addWidget(cSlider);
    cLayout->addWidget(cSBx);
    QHBoxLayout *bLayout = new QHBoxLayout;
    bLayout->addWidget(bLabel);
    bLayout->addWidget(bSlider);
    bLayout->addWidget(bSBx);

    QVBoxLayout *leftLayout = new QVBoxLayout;
    leftLayout->addLayout(rLayout);
    leftLayout->addLayout(cLayout);
    leftLayout->addLayout(bLayout);
    
    QVBoxLayout *rightLayout = new QVBoxLayout;
    rightLayout->addWidget(okButton);
    rightLayout->addWidget(closeButton);
    rightLayout->addStretch();

    QHBoxLayout *mainLayout = new QHBoxLayout;
    mainLayout->addLayout(leftLayout);
    mainLayout->addLayout(rightLayout);
    setLayout(mainLayout);

    setWindowTitle(tr("Power Tranform"));
    setFixedHeight(sizeHint().height());
}

cv::Mat makeFrame(cv::Mat control,
                  cv::Mat interaction,
                  cv::Mat fill,
                  unsigned char threshold,
                  int blurkernelsize,
                  int offsetx,
                  int offsety
                 )
{
    //take the absolute difference between the interaction and the 
    //control images and store it in diff
    cv::Mat diff; 
    cv::absdiff(control, interaction, diff);
    
    //initialize an image to store the final result
    cv::Mat result = cv::Mat::zeros( fill.rows, fill.cols, fill.type() );
    
    //initialize a blank mask
    cv::Mat mask = cv::Mat::zeros(control.rows, control.cols, CV_8UC1);
    
    
    //for every pixel in diff...
    for(int i = 0; i < diff.rows; i++)
    {
        for(int j = 0; j < diff.cols; j++)
        {
            cv::Vec3b pixel = diff.at<cv::Vec3b>(i, j);
            
            //...if the absolute value of the pixel exceeds the threshold,
            //set corresponding mask's pixel to white.
            //Otherwise, leave it black.
            /*
            if(sqrt(pixel[0] * pixel[0] +
                    pixel[1] * pixel[1] +
                    pixel[2] * pixel[2]
                   ) >= threshold
              )
            /*/
            if(cv::max( cv::max(pixel[0], pixel[1]),
                        pixel[2]
                      ) >= threshold
              )
            //*/
            {
               mask.at<unsigned char>(i, j) = 255;
            }
        }
    }
    
    //apply median-blur to mask with kernel size of blurkernelsize
    cv::Mat blurredmask;
    cv::medianBlur(mask, blurredmask, blurkernelsize);
    
    //resize mask's resolution to math fill's
    cv::resize( blurredmask, blurredmask, cv::Size(fill.cols, fill.rows) );
    
    cv::Mat roit;
    cv::Mat finalmask = cv::Mat::zeros(fill.rows,
                                       fill.cols,
                                       blurredmask.type()
                                      );
    if(offsetx >= 0)
    {
        if(offsety >= 0)
        {
            roit = cv::Mat(blurredmask,
                       cv::Range(0, blurredmask.rows - offsety),
                       cv::Range(0, blurredmask.cols - offsetx)
                      );
        
            roit.copyTo(finalmask(cv::Rect(offsetx,
                                           offsety,
                                           roit.cols,
                                           roit.rows
                                          )
                                 )
                       );
        }
        else
        {
            roit = cv::Mat(blurredmask,
                       cv::Range(-offsety, blurredmask.rows),
                       cv::Range(0, blurredmask.cols - offsetx)
                      );
        
            roit.copyTo( finalmask(cv::Rect(offsetx, 0, roit.cols, roit.rows)) );
        }
    }
    else
    {
        if(offsety >= 0)
        {
            roit = cv::Mat(blurredmask,
                       cv::Range(0, blurredmask.rows - offsety),
                       cv::Range(-offsetx, blurredmask.cols)
                      );
            roit.copyTo( finalmask(cv::Rect(0, offsety, roit.cols, roit.rows)) );
        }
        else
        {
//.........这里部分代码省略.........

//! Processes a frame and returns output image
bool VideoTrackingSample::processFrame(const cv::Mat& inputFrame, cv::Mat& outputFrame)
{
    inputFrame.copyTo(outputFrame);
    
    getGray(inputFrame, m_nextImg);
    
    if (m_activeTrackingAlgorithm == TrackingAlgorithmKLT)
    {
        
        if (m_mask.rows != inputFrame.rows || m_mask.cols != inputFrame.cols)
            m_mask.create(inputFrame.rows, inputFrame.cols, CV_8UC1);
        
        if (m_prevPts.size() > 0)
        {
            cv::calcOpticalFlowPyrLK(m_prevImg, m_nextImg, m_prevPts, m_nextPts, m_status, m_error);
        }
        
        m_mask = cv::Scalar(255);
        
        std::vector<cv::Point2f> trackedPts;
        
        for (size_t i=0; i<m_status.size(); i++)
        {
            if (m_status[i])
            {
                trackedPts.push_back(m_nextPts[i]);
                
                cv::circle(m_mask, m_prevPts[i], 15, cv::Scalar(0), -1);
                cv::line(outputFrame, m_prevPts[i], m_nextPts[i], cv::Scalar(0,250,0));
                cv::circle(outputFrame, m_nextPts[i], 3, cv::Scalar(0,250,0), -1);
            }
        }
        
        bool needDetectAdditionalPoints = trackedPts.size() < m_maxNumberOfPoints;
        if (needDetectAdditionalPoints)
        {
            m_detector->detect(m_nextImg, m_nextKeypoints, m_mask);
            int pointsToDetect = m_maxNumberOfPoints -  trackedPts.size();
            
            if (m_nextKeypoints.size() > pointsToDetect)
            {
                std::random_shuffle(m_nextKeypoints.begin(), m_nextKeypoints.end());
                m_nextKeypoints.resize(pointsToDetect);
            }
            
            std::cout << "Detected additional " << m_nextKeypoints.size() << " points" << std::endl;
            
            for (size_t i=0; i<m_nextKeypoints.size(); i++)
            {
                trackedPts.push_back(m_nextKeypoints[i].pt);
                cv::circle(outputFrame, m_nextKeypoints[i].pt, 5, cv::Scalar(255,0,255), -1);
            }
        }
        
        m_prevPts = trackedPts;
        m_nextImg.copyTo(m_prevImg);
    }
    if (m_activeTrackingAlgorithm == TrackingAlgorithmORB)
    {
        m_orbFeatureEngine(m_nextImg, cv::Mat(), m_nextKeypoints, m_nextDescriptors);
        
        if (m_prevKeypoints.size() > 0)
        {
            std::vector< std::vector<cv::DMatch> > matches;
            m_orbMatcher.radiusMatch(m_nextDescriptors, m_prevDescriptors, matches, 10);
            
            for (size_t i=0; i<matches.size(); i++)
            {
                cv::Point prevPt = m_prevKeypoints[matches[i][0].trainIdx].pt;
                cv::Point nextPt = m_nextKeypoints[matches[i][0].queryIdx].pt;
                
                cv::circle(outputFrame, prevPt, 5, cv::Scalar(250,0,250), -1);
                cv::line(outputFrame, prevPt, nextPt, cv::Scalar(0,250,0));
                cv::circle(outputFrame, nextPt, 3, cv::Scalar(0,250,0), -1);
            }
        }
        
        m_prevKeypoints.swap(m_nextKeypoints);
        m_nextDescriptors.copyTo(m_prevDescriptors);
    }
    else if(m_activeTrackingAlgorithm == TrackingAlgorithmBRIEF)
    {
        m_fastDetector->detect(m_nextImg, m_nextKeypoints);
        m_briefExtractor->compute(m_nextImg, m_nextKeypoints, m_nextDescriptors);
        
        if (m_prevKeypoints.size() > 0)
        {
            std::vector< std::vector<cv::DMatch> > matches;
            m_orbMatcher.radiusMatch(m_nextDescriptors, m_prevDescriptors, matches, 10);
            
            for (size_t i=0; i<matches.size(); i++)
            {
                cv::Point prevPt = m_prevKeypoints[matches[i][0].trainIdx].pt;
                cv::Point nextPt = m_nextKeypoints[matches[i][0].queryIdx].pt;
                
                cv::circle(outputFrame, prevPt, 5, cv::Scalar(250,0,250), -1);
                cv::line(outputFrame, prevPt, nextPt, cv::Scalar(0,250,0));
                cv::circle(outputFrame, nextPt, 3, cv::Scalar(0,250,0), -1);
            }
//.........这里部分代码省略.........

// Contructor
reconstructor::reconstructor(cv::Mat &img)
{
    cont = 0;
    img.copyTo(inImg);
    img.copyTo(outImg);
}

PERF_TEST_P(Sz, DISABLED_GeneralizedHoughGuil, CUDA_TYPICAL_MAT_SIZES)
{
    declare.time(10);

    const cv::Size imageSize = GetParam();

    const cv::Mat templ = readImage("cv/shared/templ.png", cv::IMREAD_GRAYSCALE);
    ASSERT_FALSE(templ.empty());

    cv::Mat image(imageSize, CV_8UC1, cv::Scalar::all(0));
    templ.copyTo(image(cv::Rect(50, 50, templ.cols, templ.rows)));

    cv::RNG rng(123456789);
    const int objCount = rng.uniform(5, 15);
    for (int i = 0; i < objCount; ++i)
    {
        double scale = rng.uniform(0.7, 1.3);
        bool rotate = 1 == rng.uniform(0, 2);

        cv::Mat obj;
        cv::resize(templ, obj, cv::Size(), scale, scale);
        if (rotate)
            obj = obj.t();

        cv::Point pos;

        pos.x = rng.uniform(0, image.cols - obj.cols);
        pos.y = rng.uniform(0, image.rows - obj.rows);

        cv::Mat roi = image(cv::Rect(pos, obj.size()));
        cv::add(roi, obj, roi);
    }

    cv::Mat edges;
    cv::Canny(image, edges, 50, 100);

    cv::Mat dx, dy;
    cv::Sobel(image, dx, CV_32F, 1, 0);
    cv::Sobel(image, dy, CV_32F, 0, 1);

    if (PERF_RUN_CUDA())
    {
        cv::Ptr<cv::GeneralizedHoughGuil> alg = cv::cuda::createGeneralizedHoughGuil();
        alg->setMaxAngle(90.0);
        alg->setAngleStep(2.0);

        const cv::cuda::GpuMat d_edges(edges);
        const cv::cuda::GpuMat d_dx(dx);
        const cv::cuda::GpuMat d_dy(dy);
        cv::cuda::GpuMat positions;

        alg->setTemplate(cv::cuda::GpuMat(templ));

        TEST_CYCLE() alg->detect(d_edges, d_dx, d_dy, positions);
    }
    else
    {
        cv::Ptr<cv::GeneralizedHoughGuil> alg = cv::createGeneralizedHoughGuil();
        alg->setMaxAngle(90.0);
        alg->setAngleStep(2.0);

        cv::Mat positions;

        alg->setTemplate(templ);

        TEST_CYCLE() alg->detect(edges, dx, dy, positions);
    }

    // The algorithm is not stable yet.
    SANITY_CHECK_NOTHING();
}

bool ImageGenerator::InitMat(cv::Mat &frame)	// for video interface
{
	// image_.release();	// ??
	frame.copyTo(image_);
	return true;
}

void Image::operator()(const cv::Mat& frame) {
    frame.copyTo(img);
}

Image::Image(const cv::Mat& frame) {
    frame.copyTo(img);
}

// corners (z_all_l, z_all_r) and status are output variables
void trackFeatures(const cv::Mat &img_l, const cv::Mat &img_r, std::vector<cv::Point2f> &features_l, std::vector<cv::Point2f> &features_r, std::vector<int> &status,
        int stereo, int camNumber) {
    if (!img_l.data)
        throw "Left image is invalid";
    if (stereo && !img_r.data)
        throw "Right image is invalid";

    unsigned int numPoints = status.size();
    features_l.resize(numPoints);
    std::fill(features_l.begin(), features_l.end(), cv::Point2f(-100, -100));

    features_r.resize(numPoints);
    std::fill(features_r.begin(), features_r.end(), cv::Point2f(-100, -100));

    for (size_t i = 0; i < status.size() && i < numPoints; ++i) {
        if (status[i] == 1) {
            prev_status[i] = 1;
        } else {
            prev_status[i] = 0;  // if updateVect[i] == 0 feature is inactive, == 2 request new feature
        }
    }

    std::vector<unsigned char> status_left, status_right;
    std::vector<cv::Point2f> cur_corners, right_corners;
    std::vector<float> error;

    if (!prev_img[camNumber].empty()) {
        if (!prev_corners[camNumber].empty()) {
            cv::calcOpticalFlowPyrLK(prev_img[camNumber], img_l, prev_corners[camNumber], cur_corners, status_left, error, cv::Size(9, 9), 3);
            prev_corners[camNumber] = cur_corners;
            if (stereo == 2)
                cv::calcOpticalFlowPyrLK(img_l, img_r, prev_corners[camNumber], right_corners, status_right, error, cv::Size(9, 9), 3);

            for (size_t i = 0; i < prev_corners[camNumber].size() && i < numPoints; ++i) {
                if (!(prev_status[i] && status_left[i] && (stereo != 2 || status_right[i])))
                    prev_status[i] = 0;

                if (prev_status[i] == 1) {
                    if (prev_corners[camNumber][i].x < 0 || prev_corners[camNumber][i].x > img_l.cols || prev_corners[camNumber][i].y < 0 || prev_corners[camNumber][i].y > img_l.rows
                            || ((stereo == 2)
                                    && (right_corners[i].x < 0 || right_corners[i].x > img_l.cols || right_corners[i].y < 0 || right_corners[i].y > img_l.rows))) {
                        status[i] = 0;
                    } else {
                        features_l[i] = prev_corners[camNumber][i];

                        if (stereo == 2) {
                            features_r[i] = right_corners[i];
                        }
                        status[i] = 1;
                    }
                } else {
                    if (status[i] == 1)  // be careful not to overwrite 2s in updateVect
                        status[i] = 0;
                }
            }
        }
    }

    img_l.copyTo(prev_img[camNumber]);

    // initialize new points if needed
    initMorePoints(img_l, img_r, status, features_l, features_r, stereo, camNumber);
}

bool task3_5(const cv::Mat& image, const cv::Mat& orig) {
    cv::Mat grey, tmp, res;
    image.copyTo(grey);
    grey.convertTo(grey, CV_32F);

    grey.copyTo(res);
    res.convertTo(res, CV_8U);
    std::vector<cv::Mat> planes(2, cv::Mat());
    std::vector<cv::Mat> polar(2, cv::Mat());

    cv::dft(grey, tmp, cv::DFT_COMPLEX_OUTPUT);
    cv::split(tmp, planes);
    cv::cartToPolar(planes[0], planes[1], polar[0], polar[1]);

    int cx = polar[0].cols / 2;
    int cy = polar[0].rows / 2;
    cv::Point max;

    cv::Mat top = polar[0].rowRange(0, cx);
    cv::Mat bot = polar[0].rowRange(cx, polar[0].rows);

    int row = 0;
    do {
        cv::minMaxLoc(top.rowRange(row++, top.rows), 0, 0, 0, &max);
    } while (max.x == 0);


    int r = 3;

    cv::Mat noizeCol = polar[0].colRange(max.x - r, max.x + r);
    cv::Mat noizeRow = polar[0].rowRange(max.y - r, max.y + r);
    cv::Mat blurCol = polar[0].colRange(max.x - 12, max.x - 12 + 2 * r);
    cv::Mat blurRow = polar[0].rowRange(max.y - 3 * r, max.y - r);

    blurCol.copyTo(noizeCol);
    blurRow.copyTo(noizeRow);


    cv::Mat noizeColB = polar[0].colRange(polar[0].cols - max.x - r, polar[0].cols - max.x + r);
    cv::Mat noizeRowB = polar[0].rowRange(polar[0].rows - max.y - r, polar[0].rows - max.y + r);

    blurCol.copyTo(noizeColB);
    blurRow.copyTo(noizeRowB);

    cv::Mat roi = polar[0];
    cv::Mat mean, stddev, tmp1;
    roi = roi.colRange(max.x + 20, roi.cols - max.x - 20).rowRange(max.y + 20, roi.cols - max.y - 20);
    for (int i = 0; i < roi.rows; ++i) {
        cv::Mat row = roi.row(i);
        cv::meanStdDev(row, mean, stddev);
        float m = mean.at<double>(0, 0);
        float st = stddev.at<double>(0, 0);
        for (Mfit mfit = row.begin<float>(); mfit != row.end<float>(); ++mfit) {
            if (*mfit > m + 1.5 * st) {
                *mfit = 0.5 * m;
            }
        }
    }
    visualization(polar[0], tmp);

    //    
    //    
    //    cv::namedWindow("Lesson 2", CV_WINDOW_NORMAL);
    //    cv::imshow("Lesson 2", tmp);
    //    cv::waitKey(0);


    cv::polarToCart(polar[0], polar[1], planes[0], planes[1]);
    cv::merge(planes, tmp);
    cv::dft(tmp, tmp, cv::DFT_SCALE | cv::DFT_INVERSE | cv::DFT_REAL_OUTPUT);



    tmp.convertTo(tmp, CV_8U);



    cv::Mat lut(1, 256, CV_32F, cv::Scalar(0));
    for (int i = 0; i < 256; ++i) {
        lut.at<float>(0, i) = i;
    }

    for (int i = 65; i < 200; ++i) {
        lut.at<float>(0, i) = i - 30;
    }
    
    for (int i = 200; i < 220; ++i) {
        lut.at<float>(0, i) = i - 20;
    }
    
    lut.convertTo(lut, CV_8U);

    tmp.convertTo(tmp, CV_8U);

    cv::normalize(tmp, tmp, 0, 255, cv::NORM_MINMAX);
    
    cv::LUT(tmp, lut, tmp);


    cv::GaussianBlur(tmp, tmp, cv::Size(3, 3), 1);
//.........这里部分代码省略.........

cv::Mat DarkPixelFilter2Plugin::filter(const cv::Mat &data) const
{
    cv::Mat out;
    if (data.channels() > 1)
    {
        // create gray image
        std::vector<cv::Mat> iChannels(data.channels());
        cv::split(data, &iChannels[0]);

        double a = 1.0/iChannels.size();
        iChannels[0].convertTo(out, CV_32F, a);
        for (int i=1; i<iChannels.size();i++)
        {
            out += a*iChannels[i];
        }
    }
    else
    {
        if (data.depth() == CV_32F)
        {
            data.copyTo(out);
        }
        else
        {
            data.convertTo(out, CV_32F);
        }
    }

    // -) Compute mask from specified value:
    cv::Mat datamask;
    if (_maskByValue > -12345)
    {
        datamask = out != _maskByValue;
    }


    // -) Image -> 1/Image
    cv::divide(1.0,out,out,CV_32F);

    if (_verbose) { verboseDisplayImage("Image -> 1/Image", out); }
    emit progressValue(15);


    // -) Gaussian blur
    cv::GaussianBlur(out, out, cv::Size(_gbWinSize, _gbWinSize), _gbWinSize/1.5);
    if (_verbose) { verboseDisplayImage("Gaussian blur", out); }


    // -) Resize image
    int initW=out.cols, initH=out.rows;
    double rf = _resizeFactor;
    int newW = initW*rf;
    int newH = initH*rf;
    if (newW < 256 || newH < 256)
    {
        rf = qMax(256.0 / initW, 256.0 / initH);
        SD_TRACE1("New resize factor : %1", rf);
    }

    cv::resize(out, out, cv::Size(0, 0), rf, rf, cv::INTER_NEAREST);
    if (!datamask.empty())
    {
        cv::resize(datamask, datamask, cv::Size(0, 0), rf, rf, cv::INTER_NEAREST);
    }

    emit progressValue(25);

    // -) Convert to 8U
    {
        double minVal, maxVal;
        cv::minMaxLoc(out, &minVal, &maxVal, 0, 0,datamask);
        cv::Scalar mean, std;
        cv::meanStdDev(out, mean, std, datamask);
        double nmin = mean.val[0] - 3.0*std.val[0];
        minVal = (nmin < minVal) ? minVal : nmin;
        double nmax = mean.val[0] + 3.0*std.val[0];
        maxVal = (nmax > maxVal) ? maxVal : nmax;
        cv::Mat out8U;
        out.convertTo(out8U, CV_8U, 255.0/(maxVal-minVal), -255.0*minVal/(maxVal-minVal));
        out = out8U;
        emit progressValue(30);
    }

    // -) Median blur
    cv::medianBlur(out, out, 3);

    // -) Only bright objects
    {
        cv::Scalar mean = cv::mean(out, datamask);
        cv::threshold(out, out, mean[0], 255, cv::THRESH_TOZERO);
        cv::Mat mask, m = out == 0;
        m.convertTo(mask, out.type(), mean[0]/255.0);
        out = out + mask;
    }
    if (_verbose) { verboseDisplayImage("Only bright objects", out); }

    // -) Adaptive thresholding

    // Y = (Ymax - Ymin) * (X - Xmin)/(Xmax - Xmin) + Ymin
    // Y = (Ymin - Ymax) * (X - Xmin)/(Xmax - Xmin) + Ymax
//.........这里部分代码省略.........