🐾 ▶️ 🚣🏻 पर्यावरण के नक्शे पर प्रकाश स्रोतों की मान्यता 🚣🏾 🏨 🚒

यह लेख पर्यावरण के मानचित्र (एलडीआर या एचडीआर) पर एक अप्रत्यक्ष प्रक्षेपण का उपयोग करके प्रकाश स्रोतों को पहचानने के लिए एल्गोरिथ्म के पायथन कार्यान्वयन को प्रस्तुत करता है। हालांकि, मामूली बदलाव करने के बाद, इसे सरल पृष्ठभूमि छवियों या क्यूबिक मैप्स के साथ भी इस्तेमाल किया जा सकता है। एल्गोरिथ्म के संभावित अनुप्रयोग के उदाहरण: किरण अनुरेखण कार्यक्रम जिसमें प्राथमिक प्रकाश स्रोतों को पहचानना आवश्यक है ताकि उनसे किरणें निकल सकें; rasterized रेंडरर्स में, इसे एक पर्यावरण मानचित्र का उपयोग करके छाया डालने के लिए इस्तेमाल किया जा सकता है; इसके अलावा, एल्गोरिथ्म का उपयोग स्पॉटलाइट एलिमिनेशन कार्यक्रमों में भी किया जा सकता है, उदाहरण के लिए एआर में।

एल्गोरिथ्म में निम्न चरण होते हैं:

मूल छवि के संकल्प में कमी, उदाहरण के लिए, 1024 तक।
छवि को चमक के लिए परिवर्तित करें (luminance), यदि आवश्यक हो, छवि धब्बा के साथ।
अर्ध-मोंटे कार्लो पद्धति का अनुप्रयोग।
गोलाकार निर्देशांक से समवर्ती निर्देशांक में परिवर्तन।
पड़ोसी की चमक के आधार पर छानने के नमूने।
उनकी चमक के आधार पर नमूनों को क्रमबद्ध करें।
यूक्लिडियन मीट्रिक के आधार पर फ़िल्टरिंग नमूने।
ब्रेसेनहैम एल्गोरिथ्म का उपयोग कर नमूने जोड़ना।
इसकी चमक के आधार पर प्रकाश क्लस्टर की स्थिति की गणना।

छवियों के रिज़ॉल्यूशन को कम करने के लिए कई एल्गोरिदम हैं। बिलिनियर फ़िल्टरिंग सबसे तेज़ या लागू करने में आसान है, और इसके अलावा, यह ज्यादातर मामलों में सबसे उपयुक्त है। LDR और HDR दोनों छवियों में चमक बदलने के लिए, आप मानक सूत्र का उपयोग कर सकते हैं:

lum = img[:, :, 0] * 0.2126 + img[:, :, 1] * 0.7152 + img[:, :, 2] * 0.0722

इसके अतिरिक्त, आप ब्राइट इमेज के लिए एक मामूली ब्लर लगा सकते हैं, उदाहरण के लिए, 1024 के रिज़ॉल्यूशन वाली इमेज के लिए 1-2 पिक्सल, सभी हाई-फ्रीक्वेंसी डिटेल्स (विशेष रूप से, रिज़ॉल्यूशन में कमी के कारण) को खत्म करने के लिए।

इक्विडिस्टेंट प्रोजेक्शन

पर्यावरण के नक्शों में सबसे आम प्रक्षेपण है समकालिक प्रक्षेपण ³ । मेरा एल्गोरिथ्म अन्य अनुमानों के साथ काम कर सकता है, उदाहरण के लिए, पैनोरमिक और क्यूबिक मैप्स के साथ, हालांकि, लेख में हम केवल एक समान रूप से प्रायोजित प्रक्षेपण पर विचार करेंगे। सबसे पहले आपको छवि निर्देशांक को सामान्य करने की आवश्यकता है:

 pos[0] = x / width pos[1] = y / height

फिर हमें गोलाकार निर्देशांक का उपयोग करके और कार्टेसियन निर्देशांक से कन्वर्ट करने की आवश्यकता है, अर्थात्। φ और φ, जहां θ = x * 2 and, और * = y * φ।

 def sphereToEquirectangular(pos): invAngles = (0.1591, 0.3183) xy = (math.atan2(pos[1], pos[0]), math.asin(pos[2])) xy = (xy[0] * invAngles[0], xy[1] * invAngles[1]) return (xy[0] + 0.5, xy[1] + 0.5) def equirectangularToSphere(pos): angles = (1 / 0.1591, 1 / 0.3183) thetaPhi = (pos[0] - 0.5, pos[1] - 0.5) thetaPhi = (thetaPhi[0] * angles[0], thetaPhi[1] * angles[1]) length = math.cos(thetaPhi[1]) return (math.cos(thetaPhi[0]) * length, math.sin(thetaPhi[0]) * length, math.sin(thetaPhi[1]))

हैमरस्ली सैंपलिंग

अगला कदम क्वासी-मोंटे कार्लो पद्धति को लागू करना होगा, उदाहरण के लिए, हैमरस्ले ² नमूना:

आप अन्य नमूना तरीकों का उपयोग कर सकते हैं, जैसे कि होल्टन ⁴ , लेकिन हैमर्सली तेजी से है और पूरे क्षेत्र में नमूनों का अच्छा वितरण प्रदान करता है। यदि पर्यावरण मानचित्र के बजाय एक साधारण छवि का उपयोग किया जाता है, तो होल्टन विमान के नमूनों के लिए एक अच्छा विकल्प होगा। हैमरस्ली नमूने के लिए एक अनिवार्य आवश्यकता वैन डेर कॉर्पेट की जड़ों (पंक्ति) का उलटा है, अधिक जानकारी के लिए लिंक ² देखें। यहाँ इसका त्वरित कार्यान्वयन है:

 def vdcSequence(bits): bits = (bits << 16) | (bits >> 16) bits = ((bits & 0x55555555) << 1) | ((bits & 0xAAAAAAAA) >> 1) bits = ((bits & 0x33333333) << 2) | ((bits & 0xCCCCCCCC) >> 2) bits = ((bits & 0x0F0F0F0F) << 4) | ((bits & 0xF0F0F0F0) >> 4) bits = ((bits & 0x00FF00FF) << 8) | ((bits & 0xFF00FF00) >> 8) return float(bits) * 2.3283064365386963e-10 # / 0x100000000 def hammersleySequence(i, N): return (float(i) / float(N), vdcSequence(i))

फिर हम गोले पर समान उपरिशायी का उपयोग करते हैं:

 def sphereSample(u, v): PI = 3.14159265358979 phi = v * 2.0 * PI cosTheta = 2.0 * u - 1.0 # map to -1,1 sinTheta = math.sqrt(1.0 - cosTheta * cosTheta); return (math.cos(phi) * sinTheta, math.sin(phi) * sinTheta, cosTheta)

हैमरस्ले का नमूना लेने के लिए, हम एक निश्चित संख्या में नमूने का उपयोग करते हैं, जो छवि के संकल्प पर निर्भर करता है, और गोलाकार निर्देशांक से कार्टेशियन में परिवर्तित होता है, और फिर समतुल्य के लिए:

  samplesMultiplier = 0.006 samples = int(samplesMultiplier * width * height) samplesList = [] # apply hammersley sampling for i in range(0, samples): xi = hammersleySequence(i, samples) xyz = sphereSample(xi[0], xi[1]) # to cartesian imagePos = sphereToEquirectangular(xyz) luminance = lum[imagePos[0] * width, imagePos[1] * height]

यह हमें उन नमूनों का अच्छा वितरण देगा जो प्रकाश स्रोतों की उपस्थिति के लिए जांचे जाएंगे:

प्रकाश स्रोतों को छानना

फ़िल्टरिंग के पहले पास में, हम सभी नमूनों को अनदेखा करते हैं जो चमक दहलीज से अधिक नहीं होते हैं (एचडीआर कार्ड के लिए, यह अधिक हो सकता है), और फिर उनकी चमक से सभी नमूनों को क्रमबद्ध करें:

  localSize = int(float(12) * (width / 1024.0)) + 1 samplesList = [] # apply hammersley sampling for i in range(0, samples): xi = hammersleySequence(i, samples) xyz = sphereSample(xi[0], xi[1]) # to cartesian imagePos = sphereToEquirectangular(xyz) luminance = lum[imagePos [0] * width, imagePos [1] * height] sample = Sample(luminance, imagePos , xyz) luminanceThreshold = 0.8 #do a neighbour search for the maximum luminance nLum = computeNeighborLuminance(lum, width, height, sample.imagePos, localSize) if nLum > luminanceThreshold: samplesList.append(sample) samplesList = sorted(samplesList, key=lambda obj: obj.luminance, reverse=True)

अगला पास यूक्लिडियन मीट्रिक के आधार पर फ़िल्टरिंग करेगा और पिक्सेल के बीच की दहलीज दूरी (छवि रिज़ॉल्यूशन के आधार पर) - यह एक स्थानिक डेटा संरचना है जिसका उपयोग जटिलता ओ (एन ² ) से छुटकारा पाने के लिए किया जा सकता है:

  euclideanThreshold = int(float(euclideanThresholdPixel) * (width / 2048.0)) # filter based euclidian distance filteredCount = len(samplesList) localIndices = np.empty(filteredCount); localIndices.fill(-1) for i in range(0, filteredCount): cpos = samplesList[i].pos if localIndices[i] == -1: localIndices[i] = i for j in range(0, filteredCount): if i != j and localIndices[j] == -1 and distance2d(cpos, samplesList[j].pos) < euclideanThreshold: localIndices[j] = i

परिणामस्वरूप नमूने प्रकाश स्रोतों की संख्या को कम करने के लिए विलय चरण के माध्यम से जाते हैं:

प्रकाश स्रोतों का विलय

अंतिम चरण में, एक ही प्रकाश क्लस्टर से संबंधित नमूनों का विलय किया जाता है। ऐसा करने के लिए, हम ब्रेसेनहैम एल्गोरिथ्म का उपयोग कर सकते हैं और उच्चतम चमक के साथ नमूनों के साथ शुरू कर सकते हैं, क्योंकि वे पहले से ही ऑर्डर किए गए हैं। जब हमें एक प्रकाश स्रोत मिलता है जो ब्रेसेनहैम परीक्षण को संतुष्ट करता है, तो हम इसकी स्थिति का उपयोग रन के वजन के आधार पर स्रोत की स्थिति को बदलने के लिए करते हैं:

  # apply bresenham check and compute position of the light clusters lights = [] finalIndices = np.empty(filteredCount); finalIndices.fill(-1) for i in localIndices: sample = samplesList[i] startPos = sample.pos if finalIndices[i] == -1: finalIndices[i] = i light = Light() light.originalPos = np.array(sample.pos) # position of the local maxima light.worldPos = np.array(sample.worldPos) light.pos = np.array(sample.pos) light.luminance = sample.luminance for j in localIndices: if i != j and finalIndices[j] == -1: endPos = samplesList[j].pos if bresenhamCheck(lum, width, height, startPos[0], startPos[1], endPos[0], endPos[1]): finalIndices[j] = i # compute final position of the light source sampleWeight = samplesList[j].luminance / sample.luminance light.pos = light.pos + np.array(endPos) * sampleWeight light.pos = light.pos / (1.0 + sampleWeight) imagePos = light.pos * np.array([1.0 / width, 1.0 / height) light.worldPos = equirectangularToSphere(imagePos) lights.append(light)

ब्रेसेनहैम फ़ंक्शन एक निरंतर रेखा की जांच करता है जिसमें समान चमक होती है। यदि वर्तमान पिक्सेल में डेल्टा एक निश्चित सीमा से अधिक है, तो जाँच विफल हो जाती है:

 def bresenhamCheck(lum, imageSize, x0, y0, x1, y1): dX = int(x1 - x0) stepX = int((dX > 0) - (dX < 0)) dX = abs(dX) << 1 dY = int(y1 - y0) stepY = int((dY > 0) - (dY < 0)) dY = abs(dY) << 1 luminanceThreshold = 0.15 prevLum = lum[x0][y0] sumLum = 0.0 c = 0 if (dX >= dY): # delta may go below zero delta = int (dY - (dX >> 1)) while (x0 != x1): # reduce delta, while taking into account the corner case of delta == 0 if ((delta > 0) or (delta == 0 and (stepX > 0))): delta -= dX y0 += stepY delta += dY x0 += stepX sumLum = sumLum + min(lum[x0][y0], 1.25) c = c + 1 if(abs(sumLum / c - prevLum) > luminanceThreshold and (sumLum / c) < 1.0): return 0 else: # delta may go below zero delta = int(dX - (dY >> 1)) while (y0 != y1): # reduce delta, while taking into account the corner case of delta == 0 if ((delta > 0) or (delta == 0 and (stepY > 0))): delta -= dY x0 += stepX delta += dX y0 += stepY sumLum = sumLum + min(lum[x0][y0], 1.25) c = c + 1 if(abs(sumLum / c - prevLum) > luminanceThreshold and (sumLum / c) < 1.0): return 0 return 1

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

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

परिणामों के अन्य उदाहरण:

पर्यावरण के नक्शे पर प्रकाश स्रोतों की मान्यता

इक्विडिस्टेंट प्रोजेक्शन

हैमरस्ली सैंपलिंग

प्रकाश स्रोतों को छानना

प्रकाश स्रोतों का विलय

More articles: