VertexGrid.h

/*
    Hyperspace Explorer - vizualizing 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 VertexGrid_H
#define VertexGrid_H

#include "ParametricFunction.h"

#include "LoopHelper.h"
#include "MultiDimensionalVector.h"
#include "Vector.h"

#include <memory>


template <unsigned N, unsigned P, typename NUM = double>
  class VertexGrid {

    public:

      typedef VecMath::Vector<P, unsigned> grid_size_type;
      typedef VecMath::MultiDimensionalVector< VecMath::Vector<N, NUM>, P > value_storage_type;

      VertexGrid();
      VertexGrid(const VertexGrid::grid_size_type &grid_size);
      
      VertexGrid(const value_storage_type &vertices);
      VertexGrid(const VertexGrid<N, P, NUM> &other) {
          _vertices = other._vertices;
          _grid_size = other._grid_size;
      }
      
      VertexGrid<N, P, NUM> & operator=(const VertexGrid<N, P, NUM> & other) {
          if (this == &other) return *this;
          _vertices = other._vertices;
          _grid_size = other._grid_size;
          return *this;
      }

      virtual ~VertexGrid() { }

      void setGridSize(const VertexGrid::grid_size_type &grid_size);

      const value_storage_type &getValues() const { return _vertices; }

      value_storage_type &getValuesNonConst() { return _vertices; }

    protected:

      grid_size_type _grid_size;
      value_storage_type _vertices;

};

namespace VertexGridUtility {
    template <typename T, unsigned D>
    void resizeRecursively(
        VecMath::MultiDimensionalVector<T, D> &vec,
        const VecMath::Vector<D, unsigned> &size
    );

    template <typename T>
    void resizeRecursively(
        VecMath::MultiDimensionalVector<T, 1> &vec,
        const VecMath::Vector<1, unsigned> &size
    );
}
template <unsigned N, unsigned P, typename NUM>
  VertexGrid<N, P, NUM>::VertexGrid():
    _grid_size(), _vertices() { }

template <unsigned N, unsigned P, typename NUM>
  VertexGrid<N, P, NUM>::VertexGrid(
        const VertexGrid::grid_size_type &grid_size):
      _grid_size(), _vertices() {
    setGridSize(grid_size);
  }

template <unsigned N, unsigned P, typename NUM>
  VertexGrid<N, P, NUM>::VertexGrid(
        const VertexGrid::value_storage_type &values):
      _grid_size(), _vertices(values) {
    _grid_size = values.size();
  }

template <unsigned N, unsigned P, typename NUM>
  void VertexGrid<N, P, NUM>::setGridSize(
    const VertexGrid::grid_size_type &grid_size) {
  if (grid_size == _grid_size) return;
  _grid_size = grid_size;
  VertexGridUtility::resizeRecursively(_vertices, _grid_size);
}

namespace VertexGridUtility {
    template <unsigned D> 
    VecMath::Vector<D-1, unsigned>
    clipSizeVector(const VecMath::Vector<D, unsigned> &size) {
        VecMath::Vector<D-1, unsigned> size_rest;
        for (unsigned i = 1; i < D; ++i) size_rest[i] = size[i];
        return size_rest;
    }

    template <typename T, unsigned D>
    void resizeRecursively(
        VecMath::MultiDimensionalVector<T, D> &vec,
        const VecMath::Vector<D, unsigned> &size
    ) {
        vec.resize(size[0]);
        auto size_rest = clipSizeVector(size);

        for (auto it = vec.begin(); it != vec.end(); ++it) {
            resizeRecursively(*it, size_rest);
        }
    }

    template <typename T>
    void resizeRecursively(
        VecMath::MultiDimensionalVector<T, 1> &vec,
        const VecMath::Vector<1, unsigned> &size
    ) {
        vec.resize(size[0]);
    }
}
#endif // VertexGrid_H