From fc8cdda0b9e3a5ffff97210baa42a69056fb80ea Mon Sep 17 00:00:00 2001 From: Mike Kremer Date: Mon, 13 Feb 2012 16:02:15 +0000 Subject: [PATCH] Changed inheritance structure of core components and topology specializations as described in the documentation. git-svn-id: http://www.openvolumemesh.org/svnrepo/OpenVolumeMesh/trunk@98 66977474-1d4b-4f09-8fe9-267525286df2 --- src/OpenVolumeMesh/Attribs/NormalAttrib.hh | 22 ++-- src/OpenVolumeMesh/Attribs/NormalAttribT.cc | 38 +++--- src/OpenVolumeMesh/Core/GeometryKernel.hh | 9 +- src/OpenVolumeMesh/Mesh/HexahedralMesh.hh | 4 +- ...eratorsT.cc => HexahedralMeshIterators.cc} | 50 ++++--- .../Mesh/HexahedralMeshIterators.hh | 17 +-- ...elT.cc => HexahedralMeshTopologyKernel.cc} | 76 ++++++----- .../Mesh/HexahedralMeshTopologyKernel.hh | 123 +++++++++--------- src/OpenVolumeMesh/Mesh/PolyhedralMesh.hh | 2 +- src/Unittests/unittests_basics.hh | 2 +- 10 files changed, 163 insertions(+), 180 deletions(-) rename src/OpenVolumeMesh/Mesh/{HexahedralMeshIteratorsT.cc => HexahedralMeshIterators.cc} (86%) rename src/OpenVolumeMesh/Mesh/{HexahedralMeshTopologyKernelT.cc => HexahedralMeshTopologyKernel.cc} (78%) diff --git a/src/OpenVolumeMesh/Attribs/NormalAttrib.hh b/src/OpenVolumeMesh/Attribs/NormalAttrib.hh index c4ee5ed..c0e25a7 100644 --- a/src/OpenVolumeMesh/Attribs/NormalAttrib.hh +++ b/src/OpenVolumeMesh/Attribs/NormalAttrib.hh @@ -51,15 +51,11 @@ namespace OpenVolumeMesh { -// Forward declaration -template -class GeometryKernel; - -template +template class NormalAttrib { public: - NormalAttrib(GeometryKernel& _kernel); + NormalAttrib(GeomKernelT& _kernel); virtual ~NormalAttrib(); /** \brief A simple heuristic to estimate the vertex normals @@ -79,22 +75,22 @@ public: */ void update_face_normals(); - const VecT& operator[](const VertexHandle& _h) const { + const typename GeomKernelT::PointT& operator[](const VertexHandle& _h) const { assert((unsigned int)_h.idx < v_normals_.size()); return v_normals_[_h.idx()]; } - const VecT& operator[](const FaceHandle& _h) const { + const typename GeomKernelT::PointT& operator[](const FaceHandle& _h) const { assert((unsigned int)_h.idx < f_normals_.size()); return f_normals_[_h.idx()]; } - VecT& operator[](const VertexHandle& _h) { + typename GeomKernelT::PointT& operator[](const VertexHandle& _h) { assert((unsigned int)_h.idx < kernel_.n_vertices()); return v_normals_[_h.idx()]; } - VecT& operator[](const FaceHandle& _h) { + typename GeomKernelT::PointT& operator[](const FaceHandle& _h) { assert((unsigned int)_h.idx() < kernel_.n_faces()); return f_normals_[_h.idx()]; } @@ -105,10 +101,10 @@ private: void compute_face_normal(const FaceHandle& _fh); - GeometryKernel& kernel_; + GeomKernelT& kernel_; - VertexPropertyT v_normals_; - FacePropertyT f_normals_; + VertexPropertyT v_normals_; + FacePropertyT f_normals_; }; } // Namespace OpenVolumeMesh diff --git a/src/OpenVolumeMesh/Attribs/NormalAttribT.cc b/src/OpenVolumeMesh/Attribs/NormalAttribT.cc index b4b213c..dfcc02e 100644 --- a/src/OpenVolumeMesh/Attribs/NormalAttribT.cc +++ b/src/OpenVolumeMesh/Attribs/NormalAttribT.cc @@ -50,21 +50,21 @@ namespace OpenVolumeMesh { -template -NormalAttrib::NormalAttrib(GeometryKernel& _kernel) : +template +NormalAttrib::NormalAttrib(GeomKernelT& _kernel) : kernel_(_kernel), -v_normals_(_kernel.template request_vertex_property("vertex_normals")), -f_normals_(_kernel.template request_face_property("face_normals")) { +v_normals_(_kernel.template request_vertex_property("vertex_normals")), +f_normals_(_kernel.template request_face_property("face_normals")) { } -template -NormalAttrib::~NormalAttrib() { +template +NormalAttrib::~NormalAttrib() { } -template -void NormalAttrib::update_vertex_normals() { +template +void NormalAttrib::update_vertex_normals() { if(!kernel_.has_bottom_up_adjacencies()) { std::cerr << "Error: update_vertex_normals() needs bottom-up adjacencies!" << std::endl; @@ -79,8 +79,8 @@ void NormalAttrib::update_vertex_normals() { } } -template -void NormalAttrib::update_face_normals() { +template +void NormalAttrib::update_face_normals() { for(FaceIter f_it = kernel_.f_iter(); f_it.valid(); ++f_it) { // Assume the face is planar, so just take the @@ -89,8 +89,8 @@ void NormalAttrib::update_face_normals() { } } -template -void NormalAttrib::compute_vertex_normal(const VertexHandle& _vh) { +template +void NormalAttrib::compute_vertex_normal(const VertexHandle& _vh) { std::set faces; for(VertexOHalfEdgeIter voh_it = kernel_.voh_iter(_vh); @@ -103,7 +103,7 @@ void NormalAttrib::compute_vertex_normal(const VertexHandle& _vh) { } } } - VecT normal; + typename GeomKernelT::PointT normal; for(std::set::const_iterator f_it = faces.begin(); f_it != faces.end(); ++f_it) { normal += f_normals_[f_it->idx()]; @@ -114,8 +114,8 @@ void NormalAttrib::compute_vertex_normal(const VertexHandle& _vh) { v_normals_[_vh.idx()] = normal; } -template -void NormalAttrib::compute_face_normal(const FaceHandle& _fh) { +template +void NormalAttrib::compute_face_normal(const FaceHandle& _fh) { if(kernel_.face(_fh).halfedges().size() < 3) { std::cerr << "Warning: Degenerate face detected!" << std::endl; @@ -129,12 +129,12 @@ void NormalAttrib::compute_face_normal(const FaceHandle& _fh) { std::vector halfedges = kernel_.halfface(hfh).halfedges(); std::vector::const_iterator he_it = halfedges.begin(); - VecT p1 = kernel_.vertex(kernel_.halfedge(*he_it).from_vertex()); - VecT p2 = kernel_.vertex(kernel_.halfedge(*he_it).to_vertex()); + typename GeomKernelT::PointT p1 = kernel_.vertex(kernel_.halfedge(*he_it).from_vertex()); + typename GeomKernelT::PointT p2 = kernel_.vertex(kernel_.halfedge(*he_it).to_vertex()); ++he_it; - VecT p3 = kernel_.vertex(kernel_.halfedge(*he_it).to_vertex()); + typename GeomKernelT::PointT p3 = kernel_.vertex(kernel_.halfedge(*he_it).to_vertex()); - VecT n = (p3 - p2) % (p1 - p2); + typename GeomKernelT::PointT n = (p3 - p2) % (p1 - p2); n.normalize(); f_normals_[_fh.idx()] = n; diff --git a/src/OpenVolumeMesh/Core/GeometryKernel.hh b/src/OpenVolumeMesh/Core/GeometryKernel.hh index ff274a6..e507f6f 100644 --- a/src/OpenVolumeMesh/Core/GeometryKernel.hh +++ b/src/OpenVolumeMesh/Core/GeometryKernel.hh @@ -50,11 +50,12 @@ namespace OpenVolumeMesh { -template -class GeometryKernel : public TopologyKernel { +template +class GeometryKernel : public TopologyKernelT { public: typedef VecT PointT; + typedef TopologyKernelT KernelT; /// Constructor GeometryKernel() {} @@ -99,7 +100,7 @@ public: virtual VertexIter delete_vertex(const VertexHandle& _h) { assert(_h.idx() < (int)n_vertices()); - VertexIter nV = TopologyKernel::delete_vertex(_h); + VertexIter nV = TopologyKernelT::delete_vertex(_h); vertices_.erase(vertices_.begin() + _h.idx()); @@ -109,7 +110,7 @@ public: virtual void clear() { vertices_.clear(); - TopologyKernel::clear(); + TopologyKernelT::clear(); } private: diff --git a/src/OpenVolumeMesh/Mesh/HexahedralMesh.hh b/src/OpenVolumeMesh/Mesh/HexahedralMesh.hh index f1573f2..b4d05e9 100644 --- a/src/OpenVolumeMesh/Mesh/HexahedralMesh.hh +++ b/src/OpenVolumeMesh/Mesh/HexahedralMesh.hh @@ -50,9 +50,9 @@ namespace OpenVolumeMesh { /* * Predefines for most common mesh types */ -typedef HexahedralMeshTopologyKernel > GeometricHexahedralMeshV3d; +typedef GeometryKernel GeometricHexahedralMeshV3d; -typedef HexahedralMeshTopologyKernel TopologicHexahedralMesh; +typedef HexahedralMeshTopologyKernel TopologicHexahedralMesh; } // Namespace OpenVolumeMesh diff --git a/src/OpenVolumeMesh/Mesh/HexahedralMeshIteratorsT.cc b/src/OpenVolumeMesh/Mesh/HexahedralMeshIterators.cc similarity index 86% rename from src/OpenVolumeMesh/Mesh/HexahedralMeshIteratorsT.cc rename to src/OpenVolumeMesh/Mesh/HexahedralMeshIterators.cc index 20d9429..68395a4 100644 --- a/src/OpenVolumeMesh/Mesh/HexahedralMeshIteratorsT.cc +++ b/src/OpenVolumeMesh/Mesh/HexahedralMeshIterators.cc @@ -40,8 +40,6 @@ * * \*===========================================================================*/ -#define HEXAHEDRALMESHITERATORST_CC - #include #include "HexahedralMeshIterators.hh" @@ -54,9 +52,9 @@ namespace OpenVolumeMesh { // CellSheetCellIter //================================================================================================ -template -CellSheetCellIter::CellSheetCellIter(const CellHandle& _ref_h, - const unsigned char _orthDir, const HexahedralMeshTopologyKernel* _mesh) : + +CellSheetCellIter::CellSheetCellIter(const CellHandle& _ref_h, + const unsigned char _orthDir, const HexahedralMeshTopologyKernel* _mesh) : BaseIter(_mesh, _ref_h) { if(!_mesh->has_bottom_up_adjacencies()) { @@ -73,7 +71,7 @@ BaseIter(_mesh, _ref_h) { if(_mesh->orientation(*hf_it, _ref_h) != _orthDir && _mesh->orientation(*hf_it, _ref_h) != _mesh->opposite_orientation(_orthDir)) { CellHandle ch = _mesh->incident_cell(_mesh->opposite_halfface_handle(*hf_it)); - if(ch != KernelT::InvalidCellHandle) { + if(ch != TopologyKernel::InvalidCellHandle) { neighb_sheet_cell_hs_.insert(ch); } } @@ -86,8 +84,8 @@ BaseIter(_mesh, _ref_h) { } } -template -CellSheetCellIter& CellSheetCellIter::operator--() { + +CellSheetCellIter& CellSheetCellIter::operator--() { if(cur_it_ == neighb_sheet_cell_hs_.begin()) { BaseIter::valid(false); @@ -98,8 +96,8 @@ CellSheetCellIter& CellSheetCellIter::operator--() { return *this; } -template -CellSheetCellIter& CellSheetCellIter::operator++() { + +CellSheetCellIter& CellSheetCellIter::operator++() { ++cur_it_; if(cur_it_ != neighb_sheet_cell_hs_.end()) { @@ -114,9 +112,9 @@ CellSheetCellIter& CellSheetCellIter::operator++() { // HalfFaceSheetHalfFaceIter //================================================================================================ -template -HalfFaceSheetHalfFaceIter::HalfFaceSheetHalfFaceIter(const HalfFaceHandle& _ref_h, - const HexahedralMeshTopologyKernel* _mesh) : + +HalfFaceSheetHalfFaceIter::HalfFaceSheetHalfFaceIter(const HalfFaceHandle& _ref_h, + const HexahedralMeshTopologyKernel* _mesh) : BaseIter(_mesh, _ref_h) { if(!_mesh->has_bottom_up_adjacencies()) { @@ -148,7 +146,7 @@ BaseIter(_mesh, _ref_h) { std::set hes; hes.insert(hes_v.begin(), hes_v.end()); - for(CellSheetCellIter csc_it = _mesh->csc_iter(ch, orientation); + for(CellSheetCellIter csc_it = _mesh->csc_iter(ch, orientation); csc_it.valid(); ++csc_it) { std::vector hfs = _mesh->cell(*csc_it).halffaces(); @@ -177,8 +175,8 @@ BaseIter(_mesh, _ref_h) { } } -template -HalfFaceSheetHalfFaceIter& HalfFaceSheetHalfFaceIter::operator--() { + +HalfFaceSheetHalfFaceIter& HalfFaceSheetHalfFaceIter::operator--() { --cur_it_; --edge_it_; @@ -190,8 +188,8 @@ HalfFaceSheetHalfFaceIter& HalfFaceSheetHalfFaceIter::operator return *this; } -template -HalfFaceSheetHalfFaceIter& HalfFaceSheetHalfFaceIter::operator++() { + +HalfFaceSheetHalfFaceIter& HalfFaceSheetHalfFaceIter::operator++() { ++cur_it_; ++edge_it_; @@ -207,9 +205,9 @@ HalfFaceSheetHalfFaceIter& HalfFaceSheetHalfFaceIter::operator // OutsideNeighborHalfFaceIter //================================================================================================ -template -OutsideNeighborHalfFaceIter::OutsideNeighborHalfFaceIter(const HalfFaceHandle& _ref_h, - const HexahedralMeshTopologyKernel* _mesh) : + +OutsideNeighborHalfFaceIter::OutsideNeighborHalfFaceIter(const HalfFaceHandle& _ref_h, + const HexahedralMeshTopologyKernel* _mesh) : BaseIter(_mesh, _ref_h) { if(!_mesh->has_bottom_up_adjacencies()) { @@ -224,7 +222,7 @@ BaseIter(_mesh, _ref_h) { he_it != halfedges.end(); ++he_it) { // Get outside halffaces - typename KernelT::HalfEdgeHalfFaceIter hehf_it = _mesh->hehf_iter(_mesh->opposite_halfedge_handle(*he_it)); + OpenVolumeMesh::HalfEdgeHalfFaceIter hehf_it = _mesh->hehf_iter(_mesh->opposite_halfedge_handle(*he_it)); for(; hehf_it.valid(); ++hehf_it) { if(_mesh->is_boundary(*hehf_it)) { @@ -242,8 +240,8 @@ BaseIter(_mesh, _ref_h) { } } -template -OutsideNeighborHalfFaceIter& OutsideNeighborHalfFaceIter::operator--() { + +OutsideNeighborHalfFaceIter& OutsideNeighborHalfFaceIter::operator--() { --cur_it_; --edge_it_; @@ -255,8 +253,8 @@ OutsideNeighborHalfFaceIter& OutsideNeighborHalfFaceIter::oper return *this; } -template -OutsideNeighborHalfFaceIter& OutsideNeighborHalfFaceIter::operator++() { + +OutsideNeighborHalfFaceIter& OutsideNeighborHalfFaceIter::operator++() { ++cur_it_; ++edge_it_; diff --git a/src/OpenVolumeMesh/Mesh/HexahedralMeshIterators.hh b/src/OpenVolumeMesh/Mesh/HexahedralMeshIterators.hh index 12e3055..9cca0d5 100644 --- a/src/OpenVolumeMesh/Mesh/HexahedralMeshIterators.hh +++ b/src/OpenVolumeMesh/Mesh/HexahedralMeshIterators.hh @@ -47,10 +47,9 @@ namespace OpenVolumeMesh { -template class HexahedralMeshTopologyKernel; -template + class CellSheetCellIter : public BaseIterator { private: @@ -58,7 +57,7 @@ private: CellHandle> BaseIter; public: CellSheetCellIter(const CellHandle& _ref_h, const unsigned char _orthDir, - const HexahedralMeshTopologyKernel* _mesh); + const HexahedralMeshTopologyKernel* _mesh); CellSheetCellIter& operator=(const CellSheetCellIter& _c) { BaseIter::operator=(_c); @@ -113,7 +112,7 @@ private: std::set::const_iterator cur_it_; }; -template + class HalfFaceSheetHalfFaceIter : public BaseIterator { private: @@ -121,7 +120,7 @@ private: HalfFaceHandle> BaseIter; public: HalfFaceSheetHalfFaceIter(const HalfFaceHandle& _ref_h, - const HexahedralMeshTopologyKernel* _mesh); + const HexahedralMeshTopologyKernel* _mesh); HalfFaceSheetHalfFaceIter& operator=(const HalfFaceSheetHalfFaceIter& _c) { BaseIter::operator=(_c); adjacent_halffaces_ = _c.adjacent_halffaces_; @@ -179,7 +178,7 @@ private: std::vector::const_iterator edge_it_; }; -template + class OutsideNeighborHalfFaceIter : public BaseIterator { private: @@ -187,7 +186,7 @@ private: HalfFaceHandle> BaseIter; public: OutsideNeighborHalfFaceIter(const HalfFaceHandle& _ref_h, - const HexahedralMeshTopologyKernel* _mesh); + const HexahedralMeshTopologyKernel* _mesh); OutsideNeighborHalfFaceIter& operator=(const OutsideNeighborHalfFaceIter& _c) { BaseIter::operator=(_c); neighbor_halffaces_ = _c.neighbor_halffaces_; @@ -247,8 +246,4 @@ private: } // Namespace OpenVolumeMesh -#if defined(INCLUDE_TEMPLATES) && !defined(HEXAHEDRALMESHITERATORST_CC) -#include "HexahedralMeshIteratorsT.cc" -#endif - #endif /* HEXAHEDRALMESHITERATORS_HH */ diff --git a/src/OpenVolumeMesh/Mesh/HexahedralMeshTopologyKernelT.cc b/src/OpenVolumeMesh/Mesh/HexahedralMeshTopologyKernel.cc similarity index 78% rename from src/OpenVolumeMesh/Mesh/HexahedralMeshTopologyKernelT.cc rename to src/OpenVolumeMesh/Mesh/HexahedralMeshTopologyKernel.cc index 166e676..dd8c6c5 100644 --- a/src/OpenVolumeMesh/Mesh/HexahedralMeshTopologyKernelT.cc +++ b/src/OpenVolumeMesh/Mesh/HexahedralMeshTopologyKernel.cc @@ -40,66 +40,64 @@ * * \*===========================================================================*/ -#define HEXAHEDRALMESHTOPOLOGYKERNELT_CC - #include "HexahedralMeshTopologyKernel.hh" namespace OpenVolumeMesh { -template -HexahedralMeshTopologyKernel::HexahedralMeshTopologyKernel() { + +HexahedralMeshTopologyKernel::HexahedralMeshTopologyKernel() { } //======================================================================================== -template -HexahedralMeshTopologyKernel::~HexahedralMeshTopologyKernel() { + +HexahedralMeshTopologyKernel::~HexahedralMeshTopologyKernel() { } //======================================================================================== -template -FaceHandle HexahedralMeshTopologyKernel::add_face(const std::vector& _halfedges, bool _topologyCheck) { + +FaceHandle HexahedralMeshTopologyKernel::add_face(const std::vector& _halfedges, bool _topologyCheck) { if(_halfedges.size() != 4) { std::cerr << "Face valence is not four! Aborting." << std::endl; - return KernelT::InvalidFaceHandle; + return TopologyKernel::InvalidFaceHandle; } - return KernelT::add_face(_halfedges, _topologyCheck); + return TopologyKernel::add_face(_halfedges, _topologyCheck); } //======================================================================================== -template + FaceHandle -HexahedralMeshTopologyKernel::add_face(const std::vector& _vertices) { +HexahedralMeshTopologyKernel::add_face(const std::vector& _vertices) { if(_vertices.size() != 4) { std::cerr << "Face valence is not four! Aborting." << std::endl; - return KernelT::InvalidFaceHandle; + return TopologyKernel::InvalidFaceHandle; } - return KernelT::add_face(_vertices); + return TopologyKernel::add_face(_vertices); } //======================================================================================== -template + CellHandle -HexahedralMeshTopologyKernel::add_cell(const std::vector& _halffaces, bool _topologyCheck, bool _reorderFaces) { +HexahedralMeshTopologyKernel::add_cell(const std::vector& _halffaces, bool _topologyCheck, bool _reorderFaces) { if(_halffaces.size() != 6) { std::cerr << "Cell valence is not six! Aborting." << std::endl; - return KernelT::InvalidCellHandle; + return TopologyKernel::InvalidCellHandle; } for(typename std::vector::const_iterator it = _halffaces.begin(); it != _halffaces.end(); ++it) { - if(KernelT::halfface(*it).halfedges().size() != 4) { + if(TopologyKernel::halfface(*it).halfedges().size() != 4) { std::cerr << "Incident face does not have valence four! Aborting." << std::endl; - return KernelT::InvalidCellHandle; + return TopologyKernel::InvalidCellHandle; } } @@ -113,19 +111,19 @@ HexahedralMeshTopologyKernel::add_cell(const std::vector hes = KernelT::halfface(ordered_halffaces[0]).halfedges(); + std::vector hes = TopologyKernel::halfface(ordered_halffaces[0]).halfedges(); unsigned int idx = 0; for(typename std::vector::const_iterator he_it = hes.begin(); he_it != hes.end(); ++he_it) { HalfFaceHandle ahfh = get_adjacent_halfface(ordered_halffaces[0], *he_it, _halffaces); - if(ahfh == KernelT::InvalidHalfFaceHandle) { + if(ahfh == TopologyKernel::InvalidHalfFaceHandle) { std::cerr << "The current halfface is invalid!" << std::endl; continue; } @@ -135,14 +133,14 @@ HexahedralMeshTopologyKernel::add_cell(const std::vector::add_cell(const std::vector halfedgesTop = KernelT::halfface(ordered_halffaces[0]).halfedges(); - std::vector halfedgesBot = KernelT::halfface(ordered_halffaces[1]).halfedges(); + std::vector halfedgesTop = TopologyKernel::halfface(ordered_halffaces[0]).halfedges(); + std::vector halfedgesBot = TopologyKernel::halfface(ordered_halffaces[1]).halfedges(); int offsetTop = -1; int offsetBot = -1; @@ -201,14 +199,14 @@ HexahedralMeshTopologyKernel::add_cell(const std::vector::add_cell(const std::vector + const HalfFaceHandle& -HexahedralMeshTopologyKernel::get_adjacent_halfface(const HalfFaceHandle& _hfh, const HalfEdgeHandle& _heh, +HexahedralMeshTopologyKernel::get_adjacent_halfface(const HalfFaceHandle& _hfh, const HalfEdgeHandle& _heh, const std::vector& _halffaces) const { // Search for halfface that is incident to the opposite // halfedge of _heh - HalfEdgeHandle o_he = KernelT::opposite_halfedge_handle(_heh); + HalfEdgeHandle o_he = TopologyKernel::opposite_halfedge_handle(_heh); for(typename std::vector::const_iterator it = _halffaces.begin(); it != _halffaces.end(); ++it) { if(*it == _hfh) continue; - std::vector halfedges = KernelT::halfface(*it).halfedges(); + std::vector halfedges = TopologyKernel::halfface(*it).halfedges(); for(typename std::vector::const_iterator h_it = halfedges.begin(); h_it != halfedges.end(); ++h_it) { if(*h_it == o_he) return *it; } } - return KernelT::InvalidHalfFaceHandle; + return TopologyKernel::InvalidHalfFaceHandle; } } // Namespace OpenVolumeMesh diff --git a/src/OpenVolumeMesh/Mesh/HexahedralMeshTopologyKernel.hh b/src/OpenVolumeMesh/Mesh/HexahedralMeshTopologyKernel.hh index 4d8d8e3..003edda 100644 --- a/src/OpenVolumeMesh/Mesh/HexahedralMeshTopologyKernel.hh +++ b/src/OpenVolumeMesh/Mesh/HexahedralMeshTopologyKernel.hh @@ -45,7 +45,7 @@ #include -#include "../Core/GeometryKernel.hh" +#include "../Core/TopologyKernel.hh" #include "HexahedralMeshIterators.hh" namespace OpenVolumeMesh { @@ -78,8 +78,7 @@ namespace OpenVolumeMesh { * \li \c 6. ZB */ -template -class HexahedralMeshTopologyKernel : public KernelT { +class HexahedralMeshTopologyKernel : public TopologyKernel { public: // Orientation constants @@ -113,13 +112,13 @@ public: // ======================= Specialized Iterators ============================= - friend class CellSheetCellIter; - friend class HalfFaceSheetHalfFaceIter; - friend class OutsideNeighborHalfFaceIter; + friend class CellSheetCellIter; + friend class HalfFaceSheetHalfFaceIter; + friend class OutsideNeighborHalfFaceIter; - typedef class CellSheetCellIter CellSheetCellIter; - typedef class HalfFaceSheetHalfFaceIter HalfFaceSheetHalfFaceIter; - typedef class OutsideNeighborHalfFaceIter OutsideNeighborHalfFaceIter; + typedef class CellSheetCellIter CellSheetCellIter; + typedef class HalfFaceSheetHalfFaceIter HalfFaceSheetHalfFaceIter; + typedef class OutsideNeighborHalfFaceIter OutsideNeighborHalfFaceIter; CellSheetCellIter csc_iter(const CellHandle& _ref_h, const unsigned char _orthDir) const { return CellSheetCellIter(_ref_h, _orthDir, this); @@ -137,7 +136,7 @@ public: inline HalfFaceHandle opposite_halfface_handle_in_cell(const HalfFaceHandle& _hfh, const CellHandle& _ch) { - assert((unsigned int)_ch < KernelT::cells_.size()); + assert((unsigned int)_ch < TopologyKernel::cells_.size()); if(orientation(_hfh, _ch) == XF) return xback_halfface(_ch); if(orientation(_hfh, _ch) == XB) return xfront_halfface(_ch); @@ -146,56 +145,56 @@ public: if(orientation(_hfh, _ch) == ZF) return zback_halfface(_ch); if(orientation(_hfh, _ch) == ZB) return zfront_halfface(_ch); - return KernelT::InvalidHalfFaceHandle; + return TopologyKernel::InvalidHalfFaceHandle; } inline HalfFaceHandle xfront_halfface(const CellHandle& _ch) const { - assert((unsigned int)_ch < KernelT::cells_.size()); + assert((unsigned int)_ch < TopologyKernel::cells_.size()); - return KernelT::cell(_ch).halffaces()[XF]; + return TopologyKernel::cell(_ch).halffaces()[XF]; } inline HalfFaceHandle xback_halfface(const CellHandle& _ch) const { - assert((unsigned int)_ch < KernelT::cells_.size()); + assert((unsigned int)_ch < TopologyKernel::cells_.size()); - return KernelT::cell(_ch).halffaces()[XB]; + return TopologyKernel::cell(_ch).halffaces()[XB]; } inline HalfFaceHandle yfront_halfface(const CellHandle& _ch) const { - assert((unsigned int)_ch < KernelT::cells_.size()); + assert((unsigned int)_ch < TopologyKernel::cells_.size()); - return KernelT::cell(_ch).halffaces()[YF]; + return TopologyKernel::cell(_ch).halffaces()[YF]; } inline HalfFaceHandle yback_halfface(const CellHandle& _ch) const { - assert((unsigned int)_ch < KernelT::cells_.size()); + assert((unsigned int)_ch < TopologyKernel::cells_.size()); - return KernelT::cell(_ch).halffaces()[YB]; + return TopologyKernel::cell(_ch).halffaces()[YB]; } inline HalfFaceHandle zfront_halfface(const CellHandle& _ch) const { - assert((unsigned int)_ch < KernelT::cells_.size()); + assert((unsigned int)_ch < TopologyKernel::cells_.size()); - return KernelT::cell(_ch).halffaces()[ZF]; + return TopologyKernel::cell(_ch).halffaces()[ZF]; } inline HalfFaceHandle zback_halfface(const CellHandle& _ch) const { - assert((unsigned int)_ch < KernelT::cells_.size()); + assert((unsigned int)_ch < TopologyKernel::cells_.size()); - return KernelT::cell(_ch).halffaces()[ZB]; + return TopologyKernel::cell(_ch).halffaces()[ZB]; } unsigned char orientation(const HalfFaceHandle& _hfh, const CellHandle& _ch) const { - assert((unsigned int)_ch < KernelT::cells_.size()); + assert((unsigned int)_ch < TopologyKernel::cells_.size()); - std::vector halffaces = KernelT::cell(_ch).halffaces(); + std::vector halffaces = TopologyKernel::cell(_ch).halffaces(); for(unsigned int i = 0; i < halffaces.size(); ++i) { if(halffaces[i] == _hfh) return (unsigned char)i; } @@ -244,14 +243,14 @@ public: if(_o == YB) return yback_halfface(_ch); if(_o == ZF) return zfront_halfface(_ch); if(_o == ZB) return zback_halfface(_ch); - return KernelT::InvalidHalfFaceHandle; + return TopologyKernel::InvalidHalfFaceHandle; } HalfFaceHandle adjacent_halfface_on_sheet(const HalfFaceHandle& _hfh, const HalfEdgeHandle& _heh) const { - if(!KernelT::has_bottom_up_adjacencies()) { + if(!TopologyKernel::has_bottom_up_adjacencies()) { std::cerr << "No bottom-up adjacencies computed so far, could not get adjacent halfface on sheet!" << std::endl; - return KernelT::InvalidHalfFaceHandle; + return TopologyKernel::InvalidHalfFaceHandle; } HalfFaceHandle n_hf = _hfh; @@ -259,67 +258,67 @@ public: // Try the 1st way while(true) { - n_hf = KernelT::adjacent_halfface_in_cell(n_hf, n_he); - if(n_hf == KernelT::InvalidHalfFaceHandle) break; - n_hf = KernelT::opposite_halfface_handle(n_hf); - if(n_hf == KernelT::InvalidHalfFaceHandle) break; - HalfEdgeHandle o_he = KernelT::opposite_halfedge_handle(n_he); - if(o_he == KernelT::InvalidHalfEdgeHandle) break; - n_hf = KernelT::adjacent_halfface_in_cell(n_hf, o_he); - if(n_hf == KernelT::InvalidHalfFaceHandle) break; + n_hf = TopologyKernel::adjacent_halfface_in_cell(n_hf, n_he); + if(n_hf == TopologyKernel::InvalidHalfFaceHandle) break; + n_hf = TopologyKernel::opposite_halfface_handle(n_hf); + if(n_hf == TopologyKernel::InvalidHalfFaceHandle) break; + HalfEdgeHandle o_he = TopologyKernel::opposite_halfedge_handle(n_he); + if(o_he == TopologyKernel::InvalidHalfEdgeHandle) break; + n_hf = TopologyKernel::adjacent_halfface_in_cell(n_hf, o_he); + if(n_hf == TopologyKernel::InvalidHalfFaceHandle) break; else return n_hf; } - n_hf = KernelT::opposite_halfface_handle(_hfh); - n_he = KernelT::opposite_halfedge_handle(_heh); + n_hf = TopologyKernel::opposite_halfface_handle(_hfh); + n_he = TopologyKernel::opposite_halfedge_handle(_heh); // Try the 2nd way while(true) { - n_hf = KernelT::adjacent_halfface_in_cell(n_hf, n_he); - if(n_hf == KernelT::InvalidHalfFaceHandle) break; - n_hf = KernelT::opposite_halfface_handle(n_hf); - if(n_hf == KernelT::InvalidHalfFaceHandle) break; - HalfEdgeHandle o_he = KernelT::opposite_halfedge_handle(n_he); - if(o_he == KernelT::InvalidHalfEdgeHandle) break; - n_hf = KernelT::adjacent_halfface_in_cell(n_hf, o_he); - if(n_hf == KernelT::InvalidHalfFaceHandle) break; - else return KernelT::opposite_halfface_handle(n_hf); + n_hf = TopologyKernel::adjacent_halfface_in_cell(n_hf, n_he); + if(n_hf == TopologyKernel::InvalidHalfFaceHandle) break; + n_hf = TopologyKernel::opposite_halfface_handle(n_hf); + if(n_hf == TopologyKernel::InvalidHalfFaceHandle) break; + HalfEdgeHandle o_he = TopologyKernel::opposite_halfedge_handle(n_he); + if(o_he == TopologyKernel::InvalidHalfEdgeHandle) break; + n_hf = TopologyKernel::adjacent_halfface_in_cell(n_hf, o_he); + if(n_hf == TopologyKernel::InvalidHalfFaceHandle) break; + else return TopologyKernel::opposite_halfface_handle(n_hf); } - return KernelT::InvalidHalfFaceHandle; + return TopologyKernel::InvalidHalfFaceHandle; } HalfFaceHandle adjacent_halfface_on_surface(const HalfFaceHandle& _hfh, const HalfEdgeHandle& _heh) const { - for(typename KernelT::HalfEdgeHalfFaceIter hehf_it = KernelT::hehf_iter(_heh); + for(OpenVolumeMesh::HalfEdgeHalfFaceIter hehf_it = TopologyKernel::hehf_iter(_heh); hehf_it.valid(); ++hehf_it) { if(*hehf_it == _hfh) continue; - if(KernelT::is_boundary(*hehf_it)) { + if(TopologyKernel::is_boundary(*hehf_it)) { return *hehf_it; } - if(KernelT::is_boundary(KernelT::opposite_halfface_handle(*hehf_it))) { - return KernelT::opposite_halfface_handle(*hehf_it); + if(TopologyKernel::is_boundary(TopologyKernel::opposite_halfface_handle(*hehf_it))) { + return TopologyKernel::opposite_halfface_handle(*hehf_it); } } - return KernelT::InvalidHalfFaceHandle; + return TopologyKernel::InvalidHalfFaceHandle; } HalfFaceHandle neighboring_outside_halfface(const HalfFaceHandle& _hfh, const HalfEdgeHandle& _heh) const { - if(!KernelT::has_bottom_up_adjacencies()) { + if(!TopologyKernel::has_bottom_up_adjacencies()) { std::cerr << "No bottom-up adjacencies computed so far, could not get neighboring outside halfface!" << std::endl; - return KernelT::InvalidHalfFaceHandle; + return TopologyKernel::InvalidHalfFaceHandle; } - for(typename KernelT::HalfEdgeHalfFaceIter hehf_it = KernelT::hehf_iter(_heh); + for(OpenVolumeMesh::HalfEdgeHalfFaceIter hehf_it = TopologyKernel::hehf_iter(_heh); hehf_it; ++hehf_it) { if(*hehf_it == _hfh) continue; - if(KernelT::is_boundary(*hehf_it)) return *hehf_it; - if(KernelT::is_boundary(KernelT::opposite_halfface_handle(*hehf_it))) - return KernelT::opposite_halfface_handle(*hehf_it); + if(TopologyKernel::is_boundary(*hehf_it)) return *hehf_it; + if(TopologyKernel::is_boundary(TopologyKernel::opposite_halfface_handle(*hehf_it))) + return TopologyKernel::opposite_halfface_handle(*hehf_it); } - return KernelT::InvalidHalfFaceHandle; + return TopologyKernel::InvalidHalfFaceHandle; } private: @@ -331,8 +330,4 @@ private: } // Namespace OpenVolumeMesh -#if defined(INCLUDE_TEMPLATES) && !defined(HEXAHEDRALMESHTOPOLOGYKERNELT_CC) -#include "HexahedralMeshTopologyKernelT.cc" -#endif - #endif /* HEXAHEDRALMESHTOPOLOGYKERNEL_HH */ diff --git a/src/OpenVolumeMesh/Mesh/PolyhedralMesh.hh b/src/OpenVolumeMesh/Mesh/PolyhedralMesh.hh index 7cba151..df4d255 100644 --- a/src/OpenVolumeMesh/Mesh/PolyhedralMesh.hh +++ b/src/OpenVolumeMesh/Mesh/PolyhedralMesh.hh @@ -50,7 +50,7 @@ namespace OpenVolumeMesh { /* * Predefines for most common mesh types */ -typedef GeometryKernel GeometricPolyhedralMeshV3d; +typedef GeometryKernel GeometricPolyhedralMeshV3d; typedef TopologyKernel TopologicPolyhedralMesh; diff --git a/src/Unittests/unittests_basics.hh b/src/Unittests/unittests_basics.hh index f446a7f..1bfdb07 100644 --- a/src/Unittests/unittests_basics.hh +++ b/src/Unittests/unittests_basics.hh @@ -543,7 +543,7 @@ TEST_F(PolyhedralMeshBase, VolumeMeshNormals) { generatePolyhedralMesh(mesh_); - NormalAttrib normals(mesh_); + NormalAttrib normals(mesh_); Vec3d n_x(1.0, 0.0, 0.0); Vec3d n_y(0.0, 1.0, 0.0); -- GitLab