Projector.h

/*
Hyperspace Explorer - visualizing higher-dimensional geometry
Copyright (C) 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 PROJECTOR_H
#define PROJECTOR_H

#include "Vector.impl.h"


template <unsigned D, unsigned D_> class Projector: protected Projector<D-1, D_> {
    public:

        std::vector<VecMath::Vector<D_> > operator()(
                const std::vector<VecMath::Vector<D> > &x,
                double scrW, double camW) {

            checkConsistency(scrW, camW);

            std::vector<VecMath::Vector<D-1> > x_proj = doProject(x, scrW, camW);
            return Projector<D-1, D_>::operator()(x_proj, scrW, camW);
        }


        std::vector<VecMath::Vector<D_> > operator()(
                const std::vector<VecMath::Vector<D> > &x,
                const std::vector<double> &scrW, const std::vector<double> &camW) {
            throw NotYetImplementedException("std::vector<VecMath::Vector<D_> > \n"
                    "    Projector<D, D_>::operator()(\n"
                    "        vector<Vector<D> > &, vector<double> &, "
                    "vector<double> &)");
        }

    private:

        void checkConsistency(double scrW, double camW) {
            if (D_ > D) {
                throw std::logic_error("Tried to project to a higher dimension");
            }
            if (D_ == D) {
                throw std::logic_error("Explicit specialization should be called");
            }
            if (camW <= scrW) {
                throw std::logic_error("Screen must be closer to object than eye");
            }
        }


        std::vector<VecMath::Vector<D-1> > doProject(
                const std::vector<VecMath::Vector<D> > &x,
                double scrW, double camW) {
            std::vector<VecMath::Vector<D-1> > x_proj(x.size());

            for (unsigned i = 0; i < x.size(); i++) {
                double ProjectionFactor = (scrW-camW)/(x[i][D-1]-camW);

                for (unsigned j = 0; j < D-1; j++)
                    x_proj.at(i)[j] = ProjectionFactor*x[i][j];
            }
            return x_proj;
        }

};


template <unsigned D> class Projector<D, D> {
    public:
        std::vector<VecMath::Vector<D> > operator()(
            const std::vector<VecMath::Vector<D> > &x, double, double) {
            return x;
        }
};

#endif