CodeCogs

Implements the GIF file format

You're viewing an older version of this page (#952). View the current version.

Interface

#include <codecogs/computing/graphics/formats/gif.h>

using namespace Computing::Graphics::Formats;

typedef struct RGBValue

Overview

This module implements a class that allows you to load, save and manipulate non-animated GIF content. It also allows you to set various parameters of the image, like transparency, color table, and others.

The GIF format uses a lossless data compression algorithm to store its image data. The algorithm is a modification of the classic Lempel-Ziv-Welch (LZW) dictionary method, using variable code sizes during the compression process. The modified LZW algorithm is available as VariableLZW.

The GIF class can be used in a variety of circumstances, from extracting information about a GIF file, modifying a GIF and saving it, to creating a GIF image from scratch and saving it to disk.

Expand the following example to see how you can display information about a GIF.

Example showing information about a GIF file

#include <codecogs/graphics/formats/gif.h>
#include <iostream>
#include <fstream>

int main()
{
  // name of the file to open (without the .gif extension)
  std::string fileName = "hat.gif";

  // size of the file to open
  int fileSize = 606;

  // create a temporary buffer into which the whole file is loaded
  unsigned char *buffer = new unsigned char[fileSize];

  // open the file for reading
  std::ifstream inf(fileName.c_str(), std::ios_base::in | std::ios_base::binary);

  // read all its contents into the buffer
  inf.read((char *)buffer, fileSize);

  // close the file
  inf.close();

  // decode the data in the buffer and store it in a GIF object
  Graphics::Formats::GIF image(buffer);

  // the buffer can now be removed from memory
  delete [] buffer;

  // display some information about the GIF image
  std::cout << "          Version: " << image.getVersion() << std::endl;
  std::cout << "            Width: " << image.getWidth() << std::endl;
  std::cout << "           Height: " << image.getHeight() << std::endl;

  std::cout << std::endl;

  std::cout << "   Bits per pixel: " << (int) image.getBitsPerPixel() << std::endl;
  std::cout << "     Transparency: " << (image.isTransparent() ? "On" : "Off") << std::endl;

  std::cout << std::endl;

  std::cout << " Color table size: " << image.colorTable.size() << std::endl;
  std::cout << " Background color: " << (int) image.getBackgroundColor() << std::endl;
  if (image.isTransparent())
  {
    std::cout << "Transparent color: " << (int) image.getTransparentColor() << std::endl;
  }

  std::cout << std::endl;

  return 0;
}

Input file:

Output:

Version: GIF89a
            Width: 29
           Height: 28

   Bits per pixel: 8
     Transparency: On

 Color table size: 64
 Background color: 42
Transparent color: 42

The main input-output methods provided by this class are readFromBuffer and writeToBuffer, while the actual GIF manipulation is achived by changing the colorTable public variable, or by calling the setPixel method. The next example reads a GIF file from the disk, adds a border to it using the setPixel method and then writes the new GIF file to disk.

Example adding a border to a given GIF file

#include <codecogs/graphics/formats/gif.h>
#include <iostream>
#include <fstream>

int main()
{
  // name of the file to open (without the .gif extension)
  std::string fileName = "hat";

  // size of the file to open
  int fileSize = 606;

  // create a temporary buffer into which the whole file is loaded
  unsigned char *buffer = new unsigned char[fileSize];

  // open the file for reading
  std::ifstream inf((fileName + ".gif").c_str(), std::ios_base::in | std::ios_base::binary);

  // read all its contents into the buffer
  inf.read((char *)buffer, fileSize);

  // close the file
  inf.close();

  // decode the data in the buffer and store it in a GIF object
  Graphics::Formats::GIF image(buffer);

  // the buffer can now be removed from memory
  delete [] buffer;

  // draw a border around the image using the setPixel() method

  // store the width and height of the image
  int xmax = image.getWidth(), ymax = image.getHeight();

  // index of the color to draw the border with
  unsigned char color = 0;

  // draw the horizontal lines
  for (int x = 0; x < xmax; ++x)
  {
    image.setPixel(x, 0, color);
    image.setPixel(x, ymax - 1, color);
  }

  // draw the vertical lines
  for (int y = 0; y < ymax; ++y)
  {
    image.setPixel(0, y, color);
    image.setPixel(xmax - 1, y, color);
  }

  // encode the GIF image data into the buffer (previously declared)
  // "size" stores the size of the resulting encoded data
  int size = image.writeToBuffer(buffer);

  // open the file for writing
  std::ofstream outf((fileName + "_border.gif").c_str(), std::ios_base::out | std::ios_base::binary);

  // write all the data in the buffer into the file
  outf.write((char *)buffer, size);

  // close the file
  outf.close();

  // the buffer can now be removed from memory
  delete [] buffer;

  return 0;
}

Input file:

Output file:

If you would like to create the whole GIF image from scratch, then you first need to make sure the canvas is set up properly, i.e. you need to set the dimensions of the GIF and call the createCanvas method to create the GIF's canvas on which you can draw. The next example draws a cross on a 50x50 canvas and saves it to disk.

Example showing how to manually create a GIF image

#include <codecogs/graphics/formats/gif.h>
#include <iostream>
#include <fstream>

int main()
{
  // create a GIF object
  Graphics::Formats::GIF image;

  // add the colors we need to the color table

  // enable transparency
  image.setTransparency(true);

  // add the background transparent color
  image.colorTable.push_back(Graphics::Formats::RGBValue(0, 0, 0));

  // set the transparent color's index (0 in this case)
  image.setTransparentColor(0);

  // set the background color to the transparent color
  image.setBackgroundColor(0);

  // add the red color to draw with
  image.colorTable.push_back(Graphics::Formats::RGBValue(255, 0, 0));

  // set the image dimensions
  image.setWidth(50);
  image.setImageWidth(50);
  image.setHeight(50);
  image.setImageHeight(50);

  // create the canvas with the given dimensions
  image.createCanvas();

  // draw the cross
  unsigned short xmax = image.getWidth();
  for (unsigned short i = 0; i < xmax; ++i)
  {
    image.setPixel(i, i, 1);
    image.setPixel(xmax - i - 1, i, 1);
  }

  // name of the file to write to
  std::string fileName = "cross.gif";

  // create a temporary buffer into which
  // the entire image data is temporarily stored
  unsigned char *buffer;

  // encode the GIF image data into the buffer
  // "size" stores the size of the resulting encoded data
  int size = image.writeToBuffer(buffer);

  // open the file for writing
  std::ofstream outf(fileName.c_str(), std::ios_base::out | std::ios_base::binary);

  // write all the data in the buffer into the file
  outf.write((char *)buffer, size);

  // close the file
  outf.close();

  // the buffer can now be removed from memory
  delete [] buffer;

  return 0;
}

Output file:

References

LZW and GIF explained by Steve Blackstock, http://www.cis.udel.edu/~amer/CISC651/lzw.and.gif.explained.html
"Compressed image file formats: JPEG, PNG, GIF, XBM, BMP" by John Miano, Chapter 12, http://books.google.com/books?id=_nJLvY757dQC&dq=Compressed+image+file+formats&printsec=frontcover&source=bn&hl=ro&ei=ImaPSuGxIsiK_Abyh5SvAg&sa=X&oi=book_result&ct=result&resnum=4#v=onepage&q=&f=false
The Wikipedia page on the GIF format, http://en.wikipedia.org/wiki/Graphics_Interchange_Format

DECLARATION

RGBValue

(R, G, B) color triplet associated with a pixel of the image