Bestimmte Grafik aus einer einzigen Resource laden?

[stOrM]

Hi, ich hab da folgendes Problem:

Ich weiss zwar wie man eine Resource erstellt und diese auch wieder laden kann nur, gestern bin ich über eine Bildresource gestolpert (PNG) wo ich mich wirklich frage wie man sowas lädt.

Wir stellen uns mal folgendes vor, eine PNG Resource, die mehrere verschiedene Buttons enthält, die auf dem Bild selber liegen, dass ist z.B. sehr nützlich wenn man nicht für jeden Button eine seperate Resource erstellen möchte wie z.B.

Button1 PNG "Button1.png"
Button2 PNG "Button2.png"

usw.

Sondern man hat z.B. nur GlobalButtons PNG "GlobalButtons.png" die über 40 verschiedene Buttonlayouts enthält.
Die Frage ist nun wie lade ich bestimmte Buttonlayouts aus dieser Resource?

Ich häng mal ein Bild ran, die das vielleicht besser verdeutlicht?

Viele Grüsse
s!

[Arnulf]

Ich bin ja immer derjenig der nix versteht in diesem Forum....

Was du hier hast ist ein Bild.
wenn du etwas bestimmtest daraus haben willst, dann musst du dir das schon zerschneiden, bitweise rauskopieren oder ähnliches.
du müsstest dir also ein map speichern die dir sagt - von bit_x bis bit_y enthält bild_1 usw.

oder du ladest jedes in eine eigene recource.

oder versteh ich wiedermal was nicht :)

lg
Arnulf

[stOrM]

Hehe machdir keine sorgen, du verstehstdas komplett richtig nur ich kann deine Antwort nicht wirklich umsetzen dafür fehlt mir nun wieder das Verständnis :-)
Ich müsste mal sowas sehen, wie das gemacht wird das könnte mir eventuell auf die Sprünge helfen...

Viele Grüsse
s!

[Arnulf]

Naja - ich kenne das png format nicht besonders.
aber soweit ich weiß ist das koprimiert und damit liegt es nicht genau in einem bit raster vor im gegensatz zu einer bitmap.
für bitmaps wäre es einfach, weil die daten einfach linear oder sequentiell abgespeichert werden.
es ist also eine x mal x matrix.
png müsste erst in eine solche matrix eingebaut werden um einzelne bereich raus zu kopieren.
vielleicht gibts auch schon fertige tools um aus png bilder teile auszuschneiden, aber ich kenn sowas nicht.

jedenfalls kannst du das natürlich in eine bitmap laden und dir da einzelne teile rausschneiden.
das ist relativ einfach, wenn du weißt ob es sich um ein 16, 24 oder 32 bit bitmap handelt.
ein pixel ist dann eben 2, 3, oder 4 byte lang und du kannst dir damit die pixel holen und in ein neues bitmap kopieren.

aber sinnvoll erscheint mir das nicht was du da vor hast - jeder hat allerdings so seine gründe verrückte sachen zu machen.
ich bin ja der größte spinner meißtens :)

lg
Arnulf

[rotfc]

Ob das Bild in der *.res nun als PNG, GIF, JPG oder BMP ist eigentlich egal, oder?

stOrM will nur wissen, wie man es zum weiteren Gebrauch "zerschnippelt" ;-)

[stOrM]

Zitat:

Zitat von rotfc

Ob das Bild in der *.res nun als PNG, GIF, JPG oder BMP ist eigentlich egal, oder?

stOrM will nur wissen, wie man es zum weiteren Gebrauch "zerschnippelt" ;-)

Korrekt!

Viele Grüße
s!

[marabu]

Hallo,

ich würde die Ressource mit PNGObject laden, den Stripe mittels Assign() in ein Bitmap konvertieren und dieses Bitmap in eine ImageList laden. Dabei sollte bei korrekter Dimensionierung der Einzelbilder automatisch eine interne Zerlegung stattfinden, sodass mit ImageList.GetBitmap() auf die einzelnen Bilder zugegriffen werden kann. Werden die Einzelbilder wieder im PNG-Format benötigt, so lässt sich jedes Bitmap auch wieder per Assign() in ein PNGObject umwandeln.

Grüße vom marabu

[Arnulf]

Zitat:

Ob das Bild in der *.res nun als PNG, GIF, JPG oder BMP ist eigentlich egal, oder?

Das ist es eben nicht.
wie marabu geschreiben hat muss man das wohl erstmal in ein bitmap überführen um die bilddaten ordentlich zerlegen zu können.

png lässt sich nicht einfach so zerschnippeln.
jpg vielleicht wenn man 8x8 raster verwendet.
es kommt also sehr auf das bildformat an.

so wie ich das png bild gesehen habe sind die bilder nicht gleich groß, deshalb musst du eine pixel map mitliefern die das zuerlegen überhaupt erst ermöglicht.

das war es denke ich was ich gesagt habe.
wenn alle Bilder gleich groß sind, dann gehts einfacher - so wie marabu gesagt hat.

lg
Arnulf

[Namenloser]

Wenn die ressource aber so aussieht wie im Anhang, wird das wohl nicht klappen, weil die Bilder nicht alle die gleiche Größe haben. Da bleibt dir wohl nichts anderes übrig, als die Positionen der Bilder binär oder im textformat abzuspeichern und dann aus dem Bild herauszukopieren.

Eventuell kann ich nachher mal nen kleinen Beispiel Code liefern, wenn benötigt. (hab ja grad nix zu tun :stupid: )

[stOrM]

Zitat:

Zitat von NamenLozer

Wenn die ressource aber so aussieht wie im Anhang, wird das wohl nicht klappen, weil die Bilder nicht alle die gleiche Größe haben. Da bleibt dir wohl nichts anderes übrig, als die Positionen der Bilder binär oder im textformat abzuspeichern und dann aus dem Bild herauszukopieren.

Eventuell kann ich nachher mal nen kleinen Beispiel Code liefern, wenn benötigt. (hab ja grad nix zu tun :stupid: )

Extrem notwendig, der Schnippsel, wenn Du grad eh nix zu tun hast :-)
Wobei ich gerne auf ne Imagelist verzichten würde, wenn das geht, ich wollte Graphics32 nutzen und für die einzelnen extrahierten Bilder wenns klappt halt dann nen Bitmap32 Object oder PNGObject wenns nicht konvertiert werden muss.

Viele Grüsse
s!

[Arnulf]

Aber ehrlich - einfacher wäre es doch aus den png bildern einen memory stream zu erstellen.
dh. alle png bilder hintereinander in einen stream schreiben und sich irgend ein protokoll zum auslesen überlegen.

am einfachsten wäre es wohl am stream anfang zu schreiben:
bild1:250
bild2:350
bild3:200
startofstream
binärdaten.........

und die angabe in bytes zu haben.
dann kannst du dir die bilder einfach so aus dem stream holen und einfach in ein png einfügen.
den stream kannst du als ganzes in eine recource schreiben.

Das ist meiner meinung nach einfacher und universeller als dieses bild hin und herkopieren.

lg
Arnulf
Edit:
oder noch einfacher - 2 recourcen
1. ist eine größenangabe der einzelnen bilder
bild250bild300bild200
da du hier nur zahlen und eindeutige buchstaben hast kann im protokoll zum auslesen nicht viel passieren.
2. die binärdaten wobei bild1 dann 250 bytes hat bild2 dann 300 bytes usw...
damit kannst du dirrekt aus dem stream das bild lesen und auch zuweisen.

irgend sowas...

[rotfc]

Noch eine Spur einfacher wäre es wohl, die *.res-Datei selbst zu erstellen statt die eines fremden Programms "hacken" zu wollen ;-)

Ansonsten: Die eine PNG aus der *.res in ein unsichtbares Image laden und dann dort in Einzelteile (vorzugsweise für ImageLists) zerpflücken?

[Namenloser]

Delphi-Quellcode:

type
  TRectArray = array of TRect;
  TBitmapArray = array of TBitmap;

// Zwei Funktionen die Rechtecke aufbereiten:
function FixRect(SrcRect: TRect): TRect;
  procedure Switch(var a,b: integer);
  var c: integer;
  begin
    c := a; a := b; b := c;
  end;
begin
  if SrcRect.Left > SrcRect.Right then
    Switch(SrcRect.Left,SrcRect.Right);
  if SrcRect.Top > SrcRect.Bottom then
    Switch(SrcRect.Top,SrcRect.Bottom);
  result := SrcRect;
end;
function TrimRect(SrcRect: TRect; minx,miny,maxx,maxy: integer): TRect;
begin
  result := fixrect(srcrect);
  if result.Left < minx then result.left := minx;
  if result.top < miny then result.top := miny;
  if result.right > maxx then result.right := maxx;
  if result.bottom > maxy then result.bottom := maxy;
end;

// Stanzt die in SrcRect übergebenen rechtecke aus SrcPNG aus und lädt sie ins
// DstBitmapArray
procedure GetBitmaps(const SrcPNG: TPNGObject; const SrcRects: TRectArray;
  var DstBitmapArray: TBitmapArray);
var
  i: integer;
  Rct: TRect;
  Bmp: TBitmap;
begin
  // Bitmap vom PNG Erzeugen
  Bmp := TBitmap.Create;
  Bmp.Assign(SrcPNG);
  // Länge der auszugebenden Bilderliste festlegen (=Anzahl der Rechtecke)
  setlength(DstBitmapArray,high(SrcRects)+1);
  for i := 0 to high(SrcRects) do
  begin
    // Bitmap erzeugen
    DstBitmapArray[i] := TBitmap.Create;
    // Rechteck vorbereiten mit obigen Funktionen (ggf Zurechtschneiden,
    // falls es über die Grenzen des PNGs hinausgeht)
    Rct := TrimRect(SrcRects[i],0,0,SrcPng.Width,SrcPNG.Height);
    // Größe des Bitmaps setzen
    DstBitmapArray[i].SetSize(rct.Right-rct.left,rct.bottom-rct.top);
    // rechteck ausstanzen und auf Bitmap kopieren
    BitBlt(DstBitmapArray[i].Canvas.Handle,0,0,DstBitmapArray[i].width,
      DstBitmapArray[i].Height,bmp.Canvas.handle,rct.left,rct.top,srccopy);
  end;
  Bmp.free;
end;

// Stanzt ebenfalls Bilder aus dem PNG aus, die rechtecke werden aber im
// Parameter Positions testbasiert übergeben. jede Zeile definiert ein rechteck
// Die Koordinaten des Rechtecks werden in der reihenfolge Left, Top, Right, Bottom
// angegeben und durch Kommata separiert. Beispiel:
// 0,0,100,50
// 100,0,100,100
// etc...
procedure LoadBitmaps(const SrcPNG: TPNGObject; const Positions: TStrings;
  var DstBitmapArray: TBitmapArray);
var
  i: integer;
  l: integer;
  rectarray: TRectArray;
  tmp: tstringlist;
begin
  setlength(rectarray,positions.Count);
  l := 0;
  tmp := tstringlist.Create;
  tmp.Delimiter := ',';
  for i := 0 to positions.count - 1 do
  begin
    tmp.DelimitedText := Positions[i];
    if TryStrToInt(trim(tmp[0]),rectarray[l].Left) and
       TryStrToInt(trim(tmp[1]),rectarray[l].Top) and
       TryStrToInt(trim(tmp[2]),rectarray[l].Right) and
       TryStrToInt(trim(tmp[3]),rectarray[l].Bottom) then
      inc(l);
  end;
  setlength(rectarray,l);
  GetBitmaps(srcpng,rectarray,dstbitmaparray);
  tmp.free;
end;

Ein einfach gehaltenes Beispiel. listen wären besser als Arrays, hätten den Code aber zu sehr aufgebläht. (Wie fast immer bei mir) ist das ganze ungetestet, aber zumindest das Prinzip sollte klar sein.

Wobei die Lösung per Memorystream sowohl im Aufwand als auch in der Dateigröße allerdings elegeanter ist... In einem meiner eigenen projekte habe ich es mit XML gelöst (was aber den nachteil hat, dass Binärdateien Base64 enkodiert werden, was wieder etwas speicher kostet.) Aber das Schöne an objektorientierter Programmierung ist ja, dass ich die Klasse bei bedarf einfach austauschen könnte :cheers:

[stOrM]

Zitat:

Zitat von rotfc

Noch eine Spur einfacher wäre es wohl, die *.res-Datei selbst zu erstellen statt die eines fremden Programms "hacken" zu wollen ;-)

Ansonsten: Die eine PNG aus der *.res in ein unsichtbares Image laden und dann dort in Einzelteile (vorzugsweise für ImageLists) zerpflücken?

Kann ruhig jeder Wissen, das die Res von Devexpress ist für Ribbons, nur für die Frage dich ich hier gepostet hab, lohnt es nicht wirklich jetzt Photoshop anzuwerfen und erstmal Buttons zu malen und ggf so anzurodnen wie die Res von Devexpress oder? Mir gehts nur darum wie man so eine Res ausliest und die ausgelesenen Sachen z.B. auf nen Bitmap32 Object wieder anordnet die Res von DE interessiert mich nicht wirklich...

VG
s!

[stOrM]

Zitat:

Zitat von NamenLozer

Delphi-Quellcode:

type
  TRectArray = array of TRect;
  TBitmapArray = array of TBitmap;

// Zwei Funktionen die Rechtecke aufbereiten:
function FixRect(SrcRect: TRect): TRect;
  procedure Switch(var a,b: integer);
  var c: integer;
  begin
    c := a; a := b; b := c;
  end;
begin
  if SrcRect.Left > SrcRect.Right then
    Switch(SrcRect.Left,SrcRect.Right);
  if SrcRect.Top > SrcRect.Bottom then
    Switch(SrcRect.Top,SrcRect.Bottom);
  result := SrcRect;
end;
function TrimRect(SrcRect: TRect; minx,miny,maxx,maxy: integer): TRect;
begin
  result := fixrect(srcrect);
  if result.Left < minx then result.left := minx;
  if result.top < miny then result.top := miny;
  if result.right > maxx then result.right := maxx;
  if result.bottom > maxy then result.bottom := maxy;
end;

// Stanzt die in SrcRect übergebenen rechtecke aus SrcPNG aus und lädt sie ins
// DstBitmapArray
procedure GetBitmaps(const SrcPNG: TPNGObject; const SrcRects: TRectArray;
  var DstBitmapArray: TBitmapArray);
var
  i: integer;
  Rct: TRect;
  Bmp: TBitmap;
begin
  // Bitmap vom PNG Erzeugen
  Bmp := TBitmap.Create;
  Bmp.Assign(SrcPNG);
  // Länge der auszugebenden Bilderliste festlegen (=Anzahl der Rechtecke)
  setlength(DstBitmapArray,high(SrcRects)+1);
  for i := 0 to high(SrcRects) do
  begin
    // Bitmap erzeugen
    DstBitmapArray[i] := TBitmap.Create;
    // Rechteck vorbereiten mit obigen Funktionen (ggf Zurechtschneiden,
    // falls es über die Grenzen des PNGs hinausgeht)
    Rct := TrimRect(SrcRects[i],0,0,SrcPng.Width,SrcPNG.Height);
    // Größe des Bitmaps setzen
    DstBitmapArray[i].SetSize(rct.Right-rct.left,rct.bottom-rct.top);
    // rechteck ausstanzen und auf Bitmap kopieren
    BitBlt(DstBitmapArray[i].Canvas.Handle,0,0,DstBitmapArray[i].width,
      DstBitmapArray[i].Height,bmp.Canvas.handle,rct.left,rct.top,srccopy);
  end;
  Bmp.free;
end;

// Stanzt ebenfalls Bilder aus dem PNG aus, die rechtecke werden aber im
// Parameter Positions testbasiert übergeben. jede Zeile definiert ein rechteck
// Die Koordinaten des Rechtecks werden in der reihenfolge Left, Top, Right, Bottom
// angegeben und durch Kommata separiert. Beispiel:
// 0,0,100,50
// 100,0,100,100
// etc...
procedure LoadBitmaps(const SrcPNG: TPNGObject; const Positions: TStrings;
  var DstBitmapArray: TBitmapArray);
var
  i: integer;
  l: integer;
  rectarray: TRectArray;
  tmp: tstringlist;
begin
  setlength(rectarray,positions.Count);
  l := 0;
  tmp := tstringlist.Create;
  tmp.Delimiter := ',';
  for i := 0 to positions.count - 1 do
  begin
    tmp.DelimitedText := Positions[i];
    if TryStrToInt(trim(tmp[0]),rectarray[l].Left) and
       TryStrToInt(trim(tmp[1]),rectarray[l].Top) and
       TryStrToInt(trim(tmp[2]),rectarray[l].Right) and
       TryStrToInt(trim(tmp[3]),rectarray[l].Bottom) then
      inc(l);
  end;
  setlength(rectarray,l);
  GetBitmaps(srcpng,rectarray,dstbitmaparray);
  tmp.free;
end;

Ein einfach gehaltenes Beispiel. listen wären besser als Arrays, hätten den Code aber zu sehr aufgebläht. (Wie fast immer bei mir) ist das ganze ungetestet, aber zumindest das Prinzip sollte klar sein.

Wobei die Lösung per Memorystream sowohl im Aufwand als auch in der Dateigröße allerdings elegeanter ist... In einem meiner eigenen projekte habe ich es mit XML gelöst (was aber den nachteil hat, dass Binärdateien Base64 enkodiert werden, was wieder etwas speicher kostet.) Aber das Schöne an objektorientierter Programmierung ist ja, dass ich die Klasse bei bedarf einfach austauschen könnte :cheers:

Schau ich mir am WE an vielen Dank erstmal für deine Mühe, bin mal gespannt obs hinhaut :-)
VG
s!