Width and Height of Images - Where is the Rest like Colors?

[manfred23]

Hallo liebe Forumleser und Delphibegeisterte,

Ich möchte wissen, wie viele Farben eine Bilddatei hat.

Dazu folgendes Beispiel:

Delphi-Quellcode:

uses ..., ... GraphicEx;

Image : TImage;

procedure mach;
var PicFile : TPicture;
    {(1)}
    dx, dy : integer; {dx=width, dy=height}
    bpp : byte; {BitsPerPixel}

begin
PicFile:=TPicture.Create;
{(2)}
try PicFile.LoadFromFile('Beispiel.BILD');
    {(3) Prop ... }
    Image.Picture:=PicFile;
    dx:=PicFile.Width; {width und height sind kein Problem}
    dy:=PicFile.Height;
    {(4) bpp:=???}

(*
Und hier verliesen sie mich...

Es gibt in GraphicEx eine TImageProperties für alle
unterstützten Formate, so auch ein Wert namens BitsPerPixel.
Bei BMP (und JPG) gibt es das T(JPEG)PixelFormat mit pfDevice, pf8Bit, ...

Ich habe also folgendes versucht bzw. eingefügt in den Quelltext oben:
...
(1) var Prop : TImageProperties; {ist okay}
...
(2) Prop:=TImageProperties.Create; {ist okay}
...
(3) Hier nun meine Frage.
Wie kriege ich die Daten aus dem gelesenen PicFile
in die Prop Variable, so daß dort alle Felder mit den
richtigen Werten gefüllt sind und ich sie zur Verfügung habe?

Ich habe so ziemlich alles versucht:
Prop:=LoadImageProperties(LoadFromFile('Beispiel.B ILD');
und sogar mit TGraphicExGraphic experimentiert,
aber entweder paßt dann TPicture nicht zu TGraphicExGraphic,
usw.

Gut, ich kann den Header des jeweils erkannten Bildformates
auslesen und so an die Werte rankommen, aber warum zweimal
auf eine Datei zugreifen? Wäre doch Schwachsinn, oder?

...
(4) bpp:=Prop.BitsPerPixel; {ist auch okay, übergibt aber nur den Wert 0 wegen fehlendem (3)}
...
(5) Prop.Free; {nicht zu vergessen}
*)

Delphi-Quellcode:

finally
    PicFile.Free;
    {(5)}
end;
end;

[edit=sakura] Delphi-Tags. Mfg, sakura[/edit]

[mr_emre_d]

Zitat:

Ich möchte wissen, wie viele Farben eine Bilddatei hat.

Das hängt vom Format ab

Zitat:

Bei BMP (und JPG) gibt es das T(JPEG)PixelFormat mit pfDevice, pf8Bit, ...

2^8 = 255 Farbmöglichkeiten ...(0..255 ;) )

Ich habe dein Post nur überflogen, also sorry falls das nicht das ist, was du brauchst :)

MfG

[manfred23]

Danke für die Antwort,

aber das meinte ich nicht:(

Die GraphicEx Bibliothek stellt eine TImageProperties zur Verfügung
in der man unter anderem auch einen BitsPerPixel Wert zur Verfügung
hat.

Nun, mit GraphicEx lade ich das Bild, aber außer Width und Height
aus dem TPicture kriege ich keine weitere Informationen mehr,
weil es mir nicht gelingt etwas bereits bestehendes, nämlich
diesen Typ TImageProperties und seine ganzen möglichen Rekordwerte
richtig zuzuordnen um an die Werte wie z.B. BitsPerPixel zu kommen.

Ich habe mich bereits durch die GraphicEx.chm datei gelesen sonst
wüßte ich ja überhaupt nicht, daß es diese Möglichkeit gibt.

Dann, mal nur so nebenbei, noch eine andere Sache,
die das TIcon betrifft, egal was ich mache, alle meine
geladenen ICO-dateien haben 32x32 pixel und 24bit colors.

Das stört dann, wenn man einen Rahmen (TBevel) und eine Komponente
(TImage) der Größe nach eben der Größe des anzuzeigenden Icons (Bildes)
anpassen möchte. Was glaube ich doch sinnvoll ist.

Selbst Irfanview (version 4.20) zeigt bei 2, 16, oder 256 Farben
jede ICO-dateien mit Truecolor (24bit) an. Scheint daß ich mit dem
Problem nicht alleine dastehe.

Natürlich besteht die Möglichkeit mithilfe von wosits Informationen
einen bestimmten Wert aus dem Header der Bilddatei auszulesen und so
den richtigen Wert über BitsPerPixel usw. zu erhalten...
Aber das wäre völliger Quatsch.

Danke für den Tip, daß 2 hoch 8 ein 8bit Bild mit 256 Farben ist.
Nebenbei, ich habe Informatik studiert, allerdings als Windows
noch in den Kinderschuhen steckte und 8MByte Speicher 1000.-DM
kosteten und die DDR noch nicht zur BRD gehörte!

Mit freundlichen Grüßen,
manfred23

[angos]

Hi,

ich bin zwar nicht wirklich der Grafik-Crack, aber kommt man da nicht über

Delphi-Quellcode:

Picture.Bitmap.PixelFormat

dran?

Gruß

[manfred23]

Hallo liebe Delphiforumleser,

zu dem Problem, wie man zusätzliche Informationen
zu einer Bilddatei bekommt, habe ich folgende
Codeausschnitte hier mal reingesetzt.

Delphi-Quellcode:

uses ..., GraphicColor, GraphicEx;

type T...  = class(TForm)
       ...
       ImaInfo: TImage; {hier wird die Bilddatei reingeladen}
      ...
      private
      ...
{ein paar Variablen über die Bildinformation}
        prvBitsPerSample, prvSamplesPerPixel, prvChannels, 
        prvFilterMode, prvBitsPerPixel, prvRotate : byte;
        prvXResolution, prvYResolution, prvFileGamma : single;
        prvHeight, prvWidth, prvXPelsPerMeter, prvYPelsPerMeter : integer;
        prvImageCount, prvPlanes : word;
        prvVersion, prvBMPCompression, prvClrUsed, prvClrImportant : cardinal;
        prvInterlaced, prvLocalColorTable, prvHasAlpha, prvMono, prvOverview : boolean;
        prvCompression: TCompressionType;
        prvColorScheme: TColorScheme;

implementation
...
{der Spaß, um die richtigen Werte von ICO-dateien aus deren
{Header auszulesen}
type TIconHeaderInfo = record
                       IHfiller : array[0..5] of byte;
                       IHdx : byte; {width}
                       IHdy : byte; {height}
                       IHfiller2 : array[0..27] of byte;
                       IHbpp : byte; {bits per pixel}
                       end;
var IconHeader : TIconHeaderInfo;

{das TPixelFormat in BitsPerPixel convertieren}
function _getPixelFormat(MyPixelFormat:TPixelFormat):byte;
begin
result:=0;
case MyPixelFormat of
  pfDevice: result:=0; {!?}
    pf1bit: result:=1;
    pf4bit: result:=4;
    pf8bit: result:=8;
   pf15bit: result:=15;
   pf16bit: result:=16;
   pf24bit: result:=24;
   pf32bit: result:=32;
  pfCustom: result:=0; {!?}
end; {case}
end;

{für den TCompressionType in GraphicEx was lesbares kriegen}
function _getCompressionType(ct:TCompressionType):str_12;
begin
result:='No Info';
case ct of
        ctUnknown: result:='Unknown';
           ctNone: result:='None';
            ctRLE: result:='RLE';
     ctPackedBits: result:='PackedBits';
            ctLZW: result:='LZW';
           ctFax3: result:='Fax3';
         ctFaxRLE: result:='Fax RLE';
           ctFax4: result:='Fax 4';
        ctFaxRLEW: result:='Fax RLE';
           ctLZ77: result:='LZ77';
           ctJPEG: result:='JPEG New';
          ctOJPEG: result:='JPEG Old';
    ctThunderscan: result:='Thunderscan';
           ctNext: result:='Next';
       ctIT8CTPAD: result:='IT8CTPAD';
          ctIT8LW: result:='IT8LW';
          ctIT8MP: result:='IT8MP';
          ctIT8BL: result:='IT8BL';
      ctPixarFilm: result:='PixarFilm';
       ctPixarLog: result:='PixarLog';
            ctDCS: result:='DCS';
           ctJBIG: result:='JBIG';
    ctPCDHuffmann: result:='PCD Hufman';
end; {case}
end;

{für den TColorScheme in GraphicColor aka GraphicEx was lesbares kriegen}
function _getColorScheme(colsch:TColorScheme):str_12;
begin
result:='No Info';
case colsch of
   csUnknown: result:='Not Defined';
   csIndexed: result:='Indexed';
         csG: result:='Grayscale';
        csGA: result:='Grayscale AC';
       csRGB: result:='RGB';
      csRGBA: result:='RGB AC';
       csBGR: result:='BGR';
      csBGRA: result:='BGR AC';
       csCMY: result:='CMY';
      csCMYK: result:='CMY Black';
    csCIELab: result:='CIE Lab';
     csYCbCr: result:='YCbCr';
  csPhotoYCC: result:='PhotoYCC';
end; {case}
end;

{die Bilddatei ins Object ImaInfo:TImage laden und ein paar Bildwerte holen}
procedure TMZInfo._loadFile;
var   BmpHeader : TBitmapfileheader;
      BmpInfo : TBitmapinfoheader;
      PicStream : TFileStream;
      BmpFile : TBitmap;
      PicFile : TPicture;
      IconFile : TIcon;
      GIFProperties : TGIFGraphic;
      PNGProperties : TPNGGraphic;
begin
...

{
 Um GIF-dateien handhaben zu können mit dem GraphicEx Tool
 muß man einiges zuerst tun:
 die mitgelieferte GraphicConfiguration.Inc datei editieren
 und dort" {.$define UseLZW}" gegen "{$define UseLZW}" tauschen
 sonst wird zwar "{$define GIFGraphic}", also das GIF-format definiert,
 aber weiter unten wieder "{$ifndef UseLZW} {$undef GIFGraphic} {$endif}"
 entdefiniert. Eine Sicherheitsmaßnahme von Herrn Mike Lischke
 um nicht ins Gefängnis zu müssen.
}

{
hier nun das Beispiel für die GIF datei.
prvFile ist z.B. 'Bild.GIF' und prvExt wäre dann '.GIF'.
Interessant wäre eine zusätzliche Information wieviele 
Einzelbilder die Datei enthält und was so an Kommentaren 
mit drinsteht, aber das Problem habe ich noch nicht gelöst.
}

if ((prvExt = '.GIF')) then begin
   PicFile:=TPicture.Create;
   GIFProperties:=GraphicEx.TGIFGraphic.Create;
   try {erster Zugriff auf die Bilddatei}
       PicFile.LoadFromFile(prvFile); 
        {erneuter Zugriff auf die Bilddatei}
       GIFProperties.LoadFromFile(prvFile);
       {Bild anzeigen}
       ImaInfo.Picture:=PicFile; 
       {Bildwerte holen und sich merken}
       prvWidth:=GIFProperties.ImageProperties.Width;
       prvHeight:=GIFProperties.ImageProperties.Height;
       prvCompression:=GIFProperties.ImageProperties.Compression;
       prvBitsPerPixel:=GIFProperties.ImageProperties.BitsPerPixel;
       prvBitsPerSample:=GIFProperties.ImageProperties.BitsPerSample;
       prvSamplesPerPixel:=GIFProperties.ImageProperties.SamplesPerPixel;
       prvColorScheme:=GIFProperties.ImageProperties.ColorScheme;
       prvVersion:=GIFProperties.ImageProperties.Version;
       prvInterlaced:=GIFProperties.ImageProperties.Interlaced;
       prvLocalColorTable:=GIFProperties.ImageProperties.LocalColorTable;
   finally
       PicFile.Free;
       GIFProperties.Free;
   end;
   ...
end;
...
{nur als Beispiel, dasselbe mit einer PNG-datei}
if ((prvExt = '.PNG')) then begin
   PicFile:=TPicture.Create;
   PNGProperties:=GraphicEx.TPNGGraphic.Create;
   try PicFile.LoadFromFile(prvFile);
       PNGProperties.LoadFromFile(prvFile);
       ImaInfo.Picture:=PicFile;
       prvWidth:=PNGProperties.ImageProperties.Width;
       prvHeight:=PNGProperties.ImageProperties.Height;
       prvCompression:=PNGProperties.ImageProperties.Compression;
       prvBitsPerPixel:=PNGProperties.ImageProperties.BitsPerPixel;
       prvBitsPerSample:=PNGProperties.ImageProperties.BitsPerSample;
       prvSamplesPerPixel:=PNGProperties.ImageProperties.SamplesPerPixel;
       prvColorScheme:=PNGProperties.ImageProperties.ColorScheme;
       prvFileGamma:=PNGProperties.ImageProperties.FileGamma;
       prvInterlaced:=PNGProperties.ImageProperties.Interlaced;
       prvHasAlpha:=PNGProperties.ImageProperties.HasAlpha;
       prvFilterMode:=PNGProperties.ImageProperties.FilterMode;
   finally
       PicFile.Free;
       PNGProperties.Free;
   end;
   ...
end;

{hier nun das, d.h. mein, Problem mit den ICO-dateien}
if ((prvExt = '.ICN') or
    (prvExt = '.ICO')) then begin
   IconFile:=TIcon.Create;
   try IconFile.LoadFromFile(prvFile);
       ImaInfo.Picture.Icon:=IconFile;
       {es wird standardmäßig immer ein 32x32 Icon gemeldet}
       {und Pustekuchen, was die Farbanzahl einer ICO-datei ist}
       {prvWidth:=IconFile.Width;   {these values sucks}
       {prvHeight:=IconFile.Height; { " }
       {prvBitsPerPixel:=?;         {not avail}
   finally
       IconFile.Free;
   end;
   {um die wahren Werte zu kriegen, bleibt mir nur das hier übrig}
   {den IconHeader habe ich oben definiert, siehe TIconHeader}
   // read enhanced info of the ICO-file
   PicStream:=TFileStream.Create(prvFile, fmOpenRead);
   try PicStream.Read(IconHeader, sizeof(IconHeader));
       prvWidth:=IconHeader.IHdx;         {get correct values}
       prvHeight:=IconHeader.IHdy;        { " }
       prvBitsPerPixel:=IconHeader.IHbpp; { " }
   finally
       PicStream.Free;
   end;
   ...
end;

{auch bei der BMP-datei erwarten einen einige Probleme}
{wenn man an mehr Werte über die Datei kommen will}
if ((prvExt = '.BMP')) then begin
   BmpFile:=TBitmap.Create;
   try BmpFile.LoadFromFile(prvFile);
       ImaInfo.Picture.Bitmap:=BmpFile;
       prvWidth:=BmpFile.Width;
       prvHeight:=BmpFile.Height;
       prvMono:=BmpFile.Monochrome;
       prvBitsPerPixel:=_getPixelFormat(BmpFile.PixelFormat);
   finally
      BmpFile.Free;
   end;
   // read enhanced info of the BMP-file
   PicStream:=TFileStream.Create(prvFile, fmOpenRead);
   try PicStream.Read(BmpHeader, sizeof(BmpHeader));
       PicStream.Read(BmpInfo, sizeof(BmpInfo));
       prvXPelsPerMeter:=BmpInfo.biXPelsPerMeter;
       prvYPelsPerMeter:=BmpInfo.biYPelsPerMeter;
       prvPlanes:=BmpInfo.biPlanes;
       prvBMPCompression:=BmpInfo.biCompression;
       prvClrUsed:=BmpInfo.biClrUsed;
       prvClrImportant:=BmpInfo.biClrImportant;
   finally
       PicStream.Free;
   end;
   ...
end;

{
Bei den JPEG-dateien arbeite ich noch dran
aber das Format ist ziemlich kompliziert.
Bis jetzt genügt mir die Breite und Höhe des Bildes
und die Farbtiefe von 24 bit setzte ich mal für stets voraus
}

if ((prvExt = '.JFIF') or
    (prvExt = '.JPE') or
    (prvExt = '.JPEG') or
    (prvExt = '.JPG')) then begin
   PicFile:=TPicture.Create;
   try PicFile.LoadFromFile(prvFile);
       ImaInfo.Picture:=PicFile;
       prvWidth:=PicFile.Width;
       prvHeight:=PicFile.Height;
       prvBitsPerPixel:=24; {! :)}
   finally
       PicFile.Free;
   end;
   ...
end;

Soweit bin ich letztes Wochenende gekommen.
Ne schöne Woche noch,
Tschüß.

[DeddyH]

Könntest Du noch Delphi-Tags setzen? Das ist nahezu unlesbar.

[Luckie]

Und ich möchte dich bitten deinem Thread einen aussagekräftigen Titel zu geben. Danke.

[manfred23]

@Luckie:
Danke, das mit dem Titel hab ich vergessen.
Ich dachte ein Re: ... täte es auch.

@DeddyH:
Das ist ja cool mit den Tags.
Ich habe mich schon gewundert,
warum das bei mir nicht funktioniert hat.

Doch nun zurück zu dem Problem an sich.
Ich habe mich etwas durch die Code-Library hier gelesen
und da taucht doch immer wieder mal folgendes auf, wenn
man versucht die Width und Height von ICO-dateien haben
zu wollen.

Delphi-Quellcode:

...
Image1 : TImage;
...
var IconFile : TIcon;
    MyWidth, MyHeight : integer;
...
IconFile:=TIcon.Create;
try IconFile.LoadFromFile('Beispiel.ico');
    Image1.Picture.Icon:=IconFile;
    MyWidth:=IconFile.Width;   
    MyHeight:=IconFile.Height;
    ...

Es scheint, daß das bei allen funktioniert,
nur bei mir nicht.

Tschüß.