Ich hab da noch mal drüber nachgedacht, und ich denke, mehr als eine ungefähre Abschätzung ist eigentlich gar nicht möglich.

Mal zuerst, ich möchte nicht deinen BCC schlechtreden, da die Idee sehr gut ist. So ein Tool wäre sehr nützlich und sowas programmieren finde ich sehr spannend.

Ich denke aber, dass die Aufgabe nicht lösbar ist. Die Reliefkarte ist ja im Endeffekt eine Lightmap, und die Heightmap eine Bumpmap. Man muss hier also das Bumpmapping reversieren.

Um von einer Bumpmap auf eine Lightmap zu kommen muss man zwei Schritte machen, die beide verlustbehaftet sind, nämlich muss man die Bumpmap in eine Normalmap umwandeln, und die dann eine Lightmap.

Die Normalmap ist eine Umformung der ersten Ableitung der Bumpmap. Hierbei gehen die originalen Höheninformationen verloren, es bleiben nur mehr die Winkel jedes Texels übrig. Das lässt sich noch korrigieren, wenn es rund um das Bild einen Ramen mit Höhe 0 gibt (wie in deinem 2. Bild).

Von der Normalmap zur Lightmap kommt man so: (für jedes Texel)

lightmap[x,y] = dot(normalmap[x,y], lightvector)

Leider ist das Dot-Product auch verlustbehaftet. Das sieht ja so aus:

dot(v, u) = vx*ux + vy*uy + vz*uz

Das heißt, wenn der Lightvector bekannt ist, und das Ergebnis des Dot-Products (steht ja in der Lightmap), die drei Koordinaten der Normalmap aber nicht, dann gibt es hier ein Problem: man muss 3 Variablen ein einer Gleichung finden, was nicht möglich ist. Man braucht immer mindestens so viele Gleichungen in einem Gleichungssystem wie Variablen die man lösen möchte.

So gibt es einen ganzen "Ring" an möglichen Lösungsvektoren für jede dieser Gleichungen. So ist es bei einer Lichtquelle mit den Werte Azimut 135° und Elevation 45° nicht sicher, ob z.B. der Azimut des Normalvektors 130° oder 140° beträgt, oder die Elevation 40° oder 50° beträgt, da das Dot-Product nur die Abweichung der zwei Vektoren widerspiegelt. Problematischer wird es dann noch wenn es sich um eine Kombination der Abweichungen handelt, also wo sowohl Azimut und Elevation sich von der Lichtquelle unterscheiden (was leider fast immer der Fall sein wird).

Hast du eine Idee wie man da noch drum rum kommen kann?

Grüße,
Dakkaron

DAK hat Folgendes geschrieben:

Das ist korrekt. Manch ein Praktiker oder Mathematiker mag mir da sicher widersprechen, aber wenn's um meine Meinung geht, dann sieht die so aus, dass es nicht eindeutig rekonstruierbar ist. Ist ja aber auch nicht gefragt. Es reicht eine mögliche Rekonstruktion. Die Aufgabenstellung lässt es eigentlich sogar zu, den Rand als gleichhoch zu betrachten und dann in eine Richtung zu scannen. Der Mensch wird zwar einen Fehler erkennen, weil so auf eindeutig (=scheinbar) flachen Flächen Stufen entstehen.

Selbstverständlich kann man unzählige Filter entwerfen, um solche Fehler zu kaschieren, aber zwingend notwendig ist das nicht.

SuperStrict

SetGraphicsDriver GLMax2DDriver()
Graphics(512,512)

Global FACT:Double = 2

Local img:TImage = LoadImage("D:\Mitarbeit\BBP\mbcc24-Vorlage\map.png")

Local hm:TImage = Lief(img)

Local tmr:TTimer = CreateTimer(20)

While Not (KeyDown(KEY_ESCAPE) Or AppTerminate())
	FACT :+ MouseZSpeed() /100.0
	
	hm = Lief(img)
	
	DrawImage hm,0,0
	
	'DrawText FACT, 0,0
	
	WaitTimer(tmr)
	Flip 0
Wend

Function Lief:TImage(pImg:TImage)
	Local hmax:Float
	Local hm:Float[512,512]
	' read shadowmap
	Local pms:TPixmap = LockImage(pImg)
	For Local y:Int = 0 Until 512
		For Local x:Int = 0 Until 512
			Local tx:Int, ty:Int, th:Float
			' inclination
			Local f:Float = (ReadPixel(pms, x, y) & $ff) /180.0
			Local h:Float = f^FACT -1
			If h > 0 Then
				tx = x +1
				ty = y +1
				th = h
			ElseIf h < 0 Then
				tx = x -1
				ty = y -1
				th = -h
			EndIf
			If tx >= 0 And tx < 512 And ty >= 0 And ty < 512 Then
				hm[tx,ty] :+ th
				If hm[tx,ty] > hmax Then
					hmax = hm[tx,ty]
				EndIf
			EndIf
		Next
	Next
	UnlockImage(pImg)
	' write heightmap
	Local imghm:TImage = CreateImage(512,512)
	Local pmh:TPixmap = LockImage(imghm)
	For Local y:Int = 0 Until 512
		For Local x:Int = 0 Until 512
			Local h:Float = hm[x,y]
			Local g:Int = h *255 /hmax
			WritePixel(pmh, x,y, $ff000000 | (g Shl 16) | (g Shl 8) | g)
		Next
	Next
	UnlockImage(imghm)
	Return imghm
End Function