GR32 bilder verdunkeln

[alienous]

hi,

ja, ich weiss, mit der suche findet man proceduren zum verdunkeln, aber hab nix mit scanline + GR32 gefunden, aber habs schonmal versucht zu basteln, probleme gibt es noch mit dem array

Delphi-Quellcode:

procedure dunkler(Bitmap: TBitmap32; const dp: Byte = 10);
var
  PixelLine: pColor32array; //hier gibts problmeme, weiss nicht welchen typ ich hier angeben muss
  x, y: integer;
begin

  for y := 0 to Bitmap.height - 1 do
  begin
    PixelLine := Bitmap.ScanLine[y];
    for x := 0 to (Bitmap.width * 3) - 1 do
       PixelLine^[x] := PixelLine^[x] - round(PixelLine^[x] / dp); 
  end;
end;

den code hab ich hier im forum gefunden, und wollte ihn halt für gr32 umschreiben.
wenn ich den code so ausführe, wird er compiliert, aber beim aufruf gibt es irgendwann ne accessviolation :(

findet da jemand den fehler?
währe echt cool, thx

[Khabarakh]

"* 3" muss weg (wenn, dann wäre es sowieso * 4 :zwinker: ). Außerdem kannst du einen Farbwert nicht einfach dividieren, du musst ihn zuerst in die einzelnen Kanäle zerlegen.

[alienous]

:gruebel: den code hab ich hier ausm board, hab gedacht der wär korrekt.

verstehe momentan noch kaum was von bildbearbeitung, könntest mir ein beispiel geben? oder gibts das schon hier irgendwo im board?

Delphi-Quellcode:

procedure dunkler(Bitmap: TBitmap32; const dp: Byte = 10);
var
  PixelLine: pColor32array; //hier gibts problmeme, weiss nicht welchen typ ich hier angeben muss
  x, y: integer;
begin

  for y := 0 to Bitmap.height - 1 do
  begin
    PixelLine := Bitmap.ScanLine[y];
    for x := 0 to (Bitmap.width) - 1 do
       PixelLine^[x] := PixelLine^[x] - round(PixelLine^[x] / dp); 
  end;
end;

so in etwa?

würd gerne ne routine programmieren, die ziehmlich genau arbeite, ist das bei dieser nicht der fall? :wiejetzt:

[Khabarakh]

In einem Achtel aller Fälle wird die Funktion korrekt arbeiten, in allen anderen wird das Resultat ziemlich schräg aussehen :zwinker: .
Ein Beispiel findest du hier: GR32_Blend.Lighten

[Der_Unwissende]

Hi,
dein Problem ist (glaube ich) dass du die Funktionsweise von Scanline nicht richtig verstanden hast.
Eine Scanline ist einfach nur ein Zeiger auf das erste Byte der rohen Daten. Anders gesagt, du hast einfach den Zeiger auf ein Byte, Delphi weiß nicht was für eine Struktur du an dieser Stelle erwartest. Das ermöglicht dir einfach die max. Flexibilität. Du kannst hier eine beliebige Umwandlung vornehmen.
In deinem Fall wandelst du in ein PColor32Array. Das ist ein Zeiger auf eine Color32Array. Anders gesagt, du hast ein Array von TColor32 Werten. Ein TColor32 besteht aus 4 Byte. Die Kodierung findest du in der OH von der Graphics32.
Du musst jetzt für alle Kanäle (Alpha, Rot, Grün, Blau) die Helligkeit senken. Ein TColor 32 fässt diese 4 Byte zu einem 32 Bit Wert zusammen. Du musst also Byteweise ändern. Das kannst du mit einer entsprechenden Maske machen oder halt (transparenter) Byte weise.

Delphi-Quellcode:

procedure dunkler(Bitmap: TBitmap32; const dp: Byte = 10);
var
  PixelLine: pColor32array; //hier gibts problmeme, weiss nicht welchen typ ich hier angeben muss
  x, y: integer;
begin

  for y := 0 to Bitmap.height - 1 do
  begin
    PixelLine := Bitmap.ScanLine[y];
    for x := 0 to (Bitmap.width) - 1 do
       // für die drei Farbkanäle sähe das so aus:
       PixelLine[x].Red := PixelLine[x].Red - round(PixelLine^[x].Red / dp); 
       PixelLine[x].Green := PixelLine[x].Green - round(PixelLine^[x].Green / dp); 
       PixelLine[x].Blue := PixelLine[x].Blue - round(PixelLine^[x].Blue / dp); 
  end;
end;

Gruß Der Unwissende

[alienous]

edit: ups, da warste schneller, ich bearbeite mal:

Delphi-Quellcode:

procedure dunkler(Bitmap: TBitmap32; const dp: Byte = 10);
var
  PixelLine: pColor32array; //hier gibts problmeme, weiss nicht welchen typ ich hier angeben muss
  x, y: integer;
begin

  for y := 0 to Bitmap.height - 1 do
  begin
    PixelLine := Bitmap.ScanLine[y];
    for x := 0 to (Bitmap.width) - 1 do
       PixelLine[x].Red := lighten(PixelLine[x].red, dp * (-1)); //Lighten(C: TColor32; Amount: Integer): TColor32;
       PixelLine[x].Green := lighten(PixelLine[x].green, dp * (-1)); //Lighten(C: TColor32; Amount: Integer): TColor32;
       PixelLine[x].Blue := lighten(PixelLine[x].blue, dp * (-1)); //Lighten(C: TColor32; Amount: Integer): TColor32;
       

  end;
end;

also so? amount sollte beim verdunkeln wohl negativ sein, also *(-1)

Zitat:

Lighten
function Lighten(C: TColor32; Amount: Integer): TColor32;

Description
The resulting color is formed from the color components of the parameter C by adding Amount to each of them and clipping the sum to [0…255] range.

Amount may be negative.

See Also

[Khabarakh]

Ähm, nein.
Deine Funktion verdunkelt das Bild, indem die Farbwerte durch (1 - dp) geteilt werden. Lighten jedoch addiert/subtrahiert einen konstanten Wert.

Zitat:

Zitat von Khabarakh

Ein Beispiel findest du hier: GR32_Blend.Lighten

Du sollst nicht die Funktion benutzen, sondern dir den Source der Funktion anschauen ;) .
Des Unwissenden Code kannst du allerdings direkt übernehmen, nur mit einer kleinen Änderung: Entweder benutzt du PColor32Entry oder extrahierst die Kanäle wie in Lighten zu sehen.

[edit]Na jetzt wirfst du alles durcheinander ;) . Lighten arbeitet mit einem ganzen TColor32-Wert, nicht mit Bytes. [/edit]

[alienous]

Delphi-Quellcode:

PixelLine: PColor32Entry;

klappt auch nicht, PixelLine[x].Red usw funktioniert bei array und auch bei entry nicht, wobei bei entry auch die zuweisung PixelLine := Bitmap.ScanLine[y]; nicht funtkioniert.

hab mir lighten angesehn und verstehe überhaupt nix, wüsste nicht wie ich das da einbauen könnte :(

[Khabarakh]

Wenn du PixelLine ersetzen willst, musst du dementsprechend PColor32EntryArray nutzen. Da TColor32 und TColor32Entry gleich groß sind, kannst du das Ergebnis von Scanline ohne Probleme casten.

Zitat:

Zitat von alienous

hab mir lighten angesehn und verstehe überhaupt nix, wüsste nicht wie ich das da einbauen könnte :(

So groß ist die Funktion nun auch wieder nicht :gruebel: .

Delphi-Quellcode:

  // Extraktion der Kanalwerte aus einem TColor32-Wert
  a := C shr 24;
  r := C and $00FF0000;
  g := C and $0000FF00;
  b := C and $000000FF;

[alienous]

Delphi-Quellcode:

procedure makedarker(Bitmap: TBitmap32; const dp: Byte = 10);
var
  PixelLine: PColor32Entryarray;
  x, y: integer;
begin

  for y := 0 to Bitmap.height - 1 do
  begin

    PColor32Array(PixelLine) := Bitmap.ScanLine[y];

    for x := 0 to (Bitmap.width) - 1 do
       // für die drei Farbkanäle sähe das so aus:
       PixelLine[x].R := PixelLine[x].R - round(PixelLine^[x].R / dp);
       PixelLine[x].G := PixelLine[x].G - round(PixelLine^[x].G / dp);
       PixelLine[x].B := PixelLine[x].B - round(PixelLine^[x].B / dp);
  end;
end;

so müsste das eigentlich auch gehn oder? wenn ich als parameter 100 übergebe, merke ich nichts, weil fast nichst subtrahiert wird, wenn ich 2 als dp übergebe, wird die farbe des bildes verändert, aber es wird grün :O eigentlich sollte es doch dunkler werden aber nicht grüner oder? ist die berechnung nun falsch oder wieso bekommt das bild einen grünstich :gruebel: