PgmFile.C

Go to the documentation of this file.

/*---------------------------------------------------------------------+
 | Library QgarLib, graphics analysis and recognition                  |
 | Copyright (C) 2002  Qgar Project, LORIA                             |
 |                                                                     |
 | This library is free software; you can redistribute it and/or       |
 | modify it under the terms of the GNU Lesser General Public          |
 | License version 2.1, as published by the Free Software Foundation.  |
 |                                                                     |
 | This library 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 Lesser General Public License for more details.         |
 |                                                                     |
 | The GNU Lesser General Public License is included in the file       |
 | LICENSE.LGPL, in the root directory of the Qgar packaging. See      |
 | http://www.gnu.org/licenses/lgpl.html for the terms of the licence. |
 | To receive a paper copy, write to the Free Software Foundation,     |
 | Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.       |
 |                                                                     |
 | Contact Project Qgar for any information:                           |
 |   LORIA - équipe Qgar                                               |
 |   B.P. 239, 54506 Vandoeuvre-lès-Nancy Cedex, France                |
 |   email: qgar-contact@loria.fr                                      |
 |   http://www.qgar.org/                                              |
 *---------------------------------------------------------------------*/


/**
 * @file   PgmFile.C
 * @brief  Implementation of class qgar::PgmFile.
 *
 *         See file PgmFile.H for the interface.
 *
 * @author <a href="mailto:qgar-develop@loria.fr?subject=Qgar fwd Karl Tombre">Karl Tombre</a>
 * @date   Jul 3, 2001  16:57
 * @since  Qgar 1.0
 */


// Most of the code documented here is an adaptation of code from the PBM
// software package. Here is the copyright notice of this package:
//
// +------------------------------------------------------------------------+
// | Copyright (C) 1988 by Jef Poskanzer                                    |
// |                                                                        |
// | Permission to use, copy, modify, and distribute this software and its  |
// | documentation for any purpose and without fee is hereby granted,       |
// | provided that the above copyright notice appear in all copies and that |
// | both that copyright notice and this permission notice appear in        |
// | supporting documentation.  This software is provided "as is" without   |
// | express or implied warranty.                                           |
// +------------------------------------------------------------------------+



// STD
#include <sstream>
// QGAR
#include <qgarlib/AbstractPbmPlusFile.H>
#include <qgarlib/PgmFile.H>
#include <qgarlib/QgarErrorIO.H>



namespace qgar
{

// -------------------------------------------------------------------
// I N I T I A L I Z A T I O N S   O F   S T A T I C   D A T A 
// -------------------------------------------------------------------


const unsigned char  PgmFile::_s_pgm_magic1 = 'P';

const unsigned char  PgmFile::_s_pgm_magic2 = '2';

const unsigned short PgmFile::_s_pgm_format =
  (((unsigned short) PgmFile::_s_pgm_magic1) * 256)
+ (unsigned short) PgmFile::_s_pgm_magic2;

const unsigned char  PgmFile::_s_rpgm_magic2 = '5';

const unsigned short PgmFile::_s_rpgm_format =
  (((unsigned short) PgmFile::_s_pgm_magic1) * 256)
+ (unsigned short) PgmFile::_s_rpgm_magic2;


// -------------------------------------------------------------------
// C O N S T R U C T O R S 
// -------------------------------------------------------------------


// INITIALIZE FROM FILE NAME AND FORMAT

PgmFile::PgmFile(const char* aFileName, QGEpbmFormat aFormat)

    : AbstractPbmPlusFile(aFileName, 0, 0, aFormat),
      _maxPix(0)

{
  // VOID
}


// INITIALIZE FROM FULL DATA

PgmFile::PgmFile(const char*  aFileName,
                 unsigned int aRowCnt,
                 unsigned int aColCnt,
                 unsigned int aMax,
                 QGEpbmFormat aFormat)

  : AbstractPbmPlusFile(aFileName, aRowCnt, aColCnt, aFormat),
    _maxPix(aMax)

{
  // VOID
}


// -------------------------------------------------------------------
// I N P U T 
// -------------------------------------------------------------------


// READ FILE HEADER

void
PgmFile::readHeader()

  throw(QgarErrorIO)

{
  int c1 = _fileStream.get();
  if (c1 == EOF)
    {
      std::ostringstream os;
      os << "EOF while reading in file "
         << _fileName;
      throw QgarErrorIO(__FILE__, __LINE__,
                        "void qgar::PgmFile::readHeader()",
                        os.str());
    }

  int c2 = _fileStream.get();
  if (c2 == EOF)
    {
      std::ostringstream os;
      os << "EOF while reading in file "
         << _fileName;
      throw QgarErrorIO(__FILE__, __LINE__,
                        "void qgar::PgmFile::readHeader()",
                        os.str());
    }

  unsigned short magicNb = (c1 * 256) + c2;
  if (magicNb == _s_pgm_format)
    {
      _format = QGE_PBM_PLAIN;
    }
  else if (magicNb == _s_rpgm_format)
    {
      _format = QGE_PBM_RAW;
    }
  else 
    {
      std::ostringstream os;
      os << "Bad magic number in file "
         << _fileName;
      throw QgarErrorIO(__FILE__, __LINE__,
                        "void qgar::PgmFile::readHeader()",
                        os.str());
    }

  _colCnt = getInt();
  _rowCnt = getInt();
  _maxPix = getInt();
  if (_maxPix > 255)
    {
      std::ostringstream os;
      os << "Bad max pixel value in file "
         << _fileName;
      throw QgarErrorIO(__FILE__, __LINE__,
                        "void qgar::PgmFile::readHeader()",
                        os.str());
    }

  newRow();
}


// READ A ROW FROM THE FILE

void
PgmFile::readRow()
{
  isOpenR();

  int col = 0;
  unsigned char* pRow = _pRow;

  switch(_format)
    {
    case QGE_PBM_PLAIN:
      for (/* VOID */ ; col < _colCnt; ++col, ++pRow)
        {
          *pRow = (unsigned char) getInt();
        }
      break;

    case QGE_PBM_RAW:
      for ( ; col < _colCnt; ++col, ++pRow )
        {
          *pRow = getRawByte();
        }
    } // END switch
}


// -------------------------------------------------------------------
// O U T P U T 
// -------------------------------------------------------------------


// WRITE FILE HEADER

void
PgmFile::writeHeader()
{
  if (_format == QGE_PBM_RAW)
    {
      _fileStream << _s_pgm_magic1
                  << _s_rpgm_magic2
                  << std::endl;
    }
  else
    {
      _fileStream << _s_pgm_magic1
                  << _s_pgm_magic2
                  << std::endl;
    }

  _fileStream << _colCnt
              << ' '
              << _rowCnt
              << std::endl
              << _maxPix
              << std::endl;
  
  newRow();
}


// WRITE A ROW INTO THE FILE

void
PgmFile::writeRow()
{
  isOpenW();

  if (_format == QGE_PBM_RAW)
    {
      int col        = 0;
      unsigned char* pRow = _pRow;

      for ( ; col < _colCnt ; ++col, ++pRow)
        {
          _fileStream.put(*pRow);
        }
    }
  else
    {
      int charCnt    = 0;
      int col        = 0;
      unsigned char* pRow = _pRow;

      for ( ; col < _colCnt ; ++col, ++pRow)
        {
          if (charCnt >= 65)
            {
              _fileStream << std::endl;
              charCnt = 0;
            }
          else if (charCnt > 0)
            {
              _fileStream << ' ';
              ++charCnt;
            }

          putUchar(*pRow);
          charCnt += 3;
        }

      if (charCnt > 0)
        {
          _fileStream << std::endl;
        }
    }
}


// WRITE FILE FOOTER

void
PgmFile::writeFooter()
{
  // VOID
}


// PUT AN unsigned char INTO THE FILE

void
PgmFile::putUchar(unsigned char anUchar)
{
  if (anUchar >= 10)
    {
      putUchar(anUchar / 10);
    }

  _fileStream << (char) (anUchar % 10 + '0');
}


// -------------------------------------------------------------------


} // namespace qgar