was soll das übersetzt heißen?

[EMS]

Hallo
Ich habe hier diesen Quelltext aber kann damit nix anfangen
kann mir den jemand erkläre?

Delphi-Quellcode:

s:='';
   for index:=1 to anz do
       begin
       farbe:=image1.canvas.pixels[index,0]; //showmessage(inttostr(farbe));

       b:=farbe and $ff; ch :=chr(b);
       s:=s+ch;

       b:=(farbe and $ff00) shr 8; ch :=chr(b);
       s:=s+ch;

       b:=(farbe and $ff0000) shr 16; ch :=chr(b);
       s:=s+ch;

[Popov]

Es handelt sich hier wohl um eine 24 Bit Bitmap. Das macht 3 Byte. Hier wird der Wert jedes der Bytes ermittelt in dem man es mit $FF Wert AND rechnet.

Ein 3 Byte Beispiel

Delphi-Quellcode:

00101001 10011011 01001010
00000000 11111111 00000000 AND
--------------------------
00000000 10011011 00000000 Ergebnis

In der ersten Zeile ist ein 3 Byte Wert (24 Bite). Dadurch, dass hier nur das zweite Byte mit $FF (oder 11111111) und AND gerechnet wird, bekonnt man nur das Ergebnis des zweiten Bytes zurück. Denn 1 and 1 ergeben 1. Und 1 and 0 ergeben 0. Da also das erste und dritte Byte mit $00 gerechnet werden, ist da das Ergebnis immer $00.

//Edit:

Ach so, und SHR verschiebt den Wert um die Anzahl Bites nach Rechts. Hast du also 10101010 00000000 SHR 6, wird alles um 6 nach rechts verschoben 00000010 10101000.

[EMS]

ja das habe ich soweit verstanden aber ich verstehe nicht was das s:=s+ch
bzw. ch :=chr(b);macht und dann noch dreimal hintereinander?

[Popov]

Wenn du einen Code hast den du verstehst, bis auf eine Sache, dann schreib das auch so hin und nicht "Ich habe hier diesen Quelltext aber kann damit nix anfangen". Vorher soll einer aus dem Satz erkennen was du weißt und was nicht.

Ein Tipp: guck in der OH, experimentiere ein wenig, dann verstehst du den Rest auch.

[EMS]

das programm geht ja nicht richtig, deshalb würde ich es gerne mal verstehen
und dann selber nachbauen schritt für schritt aber ich weiß nicht was es jetzt da in diesen Zeilen tut mit den werten

[Popov]

Dann stelle ich die richtigen Fragen:

- was macht CHR?
- was macht $00FF0 SHR 8? Was macht $FF0000 SHR 16?
- was passiert wenn man Word zu Byte konvertiert?
- was liefert Char := Chr(Byte);
- was passiert wenn man String := String + Char zusammenfügt?

[EMS]

chr ist eine Funktion und gibt einen zahlen(Integer) wert als Buchstaben aus.

$00FF00 SHR 8?

ist der Farbfilter für den Grünenbereich und gibt diese "hohe Zahl/ WERT*256" aus und schiebt in den Rotenbereich dort wird diese Zahl dann als Wert zwischen 0 und 255 angezeigt

$FF0000 SHR 16?

Das selber Spiel für den Blaubereich und hier wird die Wert*256*256 ebenfalls nach rot geschoben

Word zu Byte

Ich vermute aus den Buchstaben werden Integers gewandelt???

was liefert Char := Chr(Byte);

Soll einen Buchstaben liefern. Aber wiese soll nun aus einer Zahl das CHR gemacht werden´??

was passiert wenn man String := String + Char zusammenfügt?

Hier hat man eine Zeichenkette mit einem Zeichen zusammen geführt.

[Popov]

Der Code

Delphi-Quellcode:

$00FF00 SHR 8

ist kein Farbfilter, wird hier aber u. a. für diese Aufgabe eingesetzt.

Delphi-Quellcode:

SHR 8

macht aus

Delphi-Quellcode:

$00FF00

den Wert

Delphi-Quellcode:

$0000FF

. Die Bits wurden eben um 8 Bits nach rechts verschoben. Wenn man das jetzt zum Byte konvertiert, und das passiert nebenbei wenn man die Funktion

Delphi-Quellcode:

Chr(X: Byte): Char;

nutzt, dann bleibt von

Delphi-Quellcode:

$0000FF

nur noch

Delphi-Quellcode:

$FF

. Bei

Delphi-Quellcode:

$00FF00

wäre es

Delphi-Quellcode:

$00

. Es wird also mit

Delphi-Quellcode:

$00FF00 SHR 8

der interessante zweite Byte weiterverschoben, sozusagen zu Byte zugeschnitten und mit Chr zum ASCII Zeichen konvertiert. Macht man das mit allen drei Byte Werten, ergibt das drei ASCII Zeichen die zum Schluss einen String aus drfei Buchstaben ergeben, z. B. Aj6. Das ist dann die in String "konvertierte" Farbe. Allerdings habe ich das noch nie gesehen und auch sonst halte ich davon nichts, da eine 0 mitten drin immer Probleme bereitet. Aber irgendwer kam eben auf die Idee es so zu machen.

[EMS]

Mhh also so richtig verstanden habe ich das noch nicht.

Also ich habe jetzt mein PIXEL als Integer dieses soll jetzt ein Byte werden?
Ist das so richtig verstanden?
Ich hatte das bisher so verstanden das dieses Pixel aus 4 Bytes besteht.
Im ersten linken ist nix im 2. dann der Blau wert danach der Grün und dann der Rote.
Und jetzt leses ich aus diesem Integer die drei Farben aus das sind dann aber wieder integerwerte.
Und diese Integerwerte der jeweiligen Farbe konvertiere ich dann jetzt zu einem Byte??

[Popov]

Ja und nein. Der Code gibt zum Teil etwas Sinnvolles und zum Teil weniger Sinnvolles. Also je nach Farbtiefe gibt es z. B. die Bitmap in 32Bit, 24Bit, usw. Für RGB brauchst du nur 3 Byte (RGB), also 3 * 8 = 24 Bit. Das vierte Byte von 32Bit ist nicht leer, da sind auch Informationen gespeichert, aber jetzt keine die uns hier interessieren. Dich interessieren also nur 24Bit Bitmaps. Entweder man ignoriert jetzt das vierte Byte oder konvertiert das in 24Bit Bitmap.

Also du hast jetzt eine 24Bit Bitmap die aus 3 Bytes besteht. Die erste Aufgabe ist es jetzt die einzelnen Bytes zu filtern, d. h. mach aus dem Integer Color Wert drei einzelne Byte Werte (das vierte ignorieren wir). Also $00FFEEDD in $FF, $EE und $DD zerlegen.

Jetzt wird aus (z. B.) $DD durch Chr($DD) ein ASCII Wert (ob das einen Sinn macht ist eine andere Sache). Das alles drei mal und man hat den String.

[EMS]

ok jetzt kommts langsam.
Also macht sowas auch nur sin wenn ich ein Pixel aus einem 24BIT bitmap auslesen möchte?

[Popov]

Es muß mindestens 24Bit sein. Erstens weil nur mindestens 24Bit Bitmaps RGB bieten und zweites wenn du bei einer 8Bit (256 Farben) auf Bits über das 8 Bit zugreifst, dann kommt sowieso nur 0 raus. Bei 32Bit braucht man dann sowieso nur die 24Bit.

[EMS]

also würde das Pixel auslesen aus einem jpeg auch nicht gehen?
Oder geht das wenn ich das in ein Delphi image lade?

[Popov]

Jpeg funktioniert etwas anderes als Bitmap. Ich will jetzt nicht auf die Feinheiten eingehen, aber es ist ein verlustbehaftetes Formal und Pixel als solches spielen weniger eine Rolle. Trotzdem, jede Jpeg wird von Windows intern zum anzeigen soweit ich weiß zu Bitmap konvertiert.

Es ist weniger interessant ob Bitmap oder Jpeg, wichtiger ist Canvas. Bitmap hat Canvas, Jpeg soweit ich weiß nicht. Du ließt deine Pixel nicht von der Bitmap, sondern von der Canvas der Bitmap. Canvas ist die Leinwand der Bitmap, und da kann man eben Pixel für Pixel auslesen.

Allerdings ist es kein Problem eine Jpeg in Bitmap zu konvertieren. Ich glaube mit Bitmap.Assign(Jpeg) bist du schon dabei.

[mkinzler]

Ein Jpeg wird beim Laden in ein Image autonatisch in ein Bitmap verwandelt ( alle Formate werden von den Filtern so behandelt)

[EMS]

ok das ist gut dann hab ich das jetzt so verstanden.

jetzt möchte ich ja selber diese Buchstaben in die einzelnen Bits der Pixel schreiben.

wäre das hier richtig?

Delphi-Quellcode:

rneu:=50 and $0000FF;
gneu:=(60 and $00FF00) shr 8;
bneu:=(70 and $FF0000) shr 16;

Aber ich komm jetzt nicht drauf wie ich die dann wieder zu zB. farbe zusammen bekommeß

kann ich da sagen
farbe:=rneu + gneu + bneu;

Wäre das richtig´?

[Popov]

Das Gleiche, nur in die andere Richtung:

Delphi-Quellcode:

farbe:= (bneu shl 16) + (gneu shl 8) + rneu;
...

Edit:

Hier ein einfach Beispiel:

Delphi-Quellcode:

var
  L: LongInt;
  R, G, B: Byte;
begin
  L := ColorToRGB(Farbe); //macht aus Delphi-Color RGB-Color, konvertiert also auch clRed in rot

  R := Byte(L);
  G := Byte(L shr 8);
  B := Byte(L shr 16);

  //mach was mit den einzelnen R, G und B Bytes und dann wieder zusammensetzten

  Farbe := (B shl 16) + (G shl 8) + R;
end;

[EMS]

Ich hab jetzt das stehen

Delphi-Quellcode:

     rneu:=50 and $0000FF;
     gneu:=(60 and $00FF00);
     bneu:=(70 and $FF0000);


     Neues_Pixel:=(bneu shl 16) + (gneu shl 8)+ rneu;

Der Integer von diesem Pixel ist 50 müsste da nicht auch was 8 Stelliges raus kommen?

[EMS]

jetzt klappts so wie ich gerne wollte

Delphi-Quellcode:

     rneu:=0;
     gneu:=250;
     bneu:=0;
     Neues_Pixel:=(bneu shl 16) + (gneu shl 8)+ rneu;

[Furtbichler]

Geht auch so:

Delphi-Quellcode:

MyColor := RGB(RotAnteil,GelbAnteil,BlauAnteil);

RGB ist in der Unit Windows deklariert.

[Popov]

Also wenn das eine Option ist, dann werfe ich GetRValue, GetGValue und GetBValue ins Spiel.

Delphi-Quellcode:

Rotanteil := GetRValue(RGBFarbe);

usw.

[EMS]

ne das hatten wir nicht das gibt nur wieder rummgemecker...

jetzt hab ich nen neues Problem

Ich möchte jetzt für die rneu,gneu,bneu eine Prodcdur einsetzen die ich vorher für einen Button gemacht habe.

Das sieht jetzt so aus und geht mal wieder nicht was ist dadrann denn falsch?

rneu:=TForm1.Button6Click;
gneu:=TForm1.Button6Click;
bneu:=TForm1.Button6Click;

[mkinzler]

Eventprozeduren liefern kein Ergebnis

[EMS]

mhh
kann ich das nicht mit diesem procedure(var ....);
dann machen?

[Popov]

Sag einfach was du machen willst. Selbst mit viel Fantasie weiß ich nicht was du mit

rneu:=TForm1.Button6Click;
gneu:=TForm1.Button6Click;
bneu:=TForm1.Button6Click;

erreichen willst.

[EMS]

ok
ich hab jetzt ein editfeld dort soll ein Text rein.
Dieser muss dann ja Buchstabe für Buchstabe geladen werden.
Dann die Ordnungszahl erstellt werden und diese nacheinander für die neuen
farbwerte rneu,gneu,bneu eingesetzt werden.

[Popov]

Verstehe ich es richtig, dass du in einem Editfeld Text hast, z. B. "Hallo Welt", dann liest du "H" raus und das soll der Rotanteil sein, "a" der Grünanteil, usw. ?

[EMS]

yop genau so ist es

ich hab da mal das hier versucht

Klappt natürlich nicht

[EMS]

Delphi-Quellcode:

for spalte:=1 to laenge_der_verschluesselung do           //Pixel aus der 1. Spalte bis Stellenlänge
     begin
     farbe:=image1.Canvas.Pixels[spalte,0];                 //Erste Pixel lesen
     wert:=tex[spalte];                                     //Buchstaben aus Editfeld an der Stelle der Schleife lesen
     Ordnungszahl:=ord(wert[1]);                            //Ordnungszahl erstellen aus Buchstabe an der Stelle 1
     showmessage('Ordnungszahl '+ inttostr(Ordnungszahl));
     repeat
     For hindex:=1 to laenge_der_verschluesselung do        //Schleife für die Anzahl der Buchstaben
     rneu:=ord(wert[hindex]);                               //Rot Wert als Ordnungszahl von Wert an der Stelle des Hilfsindex
     gneu:=ord(wert[hindex+1]);                             //Grün Wert als Ordnungszah von Wert Hilfsindex +1 (Eine Stelle weiter)
     bneu:=ord(wert[hindex+2]);
     until (hindex + 2) = laenge_der_verschluesselung;      //Abbruch Bedingung wenn hindex+2 den Wert der Länge der Verschlüsselung erreicht hat


     Neues_Pixel:=(bneu shl 16) + (gneu shl 8)+ rneu;

[Helmi]

hier fehlt ein begin/end

Delphi-Quellcode:

     For hindex:=1 to laenge_der_verschluesselung do //Schleife für die Anzahl der Buchstaben
       begin //<================HIER
         rneu:=ord(wert[hindex]); //Rot Wert als Ordnungszahl von Wert an der Stelle des Hilfsindex
         gneu:=ord(wert[hindex+1]); //Grün Wert als Ordnungszah von Wert Hilfsindex +1 (Eine Stelle weiter)
         bneu:=ord(wert[hindex+2]);
       end;  //<================HIER
      until (hindex + 2) = laenge_der_verschluesselung; //Abbruch Bedingung wenn hindex+2 den Wert der Länge der Verschlüsselung erreicht hat

[EMS]

jetzt bleibt das programm hängen er macht die schleife nicht
ist das denn mit meinen Erklärungen so richtig oder ist da ein Fehler?

[Popov]

Ich hab das jetzt aus dem Kopf geschrieben ohne es zu testen. Teste du das mal:

Delphi-Quellcode:

var
  Bmp: TBitmap;
  x, y: Integer;
  s: String;
  PixCol: TColor;
  RGBCol: Integer;
  R, G, B: Byte;
  c: Char;
begin
  Bmp := TBitmap.Create;
  try
    Bmp.LoadFromFile('c:\irgendeinbild.bmp'); //irgend ein Bmp Testbild
    Bmp.PixelFormat := pf24bit; //in 24Bit Bitmap umwandeln

    s := Edit1.Text; //Edit1.Text in s übertragen

    for y := 0 to Bmp.Height - 1 do
      for x := 0 to Bmp.Width - 1 do
      begin
        PixCol := Bmp.Canvas.Pixels[x, y]; //Pixel holen
        RGBCol := ColorToRGB(PixCol); //in RGB konvertieren

        R := GetRValue(RGBCol);
        G := GetGValue(RGBCol);
        B := GetBValue(RGBCol);

        if Length(s) > 0 then c := s[1] else c := #0; //wenn kein Zeichen, dann ersatzweise #0 oder etwas anderes
        Delete(s, 1, 1); //s um ein Zeichen kürzen
        R := Ord(...);

        if Length(s) > 0 then c := s[1] else c := #0;
        Delete(s, 1, 1); //s um ein Zeichen kürzen
        G := Ord(...);

        if Length(s) > 0 then c := s[1] else c := #0;
        Delete(s, 1, 1); //s um ein Zeichen kürzen
        B := Ord(...);

        PixCol := RGB(R, G, B);

        Bmp.Canvas.Pixels[x, y] := PixCol;
      end;
  finally
    Bmp.Free;
  end;
end;

[EMS]

mhhh das ist ja mit diesen getrvalue das hatten wir ja nicht.
das mit dem R := Ord(...); kenne ich auch nicht und weiß nicht was es bedeutet?

Merkwürdig ist das mein Programm bei rneu noch passt und dann bei gneu und bneu schon nicht funktioniert?

[Popov]

Schon alles erwähnt. Das Problem an deinem Projekt ist, dass du zuerst mit einem Auto ankommst das du repariert haben willst, dann wird es langsam zerlegt, immer mehr und mehr, bis dann irgendwann raus kommt, dass du nur die Kurbel fürs Fenster haben willst. Soll bedeuten, dass bei all deinen Fragen und was zuletzt übrig bleib, man nicht mehr weiß was eigentlich wichtig ist.

G := GetGValue(RGBCol) gibt den Grünanteil des Pixels, also das was wir mit G := Byte(Farbe shr 8) ermittelt haben. Dafür gibt es eine fertige Funktion. Und wenn du gleich gesagt hättest was du willst, dann wäre sie früher ins Spiel gekommen.

Was könnte R := Ord(...); bedeuten? Mit etwas Fantasie könnte man meinen, dass es rneu:=ord(wert[hindex]); ist, und (...) einfach nur Platzhalter. Denn ich hab immer noch keine Ahnung was du da machst. Ich weiß, dass es irgendwas mit Verschlüsselung zu tun hat, aber ...

[EMS]

das problem ist das wir so nen paar sachen erzählt bekommen haben von unserem dozenten
und der nix anderes dann akzeptiert er meint das kann dann nur ausm Internet kommen und das ist ja alles falsch und schlecht...

ich möchte jetzt ja nur diese neuen Pixelwerte aus meinem Editfeld der Reihe nach in das
rneu,gneu,bneu rein haben

jetzt hab ich das alles so geschrieben aber er bricht die schleife nicht ab.
ich hab doch das until spalte+2 oder kann der das da nicht?

Delphi-Quellcode:

procedure TForm1.Button2Click(Sender: TObject);
var
hindex,bildhoehe,bildbreite,zeile,spalte,X,Y,index1,laenge_der_verschluesselung,idt{Indexdeltatext}: integer;
b:byte;
farbe,ordnungszahl,farbe1,rneu,gneu,bneu,neues_pixel:integer;
code,tex,wert:string;
ch:char;
begin
  spalte:=0;
  zeile:=0;
  tex:=Edit4.text;
  application.processmessages;
  ASSIGNFILE(f,'NeuesBild.dat');
  REWRITE(F);

  Code:=edit4.text;
  laenge_der_verschluesselung:=length(Code);
  showmessage('Länge der Verschlüsselung '+inttostr(laenge_der_verschluesselung));
  repeat
  for spalte:=1 to laenge_der_verschluesselung do
     begin
     farbe:=image1.Canvas.Pixels[spalte,0];
     wert:=tex[spalte];

     rneu:=ord(tex[spalte]);
     gneu:=ord(tex[spalte+1]);
     bneu:=ord(tex[spalte+2]);
     showmessage('Wert rneu '+inttostr(rneu));
     showmessage('Wert gneu '+inttostr(gneu));
     showmessage('Wert bneu '+inttostr(bneu));
     end;
  until spalte+2=laenge_der_verschluesselung;
Neues_Pixel:=(bneu shl 16) + (gneu shl 8)+ rneu;
Closefile(f);
end;

[Helmi]

Du willst die Schleife abbrechen wenn die Länge der Verschlüsselung erreicht wurde
Die Variable "Spalte" gehört zur for-Schleife
Mit Break kannst du die Schleife verlassen wenn die Bedingung erfüllt ist
Die Repeat-Schleife komplett entfernen

Delphi-Quellcode:

   for spalte:=1 to laenge_der_verschluesselung do
      begin
      farbe:=image1.Canvas.Pixels[spalte,0];
      wert:=tex[spalte];

      rneu:=ord(tex[spalte]);
      gneu:=ord(tex[spalte+1]);
      bneu:=ord(tex[spalte+2]);
      showmessage('Wert rneu '+inttostr(rneu));
      showmessage('Wert gneu '+inttostr(gneu));
      showmessage('Wert bneu '+inttostr(bneu));

      If spalte = laenge_der_verschluesselung then
        break;
      end;

[EMS]

so klappt es aber wieso ging das nicht mit der repeat schleife?
ich laufe doch auf jedenfall die schleife durch.
und dann ist doch sofort das until erreicht mit
(spalte:=1) spalte + 2 ist sofort die länge meiner Zeichen im Editfeld

Ich hab jetzt aber keine idee wie ich diese schleife so hin bekomme das es so funktionert wie ich es möchte weil sobald ja die Länge wieder anders ist passen die neuen Werte für die buchstaben wieder nicht mehr...

[Helmi]

Du müsstest eine Meldung bekommen ala:
[DCC Warnung] Unit2.pas(36): W1037 FOR-Schleifenvariable 'spalte' kann nach Durchlauf undefiniert sein

Überleg mal was für einen Wert "spalte" beim letzten For-Schleifen-Durchlauf hat?
Maximal den Wert von "laenge_der_verschluesselung"
Daher kann die repeat-Schleife niemals als Bedingung

Delphi-Quellcode:

spalte + 2 = laenge_der_verschluesselung

sein
Diese Bedingung wird niemals nie nicht true

Dadurch hast du eine Endlosschleife gebastelt die nebenbei immer und immer wieder die For-Schleife ausführt...

[EMS]

mhh die dürfte ja auch nur einmal durch bis zum until dann ist doch schon die abbruch bedingung erfüllt
ich seh jetzt nicht den Fehler dadranne

[Helmi]

Zitat:

Zitat von EMS (Beitrag 1197910)

mhh die dürfte ja auch nur einmal durch bis zum until dann ist doch schon die abbruch bedingung erfüllt

wirklich?