Branch data Line data Source code
1 : : #ifndef MESHKIT_COPY_MESH_HPP
2 : : #define MESHKIT_COPY_MESH_HPP
3 : :
4 : : #include <vector>
5 : : #include <set>
6 : :
7 : : #include "meshkit/Types.hpp"
8 : : #include "meshkit/Error.hpp"
9 : : #include "meshkit/MeshScheme.hpp"
10 : : #include "meshkit/ModelEnt.hpp"
11 : :
12 : : #include "CESets.hpp"
13 : : #include "meshkit/LocalTag.hpp"
14 : : #include "Transform.hpp"
15 : :
16 : : #include "meshkit/iMesh.hpp"
17 : :
18 : : namespace MeshKit {
19 : :
20 : : class MKCore;
21 : :
22 : :
23 : : /** \class CopyMesh CopyMesh.hpp "meshkit/CopyMesh.hpp"
24 : : * \brief A simple class for meshing copy moving meshes
25 : : *
26 : : * INPUT: ModelEnts representing meshes
27 : : * MESH TYPE(S): ALL TYPES
28 : : * OUTPUT: Copied mesh along with the existing mesh
29 : : * DEPENDENCIES: (none)
30 : : * CONSTRAINTS: (none)
31 : : *
32 : : * This class performs the trivial task of copy moving meshes. There can be
33 : : * multiple instances of this class, and therefore it is pointed to and managed by ....
34 : : *
35 : : * Each instance of this class stores all the ModelEnt's representing the mesh data,
36 : : * and after execution after meshing new entities are created and tag propagation happens.
37 : : */
38 : : class CopyMesh : public MeshScheme
39 : : {
40 : : public:
41 : : //! Bare constructor
42 : : CopyMesh(MKCore *mkcore, const MEntVector &me_vec);
43 : :
44 : : //! Destructor
45 : : virtual ~CopyMesh();
46 : :
47 : : /**\brief Get class name */
48 : : static const char* name();
49 : :
50 : : /**\brief Function returning whether this scheme can mesh entities of t
51 : : * the specified dimension.
52 : : *\param dim entity dimension
53 : : */
54 : : static bool can_mesh(iBase_EntityType dim);
55 : :
56 : : /** \brief Function returning whether this scheme can mesh the specified entity
57 : : *
58 : : * Used by MeshOpFactory to find scheme for an entity.
59 : : * \param me ModelEnt being queried
60 : : * \return If true, this scheme can mesh the specified ModelEnt
61 : : */
62 : : static bool can_mesh(ModelEnt *me);
63 : :
64 : : /**\brief Get list of mesh entity types that can be generated.
65 : : *\return array terminated with \c moab::MBMAXTYPE
66 : : */
67 : : static const moab::EntityType* output_types();
68 : :
69 : : /** \brief Return the mesh entity types operated on by this scheme
70 : : * \return array terminated with \c moab::MBMAXTYPE
71 : : */
72 : : virtual const moab::EntityType* mesh_types_arr() const;
73 : :
74 : : /** \brief Re-implemented here so we can check topological dimension of model_ent
75 : : * \param model_ent ModelEnt being added
76 : : */
77 : : virtual bool add_modelent(ModelEnt *model_ent);
78 : :
79 : : //! Setup is a no-op, but must be provided since it's pure virtual
80 : : virtual void setup_this();
81 : :
82 : : //! The only setup/execute function we need, since meshing vertices is trivial
83 : : virtual void execute_this();
84 : :
85 : : // CopyMesh function local //////////////////
86 : :
87 : : /* \brief Return the copyTag used to indicate set copies
88 : : */
89 : : iBase_TagHandle copy_tag();
90 : :
91 : : void set_transform(const Copy::Transform &transform);
92 : :
93 : : void update_sets();
94 : :
95 : : /* \brief Reset the copy and expand set lists
96 : : */
97 : : void reset_sets();
98 : :
99 : : /* \brief Return reference to copy sets
100 : : */
101 : : CESets ©_sets();
102 : :
103 : : /* \brief Return reference to expand sets
104 : : */
105 : : CESets &expand_sets();
106 : :
107 : : /* \brief Tag copied sets with indicated tag from original set
108 : : */
109 : : void tag_copied_sets(const char **tag_names, const char **tag_vals,
110 : : const int num_tags);
111 : :
112 : : /* \brief Tag copied sets with indicated tag from original set
113 : : */
114 : : void tag_copied_sets(iMesh::TagHandle *tags, const char **tag_vals,
115 : : const int num_tags);
116 : :
117 : : bool flag_process_ce_set;
118 : :
119 : : private:
120 : : void do_copy(iMesh::EntitySetHandle set_handle);
121 : :
122 : : //- get the copy/expand sets based on copy/expand tags
123 : : void get_copy_expand_sets(iMesh::EntitySetHandle *©_sets,
124 : : int &num_copy_sets,
125 : : iMesh::EntitySetHandle *&expand_sets,
126 : : int &num_expand_sets);
127 : :
128 : : //- get the sets tagged with the given vector of tags/values
129 : : void get_tagged_sets(iMesh::EntitySetHandle from_set,
130 : : iMesh::TagHandle *tag_handles,
131 : : const char **tag_vals,
132 : : int num_tags,
133 : : iMesh::EntitySetHandle *&tagged_sets,
134 : : int &num_tagged_sets);
135 : :
136 : : // - get structure
137 : : int getStructure(iMesh_Instance instance,
138 : : iBase_EntitySetHandle set,
139 : : std::vector<iBase_EntityHandle> &ents,
140 : : std::vector<iBase_EntityHandle> &unique_adj,
141 : : std::vector<int> &indices,
142 : : std::vector<int> &offsets);
143 : :
144 : : iMesh *mesh; // mesh instance
145 : : LocalTag copyTag; // tag storing copy-to tag
146 : : Copy::Transform *transform; // transform function for copy-move
147 : :
148 : : CESets copySets;
149 : : CESets expandSets;
150 : : };
151 : :
152 : : /**\brief Create higher-dimension entities on a set of vertices
153 : : *
154 : : * Given an array of vertices and a template to build from, recreate the
155 : : * higher-dimension entities on the array of vertices. This is useful when
156 : : * making copies of a selection.
157 : : *
158 : : * \param mesh the iMesh instance handle
159 : : * \param local_tag the local copy tag
160 : : * \param ents the entities for the template
161 : : * \param indices index buffer into |entities|
162 : : * \param offsets offset array indicating start and end of |indices| for each
163 : : * entity in |entities|
164 : : * \param verts the array of vertices to build upon
165 : : */
166 : : void connect_the_dots(iMesh *mesh, iBase_TagHandle local_tag,
167 : : const std::vector<iBase_EntityHandle> &ents,
168 : : const std::vector<int> &indices,
169 : : const std::vector<int> &offsets,
170 : : const std::vector<iBase_EntityHandle> &verts);
171 : :
172 : 869 : inline const char* CopyMesh::name()
173 : : {
174 : 869 : return "CopyMesh";
175 : : }
176 : :
177 : 160 : inline bool CopyMesh::can_mesh(iBase_EntityType)
178 : : {
179 : : // Given just a dimension, CopyMesh can't do anything since it doesn't know
180 : : // what to copy.
181 : 160 : return false;
182 : : }
183 : :
184 : 0 : inline bool CopyMesh::can_mesh(ModelEnt *)
185 : : {
186 : 0 : return true;
187 : : }
188 : :
189 : 0 : inline const moab::EntityType* CopyMesh::mesh_types_arr() const
190 : : {
191 : 0 : return output_types();
192 : : }
193 : :
194 : 4 : inline void CopyMesh::set_transform(const Copy::Transform &trans)
195 : : {
196 [ + - ]: 4 : delete transform;
197 : 4 : transform = trans.clone();
198 : 4 : }
199 : :
200 : 1 : inline iBase_TagHandle CopyMesh::copy_tag()
201 : : {
202 : 1 : return copyTag;
203 : : }
204 : :
205 : : inline void CopyMesh::reset_sets()
206 : : {
207 : : copySets.clear();
208 : : expandSets.clear();
209 : : }
210 : :
211 : 5 : inline CESets &CopyMesh::copy_sets()
212 : : {
213 : 5 : return copySets;
214 : : }
215 : :
216 : 9 : inline CESets &CopyMesh::expand_sets()
217 : : {
218 : 9 : return expandSets;
219 : : }
220 : : } // namespace MeshKit
221 : : #endif
222 : :
223 : :
|
