🚵🏽 🧗🏿 💅🏽 TI DM368 प्रोसेसर पर वीडियो प्रसंस्करण के लिए एल्गोरिदम, जारी ... 👚 🖖🏽 👩🏽‍🌾

लेख के पहले भाग में, हमने TI DM368 वीडियो प्रोसेसर बनाने वाले हार्डवेयर ब्लॉकों की जांच की, और अब हम अपने एल्गोरिदम और कोड के अवलोकन पर आगे बढ़ते हैं।

पूरा कैमरा हार्डवेयर पाइपलाइन स्ट्रीमिंग मोड में काम करता है, अर्थात्, एक ब्लॉक द्वारा एक पिक्सेल को संसाधित करने के तुरंत बाद, इसे अगले पर प्रसारित किया जाता है। वीडियो प्रोसेसर सॉफ़्टवेयर, जब चालू होता है, तो पैरामीटर सेट करता है और सभी पाइपलाइनों को इनिशियलाइज़ करता है, फिर प्रत्येक फ्रेम को प्रोसेस करने के एक सतत चक्र में प्रवेश करता है। यदि सेंसर फ्रेम दर 30 एफपीएस है, तो सभी आवश्यक कार्यों को प्रति सेकंड 30 गुना कहा जाएगा।

अब एल्गोरिदम के संचालन के सिद्धांतों के बारे में। एई (ऑटो एक्सपोज़) एल्गोरिथ्म का सार एक्सपोज़र के मूल्यों, गुणन के गुणांक (लाभ) और शिफ्ट (ऑफसेट) को सेट करना है ताकि आउटपुट को न्यूनतम संख्या में अतिप्राप्त और अंधेरे क्षेत्रों के साथ एक चित्र प्राप्त होगा।

एक्सपोजर या इलेक्ट्रॉनिक शटर सेंसर में प्रकाश की मात्रा के प्रवेश के लिए जिम्मेदार है। आधुनिक सेंसर में, यह 1,000,000 से 1 माइक्रोसेकंड तक भिन्न हो सकता है, इसलिए प्रकाश की तीव्रता को सीमित करने के लिए एक डायाफ्राम का उपयोग करने की आवश्यकता नहीं है। लाभ और ऑफसेट का उपयोग 12 बिट्स से 8 में बदलने के लिए किया जाता है, और इसे 8-बिट डायनेमिक रेंज को अधिकतम करने के लिए चुना जाता है।

एक्सपोज़र मान का निर्धारण कैसे करें? हमने कई विकल्पों की कोशिश की: हमने इसे ऊपर से सीमित कर दिया, अर्थात, हमने एक्सपोज़र को बदल दिया ताकि हिस्टोग्राम का अधिकतम मूल्य एक निश्चित सीमा से कम हो, और हमने हिस्टोग्राम की निचली सीमा को एक निश्चित मूल्य तक कम कर दिया।

एक और दूसरी विधि दोनों पूरी गतिशील रेंज का अधिकतम उपयोग करते हैं, लेकिन इसमें एक खामी है - एक चमकदार धूप के दिन, छाया में वस्तुएं व्यावहारिक रूप से अदृश्य हैं। इस प्रकार, डिमिंग पर विचार करने के लिए, कभी-कभी दृश्य के कुछ हिस्सों को ओवरएक्सपोज़र करना बेहतर होता है। इसलिए, हमने मुफ्त तैराकी के लिए अधिकतम हिस्टोग्राम जारी किया और एक्सपोज़र का चयन किया ताकि वाई का औसत मूल्य चयनित मूल्य के साथ मेल खाता हो।

एल्गोरिदम पर आगे बढ़ने का समय है, चलो ऑटो एक्सपोज़र से शुरू करते हैं:

1. एल्गोरिथ्म का काम बॉक्सकार से आंकड़े डेटा प्राप्त करने से शुरू होता है।

Uint32 w, h; Uint16 *box; status = DRV_ipipeGetBoxcarBuf(&bufId, 0); if(status!= OSA_SOK) { OSA_ERROR("ERROR: DRV_ipipeGetBoxcarBuf()\n"); return status; } pBufInfo = DRV_ipipeGetBoxcarBufInfo(bufId); DRV_ipipePutBoxcarBuf(bufId); box = pBufInfo->virtAddr; w = gDRV_ipipeObj.boxcarInfo.width; //Boxcar width h = gDRV_ipipeObj.boxcarInfo.height; // Boxcar height

2. फिर, इन आंकड़ों के आधार पर, एक हिस्टोग्राम का निर्माण किया जाता है और वाई के औसत मूल्य की गणना की जाती है।

 Uint32 sz = w*h, sz4 = sz*4, hsz = 512; Uint32 hist[hsz]; int GN[3] = { -16, 0, 16}; memset(hist, 0, sizeof(Uint32)*hsz); //AE and WB for(i=0; i < sz4; i+=4) { r = box[i+2]>>2; g = box[i+1]>>2; b = box[i ]>>2; RR += r; GG += g; BB += b; Y += ((117*b + 601*g + 306*r)>>10); hist[r>>3]++; hist[g>>3]++; hist[b>>3]++; for(j=0; j < ns; j++) { GB[j] += abs(g - (b*(512 + GN[j])>>9)); GR[j] += abs(g - (r*(512 + GN[j])>>9)); } } Y = Y/sz; hn->Y.New = Y; RR = RR/sz; GG = GG/sz; BB = BB/sz;

3. हिस्टोग्राम का न्यूनतम मूल्य ज्ञात कीजिए।

  //Find histogram min sum = 0; for(i=0; sum < hn->SatTh; i++) sum += hist[i]; hn->Hmin.New = i; //Find histogram max sum = 0; for(i=hsz-1; sum < hn->SatTh; i--) sum += hist[i]; hn->Hmax.New = i;

4. एक्सपोज़र वैल्यू बदलें। यदि Y के औसत मूल्य का मूल्य हमारी सीमा YAE से दो गुना अधिक या कम है, तो परिवर्तन का चरण बढ़ जाता है, और यदि Y में परिवर्तन 20% से कम है, तो एक्सपोज़र नहीं बदलता है।

  if(hn->Y.New) tmp = (hn->Y.New > hn->YAE) ? hn->Y.New*100/hn->YAE : hn->YAE*100/hn->Y.New; if(tmp > 200){ if(hn->Y.New) hn->Exp.New = hn->Exp.Old*(hn->Y.New*2 + hn->YAE)/(hn->Y.New*3); } else if(tmp > 20){ if(hn->Y.New > hn->YAE) hn->Exp.New = hn->Exp.Old*99/100; else hn->Exp.New = hn->Exp.Old*100/99; } if(hn->Exp.New > hn->Exp.Range.max) hn->Exp.New = hn->Exp.Range.max;

5. वीडियो स्ट्रीम की तस्वीर को आसानी से बदलने के लिए, हम एई एल्गोरिथ्म में उपयोग किए गए मूल्यों के अंतिम कुछ मूल्यों का औसत करते हैं:

 #define HISTORY 30 int history = 0; typedef struct IAEWBF_Param{ XDAS_Int32 Old; //Old value XDAS_Int32 New; //New value XDAS_Int32 Step; //The step of changing XDAS_Int32 Avrg; //Sum of all history value XDAS_Int32 Change; //Need for smooth change XDAS_Int32 Hist[HISTORY]; //History array XDAS_Int32 HistC; //History count XDAS_Int32 NewA; //Avarage of value IAEWBF_Range Range; //The range of value changes }IAEWBF_Param; int add_history(IAEWBF_Param *p) { int diff = 0; p->Avrg += p->New; p->Avrg -= p->Hist[p->HistC]; if(p->New) diff = abs(p->Hist[p->HistC] - p->New)*100/p->New; p->Hist[p->HistC] = p->New; p->HistC = (p->HistC == (HISTORY - 1)) ? 0 : p->HistC + 1; p->NewA = (history < HISTORY) ? p->Avrg/history : p->Avrg/HISTORY; return diff; } history++; add_history(&hn->Hmax); add_history(&hn->Hmin); add_history(&hn->Y);

6. और अंत में, AE का अंतिम चरण लाभ और बदलाव निर्धारित करना है। आउटपुट पर, हम इस तथ्य पर ध्यान केंद्रित करते हैं कि Y का औसत मूल्य आउटपुट रेंज HmaxTh के बीच में लगभग गिरता है। गामा सुधार और प्रयोग को देखते हुए, यह मान hn-> HmaxTh / 4 के बराबर है।

  //Change the offset and gain hn->Offset.New = hn->Hmin.NewA; if(hn->Y.NewA - hn->Offset.New) hn->GIFIF.New = ((hn->HmaxTh/4)*512)/(hn->Y.NewA - hn->Offset.New); up = hn->Hmax.NewA*hn->GIFIF.New>>9; if((up < hn->HmaxTh) && (hn->Y.NewA - hn->Offset.New)) if(hn->Y.NewA - hn->Offset.New) hn->GIFIF.New = (((hn->HmaxTh*2 - up)/4)*512)/(hn->Y.NewA - hn->Offset.New); //Check gain range hn->GIFIF.New = hn->GIFIF.New > hn->GIFIF.Range.max ? hn->GIFIF.Range.max : hn->GIFIF.New; hn->GIFIF.New = hn->GIFIF.New < hn->GIFIF.Range.min ? hn->GIFIF.Range.min : hn->GIFIF.New;

अब सफेद संतुलन (WB) पर चलते हैं।

इसे स्थापित करने के लिए कई एल्गोरिदम हैं, हम उनमें से 2 का उपयोग अपने कैमरे में करते हैं।

दिन के मोड में, हम पूरे चित्र में स्थानीय रंग विचलन को कम करते हैं। चूंकि सफेद, काले और भूरे रंग में आर = जी = बी होता है, और सफेद भी दृश्य में सबसे उज्ज्वल है, इसकी न्यूनता कुल ऊर्जा में सबसे बड़ा योगदान देती है।

रात में, जब इन्फ्रारेड फ़िल्टर खुला होता है, तो हम ग्रे वर्ल्ड एल्गोरिथम का उपयोग करते हैं, अर्थात हम केवल रंग के साधनों को संरेखित करते हैं।

मुख्य चक्र में, हिस्टोग्राम को भरते समय, हम हरे रंग से लाल जीआर [जे] और ब्लू जीबी [जे] के कुल विचलन के मूल्यों की तलाश करते हैं और आंदोलन की दिशा को न्यूनतम तक पाते हैं:

  if(IRcutClose){ min = GR[0]; minr = 0; for(j=1; j < ns; j++){ if(GR[j] < min) { min = GR[j]; minr = j; } } min = GB[0]; minb = 0; for(j=1; j < ns; j++){ if(GB[j] < min) { min = GB[j]; minb = j; } } if(minr != 1) hn->Rgain.New = hn->Rgain.Old + (GN[minr]*hn->Rgain.Old/512); if(minb != 1) hn->Bgain.New = hn->Bgain.Old + (GN[minb]*hn->Bgain.Old/512); } else { //Night AW mode if(RR) hn->Rgain.New = GG*hn->Rgain.Old/RR; if(BB) hn->Bgain.New = GG*hn->Bgain.Old/BB; }

अलग-अलग सेंसर में पूरी तरह से अलग-अलग रंग विचलन होते हैं, लेकिन एल्गोरिथ्म दिन के दौरान हमेशा सही तरीके से काम करता है, सफेद संतुलन से पहले और बाद में सोनी IMX136 सेंसर के लिए एक उदाहरण:

आइए हम गामा सुधार पर ध्यान केंद्रित करते हैं, यह कैमरे की संवेदनशीलता और मानव आंख को संरेखित करने के लिए आवश्यक है। एक नियम के रूप में, परिवर्तन फ़ंक्शन में एक शक्ति-कानून निर्भरता है, लेकिन हम एक और का उपयोग करते हैं, हमारी व्यक्तिपरक संवेदनाओं के अनुसार, यह संकेत देता है:

गाम [i] = आउट * ((लॉग (आई + इन *) - लॉग (* में ए) / / (लॉग इन (इन * ए) - लॉग (* ए)));

इनपुट रेंज की अधिकतम सीमा कहां है,

अधिकतम - अधिकतम उत्पादन सीमा,

एक वक्रता गुणांक है (हमारे मामले में, 0.05 विभिन्न दृश्यों के लिए सबसे उपयुक्त है)

सिस्टम को इनिशियलाइज़ करते समय, हम इस वक्र को LUT टेबल में लोड करते हैं और प्रत्येक फ्रेम इसके अंदर से गुजरता है। गामा सुधार कैसे तस्वीर बदलता है इसका एक उदाहरण:

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

हमारे कैमरों के फ़र्मवेयर के लिए स्रोत कोड Git संस्करण नियंत्रण प्रणाली के माध्यम से उपलब्ध है: git: //sigrand.ru/sigticam.git। स्रोत कोड को डाउनलोड करने के लिए, आप निम्नलिखित कमांड का उपयोग कर सकते हैं: git क्लोन git: //sigrand.ru/sigticam.it।

उपरोक्त एल्गोरिदम डायरेक्टरी सिग्टिकैम / सिग्टिकैम / प्लेटफॉर्म / ti_dm368 / appro2 / av_capture / फ्रेमवर्क / alg / src / aewbf_sig में हैं

आप हमारे कैमरों से लाइव प्रसारण देख सकते हैं, न कि केवल हमारे यहाँ ।

अगले लेख में, हम देखेंगे कि हमारे कैमरों में ऑटोफोकस कैसे लागू किया जाता है

और एचडीआर या डब्ल्यूडीआर की व्यापक गतिशील सीमा क्या है।

।

TI DM368 प्रोसेसर पर वीडियो प्रसंस्करण के लिए एल्गोरिदम, जारी ...

More articles: