PbmFile.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   PbmFile.C
 * @brief  Implementation of class qgar::PbmFile.
 *
 *         See file PbmFile.H for the interface.
 *
 * @author <a href="mailto:qgar-develop@loria.fr?subject=Qgar fwd Karl Tombre">Karl Tombre</a>
 * @date   Jul 3, 2001  17:50
 * @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/PbmFile.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   M E M B E R S 
// -------------------------------------------------------------------


const unsigned char  PbmFile::_s_pbm_magic1 = 'P';

const unsigned char  PbmFile::_s_pbm_magic2 = '1';

const unsigned short PbmFile::_s_pbm_format =
   (((unsigned short) PbmFile::_s_pbm_magic1) * 256)
 + (unsigned short) PbmFile::_s_pbm_magic2;

const unsigned char  PbmFile::_s_rpbm_magic2 = '4';

const unsigned short PbmFile::_s_rpbm_format =
  (((unsigned short) PbmFile::_s_pbm_magic1) * 256)
+ (unsigned short) PbmFile::_s_rpbm_magic2;


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


// INITIALIZE FROM FILE NAME AND FORMAT.

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

  : AbstractPbmPlusFile(aFileName, 0, 0, aFormat)

{
  // VOID
}


// INITIALIZE FROM FULL DATA

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

  : AbstractPbmPlusFile(aFileName, aRowCnt, aColCnt, aFormat)

{
  // VOID
}


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


// READ FILE HEADER

void
PbmFile::readHeader()

  throw(QgarErrorIO)

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

  unsigned short magicNb = (ch1 * 256) + ch2;

  if (magicNb == _s_pbm_format)
    {
      _format = QGE_PBM_PLAIN;
    }
  else if (magicNb == _s_rpbm_format)
    {
      _format = QGE_PBM_RAW;
    }
  else
    {
      std::ostringstream os;
      os << "Bad magic number in file "
         << _fileName;
      throw QgarErrorIO(__FILE__, __LINE__,
                        "void qgar::PbmFile::readHeader()",
                        os.str());
    }

  _colCnt = getInt();
  _rowCnt = getInt();
  newRow();
}


// READ A ROW FROM THE FILE

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

  int col;
  int bitshift;
  unsigned char  item = 0;
  unsigned char* pRow;

  switch (_format)
    {
    case QGE_PBM_PLAIN:
      for (col = 0, pRow = _pRow; col < _colCnt; ++col, ++pRow)
        {
          *pRow = getBit();
        }
      break;

    case QGE_PBM_RAW:
      bitshift = -1;
      for (col = 0, pRow = _pRow; col < _colCnt; ++col, ++pRow)
        {
          if (bitshift == -1)
            {
              item = getRawByte();
              bitshift = 7;
            }
          *pRow = (item >> bitshift) & 1;
          --bitshift;
        }
    }
}


// GET A BIT FROM THE FILE

unsigned char
PbmFile::getBit()

  throw(QgarErrorIO)

{
  char c;

  do
    {
      c = getChar();
    }
  while ((c == ' ') || (c == '\t') || (c == '\n') || (c == '\r'));

  if ((c != '0') && (c != '1'))
    {
      std::ostringstream os;
      os << "Junk in file "
         << _fileName;
      throw QgarErrorIO(__FILE__, __LINE__,
                        "unsigned char qgar::PbmFile::getBit()",
                        os.str());
    }

  return((c == '1') ? 1 : 0);
}


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


// WRITE FILE HEADER

void
PbmFile::writeHeader()
{
  if (_format == QGE_PBM_RAW)
    {
      _fileStream << _s_pbm_magic1
                  << _s_rpbm_magic2
                  << std::endl;
    }
  else
    {
      _fileStream << _s_pbm_magic1
                  << _s_pbm_magic2
                  << std::endl;
    }

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


// WRITE A ROW INTO THE FILE

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

  if (_format == QGE_PBM_RAW)
    {
      int       col;
      int       bitshift = 7;
      unsigned char  item     = 0;
      unsigned char* pRow;

      for (col = 0, pRow = _pRow; col < _colCnt; ++col, ++pRow)
        {
          if (*pRow != 0)
            {
              item += 1 << bitshift;
            }
          --bitshift;
          if (bitshift == -1 )
            {
              _fileStream.put(item);
              bitshift = 7;
              item = 0;
            }
        }

      if (bitshift != 7 )
        {
          _fileStream.put(item);
        }
    }
  else
    {
      int       col;
      int       charCnt = 0;
      unsigned char* pRow;

      for (col = 0, pRow = _pRow; col < _colCnt; ++col, ++pRow)
        {
          if (charCnt >= 70)
            {
            _fileStream << std::endl;
            charCnt = 0;
            }
        _fileStream << ((*pRow !=0) ? '1' : '0');
        ++charCnt;
        }

      _fileStream << std::endl;
    }
}


// WRITE FILE FOOTER

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


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


} // namespace qgar