Pengakuan sumber cahaya pada peta lingkungan

Artikel ini menyajikan implementasi algoritma Python untuk mengenali sumber cahaya pada peta lingkungan (LDR atau HDR) menggunakan proyeksi equirectangular. Namun, setelah melakukan perubahan kecil, itu juga dapat digunakan dengan gambar latar belakang sederhana atau peta kubik. Contoh penerapan algoritma yang mungkin: program penelusuran sinar di mana diperlukan untuk mengenali sumber cahaya primer agar dapat memancarkan sinar darinya; pada penyaji raster, ini dapat digunakan untuk melemparkan bayangan menggunakan peta lingkungan; selain itu, algoritme juga dapat digunakan dalam program penghapusan sorotan, misalnya dalam AR.

Algoritme terdiri dari langkah-langkah berikut:

1. Penurunan resolusi gambar asli, misalnya, ke 1024.
2. Konversikan gambar menjadi kecerahan (luminance), jika perlu, dengan gambar buram.
3. Penerapan metode quasi-Monte Carlo.
4. Transformasi dari koordinat bola ke koordinat yang sama.
5. Memfilter sampel berdasarkan kecerahan tetangga.
6. Sortir sampel berdasarkan kecerahannya.
7. Memfilter sampel berdasarkan metrik Euclidean.
8. Menggabungkan sampel menggunakan algoritma Bresenham.
9. Perhitungan posisi cluster pencahayaan berdasarkan kecerahannya.

Ada banyak algoritma untuk mengurangi resolusi gambar. Pemfilteran bilinear adalah yang tercepat atau termudah untuk diimplementasikan, dan selain itu, paling cocok dalam banyak kasus. Untuk mengonversi kecerahan di gambar LDR dan HDR, Anda dapat menggunakan rumus standar:

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

Selain itu, Anda dapat menerapkan sedikit kekaburan pada gambar kecerahan, misalnya, 1-2 piksel untuk gambar dengan resolusi 1024, untuk menghilangkan semua detail frekuensi tinggi (khususnya, yang disebabkan oleh penurunan resolusi).

Proyeksi yang Sama

Proyeksi yang paling umum di peta lingkungan adalah proyeksi yang sama rata ³ . Algoritme saya dapat bekerja dengan proyeksi lain, misalnya, dengan panorama dan peta kubik, namun, dalam artikel ini kami hanya akan mempertimbangkan proyeksi dengan jarak yang sama. Pertama, Anda perlu menormalkan koordinat gambar:

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

Maka kita perlu mengkonversi dari dan ke koordinat Cartesian menggunakan koordinat bola, mis. θ dan φ, di mana θ = x * 2π, dan φ = 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])) 

Hammersley Sampling

Langkah selanjutnya adalah menerapkan metode quasi-Monte Carlo, misalnya, sampel Hammersley ² :


Anda dapat menggunakan metode pengambilan sampel lainnya, seperti Holton ⁴ , tetapi Hammersley lebih cepat dan memberikan distribusi sampel yang baik di seluruh bidang. Holton akan menjadi pilihan yang baik untuk sampel bidang jika gambar sederhana digunakan sebagai pengganti peta lingkungan. Persyaratan wajib untuk pengambilan sampel Hammersley adalah pembalikan akar (baris) van der Corpute, untuk lebih jelasnya lihat tautan ² . Berikut ini adalah implementasinya yang cepat:

 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)) 

Lalu kami menggunakan overlay seragam di bola:

 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) 

Untuk mengambil sampel Hammersley, kami menggunakan jumlah sampel tetap, tergantung pada resolusi gambar, dan mengkonversi dari koordinat bola ke Cartesian, dan kemudian ke jarak yang sama:

  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] 

Ini akan memberi kami distribusi sampel yang baik yang akan diperiksa keberadaan sumber cahaya:

Memfilter sumber cahaya

Pada penyaringan pertama, kami mengabaikan semua sampel yang tidak melebihi ambang kecerahan (untuk kartu HDR, mungkin lebih tinggi), dan kemudian mengurutkan semua sampel berdasarkan kecerahannya:

  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) 

Lulus berikutnya akan melakukan penyaringan berdasarkan metrik Euclidean dan jarak ambang antara piksel (tergantung pada resolusi gambar) - ini adalah struktur data spasial yang dapat digunakan untuk menghilangkan kompleksitas O (N ² ):

  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 

Sampel yang dihasilkan melewati tahap penggabungan untuk lebih mengurangi jumlah sumber cahaya:

Menggabungkan sumber cahaya

Pada tahap terakhir, penggabungan sampel milik cluster pencahayaan yang sama dilakukan. Untuk melakukan ini, kita dapat menggunakan algoritma Bresenham dan mulai dengan sampel dengan kecerahan tertinggi, karena sudah dipesan. Ketika kami menemukan sumber cahaya yang memenuhi tes Bresenham, kami menggunakan posisinya untuk mengubah posisi sumber berdasarkan pada bobot pelarian:

  # 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) 

Fungsi Bresenham memeriksa garis kontinu yang memiliki kecerahan yang sama. Jika delta dalam piksel saat ini melebihi batas tertentu, maka pemeriksaan gagal:

 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 

Perlu dicatat bahwa, jika perlu, perbaikan dapat dilakukan pada uji Bresenham, yang akan mengarah pada penggabungan sampel yang lebih baik, misalnya, dapat memperhitungkan transfer horizontal sumber cahaya yang terletak di tepi gambar. Selain itu, fungsinya dapat dengan mudah diperluas sehingga mendekati area sumber cahaya. Peningkatan lainnya: Anda bisa menambahkan ambang jarak sehingga Anda tidak menggabungkan sampel yang terlalu jauh. Hasil akhir:


Biru menunjukkan maksimum lokal dari cluster pencahayaan, biru menunjukkan posisi akhir sumber cahaya, dan merah menunjukkan sampel yang merupakan bagian dari cluster pencahayaan yang sama dan dihubungkan oleh garis.

Contoh hasil lainnya:

---

1. Deteksi sumber cahaya dalam foto digital oleh Maciej Laskowski
2. Poin Hammersley di Belahan Bumi oleh Holger Dammertz
3. Proyeksi Equirectangular oleh Paul Reed
4. Sampling dengan Poin Hammersley dan Halton oleh Tien-Tsin Wong