TransformBase.hpp

Go to the documentation of this file.

#ifndef MESHKIT_TRANSFORMBASE_HPP
#define MESHKIT_TRANSFORMBASE_HPP

#include "meshkit/Error.hpp"
#include "meshkit/iMesh.hpp"
#include "meshkit/Matrix.hpp"
#include <vector>

namespace MeshKit {
  inline double * vec2ptr(std::vector< Vector<3> > &v) {
    return reinterpret_cast<double *>(&v[0]);
  }

  namespace Copy {
    class Transform
    {
    public:
      virtual void transform(iMesh *mesh,
                             const std::vector<iMesh::EntityHandle> &src,
                             std::vector<iMesh::EntityHandle> &dest) const = 0;

      virtual Transform * clone() const = 0;

        virtual ~Transform ()
        {
        }
    };

    template<typename T>
    class BasicTransform : public Transform
    {
    public:
      virtual void transform(iMesh *mesh,
                             const std::vector<iMesh::EntityHandle> &src,
                             std::vector<iMesh::EntityHandle> &dest) const
      {
        std::vector< Vector<3> > coords(src.size());
        IBERRCHK(mesh->getVtxArrCoords(&src[0], src.size(), iBase_INTERLEAVED,
                                       vec2ptr(coords)), *mesh);

        for (size_t i=0; i<coords.size(); i++)
          static_cast<const T*>(this)->transform_one(coords[i]);

        if (&src == &dest)
        {
          IBERRCHK(mesh->setVtxArrCoords(&src[0], src.size(), iBase_INTERLEAVED,
                                         vec2ptr(coords)), *mesh);
        }
        else {
          dest.resize(src.size());
          IBERRCHK(mesh->createVtxArr(src.size(), iBase_INTERLEAVED,
                                      vec2ptr(coords), &dest[0]), *mesh);
        }
      }

      virtual Transform * clone() const
      {
        return new T(*static_cast<const T*>(this));
      }
    protected:
      BasicTransform() {}
    };
  }

  namespace Extrude {
    class Transform
    {
    public:
      virtual void transform(int step, iMesh *mesh,
                             const std::vector<iMesh::EntityHandle> &src,
                             std::vector<iMesh::EntityHandle> &dest) const = 0;
      
      virtual int steps() const = 0;

      virtual Transform * clone() const = 0;

        virtual ~Transform ()
        {
        }
    };

    template<typename T>
    class BasicTransform : public Transform
    {
    public:
      virtual void transform(int step, iMesh *mesh,
                             const std::vector<iMesh::EntityHandle> &src,
                             std::vector<iMesh::EntityHandle> &dest) const
      {
        std::vector< Vector<3> > coords(src.size());
        IBERRCHK(mesh->getVtxArrCoords(&src[0], src.size(), iBase_INTERLEAVED,
                                      vec2ptr(coords)), *mesh);

        for (size_t i=0; i<coords.size(); i++)
          static_cast<const T*>(this)->transform_one(step, coords[i]);

        dest.resize(src.size());
        IBERRCHK(mesh->createVtxArr(src.size(), iBase_INTERLEAVED,
                                    vec2ptr(coords), &dest[0]), *mesh);
      }

      virtual int steps() const
      {
        return steps_;
      }

      virtual Transform * clone() const
      {
        return new T(*static_cast<const T*>(this));
      }
    protected:
      BasicTransform(int steps) : steps_(steps)
      {}

      int steps_;
    };
  }
}

#endif