छवि विपरीत बदलने के लिए एक RGB एल्गोरिथ्म को लागू करना

वीडियो स्ट्रीम को संसाधित करने के लिए डिज़ाइन किए गए प्रोग्राम पर काम करते समय, छवि के विपरीत को बदलने के लिए एक एल्गोरिथ्म को लागू करना आवश्यक हो गया।

चूंकि वीडियो प्रसंस्करण के लिए कार्यक्रम का इरादा था, कार्यान्वयन के लिए उच्च प्रदर्शन की आवश्यकता थी, जिसमें पूर्ण HD वीडियो रिज़ॉल्यूशन को संसाधित करने की क्षमता भी शामिल थी। OpenMP लाइब्रेरी का उपयोग करके कोड C ++ में लिखा गया था।



इसके विपरीत बदलने के लिए कई एल्गोरिदम हैं, जिनमें से कुछ को इस लेख में माना जाता है [1]।

इसके विपरीत बदलने के लिए RGB एल्गोरिथ्म पर विचार करें।
सबसे पहले, हम छवि lAB की औसत चमक की गणना करते हैं। हम लूप को समानांतर बनाने के लिए OpenMP निर्देश का उपयोग करते हैं:

#pragma omp parallel for private(valueB,valueG,valueR) reduction(+:lAB) schedule(static,1) for (int j = 0; j < ptrImage->imageSize; j = j+3) { valueB = ptrImage->imageData[j]; valueG = ptrImage->imageData[j+1]; valueR = ptrImage->imageData[j+2]; lAB += (int)(valueR * 0.299 + valueG * 0.587 + valueB * 0.114); } //  lAB /= imageRows * imageCols; 

फिर, प्रत्येक रंग घटकों R, G, और B में से प्रत्येक के लिए प्रत्येक पिक्सेल के लिए, हमें औसत चमक मान डेल्टा से विचलन खोजना होगा, और इसके विपरीत कश्मीर के लाभ (क्षीणन) द्वारा इस विचलन को गुणा करना होगा। किसी छवि में सभी पिक्सेल पर सीधे प्रदर्शन करना बहुत महंगा है। इसलिए, यह देखते हुए कि हम पिक्सेल के सभी रंग घटकों को उसी तरह से परिवर्तित करते हैं, हम 256 मूल्यों की एक सरणी पेश करते हैं जो प्रत्येक रंग घटक के लिए पैलेट का प्रतिनिधित्व करेगा। सरणी का सूचकांक रंग घटक के पुराने मूल्य से मेल खाता है, और सरणी का मान परिवर्तित वाले से मेल खाता है। इस प्रकार, पैलेट के विपरीत बदलने के लिए पहले वर्णित परिवर्तनों को लागू करते हुए, हम प्राप्त करते हैं:

 //  double k = 1.0 + correction / 100.0; for (int i = 0; i < 256; i++) { int delta = (int)i - lAB; int temp = (int)(lAB + k *delta); if (temp < 0) temp = 0; if (temp >= 255) temp = 255; b[i] = (unsigned char)temp; } 

और फिर, हम पूरी छवि के पिक्सेल के लिए नए मान लागू करते हैं, परिणामी पैलेट सरणी का उपयोग करते हुए, नए के साथ पिक्सेल के रंग घटक के पुराने मूल्य की तुलना करते हैं:

 #pragma omp parallel for firstprivate(b) for (int j = 0; j < ptrImage->imageSize; j++) { unsigned char value = ptrImage->imageData[j]; ptrImage->imageData[j] = (unsigned char)b[value]; } 

विपरीत को बदलने के लिए फ़ंक्शन का संपूर्ण स्रोत कोड:

 const int L = 256; void AddContrastFilter(IplImage* ptrImage, int _correction) { //     4,      omp_set_num_threads(4); int correction = _correction; // int b[L]; //    int imageRows = ptrImage->height; int imageCols = ptrImage->width; int lAB = 0; unsigned char valueB = 0; unsigned char valueG= 0; unsigned char valueR= 0; //    #pragma omp parallel for private(valueB,valueG,valueR) reduction(+:lAB) schedule(static,1) for (int j = 0; j < ptrImage->imageSize; j = j+3) { valueB = ptrImage->imageData[j]; valueG = ptrImage->imageData[j+1]; valueR = ptrImage->imageData[j+2]; lAB += (int)(valueR * 0.299 + valueG * 0.587 + valueB * 0.114); } //    lAB /= imageRows * imageCols; //  double k = 1.0 + correction / 100.0; //RGB    for (int i = 0; i < L; i++) { int delta = (int)i - lAB; int temp = (int)(lAB + k *delta); if (temp < 0) temp = 0; if (temp >= 255) temp = 255; b[i] = (unsigned char)temp; } #pragma omp parallel for firstprivate(b) for (int j = 0; j < ptrImage->imageSize; j++) { unsigned char value = ptrImage->imageData[j]; ptrImage->imageData[j] = (unsigned char)b[value]; } return 0; } 

यह मेरे लिए निकला कि चार-कोर इंटेल Xeon प्रोसेसर पर एक पूर्ण HD फ्रेम के विपरीत को बदलने में लगभग 8 एमएस समय लगता है।

संदर्भ

1. सॉफ्टवेयर में कंट्रास्ट का रूपांतरण: http://www.kweii.com/site/color_theory/Contrast100_en.pdf