bitmaps.h

Go to the documentation of this file.

 
 
 
// Copyright (C) 1997-2020 by Pawel Pilarczyk.
//
// This file is part of my research software package. This 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 3 of the License, or (at your option) any later version.
//
// This software 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,
// please, see <https://www.gnu.org/licenses/>.
 
// Started in June 1998. Last revision: July 15, 2023.
 
// 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 bmpReadOnly
#define bmpReadOnly 0
#endif
 
#ifndef bmpReadWrite
#define bmpReadWrite 1
#endif
        int open (const char *filename, int mode = bmpReadOnly,
                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_