bitmaps.h

Go to the documentation of this file.

// Copyright (C) 1997-2010 by Pawel Pilarczyk.
//
// This file is part of the Homology Library.  This library 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 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this software; see the file "license.txt".  If not, write to the
// Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
// MA 02111-1307, USA.

// Started in June 1998. Last revision: September 3, 2003 (Nov 13, 2003).

// WARNING: This version of the module has very limited capabilities,
// e.g. it can normally write only 1-bit B/W and 24-bit true color bitmaps,
// and operates improperly if the entire output bitmap is not stored
// in the memory or is not written row by row.


#ifndef _CHOMP_BITMAPS_BITMAPS_H_
#define _CHOMP_BITMAPS_BITMAPS_H_

#include "chomp/system/config.h"
#include "chomp/system/textfile.h"

#include <iostream>
#include <stdio.h>
#include <cstdlib>

namespace chomp {
namespace homology {


// classes defined within this header file:
class bmpfile;


// --------------------------------------------------
// -------------------- bmpfile ---------------------
// --------------------------------------------------

class bmpfile
{
public:
        bmpfile (int _rows = 20);

        ~bmpfile ();

#ifndef ReadOnly
#define ReadOnly 0
#endif

#ifndef ReadWrite
#define ReadWrite 1
#endif






        int open (const char *filename, int mode = ReadOnly,
                int quiet = 0);

        int create (const char *filename, int _width, int _height,
                int _bitsperpixel = 24, int _pallength = 0,
                int32 *_pallette = NULL, int quiet = 0);

        inline void invertedpicture (int _inverted = 1)
                {inverted = _inverted;};

        int writeheader (void);

        int32 getpixel (int x, int y, bool index = false);

        int32 putpixel (int x, int y, long color = 0,
                bool index = false);

        void drawpixel (int x, int y, int thickness = 1,
                long color = 0, bool index = false);

        void drawsegment (int x1, int y1, int x2, int y2,
                int thickness = 1, long color = 0,
                bool index = false);

        inline int picture_width (void) { return width; };

        inline int picture_height (void) { return height; };

        int32 x_resolution;

        int32 y_resolution;

        long rows_read;

        long rows_written;

        void flush (void);

        int getbitsperpixel (void);

        unsigned char *getrow (int row);
        
        unsigned getrowlength () const;

        inline int32 *getpalette (void) { return palette; };

        inline int getpallength (void) { return pallength; };

private:
        char *header;

        int pallength;

        int32 *palette;

        bool palette_allocated;

        int *rownumber;

        unsigned char **rowbuf;

        char *changed;

        unsigned char *defined;

        int current;

        int readrow (int row);

        int writerow (int row);

        int bmpstart;

        unsigned rowlength;

        int bitsperpixel;

        int width;

        int height;

        FILE *fbmp;

        int fileinuse;

        int firstundefinedrow;

        int firstundefinedbyte;

        int rows;

        unsigned char fillbyte;

        int inverted;

}; /* class bmpfile */


} // namespace homology
} // namespace chomp

#endif // _CHOMP_BITMAPS_BITMAPS_H_