Mehrere Bilder in einer Datei Speichern

[Christian.Ossi]

Ich wollte mal wissen, ob es möglich ist, mehrere kleine jpg-Bilder in einer einzigen Datei - sozusagen als Datenbank - zu speichern!?

Ich hab ein Programm geschrieben wo nun kleine Bildchen noch aus einer Datei heraus gelesen werden sollen, die dann dort angezeigt werden sollen. Also muss man die auch z.B. per Nummer ansprechen können und dann eben aus einer einzigen Datei auslesen können.

Ist sowas möglich? Oder muss man dann alle einzeln abspeichern - ich wollte der Ordnung wegen nur eine einzige Datenbankdatei.


Danke schonmal!

[ferby]

Hallo,

du kannst einfach deine Bilder in ein Archiv packen (z.B.: In ein Zip Archiv)
Es gibt Komponenten die mit Zip Archiven umgehen können.

Gruß,
Ferby

[arbu man]

Eine Lösung wäre XML:

Du speicherst die jpegs in jewils einen Stream. Dann kanst du die einzelnen Streams in xml Speichern. Nachteil diese Datei wird etwas größer da die daten anderes gespeichert werden.

Hier noch eine Unit an der ich grade arbeite die streams in xml speichern soll (benötigt die JEDI Komponetenten):

Delphi-Quellcode:

{******************************************************************************}
{*                                                                            *}
{* Project:        CrashPoint                                                 *}
{* Unit:           uCP_MapFile                                                *}
{* Version:        1.0                                                        *}
{*                                                                            *}
{* Description:                                                               *}
{*                 Klasse um eine Liste von Streams in eine Datei zu          *}
{*                 speichern und zu lesen                                     *}
{*                                                                            *}
{* Log:                                                                       *}
{*               # First Version                                              *}
{*                                                                            *}
{*                                                                            *}
{* Author:         Björn R. Salgert ([e-mail])                         *}
{* URL:            N/A - [url]http://bsnx.net[/url]                                      *}
{*                                                                            *}
{******************************************************************************}
unit uCP_MapFile;

interface

uses SysUtils, Classes, JvSimpleXml, Dialogs;

type
  TMapFile = class (TJvSimpleXML)
  protected

  public
    procedure AddStream(Name: String; Stream: TStringStream);
    procedure GetStream(Name: String; Stream: TStream);
    procedure AddString(Name, Text: String);
    function GetString(Name: String): String;
    procedure AddInt(Name: String; I: Integer);
    function GetInt(Name: String): Integer;
    constructor Create(AOwner: TComponent); override;
  end;

implementation

function streamtostr(S: TStream): string;
var
  str: string;
  lStringStream: TStringStream;
begin
  lStringStream := TStringStream.Create;
  Try
    lStringStream.CopyFrom(S, 0);
    Result := lStringStream.DataString;
  Finally
    lStringStream.Free;
  End;
end;

function strtohex(Text: String): String;
var
  i: integer;
  s: string;
begin
  for i:=1 to length(Text) do begin
    s:= s+IntToHex(Byte(Text[i]), 2);
  end;
  result:=s
end;

{ TMapFile }

procedure TMapFile.AddInt(Name: String; I: Integer);
begin
  Self.Root.Items.Add(Name, i);
end;

procedure TMapFile.AddStream(Name: String; Stream: TStringStream);
begin
//  Self.Root.Items.Add(Name, strtohex(Stream.DataString));
  Stream.Position:=0;
  Self.Root.Items.Add(Name, Stream);
end;

procedure TMapFile.AddString(Name, Text: String);
begin
  Self.Root.Items.Add(Name, Text);
end;

constructor TMapFile.Create(AOwner: TComponent);
begin
  inherited;
  Self.Root.Name:= 'map';
end;

function TMapFile.GetInt(Name: String): Integer;
begin
  if Self.Root.Items.ItemNamed[Name]<>nil then begin
     result:=Self.Root.Items.ItemNamed[Name].IntValue;
  end;
end;

procedure TMapFile.GetStream(Name: String; Stream: TStream);
var
  b: Byte;
  i: integer;
begin
  if Self.Root.Items.ItemNamed[Name]<>nil then begin
     Stream.Position:=0;
     Self.Root.Items.ItemNamed[Name].GetBinaryValue(Stream);
     {
     for i:=1 to Length(Self.Root.Items.ItemNamed[Name].Value) do begin
       B:= Byte(Self.Root.Items.ItemNamed[Name].Value[i]);
       Stream.Write(B, sizeof(B));
     end; }
  end;
end;

function TMapFile.GetString(Name: String): String;
begin
  if Self.Root.Items.ItemNamed[Name]<>nil then begin
    result:= Self.Root.Items.ItemNamed[Name].Value;
  end;
end;

end.

[mr.winkle]

Du kannst auch mehrere Bilder in einer großen Bilddatei zusammenfassen, das lohnt sich aber nur bei recht kleinen bildern

wenn alle bilder die selbe größe haben gibt es in der delphix imagelist die möglichkeit eine patternwidth und patternheight festzulegen.
Du kannst dann über eine zahl auf ein bestimmtes Bild zugreifen - was z.b bei animationen sehr nützlich ist da man nicht 123 bilder verwalten muss.

Bei verschiedenen Größen müsste man mit einer Trennfarbe oä arbeiten, was allerdings recht rechenintensiv wäre.

Von anderen Lösungen habe ich noch nichts gehört, würde mich aber auch mal interessieren! :stupid:

[Christian.Ossi]

Also die Bilder wären alle max. 90x90 Pixel groß - eben im jpg-Format.
Das ist ja noch recht klein....denk ich.

Wie geht das mit DelphiX - davon habe ich schonmal was gehört.
Die Sache ist nur die - ich will ja online auf meinem Free-Webspace die einzelnen kleinen durchnummerierten Bildchen verfügbar machen und das Programm holt sich die und legt sie auf der eigenen Festplatte ab - aber nicht wie online mehrere, sondern als eine Datei.

Von dieser aus sollen die Bilder im Programm eingebunden werden.
Also sozusagen kann man online ein Bild austauschen und das Programm holt sich das Bild oder die Bilder und speichert diese dann als Art Datenbank lokal zum Öffnen im eigenen Programm.

[mkinzler]

Dann würde sich, wie schon geschrieben ein Archiv anbieten oder du speicherst die Bilder wirklich in einer Datenbank.

[Der_Unwissende]

Hi,
ich würde dir auch von einer großen Datei abraten. Hat eher eine Menge Nachteile. Gerade bei XML (hier imho völlig ungeeignet) müsstest du dann tunlichst darauf achten, dass du nicht immer die ganze Datei im Speicher hälst. Damit ist die Wahl deines XML Parsers evtl. schon eingeschränkt. Ein Archiv bietet da schon deutlich mehr Flexibilität. Am einfachsten legst du darin noch (etwas an eine DB angelehnt) eine Indexdatei an und dann kannst du über diese schnell nach bestimmten Eigenschaften suchen ohne alle Bilder ständig entpacken zu müssen. Damit solltest du also ohne Probleme nur noch gezielt auf einzelne Elemente zugreifen können.
Ich würde dir hier Abbrevia empfehlen (sorry, zu faul den Link zu suchen).

Gruß Der Unwissende

[cruiser]

Ich hätt noch Compound Documents anzubieten. Quasi ein virtuelles Dateisystem innerhalb einer Datei, leider unkomprimiert, aber ich denke, da liese sich noch was dran feilen. Vorteil dabei: du kannst auf jedes File wie vom richtigen Dateisystem auch, per Stream zugreifen ohne ein File entpacken zu müssen. Der Link in der Doku ist leider tot, aber ich kann die Files hochstellen, wenn bedarf ist.

[franktron]

Schau mal in die Code Lib da habe ich vor kurzem ein Virtuelles Dateisystem reingepackt

[Der_Unwissende]

Zitat:

Zitat von cruiser

Ich hätt noch Compound Documents anzubieten. Quasi ein virtuelles Dateisystem innerhalb einer Datei, leider unkomprimiert

Also auf Kompression denke ich sollte man bei JPEGs nicht mehr achten müssen. Die haben ja gerade schon die Eigenschaft ziemlich kompakt zu sein. Ich weiß nicht wieviel Prozent man da noch rausholt, dürfte sich aber kaum lohnen. Daran sollte es also nicht scheitern!