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

Added volume mesh selection plugin.

git-svn-id: http://www.openflipper.org/svnrepo/OpenFlipper/branches/Free@13875 383ad7c9-94d9-4d36-a494-682f7c89f535
parent 10d4cb23
include (plugin)
if (EXISTS ${CMAKE_SOURCE_DIR}/ObjectTypes/HexahedralMesh)
openflipper_plugin (INSTALLDATA Icons)
endif()
#include "VolumeMeshSelectionPlugin.hh"
//void VolumeMeshSelectionPlugin::selectAllVertices(int _objectId) {
//
// BaseObjectData* object = 0;
//
// if(!PluginFunctions::getObject(_objectId, object)) {
// emit log(LOGERR, tr("Could not get object with id %1").arg(_objectId));
// return;
// }
//
// PolyhedralMesh* volumemesh = PluginFunctions::polyhedralMesh(object);
// if(!volumemesh) volumemesh = dynamic_cast<PolyhedralMesh*>(PluginFunctions::hexahedralMesh(object));
//
// if(volumemesh) {
//
// for(unsigned int i = 0; i < volumemesh->n_vertices(); ++i) {
// volumemesh->select_vertex(i);
// }
// }
//
// emit scriptInfo("selectAllVertices(ObjectId)");
//}
//
//void VolumeMeshSelectionPlugin::deselectAllVertices(int _objectId) {
//
// BaseObjectData* object = 0;
//
// if(!PluginFunctions::getObject(_objectId, object)) {
// emit log(LOGERR, tr("Could not get object with id %1").arg(_objectId));
// return;
// }
//
// PolyhedralMesh* volumemesh = PluginFunctions::polyhedralMesh(object);
// if(!volumemesh) volumemesh = dynamic_cast<PolyhedralMesh*>(PluginFunctions::hexahedralMesh(object));
//
// if(volumemesh) {
//
// for(unsigned int i = 0; i < volumemesh->n_vertices(); ++i) {
// volumemesh->deselect_vertex(i);
// }
// }
//
// emit scriptInfo("deselectAllVertices(ObjectId)");
//}
//
//void VolumeMeshSelectionPlugin::invertVertexSelection(int _objectId) {
//
// BaseObjectData* object = 0;
//
// if(!PluginFunctions::getObject(_objectId, object)) {
// emit log(LOGERR, tr("Could not get object with id %1").arg(_objectId));
// return;
// }
//
// PolyhedralMesh* volumemesh = PluginFunctions::polyhedralMesh(object);
// if(!volumemesh) volumemesh = dynamic_cast<PolyhedralMesh*>(PluginFunctions::hexahedralMesh(object));
//
// if(volumemesh) {
//
// for(unsigned int i = 0; i < volumemesh->n_vertices(); ++i) {
//
// if(volumemesh->vertex_selected(i))
// volumemesh->deselect_vertex(i);
// else
// volumemesh->select_vertex(i);
// }
// }
//
// emit scriptInfo("invertVertexSelection(ObjectId)");
//}
//
//void VolumeMeshSelectionPlugin::selectVertices(int _objectId, const IdList _ids, bool _deselect) {
//
// if(_ids.size() == 0) return;
//
// BaseObjectData* object = 0;
//
// if(!PluginFunctions::getObject(_objectId, object)) {
// emit log(LOGERR, tr("Could not get object with id %1").arg(_objectId));
// return;
// }
//
// PolyhedralMesh* volumemesh = PluginFunctions::polyhedralMesh(object);
// if(!volumemesh) volumemesh = dynamic_cast<PolyhedralMesh*>(PluginFunctions::hexahedralMesh(object));
//
// if(volumemesh) {
// for(IdList::const_iterator it = _ids.begin(); it != _ids.end(); ++it) {
// if(*it < (int)volumemesh->n_vertices()) {
// if(_deselect) volumemesh->deselect_vertex(*it);
// else volumemesh->select_vertex(*it);
// }
// }
// }
//
// QString selection = "selectVertices(ObjectId, [ " + QString::number(_ids[0]);
//
// for (uint i = 1 ; i < _ids.size(); ++i) {
// selection += ", " + QString::number(_ids[i]);
// }
//
// selection += " ])";
//
// emit scriptInfo(selection);
//}
//
//IdList VolumeMeshSelectionPlugin::getVertexSelection(int _objectId) {
//
// BaseObjectData* object = 0;
//
// IdList list;
//
// if(!PluginFunctions::getObject(_objectId, object)) {
// emit log(LOGERR, tr("Could not get object with id %1").arg(_objectId));
// return list;
// }
//
// PolyhedralMesh* volumemesh = PluginFunctions::polyhedralMesh(object);
// if(!volumemesh) volumemesh = dynamic_cast<PolyhedralMesh*>(PluginFunctions::hexahedralMesh(object));
//
// if(volumemesh) {
//
// for(unsigned int i = 0; i < volumemesh->n_vertices(); ++i) {
// if(volumemesh->vertex_selected(i))
// list.push_back(i);
// }
// }
//
// return list;
//}
//
////=======================================================================================
//
//void VolumeMeshSelectionPlugin::selectAllEdges(int _objectId) {
//
// BaseObjectData* object = 0;
//
// if (!PluginFunctions::getObject(_objectId, object)) {
// emit log(LOGERR, tr("Could not get object with id %1").arg(_objectId));
// return;
// }
//
// PolyhedralMesh* volumemesh = PluginFunctions::polyhedralMesh(object);
// if(!volumemesh) volumemesh = dynamic_cast<PolyhedralMesh*>(PluginFunctions::hexahedralMesh(object));
//
// if (volumemesh) {
//
// for(unsigned int i = 0; i < volumemesh->n_edges(); ++i) {
// volumemesh->select_edge(i);
// }
// }
//
// emit scriptInfo("selectAllEdges(ObjectId)");
//}
//
//void VolumeMeshSelectionPlugin::deselectAllEdges(int _objectId) {
//
// BaseObjectData* object = 0;
//
// if (!PluginFunctions::getObject(_objectId, object)) {
// emit log(LOGERR, tr("Could not get object with id %1").arg(_objectId));
// return;
// }
//
// PolyhedralMesh* volumemesh = PluginFunctions::polyhedralMesh(object);
// if(!volumemesh) volumemesh = dynamic_cast<PolyhedralMesh*>(PluginFunctions::hexahedralMesh(object));
//
// if (volumemesh) {
//
// for(unsigned int i = 0; i < volumemesh->n_edges(); ++i) {
// volumemesh->deselect_edge(i);
// }
// }
//
// emit scriptInfo("deselectAllEdges(ObjectId)");
//}
//
//void VolumeMeshSelectionPlugin::invertEdgeSelection(int _objectId) {
//
// BaseObjectData* object = 0;
//
// if (!PluginFunctions::getObject(_objectId, object)) {
// emit log(LOGERR, tr("Could not get object with id %1").arg(_objectId));
// return;
// }
//
// PolyhedralMesh* volumemesh = PluginFunctions::polyhedralMesh(object);
// if(!volumemesh) volumemesh = dynamic_cast<PolyhedralMesh*>(PluginFunctions::hexahedralMesh(object));
//
// if (volumemesh) {
//
// for(unsigned int i = 0; i < volumemesh->n_edges(); ++i) {
// if(volumemesh->edge_selected(i))
// volumemesh->deselect_edge(i);
// else
// volumemesh->select_edge(i);
// }
// }
//
// emit scriptInfo("deselectAllEdges(ObjectId)");
//}
//
//void VolumeMeshSelectionPlugin::selectEdges(int _objectId, const IdList _ids, bool _deselect) {
//
// if(_ids.size() == 0) return;
//
// BaseObjectData* object = 0;
//
// if (!PluginFunctions::getObject(_objectId, object)) {
// emit log(LOGERR, tr("Could not get object with id %1").arg(_objectId));
// return;
// }
//
// PolyhedralMesh* volumemesh = PluginFunctions::polyhedralMesh(object);
// if (volumemesh) {
// for (IdList::const_iterator it = _ids.begin(); it != _ids.end(); ++it) {
//
// if(*it < (int)volumemesh->n_edges()) {
// if(_deselect) volumemesh->deselect_edge(*it);
// else volumemesh->select_edge(*it);
// }
// }
// }
//
// QString selection = "selectEdges(ObjectId, [ " + QString::number(_ids[0]);
//
// for (uint i = 1 ; i < _ids.size(); ++i) {
// selection += ", " + QString::number(_ids[i]);
// }
//
// selection += " ])";
//
// emit scriptInfo(selection);
//}
//
//IdList VolumeMeshSelectionPlugin::getEdgeSelection(int _objectId) {
//
// BaseObjectData* object = 0;
//
// IdList list;
//
// if(!PluginFunctions::getObject(_objectId, object)) {
// emit log(LOGERR, tr("Could not get object with id %1").arg(_objectId));
// return list;
// }
//
// PolyhedralMesh* volumemesh = PluginFunctions::polyhedralMesh(object);
// if(volumemesh) {
//
// for(unsigned int i = 0; i < volumemesh->n_edges(); ++i) {
// if(volumemesh->edge_selected(i))
// list.push_back(i);
// }
// }
//
// return list;
//}
void VolumeMeshSelectionPlugin::deleteSelectedCells(int _objectId) {
BaseObjectData* object = 0;
if(!PluginFunctions::getObject(_objectId, object)) {
emit log(LOGERR, tr("Could not get object with id %1").arg(_objectId));
return;
}
PolyhedralMeshObject* polyMeshObject = PluginFunctions::polyhedralMeshObject(object);
if(!polyMeshObject) {
emit log(LOGERR, tr("Could not cast object to VolumeMeshObject"));
return;
}
PolyhedralMesh* volumemesh = PluginFunctions::polyhedralMesh(object);
if(volumemesh) {
for(OpenVolumeMesh::CellIter c_it = volumemesh->cells_begin();
c_it != volumemesh->cells_end(); ++c_it) {
if(polyMeshObject->status()[*c_it].selected()) {
polyMeshObject->status()[*c_it].set_deleted(true);
}
}
polyMeshObject->status().garbage_collection();
return;
}
HexahedralMeshObject* hexMeshObject = PluginFunctions::hexahedralMeshObject(object);
HexahedralMesh* hexmesh = PluginFunctions::hexahedralMesh(object);
if(hexmesh) {
for(OpenVolumeMesh::CellIter c_it = hexmesh->cells_begin();
c_it != hexmesh->cells_end(); ++c_it) {
if(hexMeshObject->status()[*c_it].selected()) {
hexMeshObject->status()[*c_it].set_deleted(true);
}
}
hexMeshObject->status().garbage_collection();
return;
}
}
This diff is collapsed.
/*===========================================================================*\
* *
* OpenFlipper *
* Copyright (C) 2001-2010 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: 11942 $ *
* $Author: kremer $ *
* $Date: 2011-07-06 15:10:17 +0200 (Wed, 06 Jul 2011) $ *
* *
\*===========================================================================*/
#ifndef VOLUMEMESHSELECTIONPLUGIN_HH
#define VOLUMEMESHSELECTIONPLUGIN_HH
#include <QObject>
#include <OpenFlipper/BasePlugin/BaseInterface.hh>
#include <OpenFlipper/BasePlugin/KeyInterface.hh>
#include <OpenFlipper/BasePlugin/LoggingInterface.hh>
#include <OpenFlipper/BasePlugin/ToolboxInterface.hh>
#include <OpenFlipper/BasePlugin/ToolbarInterface.hh>
#include <OpenFlipper/BasePlugin/LoadSaveInterface.hh>
#include <OpenFlipper/BasePlugin/BackupInterface.hh>
#include <OpenFlipper/BasePlugin/INIInterface.hh>
#include <OpenFlipper/BasePlugin/ScriptInterface.hh>
#include <OpenFlipper/BasePlugin/SelectionInterface.hh>
#include <OpenFlipper/common/Types.hh>
#include <OpenFlipper/BasePlugin/PluginFunctions.hh>
#include <OpenFlipper/INIFile/INIFile.hh>
#include <ObjectTypes/PolyhedralMesh/PolyhedralMesh.hh>
#include <ObjectTypes/HexahedralMesh/HexahedralMesh.hh>
class VolumeMeshSelectionPlugin : public QObject, BaseInterface, KeyInterface,
INIInterface, BackupInterface, LoggingInterface, ScriptInterface, SelectionInterface
{
Q_OBJECT
Q_INTERFACES(BaseInterface)
Q_INTERFACES(KeyInterface)
Q_INTERFACES(INIInterface)
Q_INTERFACES(BackupInterface)
Q_INTERFACES(LoggingInterface)
Q_INTERFACES(ScriptInterface)
Q_INTERFACES(SelectionInterface)
public:
/// IdList type
typedef std::vector<int> IdList;
/// Default constructor
VolumeMeshSelectionPlugin();
/// Default destructor
~VolumeMeshSelectionPlugin();
signals:
// BaseInterface
void updateView();
void updatedObject(int, const UpdateType);
void nodeVisibilityChanged(int _identifier);
void setSlotDescription(QString _slotName, QString _slotDescription,
QStringList _parameters, QStringList _descriptions);
// LoggingInterface
void log(Logtype _type, QString _message);
void log(QString _message);
// ScriptInterface
void scriptInfo(QString _functionName);
// SelectionInterface
void addSelectionEnvironment(QString _modeName, QString _description, QIcon _icon, QString& _handleName);
void registerType(QString _handleName, DataType _type);
void addPrimitiveType(QString _handleName, QString _name, QIcon _icon, SelectionInterface::PrimitiveType& _typeHandle);
void addSelectionOperations(QString _handleName, QStringList _operationsList, QString _category, SelectionInterface::PrimitiveType _type = 0u);
void showToggleSelectionMode(QString _handleName, bool _show, SelectionInterface::PrimitiveType _associatedTypes);
void showVolumeLassoSelectionMode(QString _handleName, bool _show, SelectionInterface::PrimitiveType _associatedTypes);
void addCustomSelectionMode(QString _handleName, QString _modeName, QString _description, QIcon _icon,
SelectionInterface::PrimitiveType _associatedTypes, QString& _customIdentifier);
void getActiveDataTypes(SelectionInterface::TypeList& _types);
void getActivePrimitiveType(SelectionInterface::PrimitiveType& _type);
void targetObjectsOnly(bool& _targetsOnly);
void registerKeyShortcut(int _key, Qt::KeyboardModifiers _modifiers = Qt::NoModifier);
private slots:
// INIInterface
void loadIniFile(INIFile& _ini, int _id);
void saveIniFile(INIFile& _ini, int _id);
// BaseInterface
void initializePlugin();
void pluginsInitialized();
void noguiSupported() {};
// SelectionInterface
void slotSelectionOperation(QString _operation);
void slotToggleSelection(QMouseEvent* _event, SelectionInterface::PrimitiveType _currentType, bool _deselect);
void slotCustomSelection(QMouseEvent *_event, SelectionInterface::PrimitiveType _currentType, QString _customIdentifier, bool _deselect);
void slotLoadSelection(const INIFile& _file);
void slotSaveSelection(INIFile& _file);
void slotKeyShortcutEvent(int _key, Qt::KeyboardModifiers _modifiers);
public slots:
// SelectionInterface
void loadSelection(int _objId, const QString& _filename);
public:
// BaseInterface
QString name() {
return (QString(tr("VolumeMesh Selection")));
};
QString description() {
return (QString(tr("Allows to select VolumeMeshes")));
};
//===========================================================================
/** @name Private methods
* @{ */
//===========================================================================
private:
/// Set slot descriptions for scripting functions
void updateSlotDescriptions();
/** @} */
public slots:
QString version() {
return QString("1.0");
};
//===========================================================================
/** @name Scriptable slots
* @{ */
//===========================================================================
// /// Select all vertices of a volume mesh
// void selectAllVertices(int _objectId);
//
// /// Deselect all vertices of a volume mesh
// void deselectAllVertices(int _objectId);
//
// /// Invert vertex selection
// void invertVertexSelection(int _objectId);
//
// /// Select specific vertices of a volume mesh
// void selectVertices(int _objectId, const IdList _ids, bool _deselect = false);
//
// /// Get current vertex selection
// IdList getVertexSelection(int _objectId);
//
// //===========================================================================
//
// /// Select all edges of a volume mesh
// void selectAllEdges(int _objectId);
//
// /// Deselect all edges of a volume mesh
// void deselectAllEdges(int _objectId);
//
// /// Invert edge selection
// void invertEdgeSelection(int _objectId);
//
// /// Select specific edges of a volume mesh
// void selectEdges(int _objectId, const IdList _ids, bool _deselect = false);
//
// /// Get current edge selection
// IdList getEdgeSelection(int _objectId);
//
// //===========================================================================
//
// /// Select all faces of a volume mesh
// void selectAllFaces(int _objectId);
//
// /// Deselect all faces of a volume mesh
// void deselectAllFaces(int _objectId);
//
// /// Invert face selection
// void invertFaceSelection(int _objectId);
//
// /// Select specific faces of a volume mesh
// void selectFaces(int _objectId, const IdList _ids, bool _deselect = false);
//
// /// Get current face selection
// IdList getFaceSelection(int _objectId);
//
// //===========================================================================
//
// /// Select all cells of a volume mesh
// void selectAllCells(int _objectId);
//
// /// Deselect all cells of a volume mesh
// void deselectAllCells(int _objectId);
//
// /// Invert cell selection
// void invertCellSelection(int _objectId);
//
// /// Select specific cells of a volume mesh
// void selectCells(int _objectId, const IdList _ids, bool _deselect = false);
//
// /// Get current cell selection
// IdList getCellSelection(int _objectId);
/// Delete selected cells from mesh
void deleteSelectedCells(int _objectId);
/** @} */
//===========================================================================
/** @name Member variables
* @{ */
//===========================================================================
private:
// Get orthogonal orientation of neighboring cell
unsigned char getOrthogonalOrientationOfNeighborCell(const OpenVolumeMesh::CellHandle& _ch1,
const OpenVolumeMesh::CellHandle& _ch2, unsigned char _firstOrthDirection, const HexahedralMesh* _mesh) const;
// Get face shared by two adjacent cells
typedef std::pair<OpenVolumeMesh::HalfFaceHandle,OpenVolumeMesh::HalfFaceHandle> HFPair;
HFPair getCommonFace(const OpenVolumeMesh::CellHandle& _ch1,
const OpenVolumeMesh::CellHandle& _ch2, const HexahedralMesh* _mesh) const;
/// Handle to selection environment
QString environmentHandle_;
QString columnSelectionHandle_;
QString sheetSelectionHandle_;
/// Primitive type handles:
PrimitiveType vertexType_;
PrimitiveType edgeType_;
PrimitiveType faceType_;
PrimitiveType cellType_;
PrimitiveType allSupportedTypes_;
/// Keep volume lasso points
QVector<QPoint> volumeLassoPoints_;
// Store last picked cell for sheet selection
OpenVolumeMesh::CellHandle lastPickedCell_;
unsigned char lastPickedOrientation_;