Realm.h

/*
Hyperspace Explorer - visualizing higher-dimensional geometry
Copyright (C) 2009-2010  Lene Preuss <lene.preuss@gmail.com>

This program 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 program 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 program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

*/


#ifndef REALM_H
#define REALM_H

//#include "uintvec.h"
#include "Vector.h"

#include <string>
#include <list>
#include <vector>

class Rotope;


class Realm {

public:

    typedef std::vector<VecMath::Vector<4> > vertex_container_type;
    typedef std::vector<Realm> realm_container_type;

    Realm(): _dimension(0), _subrealm(), _index(0) { }


    Realm(unsigned i): _dimension(0), _subrealm(), _index(i) { }


    Realm(const realm_container_type &sr): _subrealm(sr), _index() {
        if(sr.empty()) _dimension = 0;
        else _dimension = sr[0].dimension()+1;
    }

    ~Realm() { }

    unsigned size() const { return _subrealm.size(); }
    void clear();
    void push_back(const Realm &r);
    realm_container_type::iterator begin() { return _subrealm.begin(); }
    realm_container_type::const_iterator cbegin() const { return _subrealm.begin(); }

    realm_container_type::iterator end() { return _subrealm.end(); }
    realm_container_type::const_iterator cend() const { return _subrealm.end(); }

    realm_container_type::reverse_iterator rbegin() { return _subrealm.rbegin(); }

    realm_container_type::reverse_iterator rend() { return _subrealm.rend(); }

    unsigned dimension() const { return _dimension; }
    void setDimension(unsigned d) { _dimension = d; }

    unsigned toIndex() const;

    Realm extruded(unsigned delta) const;

    Realm tapered(unsigned taper_index) const;

    Realm rotated(unsigned num_segments, unsigned size) const;

    void merge(const Realm &r);

    const realm_container_type &getSubrealms() const { return _subrealm; }

    void setSubrealms(realm_container_type sr) { _subrealm = sr; }

    bool operator==(const Realm &other) const;

    bool contains(const Realm &other) const;

    std::string toString() const;


    void addOffset(unsigned delta);

private:

    Realm extrudedPoint(unsigned delta) const;
    Realm extrudedLine(unsigned delta) const;
    Realm extrudedPolygon(unsigned delta) const;
    Realm extrudedRealm(unsigned delta) const;

    Realm taperedLine(unsigned taper_index) const;
    Realm taperedPolygon(unsigned taper_index) const;
    Realm taperedRealm(unsigned taper_index) const;

    Realm rotatedLine(unsigned num_segments, unsigned size) const;

    std::list<realm_container_type> generateListOfPointsToAdd(
        std::list<Realm> original_list,
        unsigned num_segments, unsigned size) const;
    void insertNewPoints(std::list<Realm> &original_list,
                         const std::list<Realm::realm_container_type> &new_points) const;

    Realm rotatedPolygon(unsigned num_segments, unsigned size) const;
    Realm rotatedPolygonCap(const realm_container_type &temp_subrealms) const;
    Realm rotatedRealm(unsigned num_segments, unsigned size) const;

    Realm rotateStep(unsigned index, unsigned base, unsigned delta) const;
    Realm generateStripBetweenGreatCircles(unsigned base, unsigned delta) const;

    realm_container_type rectsBetweenGreatCircles(unsigned base, unsigned delta) const;
    Realm reorderRectsBetweenGreatCircles(Realm::realm_container_type subrealms, unsigned int index) const;
    Realm generateRectSegment(unsigned i, unsigned base, unsigned delta) const;

    void addRotationStrip(Realm &all_strips, unsigned rotation_step, unsigned num_segments) const;
    void addStayingWithinSameStrip(unsigned total_vertices, unsigned rotation_step);
    void checkArgumentsForAddStayingWithinSameStrip() const;
    std::pair<unsigned, unsigned> wrapToStayWithinStrip(unsigned base, unsigned extruded,
                                                        unsigned num_segments, unsigned rotation_step) const;

    static Realm generateEmpty3DRealm();

    unsigned _dimension;
    realm_container_type _subrealm;
    unsigned _index;

    const static bool DEBUG_ROTATE = false;
    static const unsigned OFFSET_BETWEEN_NEIGHBORING_INDICES = 2;

    class RealmPrinter {

        static const std::string PRINT_DIMENSION_SPACER;

    public:

        RealmPrinter(const Realm *realm): _realm(realm) { }

        void print(std::ostream &out) const;

    private:
        void printHeader(std::ostream &out) const;
        void printFooter(std::ostream &out) const;
        void printPoint(std::ostream &out) const;
        void printSubrealms(std::ostream &out) const;
        void indentNextLine(std::ostream &out) const;

        const Realm * _realm;

        static unsigned _max_dimension;

    };

};

#endif