AGB  ·  Datenschutz  ·  Impressum  







Anmelden
Nützliche Links
Registrieren
Zurück Delphi-PRAXiS Programmierung allgemein Multimedia Delphi Darstellung von Falschfarben

Darstellung von Falschfarben

Ein Thema von KPBecker · begonnen am 23. Jan 2010 · letzter Beitrag vom 23. Dez 2016
Antwort Antwort
KPBecker

Registriert seit: 1. Mär 2004
Ort: Mannheim
120 Beiträge
 
Delphi 2010 Architect
 
#1

Darstellung von Falschfarben

  Alt 23. Jan 2010, 17:27
Hallo, Delphi-Praktiker,

das menschliche Auge kann ca. 100 Grauabstufungen unterscheiden aber viel mehr Farbnuancen. Daher werden Verläufe, die eigentlich gar nichts mit Farben zu tun haben, oft durch sogenannte "Falschfarben" visualisiert (z.B. Temperaturen auf einer Skala von dunklem Blau bis zu leuchtendem Gelb).
Die Umsetzung von Zahlen (z.B. von 0 - 1000) auf eine solche plausible, eingängige Farbskala ist gar nicht so einfach.

Frage:
Kennt jemand einen Algorithmus, der aus einer 1-dimensionalen, skalaren Größe eine solche Farbskala erzeugt ?

Vielen Dank,
KPBecker
  Mit Zitat antworten Zitat
bassman

Registriert seit: 8. Apr 2008
18 Beiträge
 
Delphi 2009 Professional
 
#2

Re: Darstellung von Falschfarben

  Alt 25. Jan 2010, 08:57
Hallo KPBecker,

dies brauche ich häufig.
Ich benutze folgende Code um eine Lookup Tabelle zu generieren:

Delphi-Quellcode:
type
  TColorRGB = record
                r, g, b : byte;
              end;

  TColorLUT = Array of TColorRGB;
  
var
  LutScale : Double;

// Farbe zwischen 2 vorgegebenen Farbwerten berechnen
function ColorBetween(C1, C2 : TColor; blend:Real):TColor;
var
   r, g, b : Byte;
   y1, y2 : Byte;
begin
   C1 := ColorToRGB(C1);
   C2 := ColorToRGB(C2);

   y1 := GetRValue(C1);
   y2 := GetRValue(C2);

   r := Round(y1 + (y2-y1)*blend);

   y1 := GetGValue(C1);
   y2 := GetGValue(C2);

   g := Round(y1 + (y2-y1)*blend);

   y1 := GetBValue(C1);
   y2 := GetBValue(C2);

   b := Round(y1 + (y2-y1)*blend);
   Result := RGB(r, g, b);
end;

// Farbe zwischen beliebig vielen vorgegebenen Farbwerten berechnen
function ColorsBetween(colors:array of TColor; blend:Real):TColor;
var
   a : Integer;
   faktor : Real;
begin
   if blend <= 0.0 then
      Result := colors[0]
   else if blend >= 1.0 then
      Result := colors[High(colors)]
   else
   begin
      a := Trunc(High(colors) * blend);
      faktor := 1.0 / High(colors);
      Result := ColorBetween(colors[a], colors[a+1], (blend-(a * faktor)) / faktor);
   end;
end;

function CalcLUT(LUTsize : word; offset : Integer) : TColorLUT;
var
  ii : integer;
  blend : Real;
  clut : TColorLUT;
  col : TColor;
begin
  setlength(clut,LUTsize);
  for ii := 0 to LUTSize-1 do
  begin
    blend := (ii-offset)/LUTsize;
    col := ColorsBetween([clBlack,$00AC0260, clBlue, clAqua, clLime, clYellow, $000080FF, clRed, clBlack], blend);
    clut[ii].r := GetRValue(col);
    clut[ii].g := GetGValue(col);
    clut[ii].b := GetBValue(col);
  end;
  result := clut;
end;
Gruss, Jörn
  Mit Zitat antworten Zitat
KPBecker

Registriert seit: 1. Mär 2004
Ort: Mannheim
120 Beiträge
 
Delphi 2010 Architect
 
#3

Re: Darstellung von Falschfarben

  Alt 25. Jan 2010, 21:30
Hallo, Jörn,
vielen Dank !

Klaus-Peter
  Mit Zitat antworten Zitat
Benutzerbild von Nikolas
Nikolas

Registriert seit: 28. Jul 2003
1.528 Beiträge
 
Delphi 2005 Personal
 
#4

Re: Darstellung von Falschfarben

  Alt 25. Jan 2010, 22:55
Alternativ könntest du dir auch den HSV-Farbraum anschauen. Anders als bei RGB hast du hier nur einen Parameter (H), der die Farbe festlegt.
Erwarte das Beste und bereite dich auf das Schlimmste vor.
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
38.712 Beiträge
 
Delphi 10.4 Sydney
 
#5

Re: Darstellung von Falschfarben

  Alt 26. Jan 2010, 09:49
Jupp, Vorteil ist auch, daß beim HSV der Wertebereich von "Hue"/Farbe weitaus größer als nur 256 ist.

http://www.delphipraxis.net/internal...&highlight=hsv


Bei meiner Implementation hatte ich damals für Hue einen Wertebereich von 0 bis 65520 gewählt.
(macht 182 Schritte pro Grad)

In dem verlinken CL-Eintrag geht es bei Hue "nur" von 0 bis 360, welches dir vermutlich nicht ausreichen wird.

Delphi-Quellcode:
(******************************************************************************************** )
(                                                                                            )
(  THSVRec (Hue, Saturation, Value) and THSBRec (Hue, Saturation, Brightness):                )
(  ***************************************************************************                )
(                                                                                            )
(  THSVRec/THSBRec = Record Case Byte of                                                      )
(    0: (Org: THSV);                                                                          )
(    1: (Hue: Word; Saturation, Brightness: Byte);                                            )
(    ...                                                                                      )
(  End;                                                                                      )
(                                                                                            )
(  Hue              =  0..65520  >  X * ~180  >  0..360°                                    )
(  Saturation        =  0..256    >  X * 2.56  >  0..100%                                    )
(  Brightness\Value  =  0..256    >  X * 2.56  >  0..100%                                    )
(                                                                                            )
(  Hue:    0° = Red        60° = Yellow                                                      )
(        120° = Green    180° = Cyan                                                        )
(        240° = Blue      300° = Magenta                                                      )
(                                                                                            )
(                                                                                            )
(  Known also still as HLS (Hue, Luminance, Saturation)  =>  Luminance = Brightness\Value    )
(                                                                                            )
(*********************************************************************************************)


Type THSB = Type LongWord;
  THSV = THSB;

  PHSB = ^THSB;
  PHSV = PHSB;

  THSBRec = packed Record Case Byte of
    0: (Org: THSB);
    1: (Hue: Word; Saturation, Brightness: Byte);
    4: (Bin: LongWord);
    6: (Bits: TLongWordSet);
    7: (Bytes: TByteArray4);
    8: (Words: TWordArray2);
  End;
  THSVRec = THSBRec;

Function RGBtoHSV(RGB: TColor): THSV;
Function HSVtoRGB(HSV: THSV): TColor;



Function RGBtoHSV(RGB: TColor): THSV;
  Var _RGB: TColorRec Absolute RGB;
    _HSV: THSVRec Absolute Result;
    Darkness: Byte;
    H: LongInt;

  Begin
    RGB := ColorToRGB(RGB);
    If _RGB.Red > _RGB.Green Then _HSV.Brightness := _RGB.Red Else _HSV.Brightness := _RGB.Green;
    If _RGB.Blue > _HSV.Brightness Then _HSV.Brightness := _RGB.Blue;
    If _RGB.Red < _RGB.Green Then Darkness := _RGB.Red Else Darkness := _RGB.Green;
    If _RGB.Blue < Darkness Then Darkness := _RGB.Blue;
    If _HSV.Brightness = 0 Then _HSV.Saturation := 0
    Else _HSV.Saturation := MulDiv(_HSV.Brightness - Darkness, 255, _HSV.Brightness);
    If _HSV.Saturation <> 0 Then Begin
      If _RGB.Red = _HSV.Brightness Then H := Round((_RGB.Green - _RGB.Blue) / (_HSV.Brightness - Darkness) * 10920)
      Else If _RGB.Green = _HSV.Brightness Then H := Round(21840 + (_RGB.Blue - _RGB.Red) / (_HSV.Brightness - Darkness) * 10920)
      Else H := Round(43680 + (_RGB.Red - _RGB.Green) / (_HSV.Brightness - Darkness) * 10920);
      If H >= 0 Then _HSV.Hue := H Else _HSV.Hue := H + 65520;
    End Else _HSV.Hue := 0;
  End;

Function BGRtoHSV(RGB: TBGRRec): THSVRec;
  Var Darkness: Byte;
    H: LongInt;

  Begin
    If RGB.Red > RGB.Green Then Result.Brightness := RGB.Red Else Result.Brightness := RGB.Green;
    If RGB.Blue > Result.Brightness Then Result.Brightness := RGB.Blue;
    If RGB.Red < RGB.Green Then Darkness := RGB.Red Else Darkness := RGB.Green;
    If RGB.Blue < Darkness Then Darkness := RGB.Blue;
    If Result.Brightness = 0 Then Result.Saturation := 0
    Else Result.Saturation := MulDiv(Result.Brightness - Darkness, 255, Result.Brightness);
    If Result.Saturation <> 0 Then Begin
      If RGB.Red = Result.Brightness Then H := Round((RGB.Green - RGB.Blue) / (Result.Brightness - Darkness) * 10920)
      Else If RGB.Green = Result.Brightness Then H := Round(21840 + (RGB.Blue - RGB.Red) / (Result.Brightness - Darkness) * 10920)
      Else H := Round(43680 + (RGB.Red - RGB.Green) / (Result.Brightness - Darkness) * 10920);
      If H >= 0 Then Result.Hue := H Else Result.Hue := H + 65520;
    End Else Result.Hue := 0;
  End;

Function HSVtoRGB(HSV: THSV): TColor;
  Var _RGB: TColorRec Absolute Result;
    _HSV: THSVRec Absolute HSV;

  Begin
    _RGB.Palette := cpSystemPalette;
    If _HSV.Saturation <> 0 Then Begin
      If _HSV.Hue >= 54600 Then Begin
        _RGB.Red := _HSV.Brightness;
        _RGB.Green := MulDiv(_HSV.Brightness, not _HSV.Saturation, 255);
        _RGB.Blue := Round(_HSV.Brightness * (255 - _HSV.Saturation * (_HSV.Hue mod 10920) / 10920) / 255);
      End Else If _HSV.Hue >= 43680 Then Begin
        _RGB.Red := Round(_HSV.Brightness * (255 - _HSV.Saturation * (10920 - (_HSV.Hue mod 10920)) / 10920) / 255);
        _RGB.Green := MulDiv(_HSV.Brightness, not _HSV.Saturation, 255);
        _RGB.Blue := _HSV.Brightness;
      End Else If _HSV.Hue >= 32760 Then Begin
        _RGB.Red := MulDiv(_HSV.Brightness, not _HSV.Saturation, 255);
        _RGB.Green := Round(_HSV.Brightness * (255 - _HSV.Saturation * (_HSV.Hue mod 10920) / 10920) / 255);
        _RGB.Blue := _HSV.Brightness;
      End Else If _HSV.Hue >= 21840 Then Begin
        _RGB.Red := MulDiv(_HSV.Brightness, not _HSV.Saturation, 255);
        _RGB.Green := _HSV.Brightness;
        _RGB.Blue := Round(_HSV.Brightness * (255 - _HSV.Saturation * (10920 - (_HSV.Hue mod 10920)) / 10920) / 255);
      End Else If _HSV.Hue >= 10920 Then Begin
        _RGB.Red := Round(_HSV.Brightness * (255 - _HSV.Saturation * (_HSV.Hue mod 10920) / 10920) / 255);
        _RGB.Green := _HSV.Brightness;
        _RGB.Blue := MulDiv(_HSV.Brightness, not _HSV.Saturation, 255);
      End Else Begin
        _RGB.Red := _HSV.Brightness;
        _RGB.Green := Round(_HSV.Brightness * (255 - _HSV.Saturation * (10920 - (_HSV.Hue mod 10920)) / 10920) / 255);
        _RGB.Blue := MulDiv(_HSV.Brightness, not _HSV.Saturation, 255);
      End;
    End Else Begin
      _RGB.Red := _HSV.Brightness;
      _RGB.Green := _HSV.Brightness;
      _RGB.Blue := _HSV.Brightness;
    End;
  End;
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
Delphi-Tage 2005-2014
  Mit Zitat antworten Zitat
Sandi007

Registriert seit: 29. Mär 2011
Ort: Milchstraße (Eine Info, nichts für Erbsenzähler.)
12 Beiträge
 
#6

AW: Darstellung von Falschfarben

  Alt 22. Dez 2016, 17:44
Hi Himitsu,

danke für deinen Beitrag. Welche Units müssen bei deiner Variante eingebunden werden und wo finde ich die TLongWordSet, TByteArray4, WordArray2 usw?

Grüße
SD
while Leser = Sichtbar do begin Winken End;
  Mit Zitat antworten Zitat
Benutzerbild von himitsu
himitsu

Registriert seit: 11. Okt 2003
Ort: Elbflorenz
38.712 Beiträge
 
Delphi 10.4 Sydney
 
#7

AW: Darstellung von Falschfarben

  Alt 23. Dez 2016, 05:31
Ups, ich glaub die waren aus meiner eigenen alten Typ-Unit, aber im Prinzip ist es das, nach was es klingt.
Delphi-Quellcode:
type
  TLongWordSet = set of 0..31;
  TByteArray4 = array[0..3] of Byte;
  TWordArray2 = array[0..1] of Word;
Das SET braucht man hier nicht unbedingt und könnte man auch weglassen.

Eigene Typ-Konvertierungs-Typen definiere ich gern aus Prinzip "vollständig", also mit allen "möglichen" Untereinteilungen.
Hier ist der Typ 4 Byte groß, also kann man ihn komplett in LongWord/Cardinal/Integer oder teilweise in Word, Bytes und Bits aufteilen um mit "allgemeinen" Funktionen/Mustern auf alle Einzelteile zugreifen zu können.
Garbage Collector ... Delphianer erzeugen keinen Müll, also brauchen sie auch keinen Müllsucher.
Delphi-Tage 2005-2014

Geändert von himitsu (23. Dez 2016 um 05:44 Uhr)
  Mit Zitat antworten Zitat
Themen-Optionen Thema durchsuchen
Thema durchsuchen:

Erweiterte Suche
Ansicht

Forumregeln

Es ist dir nicht erlaubt, neue Themen zu verfassen.
Es ist dir nicht erlaubt, auf Beiträge zu antworten.
Es ist dir nicht erlaubt, Anhänge hochzuladen.
Es ist dir nicht erlaubt, deine Beiträge zu bearbeiten.

BB-Code ist an.
Smileys sind an.
[IMG] Code ist an.
HTML-Code ist aus.
Trackbacks are an
Pingbacks are an
Refbacks are aus

Gehe zu:

Impressum · AGB · Datenschutz · Nach oben
Alle Zeitangaben in WEZ +1. Es ist jetzt 04:48 Uhr.
Powered by vBulletin® Copyright ©2000 - 2021, Jelsoft Enterprises Ltd.
LinkBacks Enabled by vBSEO © 2011, Crawlability, Inc.
Delphi-PRAXiS (c) 2002 - 2021 by Daniel R. Wolf