Zitat von
EWeiss:
In PB dimensioniere ich mir ein Array das auf die Adresse bm.bmBits zeigt
REDIM Ar(0) AS LONG AT bm.bmBits
Das ist mir klar, von daher nochmal und anders formuliert:
Du hast ein dynamisches Array und das zeigt auf den reservierten Speicherbereich mit der in SetLength() angegebenen Grösse. Die deklarierte Variable deines Arrays ist dabei ein Zeiger, welcher durch SetLength(), wie zuvor beschrieben, initialisiert wurde. Mit deiner Zuweisung von dmBits auf die Array Variable lässt du die Variable (den Pointer im Endeffekt) nicht mehr auf das Array sondern auf deine Pixeldaten zeigen. Das reservierte Array liegt dann immernoch an seiner Original-reservierten Position im Speicher und ist verloren, da du mit der Zuweisung die letzte Zugriffsmöglichkeit zerschossen hast. Da die Dimensionierung aber vor dem Array im Speicher liegt, auf den der Zeiger mal original hingezeigt hat und dein Pixeldaten keine solche Informationen vor dem ersten Pixel hat, ist die Dimensionierung hinfällig. Ich hoffe du verstehst nun meine Einwände...
Zitat von
EWeiss:
Da ist nichts mit Quads
Nein, richtig. Aber warum das Leben unnötig schwer machen? Du hast einen Zeiger auf die Pixeldaten. Diese liegen im 32 Bit (32bpp) Format vor. Anscheinend ja sogar (dank
GDI+) im RGBA Format und nicht nur im RGBx Format. Ich könnte es genauso übernehmen wie du es hattest und den Zeiger als PLongWord deklarieren. Aber wozu? Ich weiss das ich eine Struktur mit 4 Elementen zu je einem Byte an der Stelle liegen habe. Also nutze ich doch einfach PRGBQuad und habe dann gleich Zugriff auf die Elemente, also den Rot-Anteil, den Grün-Anteil und den Blau-Anteil. Und abhängig vom Format auch gleich noch den Alpha-Wert. Alternativ kannst du gerne beim alten Code bleiben und ein LongWord haben und dir dann mit Shift-Operationen und ausmaskieren dir die nötigen Anteile rausholen. Aber wie gesagt: stures portieren oder gleich was verbessern? Die Lesbarkeit erhöhen? Ich weiss, es lief ja schon immer so - never change a running system...
Dein Weg:
Delphi-Quellcode:
var
lPixel: PLongWord;
begin
lPixel := bm.bmBits;
Red := lPixel^ and $ff;
Green := (lPixel^ shr 8) and $ff;
Blue := (lPixel^ shr 16) and $ff;
Alpha := (lPixel^ shr 24) and $ff;
Mein Vorschlag:
Delphi-Quellcode:
var
lPixel: PRGBQuad;
begin
lPixel := bm.bmBits;
Red := lPixel^.rgbRed;
Green := lPixel^.rgbGreen;
Blue := lPixel^.rgbBlue;
Alpha := lPixel^.rgbReserved;
Ich find mein Code lesbarer - aber Vorsicht: Subjektive Meinung!
Zitat von
EWeiss:
Mein problem ist halt eine lösung für mich zu finden die Daten nach Delphi rüber zu bringen
will aber auch nicht meine Progr.. die anderen vielleicht noch von nutzen sein können
in die Tonne werfen nur weil ich jetzt nix mehr in basic mache.
Verlangt niemand von dir und ich finde es ehrlich gesagt auch wirklich gut, dass du sie portierst. Ich hoffe auch, dass du dabei auch dein Wissen erweiterst und die Möglichkeiten der neuen Sprache nutzt und vllt. auch lieben lernst.
Zitat von
EWeiss:
Jo in Delphi ist der ersatz für 1 = 1 + 1 inc(1) hab ich schon verstanden.
Nein, anscheinend nicht richtig. Inc() kann mehr als das.
Inc() auf ordinale Typen macht das von dir beschriebene. Inc() auf typisierte Zeiger macht was anderes. Der macht auch mal +2 oder +x - abhängig vom Pointer.
Wenn der typisierte Pointer mit Inc() oder
Dec() verändert wird, dann wird der Pointer jeweils
um die Grösse des Typs verschoben.
Also (um auf dein Beispiel zurück zu kommen):
Delphi-Quellcode:
var
lPixel: PLongWord;
begin
lPixel := Addr($1000);
Inc(lPixel);
// hier ist lPixel ein Zeiger auf die Adresse $1004 !!!
lPixel := Addr($1000);
Inc(lPixel, 2);
// hier ist lPixel ein Zeiger auf die Adresse $1008
end;
Und wenn wir uns das ganze nun nochmal mit einem PRGBQuad anschauen:
Delphi-Quellcode:
var
lPixel: PRGBQuad;
begin
lPixel := Addr($1000);
Inc(lPixel);
// hier ist lPixel ein Zeiger auf die Adresse $1004 !!!
lPixel := Addr($1000);
Inc(lPixel, 2);
// hier ist lPixel ein Zeiger auf die Adresse $1008
end;
Kein Unterschied von dem Adresshandler, da der Typ, auf den der Zeiger zeigt, gleich gross ist.
Oder allgemein formuliert:
Bei Inc() und
Dec() auf typisierte Zeiger gilt:
Inc/
Dec(p, x):
p := p +/- x * sizeof(p^);
Aber egal, ich weiss nun, ich werde lieber nichts eigenmächtig verbessern oder ersetzen sollte in deinen Codes. Und ich hoffe du weisst nun, dass man dir nicht immer in die Suppe spucken will. Fremde Programmiersprachen zu lesen und zu verstehen ist nicht immer schwierig, da das Prinzip der meisten gleich ist, nur die Syntax ist anders.