• LoadFromFile
• SaveToFile

Image1.Picture.LoadFromFile('c:\windows\help.ico');
Image1.Picture.LoadFromFile('c:\windows\Bubbles.bmp');
Image1.Picture.LoadFromFile('c:\QUAKE2\q2.ico');      // this fails

procedure TForm1.FormCreate(Sender: TObject);
begin
  Form1.DoubleBuffered := true;
end;

• SaveToClipboardFormat
• LoadFromClipboardFormat
• RegisterClipboardFormat

Instead, you should use TClipboard.Assign and TPicture.Assign which do use the TPicture clipboard commands.

Clipboard.Assign(Image1.Picture);
Clipboard.Assign(SpeedButton1.Glyph); // Glyph is a TBitmap
Image1.Picture.Assign(Clipboard);

For more info, see the Clipboard section of efg's Delphi Graphics: Algorithms.

Image1.Picture.LoadFromFile('c:\windows\help.ico');
Clipboard.Assign(Image1.Picture);           // This fails
Clipboard.Assign(Image1.Picture.Graphic);   // and this fails

Image1.Picture.LoadFromFile('c:\windows\Bubbles.bmp');
Clipboard.Assign(Image1.Picture); // This works fine

Image1.Picture.LoadFromFile('c:\windows\Circles.bmp');
Clipboard.Assign(Image1.Picture); // This crashes the system

On a separate system (running Windows 95), I got "Invalid clipboard format" the first time this code executed. Afterwards, it simply copied a null graphic to the clipboard. (Note: Windows 98 crashes, Windows 95 simply reports an error.)

On the Windows 98 system, Circles.bmp also causes the Microsoft Paint program to crash if you select Edit / Select All.

Using Windows XP, it sort of works. Circles.bmp is monochrome - Dark Blue and Light Blue - but when you paste it, it is black and white. (Well, at least it doesn't crash.) Of course, this means that Delphi is ok, it is just another Windows design problem that users will blame on you and your code.

Image1.Picture.LoadFromFile('c:\windows\Circles.bmp');

if Image1.Picture.Graphic is TBitmap then
  if not Image1.Picture.Bitmap.Monochrome then
    Clipboard.Assign(Image1.Picture.Graphic)
  else
    Clipboard.Clear
else if Image1.Picture.Graphic is TIcon then
    Clipboard.Clear
else // Metafile, jpeg, ...
  Clipboard.Assign(Image1.Picture.Graphic);

if Clipboard.HasFormat(CF_PICTURE) then
  Image2.Picture.Assign(Clipboard);
end;

Modifying and/or creating JPEG images is a bit more complex and is covered in the separate JPEG Image page.

Locating, installing, and using this code is covered in the separate PNG Image page.

Uses ..., axctrls;

procedure TForm1.Open1Click(Sender: TObject);
var
  f : TFileStream;
  graphic : TOleGraphic;
begin
  if OpenDialog1.Execute then
  begin
    graphic := TOleGraphic.Create;  

    f := TFileStream.Create (OpenDialog1.FileName, 
                              fmOpenRead or fmShareDenyNone);
    try
      graphic.LoadFromStream(f);
      Image1.Picture.Assign(graphic);
    finally
      f.Free
    end
  end
end;

To create a tiff file, just copy Bmp2tiff.pas to your program directory and call it via something like this

 // Save Image as TIFF in the same path with extension '.TIF'
 WriteTiffToFile( ChangeFileExt(OpenDialog1.FileName, '.TIF'),
             Image1.Picture.Bitmap );

SavePictureDialog1.DefaultExt := GraphicExtension(TBitmap);

SavePictureDialog1.Filter := GraphicFilter(TBitmap);
if SavePictureDialog1.Execute then

ColorToRGB
ColorToString
StringToColor

I have an application that displays MRI images that are stored as simple data files (2 bytes per pixel).

The following code requires about 3 seconds to load each image

var
//  F: File;  // Defined as a global variable
  S: string;
  i, j: integer;
  buff: array [0..131072] of char;
  tc:TColor;
begin
  AssignFile(F, 'downloads\bruce_June5.txt');
  Reset(F, 2);
  BlockRead(F, ImageArray[0, 0], 256*256);

 Image1.Picture.Bitmap.Height := 256;
 Image1.Picture.Bitmap.Width := 256;
  for i := 0 to 255 do
   for j := 0 to 255 do begin
    tc := ImageArray[i, j];
    Image1.Picture.Bitmap.Canvas.Pixels[i, j] := tc;
   end;
  Image1.Canvas.Refresh;
//  CloseFile(F);
end;

var
//  F: File;
  S: string;
  i, j, k: integer;
  buff: array [0..131072] of char;
  tc:TColor;
  Bitmap: TBitmap;
begin
  AssignFile(F, 'downloads\bruce_June5.txt');
  Reset(F, 2);

  ImageList1.CreateSize(256, 256);

  for k := 0 to 155 do begin  // 155
    Bitmap := TBitmap.Create;
    Bitmap.Height := 256;
    Bitmap.Width := 256;

    BlockRead(F, ImageArray[0, 0], 256*256);
    for i := 0 to 255 do
     for j := 0 to 255 do begin
      tc := ImageArray[i, j];
      Bitmap.Canvas.Pixels[i, j] := tc;
     end;
    ImageList1.Add(Bitmap, nil);
  end;

  Image1.Picture.Bitmap := Bitmap; // This just indicates that the load is done
end;

Reading an *.bmp file is very fast (about 6 seconds for 155 images), however, the images are arranged as 4 x n. As a result, when the images are read, only the first 4 can be seen via the ImageList.

var
  hb: HBITMAP;
  Stream: TFileStream;
begin
  Stream := TFileStream.Create('xxyy.bmp',fmOpenRead );
  Imagelist1.Height := 256; Imagelist1.Width := 256;
  Imagelist1.Clear;
  bm.LoadFromStream(Stream);
  Imagelist1.Add(bm, nil);
 // bm.ReleaseHandle;
  Stream.Destroy;

  Image1.Picture.Bitmap := bm; // This just indicates that the load is done
end;

The problem is with how the *.bmp file was created - I loaded the 156 images into an imagelist (but only the first 74 are available using Windows 98, they are all read using Windows XP - same *.exe) and then saved them to the *.bmp file using this code.

var
  hb: HBITMAP;
  Stream: TFileStream;
  bm: TBitmap;
begin
  Stream := TFileStream.Create('xxyy.bmp',fmCreate );
  bm := TBitmap.Create;

  hb := Imagelist1.GetImageBitmap ;
  bm.Width := 256*100;               // This is part of the debug
  bm.Handle := hb;
  bm.SaveToStream (Stream);
  bm.ReleaseHandle;
  Stream.Destroy;
end;

All images in an image list are contained in a single, wide bitmap in screen device format.

I tried setting the width of the bitmap object before assigning the handle - no effect. Either way, after

bm.Handle := hb;

Presumably, this is controlled by the AllocBy parameter.

It only takes a second to read the entire 20M file into an array. Reformatting it into a second array with RGB planes takes 20 seconds. I assume that the Trunc command is taking too long. I have experimented with several commands that convert an integer to a byte (trunc, dividing by 256, and shr which is the fastest).

Tbitmap writes to a stream as 3 bytes (RGB) per pixel. This code replaces one image with another (it is actually fairly fast). If you don't set PixelFormat to 24-bits, then the number of bytes per pixel depends on the screen resolution.

var
 bm2: TBitmap;
 st: TMemoryStream;
begin
  bm2:= TBitmap.Create;

  bm2.PixelFormat := pf24bit;
  bm2.Width       := 256    ;
  bm2.Height      := 256    ;

  st := TMemoryStream.Create;
  bm2.SaveToStream (st);
   st.Seek( - (256*256*3), soFromEnd);
   st.WriteBuffer( ColorArray[ScrollPos,0,0,1] , 256*256*3);
  st.Seek(0, soFromBeginning );
  bm2.LoadFromStream(st);
  Image1.Picture.Bitmap := bm2;
  bm2.Destroy ;
  st.Destroy;

end;

ColorArray[ScrollPos,0,0,1]
                     | | |
                     | | - color plane - 1-blue  2-green  3-red
                     | --- x  0 is  left  of bitmap, Increases toward right
                     ----- y  0 is bottom of bitmap, Increases toward  top

• Read the image into a TPicture (supports various file formats)
• Convert the image into a bitmap
• Create a new bitmap the same size as your TImage
• Set the background color (for the part of the TImage not covered)
• Use StretchDraw to copy the bitmap to a new bitmap
• Copy the new bitmap to a TImage component

Reference: efg's Computer Lab

  PRGBTriple = ^TRGBTriple;
  {$EXTERNALSYM tagRGBTRIPLE}
  tagRGBTRIPLE = packed record
    rgbtBlue: Byte;
    rgbtGreen: Byte;
    rgbtRed: Byte;
  end;
  TRGBTriple = tagRGBTRIPLE;
  {$EXTERNALSYM RGBTRIPLE}
  RGBTRIPLE = tagRGBTRIPLE;

  PRGBQuad = ^TRGBQuad;
  {$EXTERNALSYM tagRGBQUAD}
  tagRGBQUAD = packed record
    rgbBlue: Byte;
    rgbGreen: Byte;
    rgbRed: Byte;
    rgbReserved: Byte;
  end;
  TRGBQuad = tagRGBQUAD;
  {$EXTERNALSYM RGBQUAD}
  RGBQUAD = tagRGBQUAD;

Also useful and undocumented in the Delphi 5 help file

TDIBSection.dsbmih refers to a TBitmapInfoHeader - see windows.pas
size, width, height, planes, bitCount, etc.

URL: http:// mc-computing.com / Languages / Delphi / Images.html