Discussion :

[lil_jam63]

SAlut, je cherche un moyen de pouvoir stocker une dizaines de bitmap dans un seul fichier pour ensuite les utiliser avec des TBitmap, est ce que l'un d'entre vous à deja fais ce genre de choses, j'ai une p'tite idée mais je pense pas que ce soit la meilleure solution, je pense à stocker les bits de chaque image dans un fichier ini et ensuite recréer le bitmap en execution pour l'ouvrir avec TBitmap.loadFromFile(), qu'en pensez vous?

Et dans la foulée, est ce que c'est possible de charger un bitmap à partir des bytes le composant ça éviterais de le recréé sur le disque.

PS: je ne peux pas utiliser les ressources, c'est un fichier editable par un autre soft.

[fred_malette]

Salut,

Je ne suis pas certain d'avoir bien saisi, mais en tout cas j'avais fait un truc similaire il y a quelques années. A l'époque j'avais utilisé DirectX, mais j'imagine que cela doit être faisable en tapant dans l'API windows 'de base' : as-tu essayé de réunir tous tes bitmaps en un seul gros bitmap (comme les palettes de sprites utilisées dans les jeux 2D), de stocker les coordonnées de chaque bitmap 'atomique' (par exemple dans un fichier ini), et de les reconstituer ensuite à la volée en découpant ton bitmap parent ?

A+

[lil_jam63]

J'y ai en effet pensé mais c'est pas la meilleure solution pour moi, ça m'imposerais 2 fichiers et trop "merdique" à gérer par la suite, de plus, e dois stocker plusieurs autres données dans ce fichier, sinon pource ui est de l'API, en faisant une recherche sur le msdn, je suis tombé sur ça mais je crois qu'il faut avoir .net d'installer sur son pc, ce qui n'est pas le cas de tout le monde.

[fred_malette]

Salut,

Hmmm, j'avoue que je suis assez surpris que tu qualifies cette solution de 'merdique' - personnellement je trouve ça plutôt propre (en tout cas plus propre que de regénérer des bitmaps octet par octet, ou que d'avoir des centaines de tous petits fichiers bitmap qui trainent). Mais bon - question de goût, j'imagine )

En tout cas, la mémoire m'est un peu revenue : je te confirme qu'il est tout à fait possible, en utilisant uniquement l'api windows standard (nul besoin de .net, donc), de 'blitter' des portions d'un gros bitmap pour en générer une série de bmp plus petits. Je n'ai plus les fonctions en tête, mais j'essaierai de fouiller dans mes sources ce soir si tu n'as pas résolu ton pb d'ici là.

A+

[Pierre Castelain]

Si le format du fichier est libre, le plus simple est d'utiliser un fichier "binaire" dans lequel les images sont stockées à la file. Il suffit d'utiliser un TFileStream ayant un format du style :
Taille de l'image (nombre d'octets dans le flux)
Image (bitmap.SaveToStream)
Taille de l'image (nombre d'octets dans le flux)
Image (bitmap.SaveToStream)
...
Il est nécessaire de passer par un flux temporaire pour la lecture, mais ça ne pose pas de problème particulier.

[Pierre Castelain]

Voila un exemple de ce que j'ai dit précédemment (non testé, mais l'idée y est) :

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
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
 
const
  FILE_SIGNATURE = 'BitmapsEnSérie';
 
procedure SaveBitmaps(filename: string; Bitmaps: TBitmapArray);
var
  fileStream: TFileStream;
  memoryStream :TMemoryStream;
  i, streamLength: Integer;
  signature: string;
begin
  if Length(Bitmaps) <> 0 then
  begin
    fileStream:= TFileStream.Create(filename, fmCreate);
    try
      // Je conseille vivement d'ajouter un marqueur pour identifier le fichier
      signature:= FILE_SIGNATURE;
      fileStream.Write(signature[1], Length(signature));
      memoryStream:= TMemoryStream.Create;
      try
        for i:= Low(Bitmaps) to High(Bitmaps) do
        begin
          memoryStream.Clear;
          Bitmaps[i].SaveToStream(memoryStream);
          memoryStream.Seek(0, soFromBeginning);
          streamLength:= memoryStream.Size;
          fileStream.Write(streamLength, SizeOf(streamLength));
          memoryStream.SaveToStream(fileStream);
        end;
      finally
        memoryStream.Free;
      end;
    finally
      fileStream.Free;
    end;
  end;
end;
 
procedure LoadBitmaps(Filename: string; Bitmaps: TBitmapArray);
var
  fileStream: TFileStream;
  memoryStream :TMemoryStream;
  streamLength: Integer;
  signature: string;
  bmp: TBitmap;
begin
  Setlength(Bitmaps, 0);
  fileStream:= TFileStream.Create(Filename, fmOpenRead);
  try
    SetLength(signature, Length(FILE_SIGNATURE));
    fileStream.Read(signature[1], Length(FILE_SIGNATURE));
    if signature <> FILE_SIGNATURE then
      raise Exception.Create('Type de fichier incorrect.');
    memoryStream:= TMemoryStream.Create;
    while fileStream.Position < fileStream.Size  do
    try
      fileStream.Read(streamLength, SizeOf(streamLength));
      memoryStream.Clear;
      memoryStream.CopyFrom(fileStream, streamLength);
      bmp:= TBitmap.Create;
      try
        memoryStream.Seek(0, soFromBeginning);
        bmp.LoadFromStream(memoryStream);
        SetLength(Bitmaps, Length(Bitmaps) + 1);
        Bitmaps[High(Bitmaps)]:= bmp;
      except
        bmp.Free;
      end;
    finally
      memoryStream.Free;
    end;
  finally
    fileStream.Free;
  end;
end;

[lil_jam63]

T'as tout compris Pierre c'est exactement ce que je cherche, un seul fichier qui contient tous mes bitmap et des infos de type string, je vais repartir sur ton exemple et arranger ça pour mes besoins, merci beaucoup .

[Invité]

Salut,

J'essaye de faire un peu la même chose. Le problème, c'est que quand je fais

Code :

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

 fileStream:= TFileStream.Create(Filename, fmOpenRead);

j'ai fileStream.Size = 0.

Est ce normal?