cubfiles.h

Go to the documentation of this file.

// This file copyright (C) 1997-2010 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 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 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_