Discussion :

[BobaL]

Bonjour,

Je cherche à charger une image depuis une chaine hexadécimale.
J'ai fais quelque recherche mais rien de concluant au final.
Du coup je viens vous montrer mon code en espérant que cela vous inspire

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
function StreamToHex(Stream: TStream; var Hex: string): Boolean;
var
  Buffer: Byte;
begin
  Hex := EmptyStr;
  Stream.Seek(0, soFromBeginning);
  while Stream.Read(Buffer, 1) = 1
    do Hex := Hex + IntToHex(Buffer, 2);
  Result := not SameText(Hex, EmptyStr)
end;
 
function HexToStream(const Hex: string; var Stream: TMemoryStream): Boolean;
begin
  Stream.Size := Length(Hex) div 2;
  Result := Stream.Size > 0;
  HexToBin(PChar(Hex), Stream.Memory, Stream.Size);
end;
 
procedure TForm4.Button2Click(Sender: TObject);
var
  Stream: TMemoryStream;
begin
  Stream := TMemoryStream.Create;
  try
    Image1.Picture.Graphic.SaveToStream(Stream);
 
    if StreamToHex(Stream, FHex) then
    begin
      Label1.Caption := IntToStr(Stream.Size);
 
      Memo1.Lines.BeginUpdate;
      Memo1.Text := FHex;
      Memo1.Lines.EndUpdate;
    end;
  finally
    Stream.Free;
  end;
end;
 
procedure TForm4.Button3Click(Sender: TObject);
var
  Stream: TMemoryStream;
begin
  Stream := TMemoryStream.Create;
  try
    if HexToStream(FHex, Stream) then
    begin
      Label2.Caption := IntToStr(Stream.Size);
      Image2.Picture.Graphic.LoadFromStream(Stream);
    end;
  finally
    Stream.Free;
  end;
end;

Une idée ?

Merci.

[ShaiLeTroll]

Ton StreamToHex est très étrange, pourquoi ne pas avoir utilisé BinToHex la réciproque de HexToBin de HexToStream ?

{EDIT}
IntToHex renvoie ABCDEF !
Majuscule, HexToBin ne le supporte pas comme c'est mentionné dans la documentation !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
function HexToStream(const Hex: string; var Stream: TMemoryStream): Boolean;
begin
  Stream.Size := Length(Hex) div 2;
  Result := false;
  if Stream.Size > 0 then
    Result := HexToBin(PChar(LowerCase(Hex)), Stream.Memory, Stream.Size) = 0;
end;

{/EDIT}

Après HexToStream, la Position du Stream est toujours zéro je suppose puisque tu as directement utilisé le Memory !

Le code Hex := Hex + ... est d'une EFFROYABLE lenteur !
Sous D7, c'est une catastrophe,
sous FastMM ou 2005 à XE2, c'est 100 fois plus rapide mais reste plus lent qu'une allocation complète puis d'un remplissage !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
function StreamToHex(Stream: TStream; var Hex: AnsiString): Boolean;
begin
  Stream.Seek(0, soFromBeginning);
  SetLength(Hex, Stream.Size * 2);
  BinToHex(PAnsiChar(@Result), PAnsiChar(Hex), Stream.Size);
end;

Quelle version de Delphi ?
Attention au PChar sous XE2 !


Tient dans le sujet mettre image dans un 'INSERT TO', j'avais écrit une chose similaire, ou dans le sujet Récupérer un Blob en Hexa.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
 
function BinFileToHexaString(const InFileName: TFileName): AnsiString;
var
  FileStream: TFileStream;
  MemoryStream: TMemoryStream;
begin
  FileStream := TFileStream.Create(InFileName, fmOpenRead );
  try
    if FileStream.Size > 0 then
    begin
      SetLength(Result, FileStream.Size * 2);
 
      MemoryStream := TMemoryStream.Create();
      try
        MemoryStream.CopyFrom(FileStream, FileStream.Size);
        MemoryStream.Position := 0;
 
        BinToHex(PAnsiChar(Integer(Stream.MemoryStream)), PAnsiChar(Result), MemoryStream.Size);
      finally
        MemoryStream.Free;
      end;
    end;
  finally
    FileStream.Free;
  end;
end;

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
procedure HexaStringToBinFile(const OutFileName: string; const HexaText: string);
 
   function LowCharCase(C: Char): Char;
   asm
           CMP     AL,'A'
           JB      @@exit
           CMP     AL,'Z'
           JA      @@exit
           SUB     AL,'A' - 'a'
   @@exit:
   end;
 
var
   HexaCleanText: string;
   HexaBuffer: array of Char;
   OutFile: file;
   I, Count: Integer;
begin
   AssignFile(OutFile, OutFileName);
   Rewrite(OutFile, 1);
   try
      Count := 0;
      SetLength(HexaCleanText, Length(HexaText));
      ZeroMemory(@HexaCleanText[1], Length(HexaCleanText));
      for I := 1 to Length(HexaText) do
      begin
         if HexaText[I] in ['0'..'9', 'A'..'F', 'a'..'f'] then
         begin
            Inc(Count);
            HexaCleanText[Count] := LowCharCase(HexaText[I]);
         end;
      end;
      Count := Count div 2;
      SetLength(HexaBuffer, Count);
      HexToBin(@HexaCleanText[1], @HexaBuffer[0], Count);
      BlockWrite(OutFile, HexaBuffer[0], Count);
   finally
      CloseFile(OutFile);
   end;
end;

HexToBin ne supporte que les minuscule, n'est ce-pas dommage !
HexaStringToBinFile a été conçu pour gérer du Hexa aussi bien FFFFffff ou FF ff FF ff

je me suis fait une fonction capable de gérer normalement n'importe quelle base, je crois qu'elle est fiable

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
 
//---------------------------------------------------------------------------
AnsiString __fastcall ConversionIntToBase(__int64 Value, const AnsiString &Base)
{
  AnsiString Result = "";
 
  int BaseLen = Base.Length();
  if (BaseLen >= 0)
  {
    if (Value >= BaseLen)
    {
      Result.SetLength(Floor(LogN(BaseLen, Value)) + 1); // LogN est-il plus rapide que des réallocations de chaine dans une boucle ?
      char* pResult = Result.AnsiLastChar();
 
      while (Value > 0)
      {
        *pResult = Base[Value % BaseLen + 1];
        Value = Value / BaseLen; // Division entière en C++ grace au type !
        pResult--;
      }
    }
    else
      Result = Base[Value + 1];
  }
 
  return Result;
}

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
ConversionIntToBase(257, '01');
ConversionIntToBase(257, '01234567');
ConversionIntToBase(257, '0123456789');
ConversionIntToBase(257, '0123456789ABCDEF');

[BobaL]

Merci pour toutes ces précisions.
J'arrive maintenant à convertir dans les 2 sens des images Bitmap vers les données hexa grâce à cette page http://delphi.cjcsoft.net/viewthread.php?tid=48465

Je suis en effet tombé sur les pages du forum hier soir... même si je ne suis pas arrivé à faire ce que je voulais avec.

Mon problème maintenant est que les données que je récupère de la base de données ne semblent pas être de l'hexa :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32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La colonne de la table mentionne 'données binaires'.
Il s'agit d'une image stockée par la plateforme OpenERP.

Une idée pour l'afficher dans Delphi ?
Merci de votre aide.

[tourlourou]

Base64, comme les images en PJ de mails ? Il existe des convertisseurs dans la suite Indy pour essayer

[ShaiLeTroll]

Pas besoin d'Indy !
La bonne vielle EncdDecd (Soap.EncdDecd en XE2)

En Delphi 6

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
procedure EncodeStream(Input, Output: TStream);
procedure DecodeStream(Input, Output: TStream);
function  EncodeString(const Input: string): string;
function  DecodeString(const Input: string): string;

Nouveaute de XE2

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
function  DecodeBase64(const Input: AnsiString): TBytes;
function  EncodeBase64(const Input: Pointer; Size: Integer): AnsiString;

Ton Base64 contient un JPEG 34x100 CocaCola
Pense à utiliser un TJPEGImage
Selon D6 ou XE2, le comportement du TJPEGImage diffère un peu, mais rien d'insurmontable

Code c++ :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
AnsiString toto = "/9j/4AAQSkZJRgABAQAAAQ ... qgZPqaKKEBNRRRQB//2Q==";
TStringStream *src = new TStringStream(toto);
TMemoryStream *dest = new TMemoryStream();
DecodeStream(src, dest);
dest->Position = 0;
TJPEGImage *JPEGImage = new TJPEGImage();
JPEGImage->LoadFromStream(dest);
Image1->Picture->Assign(JPEGImage);

[BobaL]

Merci beaucoup ShaiLeTroll !

Je vais tout de même te demander comment utiliser DecodeBytes64 car j'ai la chance d'avoir XE2 mais je ne sais pas quoi faire du TArray<Byte> qu'il retourne...

En fait j'ai essayé ça mais sans succès :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
procedure TForm4.Button1Click(Sender: TObject);
var
  Jpeg: TJPEGImage;
  Stream: TMemoryStream;
begin
  Jpeg := TJPEGImage.Create;
  Stream := TStringStream.Create(DecodeBytes64(Memo1.Text));
  try
    Jpeg.LoadFromStream(Stream);
    Image1.Picture.Assign(Jpeg);
  finally
    Jpeg.Free;
    Stream.Free;
  end;
end;

Merci encore

[tourlourou]

Je ne connais pas XE2 et le TBytes, mais ça doit pouvoir le faire avec un code du style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
procedure TForm4.Button1Click(Sender: TObject);
var
  Jpeg: TJPEGImage;
  Stream: TMemoryStream;
  Flux: TBytes;
begin
  Jpeg := TJPEGImage.Create;
  Stream := TMemoryStream.Create; 
  Flux:=DecodeBytes64(Memo1.Text);
  Stream.WriteBuffer( Flux[0], Length(Flux) );
  Stream.Position := 0;
  try
    Jpeg.LoadFromStream(Stream);
    Image1.Picture.Assign(Jpeg);
  finally
    Jpeg.Free;
    Stream.Free;
    SetLength(Flux, 0);
  end;
end;

[ShaiLeTroll]

Pourquoi vouloir utiliser DecodeBytes64 qui issu encore d'une autre unité CloudAPI et non EncdDecd !
En plus tu n'as pas vu Decode64 qui s'utilise comme EncdDecd.DecodeString

Utilise DecodeStream, j'ai fourni un exemple (certe en C++ mais facile a traduire sachant que j'ai testé le code)

Ou alors DecodeString qui ne manipule que des String (comme c'est ton cas en Memo et TStringStream)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
procedure TForm4.Button1Click(Sender: TObject);
var
  Jpeg: TJPEGImage;
  Stream: TMemoryStream;
begin
  Jpeg := TJPEGImage.Create;
//  Stream := TStringStream.Create(CloudAPI.Decode64(Memo1.Text));
  Stream := TStringStream.Create(EncdDecd.DecodeString(Memo1.Text));
  try
    Jpeg.LoadFromStream(Stream);
    Image1.Picture.Assign(Jpeg);
  finally
    Jpeg.Free;
    Stream.Free;
  end;
end;