cubfiles.h

Go to the documentation of this file.

 
 
 
// This file copyright (C) 1997-2016 by Pawel Pilarczyk.
//
// This file is part of the "chomp" program. It 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 March 2006. Last revision: July 6, 2007.
 
 
#ifndef _CAPD_HOMENGIN_CUBFILES_H_ 
#define _CAPD_HOMENGIN_CUBFILES_H_ 
 
#include "chomp/system/config.h"
#include "chomp/system/textfile.h"
#include "chomp/system/timeused.h"
#include "chomp/system/arg.h"
#include "chomp/homology/homtools.h"
 
#include <cstdlib>
#include <ctime>
#include <new>
#include <exception>
#include <iostream>
#include <fstream>
#include <iomanip>
#include <vector>
#include <sstream>
#include <algorithm>
 
namespace chomp {
namespace homengin {
 
// --------------------------------------------------
// -------------- ABSTRACT CUBICAL SET --------------
// --------------------------------------------------
 
class cubfile
{
public:
        cubfile (const char *_filename);
 
        virtual ~cubfile ();
 
/*      /// Copy constructor.
        cubfile (const cubfile &c);
 
        cubfile &operator = (const cubfile &c);
*/
        const char *filename () const
        {
                return _filename. c_str ();
        }
        
        virtual int dim () const
        {
                if (_dim > 0)
                        return _dim;
                throw "Undefined dimension of a set of cubes.";
        }
        
        virtual int count () const
        {
                if (_count >= 0)
                        return _count;
                throw "Undefined number of cubes in a set.";
        }
 
        virtual bool bitmaptype () const
        {
                throw "Undefined bitmapness of a set of cubes.";
        }
 
        virtual bool elementary () const
        {
                throw "Undefined type of a set of cubes.";
        }
        
        virtual bool spacewrapping () const
        {
                return (_wrapping. size () != 0);
        }
 
        virtual int *spacewrapping (int *table) const
        {
                if (_wrapping. size ())
                {
                        std::copy (_wrapping. begin (), _wrapping. end (),
                                table);
                        return table;
                }
                throw "Unknown space wrapping of a set of cubes.";
        }
 
        virtual void setwrapping (const int *table, int count = 0)
        {
                _wrapping. clear ();
                int d = count ? count : dim ();
                _wrapping. assign (table, table + d);
                return;
        }
 
        virtual int boundingbox (int *mincoord, int *maxcoord) const
        {
                if (_min. size () && _max. size ())
                {
                        if (mincoord)
                                std::copy (_min. begin (), _min. end (),
                                        mincoord);
                        if (maxcoord)
                                std::copy (_max. begin (), _max. end (),
                                        maxcoord);
                        return 0;
                }
                throw "Undefined bounding box of a set of cubes.";
        }
 
        int volume (int chunk = 0, bool power2 = false) const;
 
        static const char *name ()
        {
                return "unknown set of cubes";
        }
 
        static std::ostream &describe (std::ostream &out)
        {
                out << "This is an unknown set of cubes.";
                return out;
        }
        
        static bool compatible (const char *filename)
        {
                return false;
        }
 
        virtual int readcubes (chomp::homology::CubicalComplex &s) const
        {
                throw "Unable to read a set of cells.";
        }
 
        virtual int readcubes (chomp::homology::SetOfCubes &s) const
        {
                throw "Unable to read a set of cubes.";
        }
 
        virtual int readcubes (int *&sizes, char *&bytes, int padding = 0,
                bool power2 = false) const
        {
                throw "Unable to read a bitmap set of cubes.";
        }
 
protected:
        std::string _filename;
 
        mutable int _dim;
 
        mutable int _count;
 
        mutable std::vector<int> _min;
 
        mutable std::vector<int> _max;
 
        mutable std::vector<int> _wrapping;
 
}; /* class cubfile */
 
// --------------------------------------------------
 
inline cubfile::cubfile (const char *filename): _filename (filename),
        _dim (0), _count (-1), _min (), _max (), _wrapping ()
{
        return;
} /* cubfile::cubfile */
 
inline cubfile::~cubfile ()
{
        return;
} /* cubfile::~cubfile */
 
 
// --------------------------------------------------
// ------------- TYPES OF CUBICAL SETS --------------
// --------------------------------------------------
 
class cubtype
{
public:
        typedef std::vector<const cubtype *> cubtypelist;
 
        static cubtypelist cubtypes;
 
protected:
        cubtype ()
        {
                cubtypes. push_back (this);
                return;
        }
 
        virtual ~cubtype ()
        {
                cubtypelist::iterator it = find (cubtypes. begin (),
                        cubtypes. end (), this);
                if (it != cubtypes. end ())
                        cubtypes. erase (it);
                return;
        }
 
public:
        virtual const char *name () const = 0;
 
        virtual std::ostream &describe (std::ostream &out) const = 0;
        
        virtual bool compatible (const char *filename) const = 0;
 
        virtual cubfile *newcubfile (const char *filename) const = 0;
 
        static std::ostream &showlist (std::ostream &out,
                const cubtype::cubtypelist &types = cubtype::cubtypes);
 
        static cubfile *newfile (const char *filename,
                const cubtype::cubtypelist &types = cubtype::cubtypes);
 
}; /* class cubtypes */
 
template <class cubfileT>
class cubfile_traits: public cubtype
{
public:
        cubfile_traits ()
        {
                return;
        }
 
        ~cubfile_traits ()
        {
                return;
        }
 
        const char *name () const
        {
                return cubfileT::name ();
        }
 
        std::ostream &describe (std::ostream &out) const
        {
                return cubfileT::describe (out);
        }
 
        bool compatible (const char *filename) const
        {
                return cubfileT::compatible (filename);
        }
 
        cubfile *newcubfile (const char *filename) const
        {
                return new cubfileT (filename);
        }
 
}; /* class cubfile_traits */
 
 
// --------------------------------------------------
// --------------- TEXT LIST OF CUBES ---------------
// --------------------------------------------------
 
class cublistfile: public cubfile
{
public:
        cublistfile (const char *filename);
 
        int dim () const;
        
        int count () const
        {
                if (_count < 0)
                        analyze ();
                return _count;
        }
 
        bool bitmaptype () const
        {
                return false;
        }
 
        bool elementary () const
        {
                return false;
        }
        
        int boundingbox (int *mincoord, int *maxcoord) const
        {
                if (!_min. size ())
                        analyze ();
                return cubfile::boundingbox (mincoord, maxcoord);
        }
 
        static const char *name ()
        {
                return "text list of cubes";
        }
 
        static std::ostream &describe (std::ostream &out);
 
        static bool compatible (const char *filename);
 
        int readcubes (chomp::homology::CubicalComplex &s) const;
 
        int readcubes (chomp::homology::SetOfCubes &s) const;
 
        int readcubes (int *&sizes, char *&bytes, int padding = 0,
                bool power2 = false) const;
 
private:
        void analyze () const;
 
        static cubfile_traits<cublistfile> t;
 
}; /* class cublistfile */
 
// --------------------------------------------------
 
inline cublistfile::cublistfile (const char *filename): cubfile (filename)
{
        return;
} /* cublistfile::cublistfile */
 
 
// --------------------------------------------------
// --------------- TEXT LIST OF CELLS ---------------
// --------------------------------------------------
 
class cellistfile: public cubfile
{
public:
        cellistfile (const char *filename);
 
        int dim () const;
 
        int count () const
        {
                if (_count < 0)
                        analyze ();
                return _count;
        }
 
        bool bitmaptype () const
        {
                return false;
        }
 
        bool elementary () const
        {
                return true;
        }
 
        int boundingbox (int *mincoord, int *maxcoord) const
        {
                if (!_min. size ())
                        analyze ();
                return cubfile::boundingbox (mincoord, maxcoord);
        }
 
        static const char *name ()
        {
                return "text list of cubical cells";
        }
 
        static std::ostream &describe (std::ostream &out);
 
        static bool compatible (const char *filename);
 
        int readcubes (chomp::homology::CubicalComplex &s) const;
 
        int readcubes (chomp::homology::SetOfCubes &s) const
        {
                throw "Trying to read cubical cells as a set of full cubes.";
        }
 
        int readcubes (int *&sizes, char *&bytes, int padding = 0,
                bool power2 = false) const
        {
                throw "Trying to read cubical cells as a bitmap.";
        }
 
private:
        void analyze () const;
 
        static cubfile_traits<cellistfile> t;
 
}; /* class cellistfile */
 
// --------------------------------------------------
 
inline cellistfile::cellistfile (const char *filename): cubfile (filename)
{
        return;
} /* cellistfile::cellistfile */
 
 
// --------------------------------------------------
// -------------- BILL KALIES' BITCODE --------------
// --------------------------------------------------
 
class bitcodefile: public cubfile
{
public:
        bitcodefile (const char *filename);
 
        int dim () const
        {
                if (_dim <= 0)
                        analyze ();
                return _dim;
        }
 
        int count () const
        {
                if (_count < 0)
                        analyze ();
                return _count;
        }
 
        bool bitmaptype () const
        {
                return false;
        }
 
        bool elementary () const
        {
                return false;
        }
 
        static const char *name ()
        {
                return "text bitcodes";
        }
 
        static std::ostream &describe (std::ostream &out);
 
        static bool compatible (const char *filename);
 
        int readcubes (chomp::homology::CubicalComplex &s) const;
 
        int readcubes (chomp::homology::SetOfCubes &s) const;
 
        int readcubes (int *&sizes, char *&bytes, int padding = 0,
                bool power2 = false) const;
 
private:
        void analyze () const;
 
        static cubfile_traits<bitcodefile> t;
 
}; /* class bitcodefile */
 
// --------------------------------------------------
 
inline bitcodefile::bitcodefile (const char *filename): cubfile (filename)
{
        return;
} /* bitcodefile::bitcodefile */
 
 
// --------------------------------------------------
// ----------------- WINDOWS BITMAP -----------------
// --------------------------------------------------
 
class winbmpfile: public cubfile
{
public:
        winbmpfile (const char *filename);
 
        int count () const;
 
        bool bitmaptype () const
        {
                return true;
        }
 
        bool elementary () const
        {
                return false;
        }
 
        int boundingbox (int *mincoord, int *maxcoord) const;
        
        static const char *name ()
        {
                return "windows bitmap";
        }
 
        static std::ostream &describe (std::ostream &out);
 
        static bool compatible (const char *filename);
 
        int readcubes (chomp::homology::CubicalComplex &s) const
        {
                throw "Trying to read a set of cells from a Win BMP file.";
        }
 
        int readcubes (chomp::homology::SetOfCubes &s) const;
 
        int readcubes (int *&sizes, char *&bytes, int padding = 0,
                bool power2 = false) const;
 
private:
        static cubfile_traits<winbmpfile> t;
 
}; /* class winbmpfile */
 
// --------------------------------------------------
 
inline winbmpfile::winbmpfile (const char *filename): cubfile (filename)
{
        _dim = 2;
        return;
} /* winbmpfile::winbmpfile */
 
 
// --------------------------------------------------
// ----------------- MROZEK'S BITMAP -----------------
// --------------------------------------------------
 
class bmdheader
{
public:
        bmdheader (const char *filename);
 
        bool little;
        
        int offset;
        
        int dim;
 
        int length;
 
        int zerowidth;
        
        std::vector<int> width;
 
        int readbytes (std::istream &f, int n) const;
 
}; /* class bmdheader */
 
// --------------------------------------------------
 
std::ostream &operator << (std::ostream &out, const bmdheader &header);
 
// --------------------------------------------------
 
 
class bmdfile: public cubfile
{
public:
        bmdfile (const char *filename);
 
        int count () const;
 
        bool bitmaptype () const
        {
                return true;
        }
 
        bool elementary () const
        {
                return false;
        }
 
        static const char *name ()
        {
                return "multi-dimensional bitmap";
        }
 
        static std::ostream &describe (std::ostream &out);
 
        static bool compatible (const char *filename);
 
        int readcubes (chomp::homology::CubicalComplex &s) const
        {
                throw "Trying to read a set of cells from a BMD file.";
        }
 
        int readcubes (chomp::homology::SetOfCubes &s) const;
 
        int readcubes (int *&sizes, char *&bytes, int padding = 0,
                bool power2 = false) const;
 
private:
        bmdheader header;
 
        static cubfile_traits<bmdfile> t;
 
}; /* class bmdfile */
 
// --------------------------------------------------
 
inline bmdfile::bmdfile (const char *filename): cubfile (filename),
        header (filename)
{
        _dim = header. dim;
        _min. assign (_dim, 0);
        _max. assign (header. width. begin (), header. width. end ());
        return;
} /* bmdfile::bmdfile */
 
 
// --------------------------------------------------
// ----------------- BITMAP BUFFER ------------------
// --------------------------------------------------
 
class cubitmap: public cubfile
{
public:
        cubitmap (const char *buffer, const int *sizes, int dim);
 
        int count () const;
 
        bool bitmaptype () const
        {
                return true;
        }
 
        bool elementary () const
        {
                return false;
        }
 
        static const char *name ()
        {
                return "bitmap buffer (memory)";
        }
 
        static std::ostream &describe (std::ostream &out);
 
        static bool compatible (const char */*filename*/)
        {
                return false;
        }
 
        int readcubes (chomp::homology::CubicalComplex &s) const
        {
                throw "Trying to read a set of cells from a bitmap buffer.";
        }
 
        int readcubes (chomp::homology::SetOfCubes &s) const;
 
        int readcubes (int *&sizes, char *&bytes, int padding = 0,
                bool power2 = false) const;
 
private:
        const char *buf;
 
        int buflength;
 
}; /* class cubitmap */
 
// --------------------------------------------------
 
inline cubitmap::cubitmap (const char *buffer, const int *sizes, int dim):
        cubfile ("(memory)"), buf (buffer)
{
        _dim = dim;
        _min. assign (_dim, 0);
        _max. assign (sizes, sizes + _dim);
        if (sizes [0] & 0x1F)
                throw "The x-size of a bitmap must be a multiple of 32.";
        buflength = sizes [0] >> 3;
        for (int i = 1; i < _dim; ++ i)
                buflength *= sizes [i];
        if (buflength <= 0)
                throw "Non-positive buffer size - something went wrong.";
        return;
} /* cubitmap::cubitmap */
 
 
} // namespace homengin
} // namespace chomp
 
#endif // _CAPD_HOMENGIN_CUBFILES_H_