---

ImageIO.cxx

Go to the documentation of this file.

/*
 * @(#)src/ImageIO.cxx  1.0  2002-08-27 13:35
 *
 * Copyright (C)  2002  Daniel Léonard
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#include <cctype>
#include <fstream>
#include <strstream>
#include "ImageIO.h"

namespace halftoner
{

//---------------------------
// Class methods
//---------------------------

   Image* ImageIO::loadPGM(std::istream& is) throw(ImageFormatError, IOError)
   {
   // litterals
      const char P = 'P';
      const char TWO = '2';
      const char FIVE = '5';
      const char COMMENT = '#';
   // greater states
      const int ASCII = 2;
      const int RAW = 5;
      const int ERROR = -1;
   // specific states
      const int BEGIN = -1;
      const int GRAY = 0;
      const int WIDTH = 1;
      const int HEIGHT = 2;
      const int END = 3;
   // tmp
      char b;
   // get the 'P'
      is.get(b);
      if (P != b)
      {
         std::string s("loadPGM - first character not P");
         throw ImageFormatError(s);
      }
   // get the '2' or '5'
      is.get(b);
      if ((TWO != b) && (FIVE != b))
      {
         std::string s("loadPGM - second character not 2 or 5");
         throw ImageFormatError(s);
      }
   // initialize finite state machine
      int mode = ERROR;
      if (TWO == b) mode = ASCII;
      if (FIVE == b) mode = RAW;
      int width = 0;
      int height = 0;
      int maxgray = 0;
      bool assembling = false;
      char conv[2]; conv[1] = '\0';
      int state = BEGIN;
   // here we go
      while (END != state)
      {
         is.get(b);
      // comment ?
         if (COMMENT == b)
         {
            while (b != '\n') is.get(b);
         }
      // a number
         if (isdigit(b))
         {
            conv[0] = static_cast<char>(b);
            assembling = true;
            switch (state)
            {
               case BEGIN:
                  width = width * 10 + atoi(conv);
                  state = WIDTH;
                  break;
               case WIDTH:
                  width = width * 10 + atoi(conv);
                  break;
               case HEIGHT:
                  height = height * 10 + atoi(conv);
                  break;
               case GRAY:
                  maxgray = maxgray * 10 + atoi(conv);
                  break;
            }
         }
      // separator, change state
         else if (isspace(b) && assembling)
         {
            switch (state)
            {
               case GRAY:
                  state = END;
                  break;
               case WIDTH:
                  state = HEIGHT;
                  break;
               case HEIGHT:
                  state = GRAY;
                  break;
            }
            assembling = false;
         }
      // white space - do nothing
         else if (isspace(b) && (assembling == false))
         {
         }
      }
   // reading data
      int len = width * height;
      int* data = new int[len];
      int dataIndex = 0;
      b = 0;
   // raw mode
      if (mode == RAW)
      {
         unsigned char uc;
         while (dataIndex < len)
         {
            is.get(uc);
            if (uc > maxgray)
            {
               ostrstream os;
               os << "loadPGM - " << uc << " greater than maxgray " << maxgray;
               throw ImageFormatError(os.str());
            }
            data[dataIndex++] = static_cast<int>((static_cast<double>(uc) / static_cast<double>(maxgray)) * 255);
         }
      }
   // ascii mode
      else if (mode == ASCII)
      {
         assembling = false;
         int gray = 0;
         while (dataIndex < len)
         {
            is.get(b);
         // a number
            if (isdigit(b))
            {
               conv[0] = b;
               gray = gray * 10 + atoi(conv);
               assembling = true;
            }
         // separator
            else if (isspace(b) && assembling)
            {
               data[dataIndex++] = static_cast<int>((static_cast<double>(gray) / static_cast<double>(maxgray)) * 255);
               gray = 0;
               assembling = false;
            }
         // white space - do nothing
            else if (isspace(b) && assembling == false)
            {
            }
         // pikachu
            else
            {
               string s("loadPGM - corrupt data");
               throw ImageFormatError(s);
            }
         }
      }
   // error checking - should not happen
      else if (ERROR == mode)
      {
         string s("loadPGM - ERROR");
         throw ImageFormatError(s);
      }
   // pedantic error checking
      else
      {
         string s("loadPGM - pikachu clause");
         throw ImageFormatError(s);
      }
   // image creation
      Image* image = new Image(width, height);
   // copy pixels
      dataIndex = 0;
      int h, w;
      for (h = 0; h < height; h++)
      {
         for (w = 0; w < width; w++)
         {
            image->setColorAt(w, h, data[dataIndex++]);
         }
      }
   // been a pleasure dealing with you
      delete [] data;
      return image;
   }

   void ImageIO::savePBMraw(const Image& image, std::ostream& os) throw(IOError)
   {
   // getting pixels and dimensions
      const unsigned char* data = image.getCopy();
      const int w = image.getWidth();
      const int h = image.getHeight();
   // printing header
      os << "P4" << '\n';
      os << w << " " << h << '\n';
   // printing pixels
      unsigned char bw = 0x00;
      int len = w * h;
      for (int i = 0; i < len; i++)
      {
         int color = data[i] & 0x01;
         switch (i % 8)
         {
            case 0:
               bw = (color << 7 | bw);
               break;
            case 1:
               bw = (color << 6 | bw);
               break;
            case 2:
               bw = (color << 5 | bw);
               break;
            case 3:
               bw = (color << 4 | bw);
               break;
            case 4:
               bw = (color << 3 | bw);
               break;
            case 5:
               bw = (color << 2 | bw);
               break;
            case 6:
               bw = (color << 1 | bw);
               break;
            case 7:
               bw = (color | bw);
               os.put(~bw & 0xff);
               bw = 0x00;
               break;
         }
      }
   }

   void ImageIO::savePBMascii(const Image& image, std::ostream& os) throw(IOError)
   {
   // getting pixels and dimensions
      const unsigned char* data = image.getCopy();
      const int w = image.getWidth();
      const int h = image.getHeight();
   // printing header
      os << "P1" << std::endl;
      os << w << " " << h << std::endl;
   // printing pixels
      int len = w * h;
      for (int i = 0; i < len; i++)
      {
         os << (1 - (data[i] & 0x01));
         if ((i % 15) == 14) os << std::endl;
         else os << " ";
      }
   }

}

---