Problem mit TColor

[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);
  ...