Was geht schneller bei zufälligen zugriff auf Farbwerte?

[griever]

Hallo,
also ich will in ein bild die farbewerte von zufällig ausgewählten pixeln ändern was geht da am schnellsten?
wenn ich auf die pixel per canvas.pixels[x,y] zugreife, wenn ich mit bitmap und scanline daran geh oder wenn ich das ganze in ein 2d array scheib und danach mit scanline das array ins bild übertrage?

[Luckie]

würdest du bitte deinem Thread einen aussagekräftigen Titel geben, in dem du deinen ersten Beitrag entsprechend editierts.

[SirThornberry]

eindeutig scanline. Dies musst du nur ein einziges mal aufrufen um einen Pointer auf den Bildspeicher zu bekommen (also nicht für jedes pixel). Die Variante mit dem Array ist logischer Weise langsamer weil du ja selbst schreibst das du dann noch zusätzlich scanline verwendest.

[griever]

naja ich dachte
man kann nur eine zeile mit scanline auslesen, weshalb man ja bei zufälligen zugriff(als0 mal zeile 1 mal 356
und dort jeweils auch nur ein pixel) man mehr aufwand hat.

[SirThornberry]

mit Scanline bekommst du einen Pointer auf den Bildspeicher der Zeile X zurück. Die Zeilen liegen aber zusammenhängend im Speicher.

Wenn du bei einem Bild mit 100 Höhe dir mit Scanline die Zeile 50 holst und dort auf der X-Achse drüber hinaus malst wirst du sehen das die eine der anliegenden Zeilen veränderst.

[griever]

heist das ich brauch nur einmal scanline machen und das resultat dann um eins erhöhen um in die nächste zeile zu kommen?

[SirThornberry]

nein. Scanline zeigt auf den Anfang einer Zeile. In der Zeile sind dann deine ganze pixel enthalten. Wenn du nur um 1 erhöhst landest du ja maximal beim 2ten pixel (eher aber beim nächsten Farbwert des ersten pixels der Zeile). Du musst wenn schon bis ans ende der zeile um in die nächste zu kommen.

[xaromz]

Hallo,

Zitat von griever:

heist das ich brauch nur einmal scanline machen und das resultat dann um eins erhöhen um in die nächste zeile zu kommen?

fast. Du musst natürlich sämtliche Pixel der aktuellen Zeile überspringen, um in die nächste Zeile zu kommen.
Du musst aber zwei Dinge beachten:
Erstens stehen Bitmaps normalerweise auf dem Kopf, d. h. Der Pointer auf die letzte Zeile ist der Startpunkt der Bilddaten.
Zweitens ist eine Bildschirmzeile immer durch vier teilbar. Hat Dein Bild also drei Pixel und eine Farbtiefe von 24Bit, dann hat jede Zeile 9 Byte Pixeldaten und am Ende drei Byte Fülldaten. Wenn Du mit 32Bit arbeitest, hast Du natürlich keine Probleme.

Ein Beispiel (32 Bit):

Delphi-Quellcode:

Bit := TBitmap.Create;
Bit.Width := 30;
Bit.Height := 20;

P := Bit.ScanLine[Bit.Height - 1];

// Pixel an 10, 5 holen:
R := P[10 * 4 + (5 * 30 * 4)];
G := P[10 * 4 + (5 * 30 * 4) + 1];
B := P[10 * 4 + (5 * 30 * 4) + 2];

Gruß
xaromz

[griever]

Delphi-Quellcode:

try
  legn:=integer(pic.scanline[1])-integer(pic.scanline[0]);
except
  raise Exception.Create('Error');
  end;
p:=pic.scanline[0];
v:= pic.Height*(legn-1);
for h:= 0 to v  do
  begin
    p^[v] := Random(256);
  end;

try
  legn := Abs(Integer(pic.ScanLine[1]) -Integer(pic.ScanLine[0]));
except
  raise Exception.Create('Error');
  end;
for h := 0 to pic.Height - 1 do
  begin
  P := pic.ScanLine[h];
  for v := 0 to legn - 1 do
    P^[v] := Random(256);
  end;

das obere is langsamer als das untere wenn ich ales pixel des bildes bearbeite
könnte sich das ändern, wenn ich nur ein pixel pro zeile bearbeite?
und wenn ja gibts ne möglichkeit einen punkt, denn ich ändern will schnell im array zu finden? nicht das der vorsprung den das obere dann evtl.hat durch das suchen wieder aufgefressen wird.
P is ja ein bytearraay, wenn ich das umändere in ein zb 4byte array(wenns sowas gibt) kann ich dann den farbwert mit einmal auslesen?(also alle farben bei pf32bit)
dann wär ja auch theoritsch jeder punkt im array durch ein punkt auf dem bild uind müsste berechnet werden durch
P[x+("länge der zeile" * y))

beim oberen teil fang ich ja bei scanline[0] an und zähl dann raufwärst mach ich da was falsch weil mein bild wird trotzdem gefüllt?

ok ich weis jetzt warum der obere teil langsamer war
bei p^[v] := Random(256); is das v falsch da müsste ein h hin jetzt ist das schonmal beim kompletten schreiben schneller

kann es sein das scanline nur zum schreiben da ist?
irgendwie bekomm ich zugriffsfehler, wenn ich nach art des oberen beispiels den inhalt des pointer in einen integer lesen will