Rotate.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 ROTATE_H
#define ROTATE_H

#include "Rotope.h"

#include "MultiDimensionalVector.h"


template <unsigned D>
    class rotate_base: public VertexData<D> {

    public:
        rotate_base(const VertexData<D> &v): VertexData<D>(v) { }

        void rotate(unsigned d);

    private:
        void checkRotationArguments(unsigned d);

        VecMath::Vector<D> rotate_vertex(const VecMath::Vector<D> &, double,
                                         unsigned, unsigned);
        void rotate_line(unsigned);
        void rotate_triangle(unsigned, const VecMath::MultiDimensionalVector<unsigned, 1> &);
        void rotate_quad(unsigned, const VecMath::MultiDimensionalVector<unsigned, 1> &);
        void rotate_polygon(unsigned, const VecMath::MultiDimensionalVector<unsigned, 1> &);
    };


template <unsigned D, unsigned Dmin, unsigned Dmax>
    class Rotate: public Rotate<D, Dmin, Dmax-1> {
    public:

        Rotate(const VertexData<D> &v): Rotate<D, Dmin, Dmax-1>(v) {
            rotate_base<D>::rotate(Dmax);
        }

    };


template <unsigned D, unsigned Dmin>
    class Rotate<D, Dmin, Dmin>: public rotate_base<D> {
    public:

        Rotate(const VertexData<D> &v): rotate_base<D>(v) {
            rotate_base<D>::rotate(Dmin);
        }

    };

template <unsigned D> void rotate_base<D>::rotate(unsigned d) {
#   if DEBUG_ROTOPES
        SingletonLog::Instance().log(__PRETTY_FUNCTION__);
#   endif

    checkRotationArguments(d);

    std::vector<VecMath::Vector<D> > Xold = VertexData<D>::raw_vertices();
    for (unsigned i = 1; i <= RotopeInterface::_numSegments; ++i) {
        double rot = 1.*i*M_PI/RotopeInterface::_numSegments;
        for (typename std::vector<VecMath::Vector<D> >::iterator j = Xold.begin();
             j != Xold.end(); ++j) {
                 VertexData<D>::raw_vertices().push_back(rotate_vertex(*j, rot, d, d-1));
        }
    }

    VertexData<D>::dimension()++;   //  object is now one dimension higher

    VertexData<D>::realm() = VertexData<D>::realm().rotated(RotopeInterface::_numSegments, Xold.size());
}

template <unsigned D> void rotate_base<D>::checkRotationArguments(unsigned d) {
    if (d >= D) {
        throw std::invalid_argument(
           "rotate_base::rotate() called on a higher dimension"
           " than the vector space allows");
    }
    if (d == 0) {
        throw std::invalid_argument(
                "rotate_base::rotate() must be called on an object of dimension"
                " at least 1");
    }
}

template <unsigned D> VecMath::Vector<D> rotate_base<D>::rotate_vertex(
        const VecMath::Vector<D> &v, double rot,
        unsigned new_axis, unsigned old_axis) {
#   if DEBUG_ROTOPES >= 2
        SingletonLog::Instance().log(__PRETTY_FUNCTION__);
#   endif
    VecMath::Vector<D> v_new(v);
    v_new[new_axis] = v_new[old_axis]*sin(rot);
    v_new[old_axis] *= cos(rot);
    return v_new;
}

template <unsigned D> void rotate_base<D>::rotate_line(unsigned d) {
#   if DEBUG_ROTOPES
        SingletonLog::Instance().log(__PRETTY_FUNCTION__);
#   endif
    VecMath::MultiDimensionalVector<unsigned, 1> new_surface; // defines the disk
    new_surface.push_back(0);
    VertexData<D>::raw_vertices().pop_back();
    for (unsigned i = 1; i <= RotopeInterface::_numSegments; ++i) {
        double rot = 2.*i*M_PI/RotopeInterface::_numSegments;
        VecMath::Vector<D> current = VertexData<D>::raw_vertices()[0];
        VecMath::Vector<D> rotated_current = rotate_vertex(current, rot,
                                                            d, d-1);
        VertexData<D>::raw_vertices().push_back(rotated_current);
        new_surface.push_back(VertexData<D>::raw_vertices().size()-1);
    }
    VertexData<D>::surface().push_back(new_surface);
}

template <unsigned D> void rotate_base<D>::rotate_triangle(
        unsigned d, const VecMath::MultiDimensionalVector<unsigned, 1> &current_surface) {

#   if DEBUG_ROTOPES
        SingletonLog::Instance().log(__PRETTY_FUNCTION__);
#   endif
    VecMath::MultiDimensionalVector<unsigned, 1> new_surface; //  defines the first cap
    new_surface.push_back(current_surface[0]);

    unsigned old_current = 0;
    for (unsigned i = 1; i <= RotopeInterface::_numSegments; ++i) {

        double rot = 2.*i*M_PI/RotopeInterface::_numSegments;

        unsigned cur_index = current_surface[0],
                 next_index = current_surface[2];

            VecMath::Vector<D> current = VertexData<D>::raw_vertices()[cur_index];
            VecMath::Vector<D> next = VertexData<D>::raw_vertices()[next_index];
            VecMath::Vector<D> rotated_current = rotate_vertex(current, rot,
                                                               d, d-2);

            VertexData<D>::raw_vertices().push_back(rotated_current);

            new_surface.push_back(VertexData<D>::raw_vertices().size()-1);

            VertexData<D>::addSurface(old_current, next_index,
                                       VertexData<D>::raw_vertices().size()-1);

            old_current = VertexData<D>::raw_vertices().size()-1;
    }
    VertexData<D>::addSurface(new_surface);
}

template <unsigned D> void rotate_base<D>::rotate_quad(
        unsigned d, const VecMath::MultiDimensionalVector<unsigned, 1> &current_surface) {
#   if DEBUG_ROTOPES
        SingletonLog::Instance().log(__PRETTY_FUNCTION__);
#   endif
    unsigned old_current = current_surface[0];  //  saved index to current vertex
    unsigned old_next = current_surface[1];     //  saved index to next vertex

    VecMath::MultiDimensionalVector<unsigned, 1> bottom;       //  defines the first ("bottom") cap
    bottom.push_back(current_surface[0]);
    VecMath::MultiDimensionalVector<unsigned, 1> top;          //  defines the second ("top") cap
    top.push_back(current_surface[2]);

    for (unsigned i = 1; i <= RotopeInterface::_numSegments; ++i) {

        double rot = 2.*i*M_PI/RotopeInterface::_numSegments;

        unsigned cur_index = current_surface[0];
        unsigned next_index = current_surface[1];

        VecMath::Vector<D> current = VertexData<D>::raw_vertices()[cur_index];
        VecMath::Vector<D> next = VertexData<D>::raw_vertices()[next_index];

        VecMath::Vector<D> rotated_current = rotate_vertex(current, rot, d, d-1);
        VecMath::Vector<D> rotated_next = rotate_vertex(next, rot, d, d-1);

        VertexData<D>::raw_vertices().push_back(rotated_current);
        VertexData<D>::raw_vertices().push_back(rotated_next);

        VertexData<D>::addSurface(old_current, old_next,
                                   VertexData<D>::raw_vertices().size()-1,
                                   VertexData<D>::raw_vertices().size()-2);

        old_current = VertexData<D>::raw_vertices().size()-2;
        old_next = VertexData<D>::raw_vertices().size()-1;

        bottom.push_back(VertexData<D>::raw_vertices().size()-2);
        top.push_back(VertexData<D>::raw_vertices().size()-1);
    }
    VertexData<D>::addSurface(bottom);
    VertexData<D>::addSurface(top);
}

template <unsigned D> void rotate_base<D>::rotate_polygon(
        unsigned d, const VecMath::MultiDimensionalVector<unsigned, 1> &current_surface) {
#   if DEBUG_ROTOPES
        SingletonLog::Instance().log(__PRETTY_FUNCTION__);
#   endif

    unsigned offset = 0;

    VertexData<D>::raw_vertices().push_back(VertexData<D>::raw_vertices()[current_surface[0]]);

    for (unsigned i = 1; i <= (RotopeInterface::_numSegments+1)/2; ++i) {

        double rot = 1.*i*M_PI/((RotopeInterface::_numSegments+1)/2);

        for (unsigned j = 0; j < current_surface.size(); j++) {

            unsigned cur_index = j+offset;

            unsigned next_index = j+1+offset;

            VecMath::Vector<D> current = VertexData<D>::raw_vertices()[cur_index-offset];
            VecMath::Vector<D> next = VertexData<D>::raw_vertices()[next_index-offset];
            VecMath::Vector<D> rotated_current = rotate_vertex(current, rot,
                                                               d, d-1);
            VecMath::Vector<D> rotated_next = rotate_vertex(next, rot, d, d-1);

            VertexData<D>::raw_vertices().push_back(rotated_next);
#           if DEBUG_ROTOPES >= 2
            std::cerr << "j: " << j << "offset: " << offset
                      << " cur_index: " << cur_index << " next_index: " << next_index
                      << " size: " << VertexData<D>::raw_vertices().size() << "\n";
#           endif
            VertexData<D>::addSurface(cur_index, next_index,
                                       VertexData<D>::raw_vertices().size()-1,
                                       VertexData<D>::raw_vertices().size()-2);

        }
        offset += current_surface.size();
    }
}

#endif