Bildbearbeitung: Linien verstärken, gibt's sowas?

[Teekeks]

@himi: Deine Version von gestern um 22:24 hat bei mir ca. 20min gebraucht um zu rechnen bei einem 250x360px-Bild... Ist das normal?? ^^
Ich probiere aber auch mal deine neuste version aus...
Wobei ich die alte version etwas abgewandelt hatte, da es bei mir irgentwie keine funktion rgb und auch kein getrvalue... gab (Lazarus/Linux)

Delphi-Quellcode:

procedure LinienFettierer(Image: TBitmap; Background: TColor; Size: Integer);
var
  x, y, x2, y2, x3, y3, R, G, B, P: Integer;
  C: TColor;
  Temp: TBitmap;
  Mask: Array of Array of Boolean;
begin
  SetLength(Mask, Size, Size);
  for x := 0 to Size - 1 do
    for y := 0 to Size - 1 do
      Mask[x, y] := True;//(x - Size div 2)
  Temp := TBitmap.Create;
  try
    Temp.Width := Image.Width + Size - 1;
    Temp.Height := Image.Height + Size - 1;
    for x := 0 to Temp.Width - 1 do
      for y := 0 to Temp.Height - 1 do
      begin
        R := 0;  G := 0;  B := 0;  P := 0;
        for x2 := 0 to Size - 1 do
        begin
          x3 := x - Size div 2 + x2;
          if (x3 >= 0) and (x3 < Image.Width) then
            for y2 := 0 to Size - 1 do
            begin
              y3 := y - Size div 2 + y2;
              if (y3 >= 0) and (y3 < Image.Height) and Mask[x2, y2] then
              begin
                C := Image.Canvas.Pixels[x3, y3];
                if C <> Background then
                begin
                  Inc(R, integer(C));
                  Inc(G, integer(C shr 8));
                  Inc(B, integer(C shr 16));
                  Inc(P);
                end;
              end;
            end;
        end;
        if P <> 0 then
          Temp.Canvas.Pixels[x, y] := Word(integer(R div P)+integer((G shr 8) div P)+integer((B shr 16) div P))//RGB(R div P, G div P, B div P)
        else
          Temp.Canvas.Pixels[x, y] := Background;
      end;
    Image.Width := Temp.Width;
    Image.Height := Temp.Height;
    Image.Canvas.Draw(0, 0, Temp);
  finally
    Temp.Free;
  end;
end;

Aber wiegesagt versuche ich nochmal alles zu verstehen und das vor allem bei der neueren version...

[hadschi92]

Dass es so langsam ist liegt an der Funktion Canvas.Pixels, diese ist sehr sehr langsam. Wenn du sie durch Scanline ersetzt ist die Funktion viel schneller. Wie oben gesagt von 45 Sekunden auf weniger als eine.

[Matze]

Du bist ein Schatz himi.

Das funktioniert bei mir einwandfrei!

PS: Nun verstehe ich auch, wieso so oft nach einer Komplettlösung gefragt wird.

[Teekeks]

Ich habe gerade einen WTF-Effekt:
Wozu das:
TScanArray = packed Array[0..0] of TRGBA;

[himitsu]

Zitat von Teekeks:

Wozu das:

Was davon?

Der Record war zur einfachen Umrechnung/Zerlegung der Farbanteile



Und Array[0..0] ist ein Sonderfall
hier wird von Delphi keine Index-Prüfung gemacht, also es entspricht sozusagen einem Array[0..{unbekannt}] und man muß so keinen Maximalwert angeben ... es kann also nicht passieren, daß hier mal eine ERangeError (Exception) geworfen wird.

Ich weiß ja nicht wie groß die Bilder sind und eh ich mir ausversehn einen zu kleinen Maxiamlwert festlege oder "mühsam" den maximal möglichen Wert berechne ...

*rechne*
Array[0..$1FFFFFFE] dürfte auch gehn und größer geht es eh nicht (die 2 GB-Grenze wäre dann erreicht)

[Medium]

Zitat von Matze:

Auch dir danke, Medium. Wenn ich die Zeit finde, probiere ich das auch mal aus, wobei das recht kompliziert aussieht.

In Code gegossen dürfte es weniger tief verschachtelt, und sogar etwas kürzer als die aktuelle Version ausfallen . Das Ergebnis wird allerdings bei steigender Dicke dem von Himi immer unähnlicher.

Was mir aber auch noch gerade einfiel ist die Hough-Transformation! Grob gesagt kannst du damit aus so einfachen Bildern recht genau die Parameter für die zugehörigen Geradengleichungen herausbekommen, und mit diesen dann sogar vektoriell ganz neu zeichnen, mit allen Freiheiten die das so bringen könnte. Also... zumindest theoretisch

Edit:
Das "array[0..0] of Typ" ist eine C-übliche Schreibweise für dynamische Arrays. Technisch entspricht das einem "^Typ", also einem Pointer. Der Unterschied ist nun, dass man einen Pointer mit inc() weiterschubsen müsste, bei der Schreibweise als Array übernimmt der Compiler die Pointerarithmetik und man kann hübsch mit Indizes dran gehen. Weniger hübsch ist, dass man ohne Netz und doppelten Boden über die Grenze des eigentlichen Datenbereichs hinweg flutschen kann, die Größenangabe also mehr als wichtig dabei ist.

Diese zwei Codefetzen dürften identische Wirkung haben:
1:

Delphi-Quellcode:

type
  TOpenIntArray = array[0..0] of Integer;

procedure Foo(input: array of Integer; length: Integer);
var
  a: TOpenIntArray;
  i, bar: Integer;
begin
  a := input;
  for i := 0 to length-1 do
  begin
    bar := a[i];
  end;
end;

2:

Delphi-Quellcode:

procedure Foo(input: array of Integer; length: Integer);
var
  a: PInteger;
  i, bar: Integer;
begin
  a := @input[0];
  for i := 0 to length-1 do
  begin
    bar := a^;
    inc(a);
  end;
end;

Da es in C keine offenen Arrays gibt, hat man sich mit diesem Konstrukt beholfen. Dort muss dann auch von Hand vom Speichermanager entsprechend RAM angefordert werden, und die Bereichsprüfung ist auch Handarbeit. Alles der Kram, der bei Delphi durch die Compilermagic in dynamischen Arrays halt so passiert. Und da es in Delphi prinzipiell auch anders und imho eleganter geht, sollte man dieses array[0..0] auch eher als Ergebnis einer 1:1 Übersetzung sehen, keinesfalls aber als empfohlen. Es ist eigentlich ein überholtes Relikt.

In diesem Fall hier ist es auch kein 2GB großes Array . Die Deklaration so einer Variable belegt an sich erstmal genau eine Registerbreite Speicher - es ist nur ein Pointer. Der wird hier dann auf den Speicherbereich des ersten (bzw. eigentlich letzten) Pixels gebogen, so dass man durch Weiterrücken pixelweise über diesen Buffer läuft. Es ist nur ein popeliger Pointer, der etwas "lustig" hingeschrieben ist damit man indizierten Zugriff ohne Handarbeit haben kann - bzw. weil irgend jemand mal C Code so nach Delphi übersetzt hat, und es Schule gemacht hat =)
Man könnte genauso gut ein "echtes" dynamisches Delphi-Array nehmen, und es mit etwas trickserei genau auf den selben Bereich zeigen lassen. Die Verwendung wäre identisch, und man fordert auch nie selbst nochmal Speicher dafür an (kein SetLength in diesem Fall). Der ist schon da, im Bitmap.

[himitsu]

So, hier nun die Resultate gemixt in einem Programm

#org ErstelleBild
#4 LinienFettiererKopieren
#14 LinienFettiererMix

#20 LinienFettiererDirekt [clRed, clGreen, clBlack]
#20 LinienFettiererDirekt [clBlack, clGreen, clRed]
#18 LinienFettiererDirekt []

#14 LinienFettiererMix + #18 LinienFettiererDirekt []


falls noch jemand einen Algo hat ... einfach her damit

[add]
ach ja, das Programm versucht erstmal eine "LinienFettierer.bmp" im Programmverzeichnis zu laden,
also falls wer mal ein anderes Bildchen ausprobieren will

und ich hab grad gemerkt, daß mehrere Funktionen nacheinander auch witzig sind
(ganz unten das einzelne Bildchen)

[Medium]

Schaut sau-nice aus Hätte anfangs nicht gedacht, dass man ohne kompliziertes Analyseglöt so gute Ergebnisse kriegen kann. Sag mal, klappt das ähnlich gut bei beliebig geformten Kurven statt Linien?

[Matze]

Zitat von Medium:

Sag mal, klappt das ähnlich gut bei beliebig geformten Kurven statt Linien?

Da der Algorithmus das Bild zeilenweise durchgeht ist die Linien- bzw. Kurvenform egal. Im 1. Beitrag habe ich "Linien" geschrieben, sehe ich gerade, doch bei mir sind alles Kurven.

[himitsu]

die LinienFettiererMix läßt sich sogar auf Fotos loslassen

die anderen Versionen brauchen aber die Hintergrundfarbe, in welche sie sich hinein ausbreiten, sonst kommen da keine guten Ergebnisse raus, falls sich überhaupt viel ändert

[edit] ach ja, für dat Foto hab ich natürlich die nötigen Rechte
dachte halt, wenn schon Foto, dann kann ich euch auch 'ne Freude machen