Durchschnittsfarbe eines TBitmap via Scanline?

[Lossy eX]

@Muetze1: Nenn mich schwer von Begriff aber eine Sache ist mir nicht ganz klar. Denn für meinen Geschmack hängt deine Beschreibung etwas. Zu mindest auf Basis von normalen Fotos. Denn diese haben eigentlich immer 24 Bit und die Schritte sehen dann wie folgt aus. Ich setze 32 Bit Farbtiefe. Damit wird ein neues Bild erstellt und das aktuelle muss ein Mal komplett eingelesen und konvertiert werden. Schlussendlich muss dann das neue Bild noch ein Mal eingelesen werden um irgendwas damit anzustellen. Das bedeutet für mich, dass ich a) einen höheren Speicherverbrauch habe und ich b) so oder so das Bild 2 Mal einlesen muss. Direkt oder indirekt.

Wenn ich es jetzt aber auf 24 Bit lasse, dann ändert sich doch eigentlich gar nichts. Zu mindest wird doch eigentlich der Vorteil von einem 32 Bit Format doch wieder dadurch zerstört, dass ich erst einmal alle Bilder konvertieren muss. Korrigiere mich bitte wenn ich das falsch sehe.

@Cyberstorm: Übermäßig viele Schleifen solltest du eher vermeiden, denn so etwas kann schon recht auf die Performance schlagen. Genau so wie Dinge die du mehrfach brauchst. Die solltest du nicht doppelt berechnen (l*j-1). Und bitte nicht i, j, k, l als Variablen nehmen.

Delphi-Quellcode:

var
  X, Y, TempX, TempY, TempPointsY, TempPointsX: Integer;
  pTemp: PRGBQuad;
begin
  TempPointsY := TestPointsY -1; // da bei TestPoints = 3 die Pixel Positionen im Array von 0 .. 2 haben.
  TempPointsX := TestPointsX -1;

  for Y := 0 to 210 -1 do begin
    pTemp := P[Y]; // Oder auch direkt Scanline der ersten zu analsierenden Zeile
    TempY := Round(Y * TempPointsY / 210); // Position berechnen sollte so vermutlich gehen

    for X := 0 to 280 -1 do begin
      TempX := Round(X * TempPointsX / 280); // Position berechnen sollte so vermutlich gehen

      average[TempX, TempY, 1] := average[TempX, TempY, 1] + Temp^.rgbBlue;
      average[TempX, TempY, 2] := average[TempX, TempY, 2] + Temp^.rgbGreen;
      average[TempX, TempY, 3] := average[TempX, TempY, 3] + Temp^.rgbRed;

      average[TempX, TempY, 4] := average[TempX, TempY, 4] + 1; // gesetzte Pixel zählen

      Inc(pTemp);
    end;
  end;

  // durch average gehen und Werte durch gesetzte Pixel rechnen.
end;

Habe den Code mal eben so geschrieben als nicht getestet etc. Kann also gut sein, dass er fehlerhaft ist oder gar nicht geht. Das Leeren von average habe ich nicht mit übernommen. Sollte aber so richtig gewesen sein.

Das mit den Pixel zählen kann evtl nötig sein, da durch die Floating Berechnung evtl eine unterschiedliche Anzahl an Pixeln in die einzelnen Felder geschrieben wird.

Um die Berechnung von X nicht dauerhaft durchführen zu müssen kann es noch einiges bringen, wenn du diese vor den Schleifen ein Mal berechnest und in einem LookupArray ablegst. Denn daran wird sich ja wahrscheinlich nichts ändern. Bei Y ist das nicht nötig, da es sowieso nur 1 Mal berechnet wird.

PS: Wobei ich gestehen muss, dass ich gerade nicht weiß wie Resample Algorithmen das machen. Aber wenn ich mich nicht irre werden die mit geringer werdender Zielgröße auch schneller. Und ich glaube die Zielgröße wird bei dir keinen Einfluss auf die Geschwindigkeit haben. Evtl solltest du da mal nach solch einem Algorithmuss schauen.