Farbcodierung von Höhendaten

[Stephan Theisgen]

Hallo!

Ich habe hier einen Satz von 2D-Daten, also zwei Koordinaten und eine Intensität. Nun würde ich gerne die Intensität (entspricht der Höhe des Signals an den jeweiligen Daten) farbcodieren, sagen wir von blau über grün nach rot und weiß, oder so. Das Problem ist nun, daß ich eine Funktion brauche, die die Intensität auf RGB-Farben so sinnvoll abbildet. Das ist gar nicht so einfach, sagen wir ich habe die Intensität von 255 und 256 bei einem einfachen cast würde 255 dann ein tiefes blau geben (0x0000FF), aber 256 wäre ein sehr dunkles kaum zu erkennendes grün (0x000100), obwohl die Intensität natürlich höher ist, erscheint es dem Auge nicht so. Ich habe im Moment dafür Etwas provisorisch zusammengebastelt. Aber nun interessiert mich, wie das professionell gemacht wird, da gibts doch bestimmt Publikationen, Bücher oder Tutorials zu? Da ich aber leider keine guten Stichworte kenne, finde ich über google nichts...

Es wäre schön, wenn mir hier jemand helfen könnte.

Viele Grüße
Stephan

[Chromanoid]

Ich habe keine Ahnung wie das professionell gemacht wird, aber wenn es um Kodierug für das menschliche Auge geht, so wie bei Thermographie, wäre es wohl das einfachste, wenn du einen Gradient konstruierst, der dem gewünschten Farbverlauf entspricht. Dann ist einfach der maximale Wert das obere Ende des Gradienten und der minimale Wert das untere Ende. Nun musst du nur noch alle Werte auf den Gradienten projezieren und du hast deine Farbzuordnung...

Rechts ist der "Wertebereich" (Graustufen) mit zugeordnetem Farbverlauf.

Hier ein Verlauf, der deinen Anforderungen annähernd entsprechen könnte...


http://de.wikipedia.org/wiki/Falschfarben
sollte auch weiterhelfen!

[Stephan Theisgen]

@Chromanoid

Das klingt richtig gut, schonmal vielen Dank für Deine Hilfe. Jetzt muß ich nur noch rausfinden, wie man einen solchen Gradienten als Funktion definiert. Sprich wie man einen solchen Farbverlauf wie rechts im Bild automatisch generiert, also welche Funktion dahinter steht. Irgendeine Idee?

@Idee:

Also es sieht so aus, als wäre das ganze einfach nur eine lineare Interpolation zwischen 2 Farben. Sprich ich gebe drei Farben an (hier im Beispiel, 1. Bild rechts: Blau 0x0000FF, Rot 0xFF0000, Gelb 0x00FFFF), teile dann den Wertebereich 0.0f bis 1.0f in 3 Teile also zwischen 0.0f-0.5f interpoliere ich linear zwischen Blau und Rot, zwischen 0.5f und 1.0f linear zwischen Rot und Gelb. Könnte klappen!

[jgl]

Hallo,

ich habe mich auch mal, in meiner Firma, damit beschäftigen müssen. Wir hatten dazu das HSV-Farbmodell verwendet. Man definiert einen mindes- und maximal Wert. Dann wird ein aktueller (Farb-)Wert auf das HSV Farbmodell abgebildet.
Den Code kann ich dir im Moment nicht geben, aber wenn du interesse hast, dann kann ich unter der Woche mal schauen...

Ciao J---

[Stephan Theisgen]

@jgl: Hi, natürlich bin ich interessiert. Aber ich brauche nicht umbedingt den Quellcode, schaden kanns natürlich nicht, da ich auch daraus den Algorithmus rekonstruieren kann. Vielleicht reicht es aber auch aus, wenn Du einfach etwas genauer beschreibst, wie das geht. Wie geht diese Abbildung genau? Also ich habe ja drei Werte H, S und V. Ich kann mir vorstellen, ich lasse S auf Maximum (1.0), beginne bei V = 0 und erhöhe auf 1.0 und danach von gehe ich in H von 0° bis 359° das gibt zumindest nach dem Farbkegel im Wikipedia Artikel einen Verlauf von schwarz über schwachem blau bis hin zu leuchtendem Blau dann weiter über Cyan, Grün, Gelb, Orange bis Rot. Ist auch nicht schlecht, unterscheidet sich aber nicht viel von meiner unten beschriebenen Idee mit der Interpolation. Vielleicht habe ich Dich jetzt aber auch ganz falsch verstanden...

[Zudomon]

Vielleicht hab ich jetzt irgendwas nicht mitbekommen. Ansonsten ist dein Problem ganz einfach lösbar.

Den Gradiant kann man sich malen oder per Programm irgendwo erstellen. Am ende hat man eine 1D-Textur, aus der man dann nur den Wert anhand des Messewertes Sampeln muss. Du musst vorher nur die Messwerte so skalieren, dass diese in das Interval von 0 bis 1 passen (X-Texturkoordinate). Die 1D-Textur muss ja 2D sein... halt mit einem Pixel höhe. Aber für die Y-Texturkoordinate kannst du einfach 0.5 nehmen. Wichtig ist noch, das die Textur geclamped wird, damit die Farbwerte bei 0 nicht mit denen von 1 bilinear interpoliert werden.

Klar könnte man auch extra ne eigene Funktion für den Gradiant schreiben, aber wozu gibs Texturen?
Von daher ist es eigentlich auch unnötig mit dem HSV-Farbraum rumzurechnen.

[jgl]

...

Stimmt, jetzt wo du's sagst,das war auch mal meine Idee (schon ziemlich lange her). Aber das dauerte meinen Kollegen zu lange, und die sind den Weg über HSV-Farbraum gegangen.
Also jetzt würde ich auch den Weg über die Textur gehen, damit ist man einfach flexibler.

[Stephan Theisgen]

Hi!

Die späte Antwort tut mir leid, aber ich war im Urlaub.
Vielen Dank an alle die mir geantwortet haben! Ich habe es nun erst einmal gelöst. Aber manchmal sieht man auch einfach die simpelste Lösung nicht. Danke an Zudomon: Nein Du hast alles richtig mitbekommen. Die Lösung war so einfach!
Einziges Problem, das ich jetzt noch habe ist, daß das Ganze in Java zu lösen war, und ich jedes Mal, wenn ich den Gradienten ändere das Bitmap aus den Daten neu zeichnen muß, was lange dauert. Kennt jemand da vielleicht eine bessere Möglichkeit, ähnlich wie hier mit Texturen vorgeschlagen oder vielleicht mit Paletten?

Jedenfalls vielen Dank für die Antworten, großes Kompliment an alle die geantwortet habe und auch an diese Forum! (<-- das mußte mal gesagt werden)!

Viele Grüße
Stephan

[Zudomon]

Also eine Möglichkeit wäre, dir in deinem Programm eine Funktion zu integrieren, die dann das Bitmap malen für dich übernimmt. Eine Gradiantfunktion also. Eventuell sogar besser eine Klasse. Der Übergibst du ein Array aus Wertepaaren. Der erste Wert gibt an, wo sich der angegebene Wert befindet. Also am besten nimmst du da ein Intervall von 0 - 1. 0 wäre dann wieder am Anfang des Farbverlaufs, 1 am Ende. Der zweite Wert gibt die Farbe an, die du an der Stelle haben möchtest. Eine Instanz der Klasse hält also das Array aus diesen Wertepaaren. Nun machst du eine Funktion in der Klasse, die dir die Farbe an einem beliebigen Punkt zurückgibt. Als Eingabewert hast du also einen Float-Wert von 0 - 1, als Ausgabe erhälst du die Farbe an dieser Stelle.
Dafür muss nun die Funktion anhand des eingabewertes erkennen, zwischen welchen beiden Farben der Eingabewert liegt. Das ganze wird dann linear Interpoliert, so das auch wirklich ein Farbverlauf entsteht.
Mit einer Instanz einer solchen Klasse kannst du nun dein Bitmap, welches du als Farbverlauf verwenden möchtest füllen. Es reicht, wenn dieses dann im Speicher bearbeitet und übergeben wird.
Das sollte schon eine Variante sein, die Echtzeittauglich wäre, also bei jedem Frame geupdatet werden könnte.

Du könntest noch einen Schritt weiter gehen und das ganze in einem Shader verpacken. Das Bitmap selbst würdest du dann als Rendertarget nehmen. So könntest du definitiv bei jedem Frame den Farbverlauf manipulieren.

Falls etwas unklar ist, einfach nochmal fragen. Ich kann mich schlecht ausdrücken, vor allem, was solche Beschreibungen angeht. :D

[Chromanoid]

Für Java gibt's da so ein ImageFilter-Framework (nativ in jeder jre mit drin). http://openbook.galileodesign.de/javain ... D21F02E100
benutzt du das schon?
Ansonsten könntest du mal http://lwjgl.org/ ausprobieren und einfach ein GLPanel mit Shader bauen. Dann dürfte es auf keinen Fall mehr Probleme beim Zeichnen geben...