Выполнение функции «imquantize» в opencv

Question

Я пытаюсь реализовать функцию Matlab, которая выполняется с помощью opencv. Какую функцию порога opencv я должен использовать для реализации функции Matlab multithresh? Как только было установлено пороговое значение, как я назову пиксели в соответствии с порогом? Это правильный способ реализации imquantize? Есть ли какая-нибудь другая функция, которую я должен включить в код?

Answer 1

Существует реализация на основе OpenCV here, где вы должны, вероятно, получить идею:

cv::Mat 
imquantize(const cv::Mat& in, const arma::fvec& thresholds) { 
    BOOST_ASSERT_MSG(cv::DataType<float>::type == in.type(), "input is not of type float"); 

    cv::Mat index(in.size(), in.type(), cv::Scalar::all(1)); 
    for (int i = 0; i < thresholds.size() ; i++) { 
     cv::Mat temp = (in > thresholds(i))/255; 
     temp.convertTo(temp, cv::DataType<float>::type); 
     index += temp; 
    } 

    return index; 
} 

Изменено: thresholds является вектором порогового поплавка значений (равномерным распределены # of levels, что вы хотите для квантования в пределах [0, 1]). Проверить the code snippet как он используется:

const float step = 1./levels[i]; 
arma::fvec thresh = arma::linspace<arma::fvec>(step, 1.-step, levels[i]-1); 
channels[i] = imquantize(channels[i], thresh); 

Answer 2

Я полагаю, вы ищете что-то вроде этого

/*function imquantize 
    * 'inputImage' is the input image. 
    * 'levels' is an array of threholds 
    * 'quantizedImage' is the reurned image 
    * with quantized levels. 
    */ 
Mat imquantize(Mat inputImage, vector<vector<int> > levels) 
{  
    //initialise output label matrix 
    Mat quantizedImage(inputImage.size(), inputImage.type(), Scalar::all(1));  

    //Apply labels to the pixels according to the thresholds 
    for (int i = 0; i < inputImage.cols; i++) 
    { 
     for (int j = 0; j < inputImage.rows; j++) 
     { 
      // Check if image is grayscale or BGR 
      if(levels.size() == 1) 
      { 
       for (int k = 0; k < levels[0].size(); k++) 
       { 
        // if pixel < lowest threshold , then assign 0 
        if(inputImage.at<uchar>(j,i) <= levels[0][0]) 
        { 
         quantizedImage.at<uchar>(j,i) = 0; 
        } 

        // if pixel > highest threshold , then assign 255 
        else if(inputImage.at<uchar>(j,i) >= levels[0][levels[0].size()-1]) 
        { 
         quantizedImage.at<uchar>(j,i) = 255; 
        } 

        // Check the level borders for pixel and assign the corresponding 
        // upper bound quanta to the pixel 
        else 
        { 
         if(levels[0][k] < inputImage.at<uchar>(j,i) && inputImage.at<uchar>(j,i) <= levels[0][k+1]) 
         { 
          quantizedImage.at<uchar>(j,i) = (k+1)*255/(levels[0].size()); 
         } 
        } 
       } 
      } 

      else 
      { 
       Vec3b pair = inputImage.at<Vec3b>(j,i); 

       // Processing the Blue Channel 
       for (int k = 0; k < levels[0].size(); k++) 
       { 
        if(pair.val[0] <= levels[0][0]) 
        { 
         quantizedImage.at<Vec3b>(j,i)[0] = 0; 
        } 
        else if(pair.val[0] >= levels[0][levels.size()-1]) 
        { 
         quantizedImage.at<Vec3b>(j,i)[0] = 255; 
        } 
        else 
        { 
         if(levels[0][k] < pair.val[0] && pair.val[0] <= levels[0][k+1]) 
         { 
          quantizedImage.at<Vec3b>(j,i)[0] = (k+1)*255/(levels[0].size()); 
         } 
        } 
       } 

       // Processing the Green Channel 
       for (int k = 0; k < levels[1].size(); k++) 
       { 
        if(pair.val[1] <= levels[1][0]) 
        { 
         quantizedImage.at<Vec3b>(j,i)[1] = 0; 
        } 
        else if(pair.val[1] >= levels[1][levels.size()-1]) 
        { 
         quantizedImage.at<Vec3b>(j,i)[1] = 255; 
        } 
        else 
        { 
         if(levels[1][k] < pair.val[1] && pair.val[1] <= levels[1][k+1]) 
         { 
          quantizedImage.at<Vec3b>(j,i)[1] = (k+1)*255/(levels[1].size()); 
         } 
        } 
       } 

       // Processing the Red Channel 
       for (int k = 0; k < levels[2].size(); k++) 
       { 
        if(pair.val[2] <= levels[2][0]) 
        { 
         quantizedImage.at<Vec3b>(j,i)[2] = 0; 
        } 
        else if(pair.val[2] >= levels[2][levels.size()-1]) 
        { 
         quantizedImage.at<Vec3b>(j,i)[2] = 255; 
        } 
        else 
        { 
         if(levels[2][k] < pair.val[2] && pair.val[2] <= levels[2][k+1]) 
         { 
          quantizedImage.at<Vec3b>(j,i)[2] = (k+1)*255/(levels[2].size()); 
         } 
        } 
       } 
      } 
     } 
    } 
    return quantizedImage; 
} 

В этой функции вход должен был быть Mat :: Изображение и 2D вектор, могут иметь разные уровни для разных каналов.