Commit d5bb9d84 authored by Mike Kremer's avatar Mike Kremer
Browse files

Temporarily removed OpenVolumeMesh integration from OpenFlipper. Will be available soon...

git-svn-id: http://www.openflipper.org/svnrepo/OpenFlipper/branches/Free@13753 383ad7c9-94d9-4d36-a494-682f7c89f535
parent e6653d5d
/*===========================================================================*\
* *
* OpenFlipper *
* Copyright (C) 2001-2011 by Computer Graphics Group, RWTH Aachen *
* www.openflipper.org *
* *
*--------------------------------------------------------------------------- *
* This file is part of OpenFlipper. *
* *
* OpenFlipper 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. *
* *
* OpenFlipper 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 OpenFlipper. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
/*===========================================================================*\
* *
* $Revision: 13489 $ *
* $LastChangedBy: kremer $ *
* $Date: 2012-01-25 12:30:09 +0100 (Wed, 25 Jan 2012) $ *
* *
\*===========================================================================*/
/**
* \file HexahedralMesh.hh
* This file contains all required includes for using polyhedral meshes
*/
#ifndef HEXAHEDRAL_MESH_INCLUDE_HH
#define HEXAHEDRAL_MESH_INCLUDE_HH
//== INCLUDES =================================================================
/** \def DATA_HEXAHEDRAL_MESH
* Use this macro to reference Hexahedral Meshes
*/
#define DATA_HEXAHEDRAL_MESH typeId("HexahedralMesh")
#include <ObjectTypes/VolumeMeshObject/VolumeMeshObject.hh>
#include <ObjectTypes/HexahedralMesh/OpenFlipperHexahedralMesh.hh>
/// Typedef for a mesh object containing a polyhedral mesh
typedef VolumeMeshObject< HexahedralMesh > HexahedralMeshObject;
#include <ObjectTypes/HexahedralMesh/PluginFunctionsHexahedralMesh.hh>
//=============================================================================
#endif // HEXAHEDRAL_MESH_INCLUDE_HH defined
//=============================================================================
/*===========================================================================*\
* *
* OpenFlipper *
* Copyright (C) 2001-2011 by Computer Graphics Group, RWTH Aachen *
* www.openflipper.org *
* *
*--------------------------------------------------------------------------- *
* This file is part of OpenFlipper. *
* *
* OpenFlipper 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. *
* *
* OpenFlipper 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 OpenFlipper. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
/*===========================================================================*\
* *
* $Revision: 13489 $ *
* $LastChangedBy: kremer $ *
* $Date: 2012-01-25 12:30:09 +0100 (Wed, 25 Jan 2012) $ *
* *
\*===========================================================================*/
/**
* \file OpenFlipperHexahedralMesh.hh
* This class extends the polyhedral mesh base class provided
* by OpenVolumeMesh by color property extensions
*/
#ifndef OPENFLIPPER_HEXAHEDRAL_MESH_INCLUDE_HH
#define OPENFLIPPER_HEXAHEDRAL_MESH_INCLUDE_HH
//== INCLUDES =================================================================
#include <string>
#include <ACG/Math/VectorT.hh>
#include <OpenVolumeMesh/HexahedralMesh/HexahedralMesh.hh>
//== NAMESPACE ================================================================
namespace OpenVolumeMesh {
//== CLASS DEF ================================================================
template < typename VecT >
class ColorHexahedralMesh : public HexahedralMesh<VecT> {
public:
ColorHexahedralMesh() :
str_vc_prop_("Vertex Colors"),
str_ec_prop_("Edge Colors"),
str_hec_prop_("HalfEdge Colors"),
str_fc_prop_("Face Colors"),
str_hfc_prop_("HalfFace Colors"),
str_cc_prop_("Cell Colors"),
vcolors_available_(false),
ecolors_available_(false),
hecolors_available_(false),
fcolors_available_(false),
hfcolors_available_(false),
ccolors_available_(false) {
// Request statuses for all entities
HexahedralMesh<VecT>::request_status();
}
virtual ~ColorHexahedralMesh() {
release_vertex_colors();
release_edge_colors();
release_halfedge_colors();
release_face_colors();
release_halfface_colors();
release_cell_colors();
}
//==================
// Vertices
//==================
void request_vertex_colors() {
HexahedralMesh<VecT>::add_property(vc_prop_, str_vc_prop_);
vcolors_available_ = true;
}
void release_vertex_colors() {
if(vcolors_available_) {
HexahedralMesh<VecT>::remove_property(vc_prop_);
}
}
bool has_vertex_colors() const {
return vcolors_available_;
}
void vertex_color(const VertexHandle& _vh, const ACG::Vec4f& _c) {
if(vcolors_available_) {
HexahedralMesh<VecT>::property(vc_prop_, _vh) = _c;
}
}
const ACG::Vec4f& vertex_color(const VertexHandle& _vh) const {
if(vcolors_available_) {
return HexahedralMesh<VecT>::property(vc_prop_, _vh);
}
}
//==================
// Edges
//==================
void request_edge_colors() {
HexahedralMesh<VecT>::add_property(ec_prop_, str_ec_prop_);
ecolors_available_ = true;
}
void release_edge_colors() {
if(ecolors_available_) {
HexahedralMesh<VecT>::remove_property(ec_prop_);
}
}
bool has_edge_colors() const {
return ecolors_available_;
}
void edge_color(const EdgeHandle& _eh, const ACG::Vec4f& _c) {
if(ecolors_available_) {
HexahedralMesh<VecT>::property(ec_prop_, _eh) = _c;
}
}
const ACG::Vec4f& edge_color(const EdgeHandle& _eh) const {
if(ecolors_available_) {
return HexahedralMesh<VecT>::property(ec_prop_, _eh);
}
}
//==================
// Half-Edges
//==================
void request_halfedge_colors() {
HexahedralMesh<VecT>::add_property(hec_prop_, str_hec_prop_);
hecolors_available_ = true;
}
void release_halfedge_colors() {
if(hecolors_available_) {
HexahedralMesh<VecT>::remove_property(hec_prop_);
}
}
bool has_halfedge_colors() const {
return hecolors_available_;
}
void halfedge_color(const HalfEdgeHandle& _heh, const ACG::Vec4f& _c) {
if(hecolors_available_) {
HexahedralMesh<VecT>::property(hec_prop_, _heh) = _c;
}
}
const ACG::Vec4f& halfedge_color(const HalfEdgeHandle& _heh) const {
if(hecolors_available_) {
return HexahedralMesh<VecT>::property(hec_prop_, _heh);
}
}
//==================
// Faces
//==================
void request_face_colors() {
HexahedralMesh<VecT>::add_property(fc_prop_, str_fc_prop_);
fcolors_available_ = true;
}
void release_face_colors() {
if(fcolors_available_) {
HexahedralMesh<VecT>::remove_property(fc_prop_);
}
}
bool has_face_colors() const {
return fcolors_available_;
}
void face_color(const FaceHandle& _fh, const ACG::Vec4f& _c) {
if(fcolors_available_) {
HexahedralMesh<VecT>::property(fc_prop_, _fh) = _c;
}
}
const ACG::Vec4f& face_color(const FaceHandle& _fh) const {
if(fcolors_available_) {
return HexahedralMesh<VecT>::property(fc_prop_, _fh);
}
}
//==================
// Half-Faces
//==================
void request_halfface_colors() {
HexahedralMesh<VecT>::add_property(hfc_prop_, str_hfc_prop_);
hfcolors_available_ = true;
}
void release_halfface_colors() {
if(hfcolors_available_) {
HexahedralMesh<VecT>::remove_property(hfc_prop_);
}
}
bool has_halfface_colors() const {
return hfcolors_available_;
}
void halfface_color(const HalfFaceHandle& _hfh, const ACG::Vec4f& _c) {
if(hfcolors_available_) {
HexahedralMesh<VecT>::property(hfc_prop_, _hfh) = _c;
}
}
const ACG::Vec4f& halfface_color(const HalfFaceHandle& _hfh) const {
if(hfcolors_available_) {
return HexahedralMesh<VecT>::property(hfc_prop_, _hfh);
}
}
//==================
// Cells
//==================
void request_cell_colors() {
HexahedralMesh<VecT>::add_property(cc_prop_, str_cc_prop_);
ccolors_available_ = true;
}
void release_cell_colors() {
if(ccolors_available_) {
HexahedralMesh<VecT>::remove_property(cc_prop_);
}
}
bool has_cell_colors() const {
return ccolors_available_;
}
void cell_color(const CellHandle& _ch, const ACG::Vec4f& _c) {
if(ccolors_available_) {
HexahedralMesh<VecT>::property(cc_prop_, _ch) = _c;
}
}
const ACG::Vec4f& cell_color(const CellHandle& _ch) const {
if(ccolors_available_) {
return HexahedralMesh<VecT>::property(cc_prop_, _ch);
}
}
private:
// Constants
const std::string str_vc_prop_;
const std::string str_ec_prop_;
const std::string str_hec_prop_;
const std::string str_fc_prop_;
const std::string str_hfc_prop_;
const std::string str_cc_prop_;
// Property handles
VPropHandleT<ACG::Vec4f> vc_prop_;
EPropHandleT<ACG::Vec4f> ec_prop_;
HEPropHandleT<ACG::Vec4f> hec_prop_;
FPropHandleT<ACG::Vec4f> fc_prop_;
HFPropHandleT<ACG::Vec4f> hfc_prop_;
CPropHandleT<ACG::Vec4f> cc_prop_;
// Availability flags
bool vcolors_available_;
bool ecolors_available_;
bool hecolors_available_;
bool fcolors_available_;
bool hfcolors_available_;
bool ccolors_available_;
};
} // Namespace OpenVolumeMesh
// Typedef for default mesh type
typedef OpenVolumeMesh::ColorHexahedralMesh<ACG::Vec3d> HexahedralMesh;
//=============================================================================
#endif // OPENFLIPPER_HEXAHEDRAL_MESH_INCLUDE_HH defined
//=============================================================================
/*===========================================================================*\
* *
* OpenFlipper *
* Copyright (C) 2001-2011 by Computer Graphics Group, RWTH Aachen *
* www.openflipper.org *
* *
*--------------------------------------------------------------------------- *
* This file is part of OpenFlipper. *
* *
* OpenFlipper 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. *
* *
* OpenFlipper 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 OpenFlipper. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
/*===========================================================================*\
* *
* $Revision: 13489 $ *
* $LastChangedBy: kremer $ *
* $Date: 2012-01-25 12:30:09 +0100 (Wed, 25 Jan 2012) $ *
* *
\*===========================================================================*/
#include <OpenFlipper/common/Types.hh>
#include <ObjectTypes/HexahedralMesh/PluginFunctionsHexahedralMesh.hh>
#include <OpenFlipper/BasePlugin/PluginFunctions.hh>
namespace PluginFunctions {
// ===============================================================================
// Get source meshes
// ===============================================================================
bool getSourceMeshes( std::vector<HexahedralMesh*>& _meshes )
{
_meshes.clear();
for ( ObjectIterator o_it(PluginFunctions::SOURCE_OBJECTS,DATA_HEXAHEDRAL_MESH) ;
o_it != PluginFunctions::objectsEnd(); ++o_it) {
_meshes.push_back ( PluginFunctions::hexahedralMesh( *o_it ) );
if( _meshes.back() == NULL)
std::cerr << "ERROR: HexahedralMesh getSourceMeshes fatal error\n";
}
return (_meshes.size() > 0 );
}
// ===============================================================================
// Get target meshes
// ===============================================================================
bool getTargetMeshes( std::vector<HexahedralMesh*>& _meshes )
{
_meshes.clear();
for ( ObjectIterator o_it(PluginFunctions::TARGET_OBJECTS,DATA_HEXAHEDRAL_MESH ) ;
o_it != PluginFunctions::objectsEnd(); ++o_it) {
_meshes.push_back ( PluginFunctions::hexahedralMesh( *o_it ) );
if( _meshes.back() == NULL)
std::cerr << "ERROR: HexahedralMesh getTargetMeshes fatal error\n";
}
return (_meshes.size() > 0 );
}
// ===============================================================================
// Get objects
// ===============================================================================
bool getObject( int _identifier, HexahedralMeshObject*& _object ) {
if ( _identifier == -1 ) {
_object = 0;
return false;
}
BaseObject* object = objectRoot()->childExists( _identifier );
_object = dynamic_cast< HexahedralMeshObject* >(object);
return ( _object != 0 );
}
// ===============================================================================
// Getting data from objects and casting between them
// ===============================================================================
HexahedralMesh* hexahedralMesh( BaseObjectData* _object ) {
if ( _object->dataType(DATA_HEXAHEDRAL_MESH) ) {
HexahedralMeshObject* object = dynamic_cast< HexahedralMeshObject* >(_object);
return object->mesh();
} else
return 0;
}
HexahedralMeshObject* hexahedralMeshObject( BaseObjectData* _object ) {
if ( ! _object->dataType(DATA_HEXAHEDRAL_MESH) )
return 0;
return dynamic_cast< HexahedralMeshObject* >( _object );
}
HexahedralMeshObject* hexahedralMeshObject( int _identifier )
{
HexahedralMeshObject* pol_obj;
if(getObject(_identifier, pol_obj))
return pol_obj;
else
return 0;
}
}
/*===========================================================================*\
* *
* OpenFlipper *
* Copyright (C) 2001-2011 by Computer Graphics Group, RWTH Aachen *
* www.openflipper.org *
* *
*--------------------------------------------------------------------------- *
* This file is part of OpenFlipper. *
* *
* OpenFlipper 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. *
* *
* OpenFlipper 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 OpenFlipper. If not, *
* see <http://www.gnu.org/licenses/>. *
* *
\*===========================================================================*/
/*===========================================================================*\
* *
* $Revision: 13489 $ *
* $LastChangedBy: kremer $ *
* $Date: 2012-01-25 12:30:09 +0100 (Wed, 25 Jan 2012) $ *
* *
\*===========================================================================*/
/**
* \file PluginFunctionsHexahedralMesh.hh
* This file contains functions which can be used by plugins to access
* HexahedralMeshes in the framework.
*/
//
#ifndef PLUGINFUNCTIONSHEXAHEDRALMESH_HH
#define PLUGINFUNCTIONSHEXAHEDRALMESH_HH
#include <ObjectTypes/VolumeMeshObject/VolumeMeshObject.hh>
#include <ObjectTypes/HexahedralMesh/HexahedralMesh.hh>
#include <OpenFlipper/common/Types.hh>
//== NAMESPACES ===============================================================
/** The Namespace PluginFunctions contains functions for all plugins. */
namespace PluginFunctions {
/** \brief Get a pointer to every HexahedralMesh which is marked as a source.
*
* @param _meshes ( vector returning the source hexahedral meshes )
* @return false, if no hexahedral mesh is selected as source
*/
DLLEXPORT
bool getSourceMeshes( std::vector<HexahedralMesh*>& _meshes );
/** \brief Get a pointer to every HexahedralMesh which is marked as a target.
*
* @param _meshes ( vector returning the target hexahedral meshes )
* @return false, if no hexahedral mesh is selected as target
*/
DLLEXPORT
bool getTargetMeshes( std::vector<HexahedralMesh*>& _meshes );
/** This functions returns the object with the given id if it is an HexahedralMeshObject.
* See get_object( int _identifier , BaseObject*& _object ) for more details.
*/
DLLEXPORT
bool getObject( int _identifier, HexahedralMeshObject*& _object );
/** \brief Get an HexahedralMesh from an object.
*
* @param _object The object should be of type BaseDataObject. If the content is
* a hexahedral mesh, a hexahedral mesh will be returned. Otherwise a NULL pointer is returned.
*/
DLLEXPORT
HexahedralMesh* hexahedralMesh( BaseObjectData* _object );
/** \brief Cast an BaseObject to an HexahedralMeshObject if possible
*
* @param _object The object should be of type BaseDataObject. If the content is
* an HexahedralMesh, an HexahedralMeshObject is returned. Otherwise a NULL pointer is returned.
*/
DLLEXPORT