Commit 960634bc authored by Mike Kremer's avatar Mike Kremer

Finished restructuring folders

git-svn-id: http://www.openvolumemesh.org/svnrepo/OpenVolumeMesh/trunk@16 66977474-1d4b-4f09-8fe9-267525286df2
parent 815b4c25
......@@ -7,7 +7,8 @@ include_directories (
# source code directories
set (directories
.
.
Core
OpenVolumeMesh
OpenVolumeMesh/Utils
OpenHexMesh
......
......@@ -62,7 +62,7 @@ class OpenVolumeMeshBaseProperty {
public:
/// Indicates an error when a size is returned by a member.
static const size_t UnknownSize = std::numeric_limits<size_t>::max();
static const size_t UnknownSize;
public:
......@@ -149,6 +149,9 @@ private:
bool persistent_;
};
// Initialize constant
const size_t OpenVolumeMeshBaseProperty::UnknownSize = std::numeric_limits<size_t>::max();
} // Namespace OpenVolumeMesh
#endif //OPENVOLUMEMESHBASEPROPERTY_HH
......
/*
* OpenHexMesh.hh
*
* Created on: Jun 10, 2011
* Author: kremer
*/
#ifndef OPENHEXMESH_HH_
#define OPENHEXMESH_HH_
/*===========================================================================*\
* *
* OpenVolumeMesh *
* Copyright (C) 2011 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* This file is part of OpenVolumeMesh. *
* *
* OpenVolumeMesh is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as *
* published by the Free Software Foundation, either version 3 of *
* the License, or (at your option) any later version with the *
* following exceptions: *
* *
* If other files instantiate templates or use macros *
* or inline functions from this file, or you compile this file and *
* link it with other files to produce an executable, this file does *
* not by itself cause the resulting executable to be covered by the *
* GNU Lesser General Public License. This exception does not however *
* invalidate any other reasons why the executable file might be *
* covered by the GNU Lesser General Public License. *
* *
* OpenVolumeMesh 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 Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU LesserGeneral Public *
* License along with OpenVolumeMesh. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
/*===========================================================================*\
* *
* $Revision: 1 $ *
* $Date: 2011-01-09 12:46:45 +0100 (Mo, 09. Jan 2011) $ *
* $LastChangedBy: kremer $ *
* *
\*===========================================================================*/
#ifndef HEXAHEDRALMESH_HH
#define HEXAHEDRALMESH_HH
#include <set>
#include "../OpenVolumeMesh/OpenVolumeMesh.hh"
#include "Utils/OpenHexMeshIterators.hh"
#include "../PolyhedralMesh/PolyhedralMesh.hh"
#include "Utils/Iterators.hh"
namespace OpenVolumeMesh {
/*
* HexMesh data structure basing on OpenVolumeMesh
......@@ -24,15 +61,15 @@
*/
template <typename VecT>
class OpenHexMesh : public OpenVolumeMesh<VecT> {
class HexahedralMesh : public PolyhedralMesh<VecT> {
public:
typedef typename OpenVolumeMesh<VecT>::VertexHandle VertexHandle;
typedef typename OpenVolumeMesh<VecT>::EdgeHandle EdgeHandle;
typedef typename OpenVolumeMesh<VecT>::HalfEdgeHandle HalfEdgeHandle;
typedef typename OpenVolumeMesh<VecT>::FaceHandle FaceHandle;
typedef typename OpenVolumeMesh<VecT>::HalfFaceHandle HalfFaceHandle;
typedef typename OpenVolumeMesh<VecT>::CellHandle CellHandle;
typedef typename PolyhedralMesh<VecT>::VertexHandle VertexHandle;
typedef typename PolyhedralMesh<VecT>::EdgeHandle EdgeHandle;
typedef typename PolyhedralMesh<VecT>::HalfEdgeHandle HalfEdgeHandle;
typedef typename PolyhedralMesh<VecT>::FaceHandle FaceHandle;
typedef typename PolyhedralMesh<VecT>::HalfFaceHandle HalfFaceHandle;
typedef typename PolyhedralMesh<VecT>::CellHandle CellHandle;
// Orientation constants
static const unsigned char XF = 0;
......@@ -48,10 +85,10 @@ public:
}
// Constructor
OpenHexMesh();
HexahedralMesh();
// Destructor
~OpenHexMesh();
~HexahedralMesh();
// Overridden function
FaceHandle add_face(const std::vector<HalfEdgeHandle>& _halfedges, bool _topologyCheck = true);
......@@ -89,7 +126,7 @@ public:
inline HalfFaceHandle opposite_halfface_handle_in_cell(const HalfFaceHandle& _hfh, const CellHandle& _ch) {
assert((unsigned int)_ch < OpenVolumeMesh<VecT>::cells_.size());
assert((unsigned int)_ch < PolyhedralMesh<VecT>::cells_.size());
if(orientation(_hfh, _ch) == XF) return xback_halfface(_ch);
if(orientation(_hfh, _ch) == XB) return xfront_halfface(_ch);
......@@ -98,54 +135,54 @@ public:
if(orientation(_hfh, _ch) == ZF) return zback_halfface(_ch);
if(orientation(_hfh, _ch) == ZB) return zfront_halfface(_ch);
return OpenVolumeMesh<VecT>::InvalidHalfFaceHandle;
return PolyhedralMesh<VecT>::InvalidHalfFaceHandle;
}
inline HalfFaceHandle xfront_halfface(const CellHandle& _ch) const {
assert((unsigned int)_ch < OpenVolumeMesh<VecT>::cells_.size());
assert((unsigned int)_ch < PolyhedralMesh<VecT>::cells_.size());
return cell(_ch).halffaces()[XF];
}
inline HalfFaceHandle xback_halfface(const CellHandle& _ch) const {
assert((unsigned int)_ch < OpenVolumeMesh<VecT>::cells_.size());
assert((unsigned int)_ch < PolyhedralMesh<VecT>::cells_.size());
return cell(_ch).halffaces()[XB];
}
inline HalfFaceHandle yfront_halfface(const CellHandle& _ch) const {
assert((unsigned int)_ch < OpenVolumeMesh<VecT>::cells_.size());
assert((unsigned int)_ch < PolyhedralMesh<VecT>::cells_.size());
return cell(_ch).halffaces()[YF];
}
inline HalfFaceHandle yback_halfface(const CellHandle& _ch) const {
assert((unsigned int)_ch < OpenVolumeMesh<VecT>::cells_.size());
assert((unsigned int)_ch < PolyhedralMesh<VecT>::cells_.size());
return cell(_ch).halffaces()[YB];
}
inline HalfFaceHandle zfront_halfface(const CellHandle& _ch) const {
assert((unsigned int)_ch < OpenVolumeMesh<VecT>::cells_.size());
assert((unsigned int)_ch < PolyhedralMesh<VecT>::cells_.size());
return cell(_ch).halffaces()[ZF];
}
inline HalfFaceHandle zback_halfface(const CellHandle& _ch) const {
assert((unsigned int)_ch < OpenVolumeMesh<VecT>::cells_.size());
assert((unsigned int)_ch < PolyhedralMesh<VecT>::cells_.size());
return cell(_ch).halffaces()[ZB];
}
unsigned char orientation(const HalfFaceHandle& _hfh, const CellHandle& _ch) const {
assert((unsigned int)_ch < OpenVolumeMesh<VecT>::cells_.size());
assert((unsigned int)_ch < PolyhedralMesh<VecT>::cells_.size());
std::vector<HalfFaceHandle> halffaces = cell(_ch).halffaces();
for(unsigned int i = 0; i < halffaces.size(); ++i) {
......@@ -196,14 +233,14 @@ public:
if(_o == YB) return yback_halfface(_ch);
if(_o == ZF) return zfront_halfface(_ch);
if(_o == ZB) return zback_halfface(_ch);
return OpenVolumeMesh<VecT>::InvalidHalfFaceHandle;
return PolyhedralMesh<VecT>::InvalidHalfFaceHandle;
}
HalfFaceHandle adjacent_halfface_on_sheet(const HalfFaceHandle& _hfh, const HalfEdgeHandle& _heh) const {
if(!OpenVolumeMesh<VecT>::has_bottom_up_adjacencies()) {
if(!PolyhedralMesh<VecT>::has_bottom_up_adjacencies()) {
std::cerr << "No bottom-up adjacencies computed so far, could not get adjacent halfface on sheet!" << std::endl;
return OpenVolumeMesh<VecT>::InvalidHalfFaceHandle;
return PolyhedralMesh<VecT>::InvalidHalfFaceHandle;
}
HalfFaceHandle n_hf = _hfh;
......@@ -211,67 +248,67 @@ public:
// Try the 1st way
while(true) {
n_hf = OpenVolumeMesh<VecT>::adjacent_halfface_in_cell(n_hf, n_he);
if(n_hf == OpenVolumeMesh<VecT>::InvalidHalfFaceHandle) break;
n_hf = OpenVolumeMesh<VecT>::opposite_halfface_handle(n_hf);
if(n_hf == OpenVolumeMesh<VecT>::InvalidHalfFaceHandle) break;
HalfEdgeHandle o_he = OpenVolumeMesh<VecT>::opposite_halfedge_handle(n_he);
if(o_he == OpenVolumeMesh<VecT>::InvalidHalfEdgeHandle) break;
n_hf = OpenVolumeMesh<VecT>::adjacent_halfface_in_cell(n_hf, o_he);
if(n_hf == OpenVolumeMesh<VecT>::InvalidHalfFaceHandle) break;
n_hf = PolyhedralMesh<VecT>::adjacent_halfface_in_cell(n_hf, n_he);
if(n_hf == PolyhedralMesh<VecT>::InvalidHalfFaceHandle) break;
n_hf = PolyhedralMesh<VecT>::opposite_halfface_handle(n_hf);
if(n_hf == PolyhedralMesh<VecT>::InvalidHalfFaceHandle) break;
HalfEdgeHandle o_he = PolyhedralMesh<VecT>::opposite_halfedge_handle(n_he);
if(o_he == PolyhedralMesh<VecT>::InvalidHalfEdgeHandle) break;
n_hf = PolyhedralMesh<VecT>::adjacent_halfface_in_cell(n_hf, o_he);
if(n_hf == PolyhedralMesh<VecT>::InvalidHalfFaceHandle) break;
else return n_hf;
}
n_hf = OpenVolumeMesh<VecT>::opposite_halfface_handle(_hfh);
n_he = OpenVolumeMesh<VecT>::opposite_halfedge_handle(_heh);
n_hf = PolyhedralMesh<VecT>::opposite_halfface_handle(_hfh);
n_he = PolyhedralMesh<VecT>::opposite_halfedge_handle(_heh);
// Try the 2nd way
while(true) {
n_hf = OpenVolumeMesh<VecT>::adjacent_halfface_in_cell(n_hf, n_he);
if(n_hf == OpenVolumeMesh<VecT>::InvalidHalfFaceHandle) break;
n_hf = OpenVolumeMesh<VecT>::opposite_halfface_handle(n_hf);
if(n_hf == OpenVolumeMesh<VecT>::InvalidHalfFaceHandle) break;
HalfEdgeHandle o_he = OpenVolumeMesh<VecT>::opposite_halfedge_handle(n_he);
if(o_he == OpenVolumeMesh<VecT>::InvalidHalfEdgeHandle) break;
n_hf = OpenVolumeMesh<VecT>::adjacent_halfface_in_cell(n_hf, o_he);
if(n_hf == OpenVolumeMesh<VecT>::InvalidHalfFaceHandle) break;
else return OpenVolumeMesh<VecT>::opposite_halfface_handle(n_hf);
n_hf = PolyhedralMesh<VecT>::adjacent_halfface_in_cell(n_hf, n_he);
if(n_hf == PolyhedralMesh<VecT>::InvalidHalfFaceHandle) break;
n_hf = PolyhedralMesh<VecT>::opposite_halfface_handle(n_hf);
if(n_hf == PolyhedralMesh<VecT>::InvalidHalfFaceHandle) break;
HalfEdgeHandle o_he = PolyhedralMesh<VecT>::opposite_halfedge_handle(n_he);
if(o_he == PolyhedralMesh<VecT>::InvalidHalfEdgeHandle) break;
n_hf = PolyhedralMesh<VecT>::adjacent_halfface_in_cell(n_hf, o_he);
if(n_hf == PolyhedralMesh<VecT>::InvalidHalfFaceHandle) break;
else return PolyhedralMesh<VecT>::opposite_halfface_handle(n_hf);
}
return OpenVolumeMesh<VecT>::InvalidHalfFaceHandle;
return PolyhedralMesh<VecT>::InvalidHalfFaceHandle;
}
HalfFaceHandle adjacent_halfface_on_surface(const HalfFaceHandle& _hfh, const HalfEdgeHandle& _heh) const {
for(typename OpenVolumeMesh<VecT>::HalfEdgeHalfFaceIter hehf_it = OpenVolumeMesh<VecT>::hehf_iter(_heh);
for(typename PolyhedralMesh<VecT>::HalfEdgeHalfFaceIter hehf_it = PolyhedralMesh<VecT>::hehf_iter(_heh);
hehf_it.valid(); ++hehf_it) {
if(*hehf_it == _hfh) continue;
if(OpenVolumeMesh<VecT>::is_boundary(*hehf_it)) {
if(PolyhedralMesh<VecT>::is_boundary(*hehf_it)) {
return *hehf_it;
}
if(OpenVolumeMesh<VecT>::is_boundary(OpenVolumeMesh<VecT>::opposite_halfface_handle(*hehf_it))) {
return OpenVolumeMesh<VecT>::opposite_halfface_handle(*hehf_it);
if(PolyhedralMesh<VecT>::is_boundary(PolyhedralMesh<VecT>::opposite_halfface_handle(*hehf_it))) {
return PolyhedralMesh<VecT>::opposite_halfface_handle(*hehf_it);
}
}
return OpenVolumeMesh<VecT>::InvalidHalfFaceHandle;
return PolyhedralMesh<VecT>::InvalidHalfFaceHandle;
}
HalfFaceHandle neighboring_outside_halfface(const HalfFaceHandle& _hfh, const HalfEdgeHandle& _heh) const {
if(!OpenVolumeMesh<VecT>::has_bottom_up_adjacencies()) {
if(!PolyhedralMesh<VecT>::has_bottom_up_adjacencies()) {
std::cerr << "No bottom-up adjacencies computed so far, could not get neighboring outside halfface!" << std::endl;
return OpenVolumeMesh<VecT>::InvalidHalfFaceHandle;
return PolyhedralMesh<VecT>::InvalidHalfFaceHandle;
}
for(typename OpenVolumeMesh<VecT>::HalfEdgeHalfFaceIter hehf_it = OpenVolumeMesh<VecT>::hehf_iter(_heh);
for(typename PolyhedralMesh<VecT>::HalfEdgeHalfFaceIter hehf_it = PolyhedralMesh<VecT>::hehf_iter(_heh);
hehf_it; ++hehf_it) {
if(*hehf_it == _hfh) continue;
if(OpenVolumeMesh<VecT>::is_boundary(*hehf_it)) return *hehf_it;
if(OpenVolumeMesh<VecT>::is_boundary(OpenVolumeMesh<VecT>::opposite_halfface_handle(*hehf_it)))
return OpenVolumeMesh<VecT>::opposite_halfface_handle(*hehf_it);
if(PolyhedralMesh<VecT>::is_boundary(*hehf_it)) return *hehf_it;
if(PolyhedralMesh<VecT>::is_boundary(PolyhedralMesh<VecT>::opposite_halfface_handle(*hehf_it)))
return PolyhedralMesh<VecT>::opposite_halfface_handle(*hehf_it);
}
return OpenVolumeMesh<VecT>::InvalidHalfFaceHandle;
return PolyhedralMesh<VecT>::InvalidHalfFaceHandle;
}
private:
......@@ -281,8 +318,10 @@ private:
};
#if defined(INCLUDE_TEMPLATES) && !defined(OPENHEXMESHT_CC)
#include "OpenHexMeshT.cc"
} // Namespace OpenVolumeMesh
#if defined(INCLUDE_TEMPLATES) && !defined(HEXAHEDRALMESHT_CC)
#include "HexahedralMeshT.cc"
#endif
#endif /* OPENHEXMESH_HH_ */
#endif /* OPENHEXMESH_HH */
/*
* OpenHexMeshT.cc
*
* Created on: Jun 10, 2011
* Author: kremer
*/
/*===========================================================================*\
* *
* OpenVolumeMesh *
* Copyright (C) 2011 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* This file is part of OpenVolumeMesh. *
* *
* OpenVolumeMesh is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as *
* published by the Free Software Foundation, either version 3 of *
* the License, or (at your option) any later version with the *
* following exceptions: *
* *
* If other files instantiate templates or use macros *
* or inline functions from this file, or you compile this file and *
* link it with other files to produce an executable, this file does *
* not by itself cause the resulting executable to be covered by the *
* GNU Lesser General Public License. This exception does not however *
* invalidate any other reasons why the executable file might be *
* covered by the GNU Lesser General Public License. *
* *
* OpenVolumeMesh 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 Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU LesserGeneral Public *
* License along with OpenVolumeMesh. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
/*===========================================================================*\
* *
* $Revision: 1 $ *
* $Date: 2011-01-09 12:46:45 +0100 (Mo, 09. Jan 2011) $ *
* $LastChangedBy: kremer $ *
* *
\*===========================================================================*/
#define OPENHEXMESHT_CC
#include "OpenHexMesh.hh"
#include "HexahedralMesh.hh"
namespace OpenVolumeMesh {
template <typename VecT>
OpenHexMesh<VecT>::OpenHexMesh() {
HexahedralMesh<VecT>::HexahedralMesh() {
}
//========================================================================================
template <typename VecT>
OpenHexMesh<VecT>::~OpenHexMesh() {
HexahedralMesh<VecT>::~HexahedralMesh() {
}
//========================================================================================
template <typename VecT>
typename OpenHexMesh<VecT>::FaceHandle
OpenHexMesh<VecT>::add_face(const std::vector<HalfEdgeHandle>& _halfedges, bool _topologyCheck) {
typename HexahedralMesh<VecT>::FaceHandle
HexahedralMesh<VecT>::add_face(const std::vector<HalfEdgeHandle>& _halfedges, bool _topologyCheck) {
if(_halfedges.size() != 4) {
std::cerr << "Face valence is not four! Aborting." << std::endl;
......@@ -38,8 +75,8 @@ OpenHexMesh<VecT>::add_face(const std::vector<HalfEdgeHandle>& _halfedges, bool
//========================================================================================
template <typename VecT>
typename OpenHexMesh<VecT>::FaceHandle
OpenHexMesh<VecT>::add_face(const std::vector<VertexHandle>& _vertices) {
typename HexahedralMesh<VecT>::FaceHandle
HexahedralMesh<VecT>::add_face(const std::vector<VertexHandle>& _vertices) {
if(_vertices.size() != 4) {
std::cerr << "Face valence is not four! Aborting." << std::endl;
......@@ -52,8 +89,8 @@ OpenHexMesh<VecT>::add_face(const std::vector<VertexHandle>& _vertices) {
//========================================================================================
template <typename VecT>
typename OpenHexMesh<VecT>::CellHandle
OpenHexMesh<VecT>::add_cell(const std::vector<HalfFaceHandle>& _halffaces, bool _topologyCheck, bool _reorderFaces) {
typename HexahedralMesh<VecT>::CellHandle
HexahedralMesh<VecT>::add_cell(const std::vector<HalfFaceHandle>& _halffaces, bool _topologyCheck, bool _reorderFaces) {
if(_halffaces.size() != 6) {
std::cerr << "Cell valence is not six! Aborting." << std::endl;
......@@ -206,8 +243,8 @@ OpenHexMesh<VecT>::add_cell(const std::vector<HalfFaceHandle>& _halffaces, bool
//========================================================================================
template <typename VecT>
const typename OpenHexMesh<VecT>::HalfFaceHandle&
OpenHexMesh<VecT>::get_adjacent_halfface(const HalfFaceHandle& _hfh, const HalfEdgeHandle& _heh,
const typename HexahedralMesh<VecT>::HalfFaceHandle&
HexahedralMesh<VecT>::get_adjacent_halfface(const HalfFaceHandle& _hfh, const HalfEdgeHandle& _heh,
const std::vector<HalfFaceHandle>& _halffaces) const {
// Search for halfface that is incident to the opposite
......@@ -226,3 +263,5 @@ OpenHexMesh<VecT>::get_adjacent_halfface(const HalfFaceHandle& _hfh, const HalfE
return OpenVolumeMesh<VecT>::InvalidHalfFaceHandle;
}
} // Namespace OpenVolumeMesh
/*
* OpenHexMeshIterators.hh
*
* Created on: 27.06.2011
* Author: mike
*/
/*===========================================================================*\
* *
* OpenVolumeMesh *
* Copyright (C) 2011 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* This file is part of OpenVolumeMesh. *
* *
* OpenVolumeMesh is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as *
* published by the Free Software Foundation, either version 3 of *
* the License, or (at your option) any later version with the *
* following exceptions: *
* *
* If other files instantiate templates or use macros *
* or inline functions from this file, or you compile this file and *
* link it with other files to produce an executable, this file does *
* not by itself cause the resulting executable to be covered by the *
* GNU Lesser General Public License. This exception does not however *
* invalidate any other reasons why the executable file might be *
* covered by the GNU Lesser General Public License. *
* *
* OpenVolumeMesh 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 Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU LesserGeneral Public *
* License along with OpenVolumeMesh. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
#ifndef OPENHEXMESHITERATORS_HH_
#define OPENHEXMESHITERATORS_HH_
/*===========================================================================*\
* *
* $Revision: 1 $ *
* $Date: 2011-01-09 12:46:45 +0100 (Mo, 09. Jan 2011) $ *
* $LastChangedBy: kremer $ *
* *
\*===========================================================================*/
#ifndef HEXAHEDRALMESHITERATORS_HH
#define HEXAHEDRALMESHITERATORS_HH
namespace OpenVolumeMesh {
//#include "../OpenHexMesh.hh"
template <class VecT>
class OpenHexMesh;
class HexahedralMesh;
#include "../../OpenVolumeMesh/Utils/Iterators.hh"
#include "../../PolyhedralMesh/Utils/Iterators.hh"
template <class VecT>
class CellSheetCellIter : public BaseIterator<VecT,
......@@ -26,7 +62,7 @@ private:
typedef typename OpenVolumeMesh<VecT>::HalfFaceHandle HalfFaceHandle;
public:
CellSheetCellIter(const CellHandle& _ref_h, const unsigned char _orthDir,
const OpenHexMesh<VecT>* _mesh);
const HexahedralMesh<VecT>* _mesh);
CellSheetCellIter& operator=(const CellSheetCellIter& _c) {
BaseIter::operator=(_c);
......@@ -94,7 +130,7 @@ private:
typedef typename OpenVolumeMesh<VecT>::EdgeHandle EdgeHandle;
public:
HalfFaceSheetHalfFaceIter(const HalfFaceHandle& _ref_h,
const OpenHexMesh<VecT>* _mesh);
const HexahedralMesh<VecT>* _mesh);
HalfFaceSheetHalfFaceIter& operator=(const HalfFaceSheetHalfFaceIter& _c) {
BaseIter::operator=(_c);
adjacent_halffaces_ = _c.adjacent_halffaces_;
......@@ -165,7 +201,7 @@ private:
typedef typename OpenVolumeMesh<VecT>::EdgeHandle EdgeHandle;
public:
OutsideNeighborHalfFaceIter(const HalfFaceHandle& _ref_h,
const OpenHexMesh<VecT>* _mesh);
const HexahedralMesh<VecT>* _mesh);
OutsideNeighborHalfFaceIter& operator=(const OutsideNeighborHalfFaceIter& _c) {
BaseIter::operator=(_c);
neighbor_halffaces_ = _c.adjacent_halffaces_;
......@@ -223,8 +259,10 @@ private:
typename std::vector<EdgeHandle>::const_iterator edge_it_;
};
#if defined(INCLUDE_TEMPLATES) && !defined(OPENHEXMESHITERATORST_CC)
#include "OpenHexMeshIteratorsT.cc"
#if defined(INCLUDE_TEMPLATES) && !defined(HEXAHEDRALMESHITERATORST_CC)
#include "IteratorsT.cc"
#endif
#endif /* OPENHEXMESHITERATORS_HH_ */
} // Namespace OpenVolumeMesh
#endif /* HEXAHEDRALMESHITERATORS_HH */
/*
* OpenHexMeshIteratorsT.cc
*
* Created on: Jun 20, 2011
* Author: kremer
*/
#define OPENHEXMESHITERATORST_CC
/*===========================================================================*\
* *
* OpenVolumeMesh *
* Copyright (C) 2011 by Computer Graphics Group, RWTH Aachen *
* www.openmesh.org *
* *
*---------------------------------------------------------------------------*
* This file is part of OpenVolumeMesh. *
* *
* OpenVolumeMesh is free software: you can redistribute it and/or modify *
* it under the terms of the GNU Lesser General Public License as *
* published by the Free Software Foundation, either version 3 of *
* the License, or (at your option) any later version with the *
* following exceptions: *
* *
* If other files instantiate templates or use macros *
* or inline functions from this file, or you compile this file and *
* link it with other files to produce an executable, this file does *
* not by itself cause the resulting executable to be covered by the *
* GNU Lesser General Public License. This exception does not however *
* invalidate any other reasons why the executable file might be *
* covered by the GNU Lesser General Public License. *
* *
* OpenVolumeMesh 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 Lesser General Public License for more details. *
* *
* You should have received a copy of the GNU LesserGeneral Public *
* License along with OpenVolumeMesh. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
/*===========================================================================*\
* *
* $Revision: 1 $ *
* $Date: 2011-01-09 12:46:45 +0100 (Mo, 09. Jan 2011) $ *
* $LastChangedBy: kremer $ *
* *
\*===========================================================================*/
#define HEXAHEDRALMESHITERATORST_CC
#include <set>
#include "OpenHexMeshIterators.hh"
#include "Iterators.hh"
namespace OpenVolumeMesh {
//================================================================================================
// CellSheetCellIter
......@@ -17,7 +54,7 @@
template <class VecT>
CellSheetCellIter<VecT>::CellSheetCellIter(const CellHandle& _ref_h,
const unsigned char _orthDir, const OpenHexMesh<VecT>* _mesh) :
const unsigned char _orthDir, const HexahedralMesh<VecT>* _mesh) :
BaseIter(_mesh, _ref_h) {