c++ सी++ के साथ ओपनसीवी में मैटलैब के इमाजस्टम के बराबर कोई फ़ंक्शन है?




सी++ प्रोग्राम्स (2)

आप उस व्यक्ति से यहां पूछने का प्रयास कर सकते हैं: http://opencv-users.1802565.n2.nabble.com/imadjust-matlab-function-with-stretchlim-OpenCV-implementation-td6253242.html

जिसने इसके कार्यान्वयन पर आधारित: http://www.mathworks.com/matlabcentral/fileexchange/12191-bilateral-filtering

फ़ाइल निम्न होनी चाहिए, लेकिन मुझे पूरी तरह यकीन नहीं है कि यह कार्य करता है:

void
getOptimalImgAdjustParamsFromHist (IplImage* p_img,unsigned int* p_optminmaxidx, int p_count)
{
  int numBins = 256;
  CvMat* bins = cvCreateMat(1,numBins,CV_8UC1);
  calcHistogram(p_img,bins,numBins);
  int sumlow = 0, sumhigh = 0;
  int low_idx = 0, high_idx = 0;
  for (unsigned int i = 0; i < numBins; i++) {
    float curval = (float) cvGetReal1D (bins, (i));
    sumlow += curval;
    if (sumlow >= p_count) {
      low_idx = i;
      break;
    }
  }
  for (unsigned int i = numBins - 1 ; i >= 0; i--) {
    float curval = (float) cvGetReal1D (bins, (i));
    sumhigh += curval;
    if (sumhigh >= p_count) {
      high_idx = i;
      break;
    }
  }
  cvReleaseMat(&bins);
  p_optminmaxidx[OPTMINIDX] = low_idx;
  p_optminmaxidx[OPTMAXIDX] = high_idx;
}

IplImage *
imageAdjust (IplImage * p_img)
{
  CvSize framesize = cvGetSize (p_img);
  int low_count = round (framesize.width * framesize.height * 0.01);
  unsigned int *optminmaxidx = new unsigned int [2];
  getOptimalImgAdjustParamsFromHist (p_img, optminmaxidx,low_count);
  int range = optminmaxidx[OPTMAXIDX] - optminmaxidx[OPTMINIDX];
  IplImage *adjustedImg = p_img;
  for (int i = 0; i < framesize.height; i++)
    for (int j = 0; j < framesize.width; j++) {
      unsigned int val = (unsigned int) getData (p_img, i, j);
      unsigned int newval = 0;
      if (val <= optminmaxidx[OPTMINIDX]) {
        newval = 0;
        setData (adjustedImg, i, j, (uchar) newval);
      } else if (val >= optminmaxidx[OPTMAXIDX]) {
        newval = 255;
        setData (adjustedImg, i, j, (uchar) newval);
      } else {
        newval =
            (unsigned int) round ((double) (((double) val -
                    (double) optminmaxidx[OPTMINIDX]) * (double) (255.0 /
                    (double) range)));
        setData (adjustedImg, i, j, (uchar) newval);
      }
    }
  delete[]optminmaxidx;
  return adjustedImg;
}

मुझे उम्मीद है इससे आपको मदद मिली होगी। फैब।

मैं imadjust में सुधार के विपरीत imadjust का उपयोग कर रहा हूँ क्या ओपेसीवी में कोई समान कार्य है?

एक Google सर्च ओपनसीवी प्रलेख चमक और विपरीत वृद्धि पर देता है लेकिन यह उन लूपों के लिए उपयोग करता है जो अक्षम हो सकते हैं। यहां तक ​​कि अगर हम मैट्रिक्स अभिव्यक्ति का उपयोग करके इसे कुशल बनाते हैं, तो यह क्या है जो imadjust करता है के बराबर नहीं है

क्या ओपनसीवी में कोई अंतर्निर्मित फ़ंक्शन है या काम के लिए कोई भी कुशल पद्धति है?

मैंने संबंधित पदों को देखा लेकिन वे या तो ओपनसीवी डॉक्टर से जुड़े हैं जो मैंने ऊपर उल्लेख किया है या वे हिस्टोग्राम समीकरण और थ्रेसहोल्डिंग का सुझाव देते हैं । मैं हिस्टोग्राम समीकरण के लिए imadjust करना पसंद करता imadjust और थ्रेसहोल्डिंग इसके विपरीत वृद्धि को करने के लिए प्रतीत नहीं होता है।

इस पर कोई मदद की सराहना की है।


हिस्टोग्राम को खींचने के लिए ओपनसीवी में कोई भी समाधान नहीं है, लेकिन आप इसे लूप में आसानी से कर सकते हैं।

imadjust ऊपरी और निचली सीमा के लिए एक सहिष्णुता का चयन करने की अनुमति देता है, या सीमा सीधे, ताकि आप पाश के लिए एक सरल से थोड़ा और तर्क की आवश्यकता है।

आप खुद को लागू करते समय संदर्भ के रूप में नीचे दिए गए उदाहरण का उपयोग कर सकते हैं:

#include <opencv2\opencv.hpp>
#include <vector>
#include <algorithm>

using namespace std;
using namespace cv;

void imadjust(const Mat1b& src, Mat1b& dst, int tol = 1, Vec2i in = Vec2i(0, 255), Vec2i out = Vec2i(0, 255))
{
    // src : input CV_8UC1 image
    // dst : output CV_8UC1 imge
    // tol : tolerance, from 0 to 100.
    // in  : src image bounds
    // out : dst image buonds

    dst = src.clone();

    tol = max(0, min(100, tol));

    if (tol > 0)
    {
        // Compute in and out limits

        // Histogram
        vector<int> hist(256, 0);
        for (int r = 0; r < src.rows; ++r) {
            for (int c = 0; c < src.cols; ++c) {
                hist[src(r,c)]++;
            }
        }

        // Cumulative histogram
        vector<int> cum = hist;
        for (int i = 1; i < hist.size(); ++i) {
            cum[i] = cum[i - 1] + hist[i];
        }

        // Compute bounds
        int total = src.rows * src.cols;
        int low_bound = total * tol / 100;
        int upp_bound = total * (100-tol) / 100;
        in[0] = distance(cum.begin(), lower_bound(cum.begin(), cum.end(), low_bound));
        in[1] = distance(cum.begin(), lower_bound(cum.begin(), cum.end(), upp_bound));

    }

    // Stretching
    float scale = float(out[1] - out[0]) / float(in[1] - in[0]);
    for (int r = 0; r < dst.rows; ++r)
    {
        for (int c = 0; c < dst.cols; ++c)
        {
            int vs = max(src(r, c) - in[0], 0);
            int vd = min(int(vs * scale + 0.5f) + out[0], out[1]);
            dst(r, c) = saturate_cast<uchar>(vd);
        }
    }
}

int main()
{
    Mat3b img = imread("path_to_image");

    Mat1b gray;
    cvtColor(img, gray, COLOR_RGB2GRAY);

    Mat1b adjusted;
    imadjust(gray, adjusted);

    // int low_in, high_in, low_out, high_out
    // imadjust(gray, adjusted, 0, Vec2i(low_in, high_in), Vec2i(low_out, high_out));

    return 0;
}

इनपुट छवि:

आउटपुट समायोजित छवि:





image-processing