ExtrudeMesh.hpp

Go to the documentation of this file.

#ifndef MESHKIT_EXTRUDE_MESH_HPP
#define MESHKIT_EXTRUDE_MESH_HPP

#include <vector>
#include <set>

#include "meshkit/Types.hpp"
#include "meshkit/Error.hpp"
#include "meshkit/MeshScheme.hpp"
#include "meshkit/ModelEnt.hpp"

#include "CESets.hpp"
#include "meshkit/LocalTag.hpp"
#include "Transform.hpp"

#include "meshkit/iMesh.hpp"


namespace MeshKit {

  class MKCore;


  class ExtrudeMesh : public MeshScheme
  {
  public:
    ExtrudeMesh(MKCore *mkcore, const MEntVector &me_vec);

    virtual ~ExtrudeMesh();

    static const char* name();

    static bool can_mesh(iBase_EntityType dim);

    static bool can_mesh(ModelEnt *me);

    static const moab::EntityType* output_types();

    virtual const moab::EntityType* mesh_types_arr() const;

    virtual bool add_modelent(ModelEnt *model_ent);

    virtual void setup_this();

    virtual void execute_this();

    // ExtrudeMesh function local //////////////////

    /* \brief Return the tag used to indicate extruded sets
     */
    iBase_TagHandle extrude_tag();

    /* \brief Return the tag used to indicate copied sets
     */
    iBase_TagHandle copy_tag();

    /* \brief Set the transform function for this operation
     */
    void set_transform(const Extrude::Transform &transform);

    /* \brief Turn copying of faces on (true) or off (false)
     */
    void copy_faces(bool copy);

    void update_sets();

    /* \brief Reset the copy and expand set lists
     */
    void reset_sets();

    /* \brief Return reference to extrude sets
     */
    CESets &extrude_sets();

    /* \brief Return reference to copy sets
     */
    CESets &copy_sets();

    /* \brief Return reference to expand sets
     */
    CESets &expand_sets();

    // - get structure
    int getStructure(iMesh_Instance instance,
                     iBase_EntitySetHandle set,
                     std::vector<iBase_EntityHandle> &ents,
                     std::vector<iBase_EntityHandle> &unique_adj,
                     std::vector<int> &indices,
                     std::vector<int> &offsets);

  private:
    void do_extrude(iMesh::EntitySetHandle set_handle);

    void get_normals(const std::vector<iBase_EntityHandle> &verts,
                     const std::vector<int> &indices,
                     const std::vector<int> &offsets, const Vector<3> &dv,
                     std::vector<int> &normals);

    void connect_up_dots(iBase_EntityHandle *src, int size,
                         iBase_TagHandle local_tag, int *norms, int *inds,
                         int *offs, iBase_EntityHandle *pre,
                         iBase_EntityHandle *post);
    void connect_up_dots(iBase_EntityHandle *src, int size,
                         iBase_TagHandle local_tag,
                         int *pre_norms,  int *pre_inds,  int *pre_offs,
                         iBase_EntityHandle *pre,
                         int *post_norms, int *post_inds, int *post_offs,
                         iBase_EntityHandle *post);

    iMesh *mesh;                   // mesh instance
    LocalTag extrudeTag;           // tag storing extrude-to tag
    LocalTag copyTag;              // tag storing copy-to tag
    Extrude::Transform *transform; // transform function for extrusion
    bool copyFaces;

    CESets extrudeSets;
    CESets copySets;
    CESets expandSets;
  };

  inline const char* ExtrudeMesh::name()
  {
    return "ExtrudeMesh";
  }

  inline bool ExtrudeMesh::can_mesh(iBase_EntityType)
  {
    // Given just a dimension, ExtrudeMesh can't do anything since it doesn't
    // know what to extrude.
    return false;
  }

  inline bool ExtrudeMesh::can_mesh(ModelEnt *me)
  {
    return me->dimension() < 3;
  }

  inline const moab::EntityType* ExtrudeMesh::mesh_types_arr() const
  {
    return output_types();
  }

  inline void ExtrudeMesh::set_transform(const Extrude::Transform &trans)
  {
    delete transform;
    transform = trans.clone();
  }

  inline void ExtrudeMesh::copy_faces(bool copy)
  {
    copyFaces = copy;
  }

  inline iBase_TagHandle ExtrudeMesh::copy_tag()
  {
    return copyTag;
  }

  inline iBase_TagHandle ExtrudeMesh::extrude_tag()
  {
    return extrudeTag;
  }

  inline void ExtrudeMesh::reset_sets()
  {
    extrudeSets.clear();
    copySets.clear();
    expandSets.clear();
  }

  inline CESets &ExtrudeMesh::copy_sets()
  {
    return copySets;
  }

  inline CESets &ExtrudeMesh::expand_sets()
  {
    return expandSets;
  }

  inline CESets &ExtrudeMesh::extrude_sets()
  {
    return extrudeSets;
  }

  inline void
  ExtrudeMesh::connect_up_dots(iBase_EntityHandle *src, int size,
                               iBase_TagHandle local_tag, int *norms, int *inds,
                               int *offs, iBase_EntityHandle *pre,
                               iBase_EntityHandle *post)
  {
    connect_up_dots(src, size, local_tag,
                    norms, inds, offs, pre,
                    norms, inds, offs, post);
  }

} // namespace MeshKit
#endif