Grauton Kalkulation

[EWeiss]

Hab hier eine Kalkulation für grautöne im Netz gefunden.

Calcuate grey
See Color Space FAQ at:

Delphi-Quellcode:

nSize := bm.bmWidth * bm.bmHeight;
for IntI := 0 to nSize do
begin
   // 0.212671 * R + 0.715160 * G + 0.072169 * B   
   iSrcR := GetDibR(ptPixels[IntI]);
   iSrcG := GetDibG(ptPixels[IntI]);
   iSrcB := GetDibB(ptPixels[IntI]);
   iGrey := (iSrcR * 54 + iSrcG * 182 + iSrcB * 19) shr 8;

   // Take color from the gradient
  Col := m_clGradient[iGrey];

   ptPixels[IntI] := RGB(
      (GetBValue(Col) * iAlpha + iSrcB * (255 - iAlpha)) shr 8,
      (GetGValue(Col) * iAlpha + iSrcG * (255 - iAlpha)) shr 8,
      (GetRValue(Col) * iAlpha + iSrcR * (255 - iAlpha)) shr 8 );
end;

Habe aber 2 kleine probleme was die definition von GetDib* und ptPixels angeht.
Übersetzung nach Delphi.

In C++

Code:

#define GetDibR(drgb)   (((drgb) & 0x00ff0000) >> 16)
#define GetDibG(drgb)   (((drgb) & 0x0000ff00) >>  8)
#define GetDibB(drgb)    ((drgb) & 0x000000ff)

Code:

UINT* ptPixels;

Wenn jemand näheres darüber weiss nur her damit ;)

gruss

[DeddyH]

Ich bin nicht gerade fit in C/C++, aber das hier müsste grob stimmen.

Delphi-Quellcode:

type 
  ptPixels = ^UINT;

function GetDibR(drgb: DWORD): DWORD;
begin
  Result := (drgb and $00FF0000) shr 16; 
end;

function GetDibG(drgb: DWORD): DWORD;
begin
  Result := (drgb and $0000FF00) shr 8; 
end;

function GetDibB(drgb: DWORD): DWORD;
begin
  Result := drgb and $000000FF; 
end;

[Namenloser]

Code:

#define GetDibR(drgb)   (((drgb) & 0x00ff0000) >> 16)
#define GetDibG(drgb)   (((drgb) & 0x0000ff00) >> 8)
#define GetDibB(drgb)    ((drgb) & 0x000000ff)

Delphi-Quellcode:

function GetDibR(const drgb: cardinal): cardinal; inline;
begin
  Result := (drgb and $00ff0000) shr 16;
end;
function GetDibG(const drgb: cardinal): cardinal; inline;
begin
  Result := (drgb and $0000ff00) shr 8;
end;
function GetDibB(const drgb: cardinal): cardinal; inline;
begin
  Result := (drgb and $000000ff);
end;

Die vordefinierten Funktionen GetRValue, GetGValue und GetBValue sollten aber an sich das gleiche tun, sofern sie nicht gerade von einer anderen Byte-Order ausgehen (ich vergesse das immer...).

Delphi-Quellcode:

UINT*

ist nichts anderes als ein

Delphi-Quellcode:

PCardinal

.

[EWeiss]

Danke!

Zitat:

UINT* ist nichts anderes als ein PCardinal .

Mein problem ist hier aber das ich einen pointer(ptPixels) so wie hier in C++
nicht einfach auf ein Array in Delphi auslegen kann.

Was bedeutet inline ? Noch nie gehört bzw. verwendet.

gruss

[Iwo Asnet]

"inline" bedeutet nur, das der Compiler versucht, den Funktionsquelltext direkt anstelle des Aufrufes in den Code zu kompilieren. Das erspart Aufruf und Rücksprung, ergo einige CPU-Zyklen. Das Programm wird größer, aber auch schneller.

Soweit ich mich erinnere, habe ich den Grauwert immer durch

Delphi-Quellcode:

Function GetGray(color : TColor) : TColor;
begin
  v := (GetRValue(color) + GetGValue(color) + GetBValue(color)) div 3;
  Result := RGB(v,v,v);
end;

hinbekommen

[EWeiss]

Danke euch allen werde mal schaun was die beste Variante ist.
Mein letztes problem weiss nicht wie ich ptPixels als Array auslegen soll.

Kann mir nicht vorstellen dass das Array sich im ^UINT befindet. Oder?

Einzigste was mir jetzt einfällt die pPixels als Dynamisches Array auszulegen of Cardinal
und die neue länge anhand von nSize zuzuweisen.

gruss

[Namenloser]

Zitat:

Zitat von EWeiss (Beitrag 1158934)

Danke!

Zitat:

UINT* ist nichts anderes als ein PCardinal .

Mein problem ist hier aber das ich einen pointer(ptPixels) so wie hier in C++
nicht einfach auf ein Array in Delphi auslegen kann.

Wenn es ein

Delphi-Quellcode:

packed

Array ist, kannst du den Pointer auf das erste Element des Arrays nehmen. Oder du schreibst den Code um und verwendest statt des Pointers einen Index, den du jedes mal inkrementierst, wenn im Originalcode der Pointer inkrementiert wird. Dann musst du immer über den Index auf das Element zugreifen.

Z.B.:

Code:

UINT* pixel;
...

++pixel; // rückt zum nächsten Pixel vor
(*pixel) = 0x00ff0000; // färbt das Pixel rot

=>

Delphi-Quellcode:

var 
  Pixels: array of cardinal;
  PixelIdx: integer;

PixelIdx := 0;

...

inc(PixelIdx);
Pixel[PixelIdx] := $00ff0000;

oder:

Delphi-Quellcode:

var 
  Pixels: packed array of cardinal;
  Pixel: PCardinal;

Pixel := @Pixels[0];

...

inc(Pixel);
Pixel^ := $00ff0000;

Zitat:

Zitat von EWeiss (Beitrag 1158934)

Was bedeutet inline ? Noch nie gehört bzw. verwendet.

Bedeutet nur, dass der Compiler den Code an der Stelle des Funktions-Aufrufs direkt einfügt, statt wie üblich einen Funktionsaufruf zu generieren, der etwas Overhead generiert, weil Daten auf den Stack kopiert werden müssen etc.. Ist nicht nötig, aber kann manchmal bemerkbaren Einfluss auf die Performance haben, wenn kurze Funktionen sehr häufig aufgerufen werden.

Ich habe inline hier aber in erster Linie verwendet, weil Inline-Funktionen in Delphi am ehesten das Equivalent zu Macros in C darstellen – Macros werden nämlich ebenfalls vom C-Compiler vor dem eigentlichen Kompiliervorgang „expandiert“, also direkt an die Stelle im Code eingefügt. Macros sind eben keine Funktionen, sondern halt „Macros“. Wenn du in C ein Macro „aufrufst“, ist das für den Compiler quasi so, als hättest du den Code direkt an der Stelle mit Copy&Paste eingefügt. Und dem kommen Inline-Funktionen halt am nächsten.

Hoffe es ist klar :wink:

[edit]

Zitat:

Zitat von Iwo Asnet (Beitrag 1158935)

Soweit ich mich erinnere, habe ich den Grauwert immer durch

Delphi-Quellcode:

Function GetGray(color : TColor) : TColor;
begin
  v := (GetRValue(color) + GetGValue(color) + GetBValue(color)) div 3;
  Result := RGB(v,v,v);
end;

Das ist die „primitive“ Variante, aber dabei wird nicht berücksichtigt, dass z.B. Grün bei gleichem Wert heller wirkt als Blau.
[/edit]

[shmia]

Um die Helligkeit einer Farbe zu ermitteln werden die Rot, Grün und Blau Anteile unterschiedlich bewertet um dem menschlichen Auge möglichst nahe zu kommen.

Mein Code verwendet dazu die Faktoren 61(rot), 174(grün) und 21(blau):

Delphi-Quellcode:

function Intensity(Color: TColor): Integer;
begin
  Color := ColorToRGB(Color);
  Result := GetBValue(Color) * 21      // Blue
    + GetGValue(Color) * 174   // Green
    + GetRValue(Color) * 61;  // Red
  Result := Result shr 8;
end;


function GreyColor(Color: TColor):TColor;
var
   i : Integer;
begin
   i := Intensity(Color);
   Result := RGB(i, i, i);
end;

Die Faktoren 54(rot), 182(grün) und 19(blau) aus dem Codebeispiel im Beitrag#1 dürften ähnliche Ergebnise bringen.
Wenn man alle Farbanteile mit 1/3 einrechnet dürfte das Ergebnis leicht unnatürlich aussehen.

[EWeiss]

Zitat:

@shmia Die Faktoren 54(rot), 182(grün) und 19(blau) aus dem Codebeispiel im Beitrag#1 dürften ähnliche Ergebnise bringen.
Wenn man alle Farbanteile mit 1/3 einrechnet dürfte das Ergebnis leicht unnatürlich aussehen.

Deshalb habe ich auch obigen link zum Color FAQ addiert.
Ein ungefährer wert käme auch nicht in frage ;)

@NamenLozer

Zitat:

Pixels: array of cardinal;

Ahh dann war meine Annahme letztendlich doch korrekt ;) Danke

Zitat:

Hoffe es ist klar

Gut erklärt besser gehts nimmer :)

Zitat:

Einzigste was mir jetzt einfällt die pPixels als Dynamisches Array auszulegen of Cardinal
und die neue länge anhand von nSize zuzuweisen.

gruss

[Iwo Asnet]

Zitat:

Zitat von NamenLozer (Beitrag 1158937)

Das ist die „primitive“ Variante

Das ist interessant, trifft mich aber hart. Dieses "primitiv" ist irgendwie ... erniedrigend.:P