Problem mit TColor

[gangs-taas]

hey,
ich muss noch einmal was wegen meinem steganografie projekt fragen.
Ich möchte ja von einem Pixel die Farbe verändern oder auslesen
und ich dachte ich mach das so :

Delphi-Quellcode:

  procedure Tcodieren.Verstecken;
  var
    i, j, k ,
    PixelX, PixelY  : integer ;
    Farbe : TColor;
    Str_BinaerBuchstabe : string ;
    BitArray : Array[1..9] of byte;
  begin
    PixelX := 0 ;
    PixelY := 0 ;
    BitArray[9] := 0 ;
    for i := 1 to Length(text)  do
    begin
      for k := 1 to 3 do
      begin
        Farbe := Bild.Canvas.Pixels[PixelX,PixelY] ;
        case k of
          1 : Bild.Canvas.Pixels[PixelX,PixelY] := Pixel_aendern(BitArray[1],
                                                           BitArray[2],
                                                           BitArray[3],
                                                           Farbe);
//...

Aber meine Variable "Farbe" aht irgendwie immer den Wert '0' und das versteh ich nicht. Mein Bild müsste auf jedenfall (da es an der stelle 0/0 Grau ist) doch eine mischung aus Rot Grün und Blau sein
und nicht 0 oder ?

könnt ihr mir nocheinmal helfen, und mir sagen, was ich falsch mach ?

[DeddyH]

Du liest ja immer dasselbe Pixel aus, da sich PixelX und PixelY nicht ändern.

[gangs-taas]

ne ich zähle am ende der schleife das pixel hoch

also ich kann ja mal den code der ganzen unit posten (ich dachte das sei nicht soo wichtig)
so aber irgendwie klappt das alles nicht :/ :

Delphi-Quellcode:

type
  TCodieren = class(Tobject)
    public
      constructor Create(ParaBild : TImage; ParaText : String);
      function Rueckgabe : TPicture ;
    private
        Text : String ;
        Bild : TImage ;
        AnzahlPixelX,
        AnzahlPixelY : integer;

      procedure Verstecken ;
      function IntToBin(Int : Integer) : String ;
      function Pixel_aendern(Bit1, bit2, bit3 : byte; Farbe : Tcolor ) : TColor ;
      procedure Pixelerhoehen(var XPixel, YPixel : integer) ;
      function Letztes_Bit_0(Eingang : byte) : byte ;
      function Letztes_Bit_1(Eingang : byte) : byte ;
  end;


implementation

  constructor TCodieren.Create(ParaBild: TImage; ParaText: string);
  begin
    Text := ParaText ;
    Bild:= ParaBild ;
    AnzahlPixelX := Bild.Width ;
    AnzahlPixelY := Bild.Height;
  end;

  function Tcodieren.Rueckgabe;
  begin
    Verstecken;
    Result := Bild.Picture ;
  end;

  // private ;

  procedure Tcodieren.Verstecken;
  var
    i, j, k ,
    PixelX, PixelY  : integer ;
    Farbe : TColor;
    Str_BinaerBuchstabe : string ;
    BitArray : Array[1..9] of byte;
  begin
    PixelX := 0 ;
    PixelY := 0 ;
    BitArray[9] := 0 ;
    for i := 1 to Length(text)  do
    begin
      Str_BinaerBuchstabe := IntToBin(Ord(Text[i]));
      for j := 1 to 8 do
      begin
        BitArray[j] := StrToInt(Str_BinaerBuchstabe[j]);
      end;
      for k := 1 to 3 do
      begin
        Farbe := Bild.Canvas.Pixels[PixelX,PixelY] ;
        case k of
          1 : Bild.Canvas.Pixels[PixelX,PixelY] := Pixel_aendern(BitArray[1],
                                                           BitArray[2],
                                                           BitArray[3],
                                                           Farbe);
          2 : Bild.Canvas.Pixels[PixelX,PixelY] := Pixel_aendern(BitArray[4],
                                                           BitArray[5],
                                                           BitArray[6],
                                                           Farbe);
          3 : Bild.Canvas.Pixels[PixelX,PixelY] := Pixel_aendern(BitArray[7],
                                                           BitArray[8],
                                                           BitArray[9],
                                                           Farbe);
        end;
        Pixelerhoehen(PixelX,PixelY);
      end;
    end;
  end;

  function TCodieren.IntToBin(Int: Integer): String;
  var
    i : Integer;
  begin
    Result := '';
    for i := 7 downto 0 do
    begin
      Result := Result + IntToStr((Int shr i) and 1);
    end;
  end;

  function TCodieren.Pixel_aendern(Bit1: Byte; bit2: Byte; bit3: Byte; Farbe: TColor) : TColor;
  var
    BValue,
    GValue,
    RValue : integer ;
  begin
    BValue := GetBValue(Farbe) ;
    GValue := GetGValue(Farbe);
    RValue := GetRValue(Farbe);
    BValue := Letztes_Bit_0(BValue);
    GValue := Letztes_Bit_0(GValue);
    RValue := Letztes_Bit_0(RValue);
    if Bit1 = 1 then
      BValue := Letztes_Bit_1(BValue);
    if Bit2 = 1 then
      GValue := Letztes_Bit_1(GValue);
    if Bit3 = 1 then
      RValue := Letztes_Bit_1(RValue);
    Result := TColor(Integer(IntToBin(BValue) + IntToBin(GValue)
                     + IntToBin(RValue)));
  end;

  procedure TCodieren.Pixelerhoehen(var XPixel: Integer; var YPixel: Integer);
  begin
    if (XPixel + 1) < AnzahlPixelX then
    begin
      inc(XPixel)
    end
    else
    begin
      XPixel := 0 ;
      inc(YPixel);
    end;
  end;

  function TCodieren.Letztes_Bit_0(Eingang: Byte) : byte ;
  begin
    Eingang := Eingang shr 1 ;
    Result := Eingang shl 1 ;
  end;

  function TCodieren.Letztes_Bit_1(Eingang: Byte) : byte ;
  begin
    Result := (Eingang or  $01 ); //00000001);
  end;

[DeddyH]

Ich habe den Code nicht in allen Einzelheiten verfolgt, aber bist Du einmal durchgesteppt und hast die Variablen überwacht?

[gangs-taas]

Wie gesagt Die Fariable Farbe ist immer 0 und nicht das was sie eigendlich sein sollte ...
und ich weiß einfach nicht warum
eigl. müsste die so doch den farb wert zugweisen bekommen ober nicht ?

Delphi-Quellcode:

Farbe := Bild.Canvas.Pixels[PixelX,PixelY] ;

[Corpsman]

Wenn es dir nur darum geht die Effekte von Stegenograpihe an zu sehen : Hier meine Version davon ;).

[gangs-taas]

naja es geht darum es vorzustellen und da dachte ich mach ich ein relativ einfach programm (ohne schnickschnack) und stell das dann vor.
und ich wüsste jetzt halt auch so mal gerne warum meins nicht läuft ...

[patti]

Also ich denke, dass das Problem damit zusammen hängen könnte, dass du (und wie du) ein TImage übergibst. Nimm stattdessen doch ein TPicture oder der Einfachkeit halber gleich ein TBitmap. Beim Create übergibst du dann das Bitmap und weist dem Bitmap-Objekt von deinem "TCodieren" dieses Bild dann zu. Dann sollte es eigentlich funktionieren...

[gangs-taas]

es geht trotzdem nicht
ich weiß einfach nicht weiter ..
Farbe ist immer null ..

ich glaub ich geb auf und stell dann ein fremdes steganografie-programm vor, dass funktioniert ...

ich häng trotzdem mal mein ganzes projekt als anhang ran, vielleicht hat einer von euch ein wenig zeit und kann sich das anschauen und mir sagen, was ich falsch gemachth ab ...

[himitsu]

Zitat:

Delphi-Quellcode:

Result := TColor(Integer(IntToBin(BValue) + IntToBin(GValue)
                     + IntToBin(RValue)));

Das Zusammensetzen geht wohl auch voll schief.

Prüf doch nochmal, was du da rechnest:
- du setzt Strings zusammen
- machst von dem String einen typecast nach Integer
- und wunderst dich dann, daß da kein entsprechender "Integer"-Wert rauskommt.

Entweder du korregierst die String>Integer-Konvertierung oder nutz doch einfach RGB.

[gangs-taas]

Zitat:

Zitat von himitsu (Beitrag 1047608)

Zitat:

Delphi-Quellcode:

Result := TColor(Integer(IntToBin(BValue) + IntToBin(GValue)
                     + IntToBin(RValue)));

Das Zusammensetzen geht wohl auch voll schief.

Prüf doch nochmal, was du da rechnest:
- du setzt Strings zusammen
- machst von dem String einen typecast nach Integer
- und wunderst dich dann, daß da kein entsprechender "Integer"-Wert rauskommt.

Entweder du korregierst die String>Integer-Konvertierung oder nutz doch einfach RGB.

Warum geht das denn nicht ?
ich möchte doch aus 3 mal 8 bit 1mal 24 bit machen
sprich z.B. (irg. zufällige zahlen in dem beispiel jetzt ..)
'00000001'+'10011001'+01110011' => '000000011001100101110011'
und ich dachte ich reihe die Strings aneinander und sag dann, das was man dann hat (sind dann ja einsen und nullen), soll halt ein integer wert sein

aber der fehler leigt ja irg. schon davor nämlich darin, dass 'farbe' immer den Wert Null hat ...

[Sir Rufo]

So kannst du es versuchen

Delphi-Quellcode:

function ColorFromRGB( const RValue, GValue, BValue : Byte ) : TColor;
begin
  Result := TColor( ( BValue shl 8 + GValue ) shl 8 + RValue );
end;

Dein Konstrukt

Delphi-Quellcode:

Integer( '00001010000100010010001' )

ergibt eigentlich nichts Substantielles
Vor allem, woher soll der Compiler wissen, dass es sich hierbei um eine Binär-Kodierung handelt?
Könnte ja jedes beliebige Zahlensystem sein. Vorzugsweise würde er das Dezimal-System benutzen.

[gangs-taas]

hey,
vielen dank
ich glaub das war (anscheinend) doch der hauptfehler in meiner CodierUnit..

könnt ihr mir noch einmal helfen und mir einen einfachen Weg (vor)-sagen, mit dem ich aus mehreren Bits (die ich beim Decodieren bekomme) wieder ein Byte (und dann einen Buchstaben) erzeugen kann ?

mich bringen die ganzen bits irg. durcheinander und das funktioniert alles nicht so wie ich dachte, dass es funktionieren müsse...

EDIT :

ich hab das hier versucht :

Delphi-Quellcode:

 function TDecodieren.BitToBuch(Bit1, bit2, bit3, bit4, bit5, bit6,
                               bit7, bit8: Integer) : Char;
var
  ZwischenInt : Integer ;
begin
  ZwischenInt := 00000000;
  if Bit1 = 1 then
    ZwischenInt := ZwischenInt or 10000000;
  if Bit2 = 1 then
    ZwischenInt := ZwischenInt or 01000000;
  if Bit3 = 1 then
    ZwischenInt := ZwischenInt or 00100000;
  if Bit4 = 1 then
    ZwischenInt := ZwischenInt or 00010000;
  if Bit5 = 1 then
    ZwischenInt := ZwischenInt or 00001000;
  if Bit6 = 1 then
    ZwischenInt := ZwischenInt or 00000100;
  if Bit7 = 1 then
    ZwischenInt := ZwischenInt or 00000010;
  if Bit8 = 1 then
    ZwischenInt := ZwischenInt or 00000001;
  Result := Chr(ZwischenInt);

aber irgendwie kommt da nur mist raus .. (obwohl die Bits den Buchstaben T ergeben )

[Sir Rufo]

Zitat:

Zitat von gangs-taas (Beitrag 1047622)

Delphi-Quellcode:

 function TDecodieren.BitToBuch(Bit1, bit2, bit3, bit4, bit5, bit6,
                               bit7, bit8: Integer) : Char;
var
  ZwischenInt : Integer ;
begin
  ZwischenInt := 00000000; // Kann man so lassen ... ist aber witzig :)
  if Bit1 = 1 then
    ZwischenInt := ZwischenInt or 128; // 10000000;
  if Bit2 = 1 then
    ZwischenInt := ZwischenInt or 64; // 01000000;
  if Bit3 = 1 then
    ZwischenInt := ZwischenInt or 32; // 00100000;
  if Bit4 = 1 then
    ZwischenInt := ZwischenInt or 16; // 00010000;
  if Bit5 = 1 then
    ZwischenInt := ZwischenInt or 8; //00001000;
  if Bit6 = 1 then
    ZwischenInt := ZwischenInt or 4; // 00000100;
  if Bit7 = 1 then
    ZwischenInt := ZwischenInt or 2; // 00000010;
  if Bit8 = 1 then
    ZwischenInt := ZwischenInt or 1; // 00000001;
  Result := Chr(ZwischenInt);

aber irgendwie kommt da nur mist raus .. (obwohl die Bits den Buchstaben T ergeben )

Wenn du 00000100 schreibst, dann ist das ein Integer mit dem Wert 100.
Von den führenden Nullen lässt sich der Compiler nicht beeindrucken.

[gangs-taas]

wow vielen vielen dank
es funktioniert :) :)

[Sir Rufo]

Damit das Umrechnen zwischen den einzelnen Zahlensystemen einfacher wird habe ich da mal einen Record zusammengebastelt.
Damit kannst du zwischen den Zahlensystemen 2..36 hin und herrechnen.

Delphi-Quellcode:

unit uBaseConv;

interface

type
  TIntBase = record
  private
    function GetAsBase( Base : Integer ) : string;
    procedure SetAsBase( Base : Integer; const AValue : string );

  public
    Value : Int64;
    property AsBase[ Base : Integer ] : string read GetAsBase write SetAsBase; default;
  end;

function IntToBase( const Value : Int64; const Base : Integer ) : string;
function BaseToInt( const Value : string; const Base : Integer ) : Int64;

implementation

uses
  SysUtils;

function IntToBase( const Value : Int64; const Base : Integer ) : string;
  var
    Val : Int64;
    Res : Byte;
  begin
    if ( Base >= 2 ) and ( Base <= 36 ) then
      begin
        Val := Value;
        while Val > 0 do
          begin
            Res := Val mod Base;
            case Res of
              0 .. 9 :
                Result := Chr( Ord( '0' ) + Res ) + Result;
              10 .. 35 :
                Result := Chr( Ord( 'A' ) + Res - 10 ) + Result;
            end;
            Val := Val div Base;
          end;
      end
    else
      raise Exception.CreateFmt( 'Basis %d ausserhalb des gülitigen Bereichs 2..36', [ Base ] );
  end;

function BaseToInt( const Value : string; const Base : Integer ) : Int64;
  var
    idx : Integer;
    pdx : Integer;
  begin
    if ( Base >= 2 ) and ( Base <= 36 ) then
      begin
        Result := 0;
        idx := 1;
        while idx <= Length( Value ) do
          begin
            Result := Result * Base;
            case Value[ idx ] of
              '0' .. '9' :
                pdx := Ord( Value[ idx ] ) - Ord( '0' );
              'A' .. 'Z' :
                pdx := Ord( Value[ idx ] ) - Ord( 'A' ) + 10;
              'a' .. 'z' :
                pdx := Ord( Value[ idx ] ) - Ord( 'a' ) + 10;
            else
              raise Exception.CreateFmt( 'Ungültiges Zeichen im Wert "%s" entdeckt!', [ Value ] );
            end;
            if pdx < Base then
              Result := Result + pdx
            else
              raise Exception.CreateFmt( 'Der Wert "%s" passt nicht zur Basis %d!', [ Value, Base ] );

            idx := idx + 1;
          end;
      end
    else
      raise Exception.CreateFmt( 'Basis %d ausserhalb des gülitigen Bereichs 2..36', [ Base ] );
  end;

{ TIntBase }

function TIntBase.GetAsBase( Base : Integer ) : string;
  begin
    Result := IntToBase( Value, Base );
  end;

procedure TIntBase.SetAsBase( Base : Integer; const AValue : string );
  begin
    Value := BaseToInt( AValue, Base );
  end;

end.

Benutzt wird das dann wie folgt:

Delphi-Quellcode:

var
  MyVal : TIntBase;
begin
  MyVal.Value := 10;  // Int64-Wert
  MyVal[ 10 ] := '10';  // Dezimalsystem
  MyVal[ 16 ] := 'A';  // Hex
  MyVal[  2 ] := '1010';  // Binär

  // Umrechnen von Hexadezimal in Binär

  MyVal[ 16 ] := 'A2F3';
  ShowMessage( MyVal[  2 ] );

  // Intern rechnen

  MyVal.Value := MyVal.Value * 2;
  
end;

[Micha88]

Zitat:

Zitat von gangs-taas (Beitrag 1047606)

es geht trotzdem nicht
ich weiß einfach nicht weiter ..
Farbe ist immer null ..

null ist nicht 0 ;)
null ist "nichts" und 0 ist 0.

Aussprache null ˌnʌl.

[jfheins]

ColorToRGB()
RGB()
GetRValue()
GetGValue()
GetBValue()

[isilive]

Zitat:

Zitat von gangs-taas (Beitrag 1047622)

Delphi-Quellcode:

 function TDecodieren.BitToBuch(Bit1, bit2, bit3, bit4, bit5, bit6,
                               bit7, bit8: Integer) : Char;
var
  ZwischenInt : Integer ;
begin
  ZwischenInt := 00000000; // Kann man so lassen ... ist aber witzig :)
  if Bit1 = 1 then
    ZwischenInt := ZwischenInt or 128; // 10000000;
  if Bit2 = 1 then
    ZwischenInt := ZwischenInt or 64; // 01000000;
  if Bit3 = 1 then
    ZwischenInt := ZwischenInt or 32; // 00100000;
  if Bit4 = 1 then
    ZwischenInt := ZwischenInt or 16; // 00010000;
  if Bit5 = 1 then
    ZwischenInt := ZwischenInt or 8; //00001000;
  if Bit6 = 1 then
    ZwischenInt := ZwischenInt or 4; // 00000100;
  if Bit7 = 1 then
    ZwischenInt := ZwischenInt or 2; // 00000010;
  if Bit8 = 1 then
    ZwischenInt := ZwischenInt or 1; // 00000001;
  Result := Chr(ZwischenInt);

Du kannst dem Compiler Dezimalzahlen hinschreiben oder Hexadezimalzahlen (zB: $a000 (in anderen Sprachen oft als 0xa000 geschrieben)), aber keine Binärzahlen (glaub ich zumindest.)

Also wenn schon dann so:

Delphi-Quellcode:

  
j := bit1 + bit2*2 + bit3*4 + bit4*8 + bit5*16 + bit6*32 + bit7*64 + bit8*128;
Result := Chr(j);

wobei es ziemlich schräg ist, dass du die bits als Integer und nicht als Boolean definiert hast. Wenn sie boolean sind müsste es halt heissen:

Delphi-Quellcode:

  j:=0;
  if bit1 then inc(j);
  if bit2 then inc(j,2);
  if bit3 then inc(j,4);
  if bit4 then inc(j,8);
  ...