diff --git a/Modules/QtWidgetsExt/QmitkApplicationBase/QmitkIOUtil.h b/Modules/QtWidgetsExt/QmitkApplicationBase/QmitkIOUtil.h index cb3d33316b..396785b0f2 100644 --- a/Modules/QtWidgetsExt/QmitkApplicationBase/QmitkIOUtil.h +++ b/Modules/QtWidgetsExt/QmitkApplicationBase/QmitkIOUtil.h @@ -1,103 +1,103 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef _QmitkIOUtil__h_ #define _QmitkIOUtil__h_ #include "MitkQtWidgetsExtExports.h" // std #include // mitk includes #include #include #include #include #include #include //Qt #include #include class MitkQtWidgetsExt_EXPORT QmitkIOUtil { /** * @brief QmitkIOUtil This is a static helper method to save any files with Qt dialogs. * Methods of opening files with dialogs are currently implemented in QmitkFileOpenAction.h. */ public: /** * @brief SaveBaseDataWithDialog Convenience method to save any data with a Qt dialog. * @param data BaseData holding the data you wish to save. * @param fileName The file name where to save the data (including path and extension). * @param parent An optional QWidget as parent. If no parent is supplied, the QFileDialog can occur anywhere on the screen. */ - static void SaveBaseDataWithDialog(BaseData *data, std::string fileName, QWidget* parent = NULL); + static void SaveBaseDataWithDialog(mitk::BaseData *data, std::string fileName, QWidget* parent = NULL); /** * @brief SaveSurfaceWithDialog Convenience method to save a surface with a Qt dialog. * @param surface The surface to save. * @param fileName The file name where to save the data (including path and extension). * @param parent An optional QWidget as parent. If no parent is supplied, the QFileDialog can occur anywhere on the screen. */ static void SaveSurfaceWithDialog(mitk::Surface::Pointer surface, std::string fileName = "", QWidget* parent = NULL); /** * @brief SaveImageWithDialog Convenience method to save an image with a Qt dialog. * @param image The image to save. * @param fileName The file name where to save the data (including path and extension). * @param parent An optional QWidget as parent. If no parent is supplied, the QFileDialog can occur anywhere on the screen. */ static void SaveImageWithDialog(mitk::Image::Pointer image, std::string fileName = "", QWidget* parent = NULL); /** * @brief SavePointSetWithDialog Convenience method to save a pointset with a Qt dialog. * @param pointset The pointset to save. * @param fileName The file name where to save the data (including path and extension). * @param parent An optional QWidget as parent. If no parent is supplied, the QFileDialog can occur anywhere on the screen. */ static void SavePointSetWithDialog(mitk::PointSet::Pointer pointset, std::string fileName = "", QWidget* parent = NULL); protected: /** * @brief GetFileNameWithQDialog Opens a QDialog and returns the filename. * @param caption Caption for the QDialog. * @param defaultFilename Default filename (e.g. "NewImage.nrrd" for images). * @param filter Filters the data according to data types (e.g. *.nrrd; *.png; etc. for images). * @param selectedFilter Default selected filter for the data. * @return The file name as QString. */ static QString GetFileNameWithQDialog(QString caption, QString defaultFilename, QString filter, QString* selectedFilter = 0, QWidget* parent = NULL); /** * @brief SaveToFileWriter Internal helper method to save data with writer's which have been supplied by extensions (e.g. TensorImage etc.). * @param fileWriter The writer supplied by an extension. * @param data The data to save in a specific format. * @param aFileName The filename. * @param propFileName Proposed file name? * @return false if writing attempt failed, true otherwise */ static bool SaveToFileWriter(mitk::FileWriterWithInformation::Pointer fileWriter, mitk::BaseData::Pointer data, const std::string fileName); }; #endif diff --git a/Modules/QtWidgetsExt/QmitkBoundingObjectWidget.cpp b/Modules/QtWidgetsExt/QmitkBoundingObjectWidget.cpp index 3de52bd5fe..fe8be5dc5d 100644 --- a/Modules/QtWidgetsExt/QmitkBoundingObjectWidget.cpp +++ b/Modules/QtWidgetsExt/QmitkBoundingObjectWidget.cpp @@ -1,450 +1,450 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkBoundingObjectWidget.h" #include #include #include #include #include #include #include #include #include #include #include #include #include QmitkBoundingObjectWidget::QmitkBoundingObjectWidget (QWidget* parent, Qt::WindowFlags f ):QWidget( parent, f ), m_DataStorage(NULL), m_lastSelectedItem(NULL), -m_lastAffineObserver(NULL), +m_lastAffineObserver(0), m_ItemNodeMap(), m_BoundingObjectCounter(1) { QBoxLayout* mainLayout = new QVBoxLayout(this); QHBoxLayout* buttonLayout = new QHBoxLayout(); QStringList boList; boList << tr("add") << tr("cube") << tr("cone") << tr("ellipse") << tr("cylinder"); m_addComboBox = new QComboBox(); m_addComboBox->addItems(boList); m_addComboBox->setItemIcon(1, QIcon(":/QmitkWidgetsExt/btnCube.xpm")); m_addComboBox->setItemIcon(2, QIcon(":/QmitkWidgetsExt/btnPyramid.xpm")); m_addComboBox->setItemIcon(3, QIcon(":/QmitkWidgetsExt/btnEllipsoid.xpm")); m_addComboBox->setItemIcon(4, QIcon(":/QmitkWidgetsExt/btnCylinder.xpm")); buttonLayout->addWidget(m_addComboBox); m_DelButton = new QPushButton("del"); buttonLayout->addWidget(m_DelButton); m_SaveButton = new QPushButton("save"); buttonLayout->addWidget(m_SaveButton); m_SaveButton->setEnabled(false); m_LoadButton = new QPushButton("load"); buttonLayout->addWidget(m_LoadButton); m_LoadButton->setEnabled(false); m_TreeWidget = new QTreeWidget(this); m_TreeWidget->setColumnCount(3); QStringList sList; sList << tr("name") << tr("inverted") << tr("visible"); m_TreeWidget->setHeaderLabels(sList); m_TreeWidget->setColumnWidth(0, 250); m_TreeWidget->setColumnWidth(1, 50); m_TreeWidget->setColumnWidth(2, 50); m_TreeWidget->setAutoScroll(true); m_TreeWidget->setSelectionMode(QAbstractItemView::SingleSelection); mainLayout->addWidget(m_TreeWidget); mainLayout->addLayout(buttonLayout); connect( m_addComboBox , SIGNAL(currentIndexChanged(int)), this, SLOT(CreateBoundingObject(int)) ); connect( m_TreeWidget, SIGNAL(itemSelectionChanged()), this, SLOT(SelectionChanged()) ); connect( m_DelButton, SIGNAL(clicked()), this, SLOT(OnDelButtonClicked()) ); connect(m_TreeWidget, SIGNAL(itemDoubleClicked(QTreeWidgetItem*, int)), this, SLOT(OnItemDoubleClicked(QTreeWidgetItem*, int)) ); connect(m_TreeWidget, SIGNAL(itemChanged(QTreeWidgetItem*, int)), this, SLOT(OnItemDataChanged(QTreeWidgetItem*, int)) ); } QmitkBoundingObjectWidget::~QmitkBoundingObjectWidget() { } void QmitkBoundingObjectWidget::setEnabled(bool flag) { ItemNodeMapType::iterator it = m_ItemNodeMap.begin(); while( it != m_ItemNodeMap.end()) { mitk::DataNode* node = it->second; QTreeWidgetItem* item = it->first; if (flag) node->SetVisibility(item->checkState(2)); else node->SetVisibility(flag); ++it; } QWidget::setEnabled(flag); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkBoundingObjectWidget::SelectionChanged() { QList selectedItems = m_TreeWidget->selectedItems(); if (selectedItems.size() < 1) return; QTreeWidgetItem* selectedItem = selectedItems.first(); if (selectedItem == m_lastSelectedItem) return; if (m_lastSelectedItem != NULL) { m_TreeWidget->closePersistentEditor(m_lastSelectedItem, 0); ItemNodeMapType::iterator it = m_ItemNodeMap.find(m_lastSelectedItem); if (it != m_ItemNodeMap.end()) { mitk::DataNode* last_node = it->second; //remove observer last_node->RemoveObserver(m_lastAffineObserver); //get and remove interactor mitk::AffineInteractor::Pointer last_interactor = dynamic_cast (last_node->GetInteractor()); if (last_interactor) mitk::GlobalInteraction::GetInstance()->RemoveInteractor(last_interactor); } } ItemNodeMapType::iterator it = m_ItemNodeMap.find(selectedItem); if (it == m_ItemNodeMap.end()) return; mitk::DataNode* new_node = it->second; mitk::AffineInteractor::Pointer new_interactor = mitk::AffineInteractor::New("AffineInteractions ctrl-drag", new_node); new_node->SetInteractor(new_interactor); mitk::GlobalInteraction::GetInstance()->AddInteractor(new_interactor); //create observer for node itk::ReceptorMemberCommand::Pointer command = itk::ReceptorMemberCommand::New(); command->SetCallbackFunction(this, &QmitkBoundingObjectWidget::OnBoundingObjectModified); m_lastAffineObserver = new_node->AddObserver(mitk::AffineInteractionEvent(), command); m_lastSelectedItem = selectedItem; } void QmitkBoundingObjectWidget::AddItem(mitk::DataNode* node) { mitk::BoundingObject* boundingObject; boundingObject = dynamic_cast (node->GetData()); std::string name; node->GetStringProperty("name", name); if (boundingObject) { QTreeWidgetItem* item = new QTreeWidgetItem(); item->setData(0, Qt::EditRole, QString::fromLocal8Bit(name.c_str())); item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled | Qt::ItemIsUserCheckable); //checkbox for positive flag item->setData(1, Qt::CheckStateRole, tr("")); item->setCheckState(1, Qt::Unchecked); //checkbox for visibleflag item->setData(2, Qt::CheckStateRole, tr("")); item->setCheckState(2, Qt::Checked); m_TreeWidget->addTopLevelItem(item); m_ItemNodeMap.insert(std::make_pair(item, node)); m_TreeWidget->selectAll(); QList items = m_TreeWidget->selectedItems(); for( int i = 0; isetItemSelected(items.at(i), false); } m_TreeWidget->setItemSelected(item, true); } else MITK_ERROR << name << " is not a bounding object or does not exist in data storage" << endl; } void QmitkBoundingObjectWidget::OnItemDoubleClicked(QTreeWidgetItem* item, int col) { if (col == 0) { m_TreeWidget->openPersistentEditor(item, col); } } void QmitkBoundingObjectWidget::OnItemDataChanged(QTreeWidgetItem *item, int col) { if (m_ItemNodeMap.size() < 1) return; ItemNodeMapType::iterator it = m_ItemNodeMap.find(item); if (it == m_ItemNodeMap.end()) return; mitk::DataNode* node = it->second; //name if (col == 0) { m_TreeWidget->closePersistentEditor(item, col); node->SetName(item->text(0).toLocal8Bit().data()); } //positive else if (col == 1) { mitk::BoundingObject* boundingObject = dynamic_cast (node->GetData()); if (boundingObject) boundingObject->SetPositive(!(item->checkState(1))); emit BoundingObjectsChanged(); } //visible else if (col == 2) { node->SetVisibility(item->checkState(2)); } mitk::RenderingManager::GetInstance()->RequestUpdateAll(); } void QmitkBoundingObjectWidget::RemoveItem() { //selection mode is set to single selection, so there should not be more than one selected item QList selectedItems = m_TreeWidget->selectedItems(); QTreeWidgetItem* item = selectedItems.first(); QString str = item->text(0); ItemNodeMapType::iterator it = m_ItemNodeMap.find(item); if (it == m_ItemNodeMap.end()) return; mitk::DataNode* node = it->second; mitk::BoundingObject* boundingObject; if (node) { boundingObject = dynamic_cast (node->GetData()); if (boundingObject) { //delete item; m_TreeWidget->takeTopLevelItem(m_TreeWidget->indexOfTopLevelItem(item)); m_ItemNodeMap.erase(m_ItemNodeMap.find(item)); m_DataStorage->Remove(node); } } } void QmitkBoundingObjectWidget::RemoveAllItems() { ItemNodeMapType::iterator it = m_ItemNodeMap.begin(); while( it != m_ItemNodeMap.end() ) { m_TreeWidget->takeTopLevelItem( m_TreeWidget->indexOfTopLevelItem(it->first) ); m_ItemNodeMap.erase(m_ItemNodeMap.find(it->first)); ++it; } m_BoundingObjectCounter = 1; } mitk::BoundingObject::Pointer QmitkBoundingObjectWidget::GetSelectedBoundingObject() { mitk::BoundingObject* boundingObject; mitk::DataNode* node = this->GetSelectedBoundingObjectNode(); if (node) { boundingObject = dynamic_cast (node->GetData()); if (boundingObject) return boundingObject; } return NULL; } void QmitkBoundingObjectWidget::SetDataStorage(mitk::DataStorage* dataStorage) { m_DataStorage = dataStorage; } mitk::DataStorage* QmitkBoundingObjectWidget::GetDataStorage() { return m_DataStorage; } void QmitkBoundingObjectWidget::OnDelButtonClicked() { RemoveItem(); } void QmitkBoundingObjectWidget::CreateBoundingObject(int type) { //get cross position mitk::Point3D pos; mitk::RenderingManager::RenderWindowVector windows = mitk::RenderingManager::GetInstance()->GetAllRegisteredRenderWindows(); //hopefully we have the renderwindows in the "normal" order const mitk::PlaneGeometry *plane1 = mitk::BaseRenderer::GetInstance(windows.at(0))->GetSliceNavigationController()->GetCurrentPlaneGeometry(); const mitk::PlaneGeometry *plane2 = mitk::BaseRenderer::GetInstance(windows.at(1))->GetSliceNavigationController()->GetCurrentPlaneGeometry(); const mitk::PlaneGeometry *plane3 = mitk::BaseRenderer::GetInstance(windows.at(2))->GetSliceNavigationController()->GetCurrentPlaneGeometry(); mitk::Line3D line; if ( (plane1 != NULL) && (plane2 != NULL) && (plane1->IntersectionLine( plane2, line )) ) { if ( !((plane3 != NULL) && (plane3->IntersectionPoint( line, pos ))) ) { return; } } if (type != 0) { mitk::BoundingObject::Pointer boundingObject; QString name; name.setNum(m_BoundingObjectCounter); switch (type-1) { case CUBOID: boundingObject = mitk::Cuboid::New(); name.prepend("Cube_"); break; case CONE: boundingObject = mitk::Cone::New(); name.prepend("Cone_"); break; case ELLIPSOID: boundingObject = mitk::Ellipsoid::New(); name.prepend("Ellipse_"); break; case CYLINDER: boundingObject = mitk::Cylinder::New(); name.prepend("Cylinder_"); break; default: return; break; } m_BoundingObjectCounter++; m_addComboBox->setCurrentIndex(0); // set initial size mitk::Vector3D size; size.Fill(10); boundingObject->GetGeometry()->SetSpacing( size ); boundingObject->GetGeometry()->Translate(pos.GetVectorFromOrigin()); boundingObject->GetTimeGeometry()->Update(); //create node mitk::DataNode::Pointer node = mitk::DataNode::New(); node->SetData( boundingObject); node->SetProperty("name", mitk::StringProperty::New( name.toLocal8Bit().data())); node->SetProperty("color", mitk::ColorProperty::New(0.0, 0.0, 1.0)); node->SetProperty("opacity", mitk::FloatProperty::New(0.7)); node->SetProperty("bounding object", mitk::BoolProperty::New(true)); node->SetProperty("helper object", mitk::BoolProperty::New(true)); m_DataStorage->Add(node); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); emit BoundingObjectsChanged(); AddItem(node); } } mitk::DataNode::Pointer QmitkBoundingObjectWidget::GetAllBoundingObjects() { mitk::DataNode::Pointer boundingObjectGroupNode = mitk::DataNode::New(); mitk::BoundingObjectGroup::Pointer boundingObjectGroup = mitk::BoundingObjectGroup::New(); boundingObjectGroup->SetCSGMode(mitk::BoundingObjectGroup::Union); mitk::NodePredicateProperty::Pointer prop = mitk::NodePredicateProperty::New("bounding object", mitk::BoolProperty::New(true)); mitk::DataStorage::SetOfObjects::ConstPointer allBO = m_DataStorage->GetSubset(prop); for (mitk::DataStorage::SetOfObjects::const_iterator it = allBO->begin(); it != allBO->end(); ++it) { mitk::DataNode::Pointer node = *it; mitk::BoundingObject::Pointer boundingObject = dynamic_cast (node->GetData()); if (boundingObject) boundingObjectGroup->AddBoundingObject(boundingObject); } boundingObjectGroupNode->SetData(boundingObjectGroup); if (boundingObjectGroup->GetCount() >0) return boundingObjectGroupNode; return NULL; } mitk::DataNode::Pointer QmitkBoundingObjectWidget::GetSelectedBoundingObjectNode() { QList selectedItems = m_TreeWidget->selectedItems(); if (selectedItems.size() <1) return NULL; QTreeWidgetItem* item = selectedItems.first(); mitk::DataNode* node = m_ItemNodeMap.find(item)->second; return node; } -void QmitkBoundingObjectWidget::OnBoundingObjectModified(const itk::EventObject& e) +void QmitkBoundingObjectWidget::OnBoundingObjectModified(const itk::EventObject&) { emit BoundingObjectsChanged(); } diff --git a/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsModel.cpp b/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsModel.cpp index 24af06bd4a..1135e759da 100644 --- a/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsModel.cpp +++ b/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsModel.cpp @@ -1,739 +1,739 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkCorrespondingPointSetsModel.h" #include #include "mitkInteractionConst.h" #include "mitkPointOperation.h" #include "mitkRenderingManager.h" #include #include #include #include #include #include #include -QmitkCorrespondingPointSetsModel::QmitkCorrespondingPointSetsModel( int t, QObject* parent ) -:QAbstractTableModel(parent), -m_PointSetNode(NULL), -m_ReferencePointSetNode(NULL), -m_TimeStepper(NULL), -m_Interactor(NULL), -m_MultiWidget( NULL ), -m_PointSetModifiedObserverTag(0), -m_ReferencePointSetModifiedObserverTag(0), -m_SelectedPointSetIndex(-1) +QmitkCorrespondingPointSetsModel::QmitkCorrespondingPointSetsModel(int, QObject* parent) + : QAbstractTableModel(parent), + m_PointSetNode(NULL), + m_ReferencePointSetNode(NULL), + m_TimeStepper(NULL), + m_SelectedPointSetIndex(-1), + m_Interactor(NULL), + m_MultiWidget( NULL ), + m_PointSetModifiedObserverTag(0), + m_ReferencePointSetModifiedObserverTag(0) { - ; } Qt::ItemFlags QmitkCorrespondingPointSetsModel::flags(const QModelIndex& index) const { if (index.isValid()) return Qt::ItemIsDragEnabled | Qt::ItemIsDropEnabled | Qt::ItemIsSelectable | Qt::ItemIsEnabled; else return Qt::ItemIsDropEnabled | Qt::ItemIsSelectable | Qt::ItemIsEnabled; } Qt::DropActions QmitkCorrespondingPointSetsModel::supportedDropActions() const { return Qt::CopyAction | Qt::MoveAction; } -bool QmitkCorrespondingPointSetsModel::dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent) +bool QmitkCorrespondingPointSetsModel::dropMimeData(const QMimeData*, Qt::DropAction action, int row, int, const QModelIndex &parent) { if (action == Qt::IgnoreAction) return true; int targetRow; if (row != -1) targetRow = row; else if (parent.isValid()) targetRow = parent.row(); else targetRow = rowCount(QModelIndex()); - this->MoveSelectedPoint(mitk::PointSet::PointIdentifier(targetRow)); + this->MoveSelectedPoint(targetRow); return true; } QmitkCorrespondingPointSetsModel::~QmitkCorrespondingPointSetsModel() { ; } void QmitkCorrespondingPointSetsModel::RemoveObservers(){ if (m_PointSetNode) { mitk::PointSet::Pointer oldPointSet = dynamic_cast(m_PointSetNode->GetData()); if (oldPointSet.IsNotNull()) { oldPointSet->RemoveObserver(m_PointSetModifiedObserverTag); } } if (m_ReferencePointSetNode) { mitk::PointSet::Pointer oldPointSet = dynamic_cast(m_ReferencePointSetNode->GetData()); if (oldPointSet.IsNotNull()) { oldPointSet->RemoveObserver(m_ReferencePointSetModifiedObserverTag); } } } void QmitkCorrespondingPointSetsModel::AddObservers() { mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode); if ( pointSet.IsNotNull()) { // add new observer for modified if necessary itk::ReceptorMemberCommand::Pointer modCommand = itk::ReceptorMemberCommand::New(); modCommand->SetCallbackFunction( this, &QmitkCorrespondingPointSetsModel::OnPointSetChanged ); m_PointSetModifiedObserverTag = pointSet->AddObserver( itk::ModifiedEvent(), modCommand ); } else { m_PointSetModifiedObserverTag = 0; } pointSet = this->CheckForPointSetInNode(m_ReferencePointSetNode); if ( pointSet.IsNotNull()) { // add new observer for modified if necessary itk::ReceptorMemberCommand::Pointer modCommand = itk::ReceptorMemberCommand::New(); modCommand->SetCallbackFunction( this, &QmitkCorrespondingPointSetsModel::OnPointSetChanged ); m_ReferencePointSetModifiedObserverTag = pointSet->AddObserver( itk::ModifiedEvent(), modCommand ); } else { m_ReferencePointSetModifiedObserverTag = 0; } } void QmitkCorrespondingPointSetsModel::OnPointSetChanged(const itk::EventObject&) { QAbstractTableModel::reset(); } void QmitkCorrespondingPointSetsModel::SetPointSetNodes( std::vector nodes ) { this->RemoveObservers(); if ( nodes.size() > 1 ) { m_PointSetNode = nodes.front(); m_ReferencePointSetNode = nodes.back(); } else if ( nodes.size() == 1 ) { m_PointSetNode = nodes.front(); m_ReferencePointSetNode = NULL; } else { m_PointSetNode = NULL; m_ReferencePointSetNode = NULL; } this->AddObservers(); QAbstractTableModel::reset(); } void QmitkCorrespondingPointSetsModel::SetTimeStep(int t) { if (!m_TimeStepper) return; m_TimeStepper->SetPos(t); QAbstractTableModel::reset(); } int QmitkCorrespondingPointSetsModel::GetTimeStep() const { if (!m_TimeStepper) return 0; return m_TimeStepper->GetPos(); } int QmitkCorrespondingPointSetsModel::rowCount(const QModelIndex&) const { if (!m_TimeStepper) return 0; mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode); mitk::PointSet::Pointer referencePointSet = this->CheckForPointSetInNode(m_ReferencePointSetNode); int sizePS = 0; int sizeRPS = 0; if ( pointSet.IsNotNull() ) { sizePS = pointSet->GetSize(m_TimeStepper->GetPos()); } if ( referencePointSet.IsNotNull() ) { sizeRPS = referencePointSet->GetSize(m_TimeStepper->GetPos()); } if ( sizePS > sizeRPS ) return sizePS; return sizeRPS; } int QmitkCorrespondingPointSetsModel::columnCount(const QModelIndex&) const { return 2; } QVariant QmitkCorrespondingPointSetsModel::data(const QModelIndex& index, int role) const { mitk::PointSet::Pointer pointSet = NULL; if ( index.column() == 0 ) pointSet = this->CheckForPointSetInNode(m_PointSetNode); else if ( index.column() == 1 ) pointSet = this->CheckForPointSetInNode(m_ReferencePointSetNode); if ( pointSet.IsNull() ) { return QVariant(); } if ( !index.isValid() ) { return QVariant(); } if ( index.row() >= pointSet->GetSize(m_TimeStepper->GetPos()) ) { return QVariant(); } if (role == Qt::DisplayRole) { - mitk::PointSet::PointsContainer::ElementIdentifier id; + int id; mitk::PointSet::PointType p; bool pointFound = this->GetPointForModelIndex(index, p, id); if (pointFound == false) return QVariant(); QString s = ""; bool firstProp = true; if (this->QTPropIdsEnabled()) { s.append(QString("%0").arg( id, 3)); firstProp = false; } if (this->QTPropCoordinatesEnabled()) { if(!firstProp) s.append(QString(": ")); s.append(QString("(%0, %1, %2)") .arg( p[0], 0, 'f', 2 ) .arg( p[1], 0, 'f', 2 ) .arg( p[2], 0, 'f', 2 )); } return QVariant(s); } else { return QVariant(); } } QVariant QmitkCorrespondingPointSetsModel::headerData(int section, Qt::Orientation orientation, int role) const { if (role != Qt::DisplayRole) { return QVariant(); } if (orientation == Qt::Horizontal) { if (section == 0) { if ( m_PointSetNode ) return QString::fromStdString(this->m_PointSetNode->GetName()); } else if (section == 1) { if ( m_ReferencePointSetNode ) return QString::fromStdString(this->m_ReferencePointSetNode->GetName()); } return QString(); } return QString("%1").arg(section); } -bool QmitkCorrespondingPointSetsModel::GetPointForModelIndex( const QModelIndex &index, mitk::PointSet::PointType& p, - mitk::PointSet::PointIdentifier& id) const +bool QmitkCorrespondingPointSetsModel::GetPointForModelIndex(const QModelIndex &index, mitk::PointSet::PointType& p, + int& id) const { if (!m_TimeStepper) return false; mitk::PointSet::Pointer pointSet = NULL; if ( index.column() == 0 ) pointSet = this->CheckForPointSetInNode(m_PointSetNode); else if ( index.column() == 1 ) pointSet = this->CheckForPointSetInNode(m_ReferencePointSetNode); if (pointSet.IsNull() || !pointSet->GetPointSet(m_TimeStepper->GetPos())) return false; if ((index.row() < 0) || (index.row() >= (int)pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->Size())) return false; // get the nth. element, if it exists. // we can not use the index directly, because PointSet uses a map container, // where the index is not necessarily the same as the key. // Therefore we have to count the elements mitk::PointSet::PointsContainer::Iterator it = pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->Begin(); for (int i = 0; i < index.row(); ++i) { ++it; if (it == pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->End()) return false; } if (it != pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->End()) // not at the end, { p = it->Value(); id = it->Index(); return true; } return false; } -bool QmitkCorrespondingPointSetsModel::GetPointForModelIndex( int row, int column, mitk::PointSet::PointType& p, - mitk::PointSet::PointIdentifier& id) const +bool QmitkCorrespondingPointSetsModel::GetPointForModelIndex(int row, int column, mitk::PointSet::PointType& p, + int& id) const { if (!m_TimeStepper) return false; mitk::PointSet::Pointer pointSet = NULL; if (column == 0 ) pointSet = this->CheckForPointSetInNode(m_PointSetNode); else if ( column == 1 ) pointSet = this->CheckForPointSetInNode(m_ReferencePointSetNode); if (pointSet.IsNull() || !pointSet->GetPointSet(m_TimeStepper->GetPos())) return false; if ((row < 0) || (row >= (int)pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->Size())) return false; // get the nth. element, if it exists. // we can not use the index directly, because PointSet uses a map container, // where the index is not necessarily the same as the key. // Therefore we have to count the elements mitk::PointSet::PointsContainer::Iterator it = pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->Begin(); for (int i = 0; i < row; ++i) { ++it; if (it == pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->End()) return false; } if (it != pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->End()) // not at the end, { p = it->Value(); id = it->Index(); return true; } return false; } -bool QmitkCorrespondingPointSetsModel::GetModelIndexForPointID(mitk::PointSet::PointIdentifier id, QModelIndex& index, int column) const +bool QmitkCorrespondingPointSetsModel::GetModelIndexForPointID(int id, QModelIndex& index, int column) const { if (!m_TimeStepper) return false; mitk::PointSet::Pointer pointSet = NULL; if (column == 0) pointSet = this->CheckForPointSetInNode(m_PointSetNode); else if (column == 1) pointSet = this->CheckForPointSetInNode(m_ReferencePointSetNode); if (!pointSet.IsNull() || !pointSet->GetPointSet(m_TimeStepper->GetPos())) { mitk::PointSet::PointsContainer::Pointer points = pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints(); if (!points->IndexExists(id)) return false; unsigned int idx = 0; for (mitk::PointSet::PointsContainer::Iterator it = points->Begin(); it != points->End(); ++it) { - if (it->Index() == id) // we found the correct element + if (static_cast(it->Index()) == id) // we found the correct element { index = this->index(idx, column); return true; } idx++; } } return false; // nothing found } bool QmitkCorrespondingPointSetsModel::GetModelIndexForSelectedPoint(QModelIndex& index) const { if (!m_TimeStepper) return false; mitk::DataNode* dataNode = NULL; if (this->m_SelectedPointSetIndex == 0) dataNode = this->m_PointSetNode; else if (this->m_SelectedPointSetIndex == 1) dataNode = this->m_ReferencePointSetNode; mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(dataNode); + if (pointSet.IsNull()) return false; - mitk::PointSet::PointIdentifier selectedID; - selectedID = pointSet->SearchSelectedPoint(m_TimeStepper->GetPos()); - - return this->GetModelIndexForPointID(selectedID, index, this->m_SelectedPointSetIndex); + return this->GetModelIndexForPointID( + pointSet->SearchSelectedPoint(m_TimeStepper->GetPos()), + index, + this->m_SelectedPointSetIndex); } void QmitkCorrespondingPointSetsModel::MoveSelectedPointUp() { if (!m_TimeStepper) return; mitk::DataNode* dataNode = NULL; if (this->m_SelectedPointSetIndex == 0) dataNode = this->m_PointSetNode; else if (this->m_SelectedPointSetIndex == 1) dataNode = this->m_ReferencePointSetNode; mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(dataNode); if (pointSet.IsNull()) return; - mitk::PointSet::PointIdentifier selectedID; - selectedID = pointSet->SearchSelectedPoint(m_TimeStepper->GetPos()); - if (selectedID==-1) + int selectedID = pointSet->SearchSelectedPoint(m_TimeStepper->GetPos()); + + if (selectedID == -1) return; - mitk::PointSet::PointType point = pointSet->GetPoint(selectedID, m_TimeStepper->GetPos()); + mitk::ScalarType tsInMS = pointSet->GetTimeGeometry()->TimeStepToTimePoint(m_TimeStepper->GetPos()); mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTUP,tsInMS, pointSet->GetPoint(selectedID, m_TimeStepper->GetPos()), selectedID, true); pointSet->ExecuteOperation(doOp); QAbstractTableModel::reset(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); emit SignalPointSetChanged(); } void QmitkCorrespondingPointSetsModel::MoveSelectedPointDown() { if (!m_TimeStepper) return; mitk::DataNode* dataNode = NULL; if (this->m_SelectedPointSetIndex == 0) dataNode = this->m_PointSetNode; else if (this->m_SelectedPointSetIndex == 1) dataNode = this->m_ReferencePointSetNode; mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(dataNode); if (pointSet.IsNull()) return; - mitk::PointSet::PointIdentifier selectedID; - selectedID = pointSet->SearchSelectedPoint(m_TimeStepper->GetPos()); - if (selectedID==-1) + int selectedID = pointSet->SearchSelectedPoint(m_TimeStepper->GetPos()); + + if (selectedID == -1) return; + mitk::ScalarType tsInMS = pointSet->GetTimeGeometry()->TimeStepToTimePoint(m_TimeStepper->GetPos()); mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTDOWN, tsInMS, pointSet->GetPoint(selectedID, m_TimeStepper->GetPos()), selectedID, true); pointSet->ExecuteOperation(doOp); QAbstractTableModel::reset(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); emit SignalPointSetChanged(); } -mitk::PointSet::PointIdentifier QmitkCorrespondingPointSetsModel::SearchSelectedPoint() +int QmitkCorrespondingPointSetsModel::SearchSelectedPoint() { if (!m_TimeStepper) return -1; mitk::DataNode* dataNode = NULL; if (this->m_SelectedPointSetIndex == 0) dataNode = this->m_PointSetNode; else if (this->m_SelectedPointSetIndex == 1) dataNode = this->m_ReferencePointSetNode; mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(dataNode); if (pointSet.IsNull()) return -1; return pointSet->SearchSelectedPoint(m_TimeStepper->GetPos()); } void QmitkCorrespondingPointSetsModel::RemoveSelectedPoint() { if (!m_TimeStepper) return; mitk::DataNode* dataNode = NULL; if (this->m_SelectedPointSetIndex == 0){ dataNode = this->m_PointSetNode; } else if (this->m_SelectedPointSetIndex == 1){ dataNode = this->m_ReferencePointSetNode; } if (dataNode == NULL) return; //send a DEL event to pointsetinteractor const mitk::Event* delEvent = new mitk::Event(this->m_MultiWidget->GetRenderWindow1()->GetRenderer(), mitk::Type_KeyPress, mitk::BS_NoButton, mitk::BS_NoButton, mitk::Key_Delete); mitk::StateEvent* delStateEvent = new mitk::StateEvent(mitk::EIDDELETE, delEvent); m_Interactor->HandleEvent(delStateEvent); delete delEvent; delete delStateEvent; QAbstractTableModel::reset(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); emit SignalPointSetChanged(); } -void QmitkCorrespondingPointSetsModel::MoveSelectedPoint(mitk::PointSet::PointIdentifier targetID) +void QmitkCorrespondingPointSetsModel::MoveSelectedPoint(int targetID) { if (!m_TimeStepper) return; mitk::DataNode* dataNode = NULL; if (this->m_SelectedPointSetIndex == 0) dataNode = this->m_PointSetNode; else if (this->m_SelectedPointSetIndex == 1) dataNode = this->m_ReferencePointSetNode; if (dataNode == NULL) return; mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(dataNode); if (pointSet.IsNull()) return; - mitk::PointSet::PointIdentifier selectedID; - selectedID = pointSet->SearchSelectedPoint(m_TimeStepper->GetPos()); + int selectedID = pointSet->SearchSelectedPoint(m_TimeStepper->GetPos()); if (targetID >= pointSet->GetSize()) targetID = pointSet->GetSize()-1; mitk::PointSet::PointsContainer::Iterator it = pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->Begin(); for (int i=0; iIndex(); - if (selectedID<0 || targetID<0) + if (selectedID < 0 || targetID < 0) return; int direction = mitk::OpNOTHING; - if (selectedID>targetID) + if (selectedID > targetID) direction = mitk::OpMOVEPOINTUP; - else if (selectedIDGetTimeGeometry()->TimeStepToTimePoint(m_TimeStepper->GetPos()); mitk::PointOperation* doOp = new mitk::PointOperation(direction, tsInMS, pointSet->GetPoint(selectedID, m_TimeStepper->GetPos()), selectedID, true); pointSet->ExecuteOperation(doOp); selectedID = pointSet->SearchSelectedPoint(m_TimeStepper->GetPos()); } QAbstractTableModel::reset(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); emit SignalPointSetChanged(); } mitk::PointSet* QmitkCorrespondingPointSetsModel::CheckForPointSetInNode(mitk::DataNode* node) const { if (node != NULL) { mitk::PointSet::Pointer pointSet = dynamic_cast(node->GetData()); if (pointSet.IsNotNull()) return pointSet; } return NULL; } bool QmitkCorrespondingPointSetsModel::QTPropCoordinatesEnabled() const { return this->QTPropShowCoordinates; } void QmitkCorrespondingPointSetsModel::QTPropSetCoordinatesEnabled(bool showCoordinates) { this->QTPropShowCoordinates = showCoordinates; } bool QmitkCorrespondingPointSetsModel::QTPropIdsEnabled() const { return this->QTPropShowIds; } void QmitkCorrespondingPointSetsModel::QTPropSetIdsEnabled(bool showIds) { this->QTPropShowIds = showIds; } std::vector QmitkCorrespondingPointSetsModel::GetPointSetNodes(){ std::vector pointSetNodes; if ( this->m_PointSetNode ) pointSetNodes.push_back(this->m_PointSetNode); if ( this->m_ReferencePointSetNode ) pointSetNodes.push_back(this->m_ReferencePointSetNode); return pointSetNodes; } void QmitkCorrespondingPointSetsModel::SetSelectedPointSetIndex(int index) { if (index<-1 || index>1) return; this->m_SelectedPointSetIndex = index; } void QmitkCorrespondingPointSetsModel::ClearSelectedPointSet() { mitk::DataNode* dataNode = NULL; if (this->m_SelectedPointSetIndex == 0) dataNode = this->m_PointSetNode; else if (this->m_SelectedPointSetIndex == 1) dataNode = this->m_ReferencePointSetNode; if (dataNode == NULL) return; mitk::PointSet* pointSet = dynamic_cast(dataNode->GetData()); mitk::PointSet::PointsContainer::Iterator it; if (this->m_TimeStepper->GetRangeMax()==-1) { while( !pointSet->IsEmptyTimeStep(0) ) { if (pointSet->GetPointSet(0)) { it = pointSet->GetPointSet(0)->GetPoints()->Begin(); pointSet->SetSelectInfo(it->Index(),true, 0); this->RemoveSelectedPoint(); } else { break; } } } else { int oldTimeStep = this->m_TimeStepper->GetPos(); for (int i=0; im_TimeStepper->GetRangeMax(); i++) { this->m_TimeStepper->SetPos(i); while( !pointSet->IsEmptyTimeStep(i) ) { if (pointSet->GetPointSet(i)) { it = pointSet->GetPointSet(i)->GetPoints()->Begin(); pointSet->SetSelectInfo(it->Index(),true, i); this->RemoveSelectedPoint(); } } } this->m_TimeStepper->SetPos(oldTimeStep); } QAbstractTableModel::reset(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); emit SignalPointSetChanged(); } void QmitkCorrespondingPointSetsModel::ClearCurrentTimeStep() { if (!m_TimeStepper) return; mitk::DataNode* dataNode = NULL; if (this->m_SelectedPointSetIndex == 0) dataNode = this->m_PointSetNode; else if (this->m_SelectedPointSetIndex == 1) dataNode = this->m_ReferencePointSetNode; if (dataNode == NULL) return; mitk::PointSet* pointSet = dynamic_cast(dataNode->GetData()); mitk::PointSet::PointsContainer::Iterator it; while( !pointSet->IsEmptyTimeStep(m_TimeStepper->GetPos()) ) { it = pointSet->GetPointSet(m_TimeStepper->GetPos())->GetPoints()->Begin(); pointSet->SetSelectInfo(it->Index(),true, m_TimeStepper->GetPos()); this->RemoveSelectedPoint(); } QAbstractTableModel::reset(); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); emit SignalPointSetChanged(); } mitk::Stepper::Pointer QmitkCorrespondingPointSetsModel::GetStepper() { return this->m_TimeStepper; } void QmitkCorrespondingPointSetsModel::SetStepper(mitk::Stepper::Pointer stepper) { this->m_TimeStepper = stepper; } int QmitkCorrespondingPointSetsModel::GetSelectedPointSetIndex() { return this->m_SelectedPointSetIndex; } void QmitkCorrespondingPointSetsModel::UpdateSelection(mitk::DataNode* selectedNode) { this->RemoveInteractor(); if(!selectedNode) return; m_Interactor = dynamic_cast(selectedNode->GetInteractor()); if (m_Interactor.IsNull())//if not present, instanciate one m_Interactor = mitk::PointSetInteractor::New("pointsetinteractor", selectedNode); //add it to global interaction to activate it mitk::GlobalInteraction::GetInstance()->AddInteractor( m_Interactor ); } void QmitkCorrespondingPointSetsModel::RemoveInteractor() { if (m_Interactor){ mitk::GlobalInteraction::GetInstance()->RemoveInteractor( m_Interactor ); m_Interactor = NULL; } } QmitkStdMultiWidget* QmitkCorrespondingPointSetsModel::GetMultiWidget() { return this->m_MultiWidget; } void QmitkCorrespondingPointSetsModel::SetMultiWidget( QmitkStdMultiWidget* multiWidget ) { this->m_MultiWidget = multiWidget; this->m_TimeStepper = m_MultiWidget->GetTimeNavigationController()->GetTime(); } diff --git a/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsModel.h b/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsModel.h index b82778f0da..ddccc5e172 100644 --- a/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsModel.h +++ b/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsModel.h @@ -1,175 +1,175 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef QMITK_CORRESPONDINGPOINTSETS_MODEL_H_INCLUDED #define QMITK_CORRESPONDINGPOINTSETS_MODEL_H_INCLUDED #include #include #include "MitkQtWidgetsExtExports.h" #include "mitkDataNode.h" #include "mitkPointSet.h" #include #include "QmitkStdMultiWidget.h" class MitkQtWidgetsExt_EXPORT QmitkCorrespondingPointSetsModel : public QAbstractTableModel { Q_OBJECT Q_PROPERTY(bool QTPropShowCoordinates READ QTPropCoordinatesEnabled WRITE QTPropSetCoordinatesEnabled) Q_PROPERTY(bool QTPropShowIds READ QTPropIdsEnabled WRITE QTPropSetIdsEnabled) public: QmitkCorrespondingPointSetsModel( int t = 0, QObject* parent = 0 ); ~QmitkCorrespondingPointSetsModel(); Qt::ItemFlags flags(const QModelIndex& index) const; void UpdateSelection(mitk::DataNode* selectedNode); void RemoveInteractor(); - // returns PointIdentifier of selected point (-1 if no point is selected) - mitk::PointSet::PointIdentifier SearchSelectedPoint(); + // returns ID of selected point (-1 if no point is selected) + int SearchSelectedPoint(); /// interface of QAbstractTableModel int rowCount( const QModelIndex& parent = QModelIndex() ) const; /// interface of QAbstractTableModel int columnCount( const QModelIndex& parent = QModelIndex() ) const; /// interface of QAbstractTableModel QVariant data(const QModelIndex& index, int role) const; /// interface of QAbstractTableModel QVariant headerData(int section, Qt::Orientation orientation, int role = Qt::DisplayRole) const; /// which point set to work on void SetPointSetNodes( std::vector nodes ); /// which time step to display/model void SetTimeStep(int t); /// which time step to display/model int GetTimeStep() const; /** * \brief get point and point ID that correspond to a given QModelIndex * * The mitk::PointSet uses a map to store points in an ID<-->Point relation. * The IDs are not neccesarily continuously numbered, therefore, we can not * directly use the QModelIndex as point ID. This method returns the point and * the corresponding point id for a given QModelIndex. The point and the point ID * are returned in the outgoing parameters p and id. If a valid point and ID were * found, the method returns true, otherwise it returns false * \param[in] QModelIndex &index the index for which a point is requested. The row() part of the index is used to find a corresponding point * \param[out] mitk::Point3D& p If a valid point is found, it will be stored in the p parameter - * \param[out] mitk::PointSet::PointIdentifier& id If a valid point is found, the corresponding ID will be stored in id + * \param[out] int& id If a valid point is found, the corresponding ID will be stored in id * \return Returns true, if a valid point was found, false otherwise */ - bool GetPointForModelIndex( const QModelIndex &index, mitk::PointSet::PointType& p, mitk::PointSet::PointIdentifier& id) const; - bool GetPointForModelIndex( int row, int column, mitk::PointSet::PointType& p, mitk::PointSet::PointIdentifier& id) const; + bool GetPointForModelIndex( const QModelIndex &index, mitk::PointSet::PointType& p, int& id) const; + bool GetPointForModelIndex( int row, int column, mitk::PointSet::PointType& p, int& id) const; /**Documentation * \brief returns a QModelIndex for a given point ID * * The mitk::PointSet uses a map to store points in an ID<-->Point relation. * The IDs are not neccesarily continuously numbered, therefore, we can not * directly use the point ID as a QModelIndex. This method returns a QModelIndex * for a given point ID in the outgoing parameter index. - * \param[in] mitk::PointSet::PointIdentifier id The point ID for which the QModelIndex will be created + * \param[in] int id The point ID for which the QModelIndex will be created * \param[out] QModelIndex& index if a point with the ID id was found, index will contain a corresponding QModelIndex for that point * \return returns true, if a valid QModelIndex was created, false otherwise */ - bool GetModelIndexForPointID(mitk::PointSet::PointIdentifier id, QModelIndex& index, int column) const; + bool GetModelIndexForPointID(int id, QModelIndex& index, int column) const; bool QTPropCoordinatesEnabled() const; void QTPropSetCoordinatesEnabled(bool qShowCoordinates); bool QTPropIdsEnabled() const; void QTPropSetIdsEnabled(bool qShowIds); std::vector GetPointSetNodes(); void SetSelectedPointSetIndex(int index); int GetSelectedPointSetIndex(); void ClearSelectedPointSet(); void MoveSelectedPointUp(); void MoveSelectedPointDown(); void RemoveSelectedPoint(); void ClearCurrentTimeStep(); void SetStepper(mitk::Stepper::Pointer stepper); mitk::Stepper::Pointer GetStepper(); Qt::DropActions supportedDropActions() const; bool dropMimeData(const QMimeData *data, Qt::DropAction action, int row, int column, const QModelIndex &parent); bool GetModelIndexForSelectedPoint(QModelIndex& index) const; void SetMultiWidget( QmitkStdMultiWidget* multiWidget ); ///< assign a QmitkStdMultiWidget for updating render window crosshair QmitkStdMultiWidget* GetMultiWidget(); ///< return the QmitkStdMultiWidget that is used for updating render window crosshair void OnPointSetChanged( const itk::EventObject & e ); private: public slots: signals: void SignalPointSetChanged(); protected: //initially checks if there is a PointSet as data in the DataNode. //returns PointSet if so and NULL if other data is set to node mitk::PointSet* CheckForPointSetInNode(mitk::DataNode* node) const; protected: bool QTPropShowIds; bool QTPropShowCoordinates; mitk::DataNode::Pointer m_PointSetNode; mitk::DataNode::Pointer m_ReferencePointSetNode; mitk::Stepper::Pointer m_TimeStepper; int m_SelectedPointSetIndex; mitk::PointSetInteractor::Pointer m_Interactor; QmitkStdMultiWidget* m_MultiWidget; unsigned long m_PointSetModifiedObserverTag; unsigned long m_ReferencePointSetModifiedObserverTag; - void MoveSelectedPoint(mitk::PointSet::PointIdentifier targetID); + void MoveSelectedPoint(int targetID); void RemoveObservers(); void AddObservers(); }; #endif diff --git a/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsView.cpp b/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsView.cpp index 758123396c..215dba81b8 100644 --- a/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsView.cpp +++ b/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsView.cpp @@ -1,524 +1,524 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkCorrespondingPointSetsView.h" #include "QmitkCorrespondingPointSetsModel.h" #include "QmitkStdMultiWidget.h" #include "QmitkEditPointDialog.h" #include "mitkRenderingManager.h" #include #include #include #include #include #include #include #include #include #include QmitkCorrespondingPointSetsView::QmitkCorrespondingPointSetsView( QWidget* parent ) :QTableView( parent ), m_CorrespondingPointSetsModel( new QmitkCorrespondingPointSetsModel() ), m_SelfCall( false ), m_swapPointSets(false), m_addPointsMode(false), m_DataStorage( NULL ) { m_CorrespondingPointSetsModel->setProperty("QTPropShowCoordinates", true); m_CorrespondingPointSetsModel->setProperty("QTPropShowIds", true); this->setContextMenuPolicy(Qt::CustomContextMenu); this->setSizePolicy(QSizePolicy::Ignored, QSizePolicy::Ignored); this->setToolTip("Use right click to open context menu"); this->setDragEnabled(true); this->setAcceptDrops(true); this->setDropIndicatorShown(true); this->setDragDropMode(QAbstractItemView::InternalMove); QTableView::setAlternatingRowColors( false ); QTableView::setSelectionBehavior( QAbstractItemView::SelectItems ); QTableView::setSelectionMode( QAbstractItemView::SingleSelection ); QTableView::setModel( m_CorrespondingPointSetsModel ); QTableView::horizontalHeader()->resizeSection(0, (int)(this->width()/3.5)); QTableView::horizontalHeader()->setStretchLastSection(true); m_TimeStepFaderLabel = new QLabel(this); QFont font("Arial", 17); m_TimeStepFaderLabel->setFont(font); connect( QTableView::selectionModel(), SIGNAL(selectionChanged(const QItemSelection &, const QItemSelection &)), this, SLOT(OnPointSelectionChanged(const QItemSelection& , const QItemSelection&)) ); connect(this, SIGNAL(customContextMenuRequested(const QPoint &)), this, SLOT(ctxMenu(const QPoint &))); connect(this->m_CorrespondingPointSetsModel, SIGNAL(SignalPointSetChanged()), this, SLOT(UpdateSelectionHighlighting())); } QmitkCorrespondingPointSetsView::~QmitkCorrespondingPointSetsView() { delete m_CorrespondingPointSetsModel; } void QmitkCorrespondingPointSetsView::SetPointSetNodes( std::vector nodes ) { if ( !this->m_swapPointSets || nodes.size()<2 ) m_CorrespondingPointSetsModel->SetPointSetNodes( nodes ); else { std::vector reverseNodes; reverseNodes.push_back(nodes.back()); reverseNodes.push_back(nodes.front()); m_CorrespondingPointSetsModel->SetPointSetNodes( reverseNodes ); } } void QmitkCorrespondingPointSetsView::SetMultiWidget( QmitkStdMultiWidget* multiWidget ) { this->m_CorrespondingPointSetsModel->SetMultiWidget(multiWidget); } QmitkStdMultiWidget* QmitkCorrespondingPointSetsView::GetMultiWidget() const { return this->m_CorrespondingPointSetsModel->GetMultiWidget(); } void QmitkCorrespondingPointSetsView::SetDataStorage(mitk::DataStorage::Pointer dataStorage) { m_DataStorage = dataStorage; } void QmitkCorrespondingPointSetsView::OnPointSelectionChanged(const QItemSelection& selected, const QItemSelection&) { if(m_SelfCall) return; std::vector pointSetNodes = this->GetPointSetNodes(); QModelIndexList selectedIndexes = selected.indexes(); m_CorrespondingPointSetsModel->SetSelectedPointSetIndex(-1); if (selectedIndexes.size() > 0) { QModelIndex index = selectedIndexes.front(); mitk::DataNode* pointSetNode = NULL; mitk::PointSet* pointSet = NULL; if (index.column() == 0) { pointSetNode = pointSetNodes.front(); } else { pointSetNode = pointSetNodes.back(); } if (pointSetNode) { this->m_CorrespondingPointSetsModel->UpdateSelection(pointSetNode); pointSet = dynamic_cast(pointSetNode->GetData()); if( pointSet->GetPointSet(m_CorrespondingPointSetsModel->GetTimeStep())) for (mitk::PointSet::PointsContainer::Iterator it = pointSet->GetPointSet(m_CorrespondingPointSetsModel->GetTimeStep())->GetPoints()->Begin(); it != pointSet->GetPointSet(m_CorrespondingPointSetsModel->GetTimeStep())->GetPoints()->End(); ++it) { QModelIndex tempIndex; if (m_CorrespondingPointSetsModel->GetModelIndexForPointID(it->Index(), tempIndex, index.column())) { if (tempIndex == index) { pointSet->SetSelectInfo(it->Index(), true, m_CorrespondingPointSetsModel->GetTimeStep()); m_CorrespondingPointSetsModel->SetSelectedPointSetIndex(index.column()); if ( this->GetMultiWidget() != NULL) { this->GetMultiWidget()->MoveCrossToPosition(pointSet->GetPoint(it->Index(), m_CorrespondingPointSetsModel->GetTimeStep())); } } else { pointSet->SetSelectInfo(it->Index(), false, m_CorrespondingPointSetsModel->GetTimeStep()); } } } } } emit(SignalPointSelectionChanged()); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); this->UpdateSelectionHighlighting(); m_SelfCall = false; } void QmitkCorrespondingPointSetsView::keyPressEvent( QKeyEvent * e ) { int key = e->key(); switch (key) { case Qt::Key_F2: m_CorrespondingPointSetsModel->MoveSelectedPointUp(); break; case Qt::Key_F3: m_CorrespondingPointSetsModel->MoveSelectedPointDown(); break; case Qt::Key_Delete: m_CorrespondingPointSetsModel->RemoveSelectedPoint(); break; default: break; } } void QmitkCorrespondingPointSetsView::wheelEvent(QWheelEvent *event) { if (!this->m_CorrespondingPointSetsModel->GetStepper()) return; int whe = event->delta(); int pos = this->m_CorrespondingPointSetsModel->GetStepper()->GetPos(); int currentTS = this->m_CorrespondingPointSetsModel->GetTimeStep(); if(whe > 0) { this->m_CorrespondingPointSetsModel->SetTimeStep(++currentTS); this->m_CorrespondingPointSetsModel->GetStepper()->SetPos(++pos); } else if( pos > 0 ) { this->m_CorrespondingPointSetsModel->SetTimeStep(--currentTS); this->m_CorrespondingPointSetsModel->GetStepper()->SetPos(--pos); } fadeTimeStepIn(); emit SignalPointSelectionChanged(); } void QmitkCorrespondingPointSetsView::fadeTimeStepIn() { if (!this->m_CorrespondingPointSetsModel->GetStepper()) return; QWidget *m_TimeStepFader = new QWidget(this); QHBoxLayout *layout = new QHBoxLayout(m_TimeStepFader); int x = (int)(this->geometry().x()+this->width()*0.75); int y = (int)(this->geometry().y()+this->height()*0.75); m_TimeStepFader->move(x,y); m_TimeStepFader->resize(60, 55); m_TimeStepFader->setLayout(layout); m_TimeStepFader->setAttribute(Qt::WA_DeleteOnClose); layout->addWidget(m_TimeStepFaderLabel); m_TimeStepFaderLabel->setAlignment(Qt::AlignCenter); m_TimeStepFaderLabel->setFrameStyle(QFrame::StyledPanel | QFrame::Raised); m_TimeStepFaderLabel->setLineWidth(2); m_TimeStepFaderLabel->setText(QString("%1").arg(this->m_CorrespondingPointSetsModel->GetStepper()->GetPos())); //give the widget opacity and some colour QPalette pal = m_TimeStepFaderLabel->palette(); QColor semiTransparentColor(139, 192, 223, 50); QColor labelTransparentColor(0,0,0,200); pal.setColor(m_TimeStepFaderLabel->backgroundRole(), semiTransparentColor); pal.setColor(m_TimeStepFaderLabel->foregroundRole(), labelTransparentColor); m_TimeStepFaderLabel->setAutoFillBackground(true); m_TimeStepFaderLabel->setPalette(pal); //show the widget m_TimeStepFader->show(); //and start the timer m_TimeStepFaderLabel->setVisible(true); QTimer::singleShot(2000, this, SLOT(fadeTimeStepOut())); } void QmitkCorrespondingPointSetsView::fadeTimeStepOut() { m_TimeStepFaderLabel->hide(); } void QmitkCorrespondingPointSetsView::ctxMenu(const QPoint &pos) { QMenu *menu = new QMenu; int x = pos.x(); int y = pos.y(); int row = QTableView::rowAt(y); int col = QTableView::columnAt(x); int numNodes = this->GetPointSetNodes().size(); //add delete point action - mitk::PointSet::PointsContainer::ElementIdentifier id; + int id; mitk::PointSet::PointType p; bool pointSelected = m_CorrespondingPointSetsModel->GetPointForModelIndex(row, col, p, id); QAction *movePointUp = new QAction(this); movePointUp->setText("Move point up"); connect(movePointUp, SIGNAL(triggered()), this, SLOT(MoveSelectedPointUp())); if(!pointSelected) movePointUp->setEnabled(false); menu->addAction(movePointUp); QAction *movePointDown = new QAction(this); movePointDown->setText("Move point down"); connect(movePointDown, SIGNAL(triggered()), this, SLOT(MoveSelectedPointDown())); if(!pointSelected) movePointDown->setEnabled(false); menu->addAction(movePointDown); QAction *delPoint = new QAction(this); delPoint->setText("Delete point"); connect(delPoint, SIGNAL(triggered()), this, SLOT(RemoveSelectedPoint())); if(!pointSelected) delPoint->setEnabled(false); menu->addAction(delPoint); QAction *separator = new QAction(this); separator->setSeparator(true); menu->addSeparator(); QAction *clearTS = new QAction(this); clearTS->setText("Clear time step"); connect(clearTS, SIGNAL(triggered()), this, SLOT(ClearCurrentTimeStep())); - if(numNodes==0 || col!=0 && col!=1) + if(numNodes==0 || (col!=0 && col!=1)) clearTS->setEnabled(false); menu->addAction(clearTS); QAction *clearList = new QAction(this); clearList->setText("Clear point set"); connect(clearList, SIGNAL(triggered()), this, SLOT(ClearSelectedPointSet())); - if(numNodes==0 || col!=0 && col!=1) + if(numNodes==0 || (col!=0 && col!=1)) clearList->setEnabled(false); menu->addAction(clearList); menu->addSeparator(); QAction *swapSets = new QAction(this); swapSets->setText("Swap point sets"); connect(swapSets, SIGNAL(triggered(bool)), this, SLOT(SwapPointSets(bool))); swapSets->setCheckable(true); swapSets->setChecked(m_swapPointSets); if (numNodes<2) swapSets->setEnabled(false); menu->addAction(swapSets); QAction *addPoints = new QAction(this); addPoints->setText("Check to add new points"); connect(addPoints, SIGNAL(triggered(bool)), this, SLOT(AddPointsMode(bool))); addPoints->setCheckable(true); addPoints->setChecked(m_addPointsMode); if (numNodes==0) addPoints->setEnabled(false); menu->addAction(addPoints); QAction *addPointSet = new QAction(this); addPointSet->setText("Create new point set"); connect(addPointSet, SIGNAL(triggered()), this, SLOT(AddPointSet())); if (!m_DataStorage) addPointSet->setEnabled(false); menu->addAction(addPointSet); menu->exec(this->mapToGlobal(pos)); } std::vector QmitkCorrespondingPointSetsView::GetPointSetNodes() { return this->m_CorrespondingPointSetsModel->GetPointSetNodes(); } std::vector QmitkCorrespondingPointSetsView::GetPointSets() { std::vector pointSetNodes = GetPointSetNodes(); std::vector pointSets; std::vector::iterator it; for ( it = pointSetNodes.begin(); it < pointSetNodes.end(); it++ ) { mitk::PointSet* pointSet = NULL; pointSet = dynamic_cast ( dynamic_cast(*it)->GetData() ); if ( pointSet != NULL ) pointSets.push_back(pointSet); } return pointSets; } void QmitkCorrespondingPointSetsView::RemoveSelectedPoint() { this->m_CorrespondingPointSetsModel->RemoveSelectedPoint(); emit(SignalPointSelectionChanged()); } void QmitkCorrespondingPointSetsView::MoveSelectedPointDown() { this->m_CorrespondingPointSetsModel->MoveSelectedPointDown(); } void QmitkCorrespondingPointSetsView::MoveSelectedPointUp() { this->m_CorrespondingPointSetsModel->MoveSelectedPointUp(); } void QmitkCorrespondingPointSetsView::ClearSelectedPointSet() { switch( QMessageBox::question( this, tr("Clear point set"), tr("Remove all points from the right clicked list?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No)) { case QMessageBox::Yes: { this->m_CorrespondingPointSetsModel->ClearSelectedPointSet(); break; } case QMessageBox::No: break; default: break; } emit(SignalPointSelectionChanged()); } void QmitkCorrespondingPointSetsView::ClearCurrentTimeStep() { switch( QMessageBox::question( this, tr("Clear time step"), tr("Remove points from current time step of the right clicked list?"), QMessageBox::Yes | QMessageBox::No, QMessageBox::No)) { case QMessageBox::Yes: { this->m_CorrespondingPointSetsModel->ClearCurrentTimeStep(); break; } case QMessageBox::No: break; default: break; } emit(SignalPointSelectionChanged()); } void QmitkCorrespondingPointSetsView::SwapPointSets(bool checked) { m_swapPointSets = checked; if ( !checked ) { std::vector nodes = this->GetPointSetNodes(); std::vector reverseNodes; reverseNodes.push_back(nodes.back()); reverseNodes.push_back(nodes.front()); this->SetPointSetNodes( reverseNodes ); } else this->SetPointSetNodes(this->GetPointSetNodes()); m_CorrespondingPointSetsModel->SetSelectedPointSetIndex((m_CorrespondingPointSetsModel->GetSelectedPointSetIndex()+1)%2); this->UpdateSelectionHighlighting(); } void QmitkCorrespondingPointSetsView::AddPointsMode(bool checked) { m_addPointsMode = checked; std::vector pointSetNodes = this->GetPointSetNodes(); std::vector::iterator it; bool selected = false; if (checked) { for ( it = pointSetNodes.begin(); it < pointSetNodes.end(); it++ ) { mitk::DataNode* dataNode = dynamic_cast(*it); dataNode->GetPropertyValue("selected", selected); if (selected) { this->UpdateSelection(dataNode); break; } } } else { this->m_CorrespondingPointSetsModel->RemoveInteractor(); } m_addPointsMode = selected; emit SignalAddPointsModeChanged(selected); } void QmitkCorrespondingPointSetsView::UpdateSelection(mitk::DataNode* selectedNode) { this->m_CorrespondingPointSetsModel->UpdateSelection(selectedNode); } void QmitkCorrespondingPointSetsView::AddPointSet() { //Ask for the name of the point set bool ok = false; QString name = QInputDialog::getText( QApplication::activeWindow() , "Add point set...", "Enter name for the new point set", QLineEdit::Normal, "PointSet", &ok ); if ( ! ok || name.isEmpty() ) return; // //Create a new empty pointset // mitk::PointSet::Pointer pointSet = mitk::PointSet::New(); // // Create a new data tree node // mitk::DataNode::Pointer pointSetNode = mitk::DataNode::New(); // // fill the data tree node with the appropriate information // pointSetNode->SetData( pointSet ); pointSetNode->SetProperty( "name", mitk::StringProperty::New( name.toStdString() ) ); pointSetNode->SetProperty( "opacity", mitk::FloatProperty::New( 1 ) ); pointSetNode->SetColor( 1.0, 1.0, 0.0 ); // // add the node to the ds // this->m_DataStorage->Add(pointSetNode); } bool QmitkCorrespondingPointSetsView::IsPointSelected() { if ( this->m_CorrespondingPointSetsModel->GetSelectedPointSetIndex()>=0 ) return true; return false; } QmitkCorrespondingPointSetsModel* QmitkCorrespondingPointSetsView::GetModel() { return this->m_CorrespondingPointSetsModel; } void QmitkCorrespondingPointSetsView::UpdateSelectionHighlighting() { this->m_SelfCall = true; QModelIndex index; bool modelIndexOkay = this->m_CorrespondingPointSetsModel->GetModelIndexForSelectedPoint(index); if(!modelIndexOkay){ this->m_SelfCall = false; return; } QTableView::selectionModel()->select( index , QItemSelectionModel::ClearAndSelect ); this->setFocus(); this->m_SelfCall = false; } diff --git a/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsWidget.cpp b/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsWidget.cpp index 0bbcf1410e..991b68e4e1 100644 --- a/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsWidget.cpp +++ b/Modules/QtWidgetsExt/QmitkCorrespondingPointSetsWidget.cpp @@ -1,213 +1,212 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkCorrespondingPointSetsWidget.h" #include #include #include #include QmitkCorrespondingPointSetsWidget::QmitkCorrespondingPointSetsWidget(QWidget *parent): QWidget(parent), m_CorrespondingPointSetsView(NULL) { // create new QTableView m_CorrespondingPointSetsView = new QmitkCorrespondingPointSetsView(); // setup user interface SetupUi(); // setup connections connect( this->m_CorrespondingPointSetsView, SIGNAL(SignalPointSelectionChanged()), this, SLOT(OnPointSelectionChanged()) ); connect( this->m_CorrespondingPointSetsView, SIGNAL(SignalAddPointsModeChanged(bool)), this, SLOT(OnAddPointsModeChanged(bool)) ); } QmitkCorrespondingPointSetsWidget::~QmitkCorrespondingPointSetsWidget() { delete m_CorrespondingPointSetsView; } void QmitkCorrespondingPointSetsWidget::SetupUi() { QBoxLayout* lay1 = new QVBoxLayout(this); // add status bar buttons if (QTPropShowButtonBar) { - bool isPointSelected = this->m_CorrespondingPointSetsView->IsPointSelected(); QBoxLayout* lay2 = new QHBoxLayout(); lay1->addLayout(lay2); lay2->stretch(true); QStatusBar* statusBar = new QStatusBar(this); statusBar->setMaximumHeight(25); m_CreatePointSetBtn = new QToolButton(); m_CreatePointSetBtn->setAutoRaise(true); m_CreatePointSetBtn->setIcon(QIcon(":/QtWidgetsExt/btnAddPointSet.png")); m_CreatePointSetBtn->setToolTip(QString("Create new point set")); connect(this->m_CreatePointSetBtn, SIGNAL(clicked()), this, SLOT(AddPointSet())); statusBar->addWidget(m_CreatePointSetBtn); m_AddPointsBtn = new QToolButton(); m_AddPointsBtn->setAutoRaise(true); m_AddPointsBtn->setIcon(QIcon(":/QtWidgetsExt/btnSetPoints.png")); m_AddPointsBtn->setToolTip(QString("Check to add new points (shift-click)")); m_AddPointsBtn->setCheckable(true); connect(this->m_AddPointsBtn, SIGNAL(clicked(bool)), this, SLOT(AddPointsMode(bool))); statusBar->addWidget(m_AddPointsBtn); m_MovePointUpBtn = new QToolButton(); m_MovePointUpBtn->setAutoRaise(true); m_MovePointUpBtn->setIcon(QIcon(":/QtWidgetsExt/btnMoveUp.png")); m_MovePointUpBtn->setToolTip(QString("Move selected point up")); connect(this->m_MovePointUpBtn, SIGNAL(clicked()), this, SLOT(MoveSelectedPointUp())); statusBar->addWidget(m_MovePointUpBtn); m_MovePointDownBtn = new QToolButton(); m_MovePointDownBtn->setAutoRaise(true); m_MovePointDownBtn->setIcon(QIcon(":/QtWidgetsExt/btnMoveDown.png")); m_MovePointDownBtn->setToolTip(QString("Move selected point down")); connect(this->m_MovePointDownBtn, SIGNAL(clicked()), this, SLOT(MoveSelectedPointDown())); statusBar->addWidget(m_MovePointDownBtn); m_RemovePointBtn = new QToolButton(); m_RemovePointBtn->setAutoRaise(true); m_RemovePointBtn->setIcon(QIcon(":/QtWidgetsExt/btnRemovePoint.png")); m_RemovePointBtn->setToolTip(QString("Remove selected point")); connect(this->m_RemovePointBtn, SIGNAL(clicked()), this, SLOT(RemoveSelectedPoint())); statusBar->addWidget(m_RemovePointBtn); m_SwapSetsBtn = new QToolButton(); m_SwapSetsBtn->setAutoRaise(true); m_SwapSetsBtn->setIcon(QIcon(":/QtWidgetsExt/btnSwapSets.png")); m_SwapSetsBtn->setToolTip(QString("Swap the two selected point sets")); m_SwapSetsBtn->setCheckable(true); connect(this->m_SwapSetsBtn, SIGNAL(clicked(bool)), this, SLOT(SwapPointSets(bool))); statusBar->addWidget(m_SwapSetsBtn); // disable buttons m_MovePointUpBtn->setEnabled(false); m_MovePointDownBtn->setEnabled(false); m_RemovePointBtn->setEnabled(false); m_SwapSetsBtn->setEnabled(false); m_AddPointsBtn->setEnabled(false); lay2->addWidget(statusBar); } lay1->insertWidget(0,m_CorrespondingPointSetsView); this->setLayout(lay1); } void QmitkCorrespondingPointSetsWidget::SetPointSetNodes(std::vector nodes) { this->m_CorrespondingPointSetsView->SetPointSetNodes(nodes); if (this->GetPointSetNodes().size()<2) m_SwapSetsBtn->setEnabled(false); else m_SwapSetsBtn->setEnabled(true); } std::vector QmitkCorrespondingPointSetsWidget::GetPointSetNodes() { return this->m_CorrespondingPointSetsView->GetPointSetNodes(); } void QmitkCorrespondingPointSetsWidget::SetMultiWidget(QmitkStdMultiWidget* multiWidget) { m_CorrespondingPointSetsView->SetMultiWidget(multiWidget); } void QmitkCorrespondingPointSetsWidget::SetDataStorage(mitk::DataStorage::Pointer dataStorage) { m_CorrespondingPointSetsView->SetDataStorage(dataStorage); } void QmitkCorrespondingPointSetsWidget::UpdateSelection(mitk::DataNode* selectedNode) { m_AddPointsBtn->setEnabled(false); if (!selectedNode || !(dynamic_cast(selectedNode->GetData()))) return; bool visible = false; selectedNode->GetPropertyValue("visible", visible); if (visible){ m_AddPointsBtn->setEnabled(true); m_CorrespondingPointSetsView->UpdateSelection(selectedNode); } } bool QmitkCorrespondingPointSetsWidget::QTPropButtonBarEnabled() const { return this->QTPropShowButtonBar; } void QmitkCorrespondingPointSetsWidget::QTPropSetButtonBarEnabled(bool showBB) { this->QTPropShowButtonBar = showBB; } void QmitkCorrespondingPointSetsWidget::AddPointSet() { m_CorrespondingPointSetsView->AddPointSet(); } void QmitkCorrespondingPointSetsWidget::OnPointSelectionChanged() { if ( this->m_CorrespondingPointSetsView->IsPointSelected() ) { m_MovePointUpBtn->setEnabled(true); m_MovePointDownBtn->setEnabled(true); m_RemovePointBtn->setEnabled(true); } else { m_MovePointUpBtn->setEnabled(false); m_MovePointDownBtn->setEnabled(false); m_RemovePointBtn->setEnabled(false); } } void QmitkCorrespondingPointSetsWidget::RemoveSelectedPoint() { this->m_CorrespondingPointSetsView->RemoveSelectedPoint(); } void QmitkCorrespondingPointSetsWidget::MoveSelectedPointDown() { this->m_CorrespondingPointSetsView->MoveSelectedPointDown(); } void QmitkCorrespondingPointSetsWidget::MoveSelectedPointUp() { this->m_CorrespondingPointSetsView->MoveSelectedPointUp(); } void QmitkCorrespondingPointSetsWidget::AddPointsMode(bool checked) { this->m_CorrespondingPointSetsView->AddPointsMode(checked); } void QmitkCorrespondingPointSetsWidget::OnAddPointsModeChanged(bool enabled) { this->m_AddPointsBtn->setChecked(enabled); } void QmitkCorrespondingPointSetsWidget::SwapPointSets(bool checked) { this->m_CorrespondingPointSetsView->SwapPointSets(checked); } diff --git a/Modules/QtWidgetsExt/QmitkHistogramJSWidget.cpp b/Modules/QtWidgetsExt/QmitkHistogramJSWidget.cpp index 7d95f44d54..12258d6568 100644 --- a/Modules/QtWidgetsExt/QmitkHistogramJSWidget.cpp +++ b/Modules/QtWidgetsExt/QmitkHistogramJSWidget.cpp @@ -1,239 +1,239 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkHistogramJSWidget.h" #include "mitkPixelTypeMultiplex.h" #include #include #include "mitkRenderingManager.h" #include "mitkBaseRenderer.h" #include "mitkImageTimeSelector.h" #include "mitkExtractSliceFilter.h" QmitkHistogramJSWidget::QmitkHistogramJSWidget(QWidget *parent) : QWebView(parent) { // set histogram type to barchart in first instance m_UseLineGraph = false; m_Page = new QmitkJSWebPage(this); setPage(m_Page); // set html from source connect(page()->mainFrame(), SIGNAL(javaScriptWindowObjectCleared()), this, SLOT(AddJSObject())); QUrl myUrl = QUrl("qrc:///QtWidgetsExt/Histogram.html"); setUrl(myUrl); // set Scrollbars to be always disabled page()->mainFrame()->setScrollBarPolicy(Qt::Horizontal, Qt::ScrollBarAlwaysOff); page()->mainFrame()->setScrollBarPolicy(Qt::Vertical, Qt::ScrollBarAlwaysOff); m_ParametricPath = ParametricPathType::New(); } QmitkHistogramJSWidget::~QmitkHistogramJSWidget() { } // adds an Object of Type QmitkHistogramJSWidget to the JavaScript, using QtWebkitBridge void QmitkHistogramJSWidget::AddJSObject() { page()->mainFrame()->addToJavaScriptWindowObject(QString("histogramData"), this); } // reloads WebView, everytime its size has been changed, so the size of the Histogram fits to the size of the widget void QmitkHistogramJSWidget::resizeEvent(QResizeEvent* resizeEvent) { QWebView::resizeEvent(resizeEvent); // workaround for Qt Bug: https://bugs.webkit.org/show_bug.cgi?id=75984 page()->mainFrame()->evaluateJavaScript("disconnectSignals()"); this->reload(); } // method to expose data to JavaScript by using properties void QmitkHistogramJSWidget::ComputeHistogram(HistogramType* histogram) { m_Histogram = histogram; HistogramConstIteratorType startIt = m_Histogram->End(); HistogramConstIteratorType endIt = m_Histogram->End(); HistogramConstIteratorType it = m_Histogram->Begin(); ClearData(); unsigned int i = 0; bool firstValue = false; // removes frequencies of 0, which are outside the first and last bin for (; it != m_Histogram->End(); ++it) { if (it.GetFrequency() > 0.0) { endIt = it; if (!firstValue) { firstValue = true; startIt = it; } } } ++endIt; // generating Lists of measurement and frequencies for (it = startIt ; it != endIt; ++it, ++i) { QVariant frequency = QVariant::fromValue(it.GetFrequency()); QVariant measurement = it.GetMeasurementVector()[0]; m_Frequency.insert(i, frequency); m_Measurement.insert(i, measurement); } m_IntensityProfile = false; this->SignalDataChanged(); } void QmitkHistogramJSWidget::ClearData() { m_Frequency.clear(); m_Measurement.clear(); } void QmitkHistogramJSWidget::ClearHistogram() { this->ClearData(); this->SignalDataChanged(); } QList QmitkHistogramJSWidget::GetFrequency() { return m_Frequency; } QList QmitkHistogramJSWidget::GetMeasurement() { return m_Measurement; } bool QmitkHistogramJSWidget::GetUseLineGraph() { return m_UseLineGraph; } void QmitkHistogramJSWidget::OnBarRadioButtonSelected() { if (m_UseLineGraph) { m_UseLineGraph = false; this->SignalGraphChanged(); } } void QmitkHistogramJSWidget::OnLineRadioButtonSelected() { if (!m_UseLineGraph) { m_UseLineGraph = true; this->SignalGraphChanged(); } } void QmitkHistogramJSWidget::SetImage(mitk::Image* image) { m_Image = image; } void QmitkHistogramJSWidget::SetPlanarFigure(const mitk::PlanarFigure* planarFigure) { m_PlanarFigure = planarFigure; } template -void ReadPixel(mitk::PixelType ptype, mitk::Image::Pointer image, mitk::Index3D indexPoint, double& value) +void ReadPixel(mitk::PixelType, mitk::Image::Pointer image, mitk::Index3D indexPoint, double& value) { if (image->GetDimension() == 2) { mitk::ImagePixelReadAccessor readAccess(image, image->GetSliceData(0)); itk::Index<2> idx; idx[0] = indexPoint[0]; idx[1] = indexPoint[1]; value = readAccess.GetPixelByIndex(idx); } else if (image->GetDimension() == 3) { mitk::ImagePixelReadAccessor readAccess(image, image->GetVolumeData(0)); itk::Index<3> idx; idx[0] = indexPoint[0]; idx[1] = indexPoint[1]; idx[2] = indexPoint[2]; value = readAccess.GetPixelByIndex(idx); } else { //unhandled } } void QmitkHistogramJSWidget::ComputeIntensityProfile(unsigned int timeStep) { this->ClearData(); m_ParametricPath->Initialize(); if (m_PlanarFigure.IsNull()) { mitkThrow() << "PlanarFigure not set!"; } if (m_Image.IsNull()) { mitkThrow() << "Image not set!"; } mitk::Image::Pointer image; if (m_Image->GetDimension() == 4) { mitk::ImageTimeSelector::Pointer timeSelector = mitk::ImageTimeSelector::New(); timeSelector->SetInput(m_Image); timeSelector->SetTimeNr(timeStep); timeSelector->Update(); image = timeSelector->GetOutput(); } else { image = m_Image; } mitk::IntensityProfile::Pointer intensityProfile = mitk::ComputeIntensityProfile(image, const_cast(m_PlanarFigure.GetPointer())); m_Frequency.clear(); m_Measurement.clear(); int i = -1; mitk::IntensityProfile::ConstIterator end = intensityProfile->End(); for (mitk::IntensityProfile::ConstIterator it = intensityProfile->Begin(); it != end; ++it) { m_Frequency.push_back(it.GetMeasurementVector()[0]); m_Measurement.push_back(++i); } m_IntensityProfile = true; m_UseLineGraph = true; this->SignalDataChanged(); } bool QmitkHistogramJSWidget::GetIntensityProfile() { return m_IntensityProfile; } diff --git a/Modules/QtWidgetsExt/QmitkLineEdit.cpp b/Modules/QtWidgetsExt/QmitkLineEdit.cpp index e9e3618908..11e58a4628 100644 --- a/Modules/QtWidgetsExt/QmitkLineEdit.cpp +++ b/Modules/QtWidgetsExt/QmitkLineEdit.cpp @@ -1,106 +1,106 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkLineEdit.h" #include QmitkLineEdit::QmitkLineEdit(QWidget* parent) : QLineEdit(parent) { this->Initialize(); } QmitkLineEdit::QmitkLineEdit(const QString& defaultText, QWidget* parent) : QLineEdit(parent), m_DefaultText(defaultText) { this->Initialize(); } QmitkLineEdit::~QmitkLineEdit() { } void QmitkLineEdit::focusInEvent(QFocusEvent* event) { QLineEdit::focusInEvent(event); emit this->FocusChanged(true); } void QmitkLineEdit::focusOutEvent(QFocusEvent* event) { QLineEdit::focusOutEvent(event); emit this->FocusChanged(false); } QString QmitkLineEdit::GetDefaultText() const { return m_DefaultText; } void QmitkLineEdit::Initialize() { m_DefaultPalette.setColor(QPalette::Text, QApplication::palette().color(QPalette::Disabled, QPalette::Text)); this->ShowDefaultText(true); connect(this, SIGNAL(FocusChanged(bool)), this, SLOT(OnFocusChanged(bool))); connect(this, SIGNAL(textChanged(const QString&)), this, SLOT(OnTextChanged(const QString&))); } void QmitkLineEdit::OnFocusChanged(bool hasFocus) { if (hasFocus) { if (this->text() == m_DefaultText && this->palette() == m_DefaultPalette) this->ShowDefaultText(false); } else { if (this->text().isEmpty()) this->ShowDefaultText(true); } } -void QmitkLineEdit::OnTextChanged(const QString& text) +void QmitkLineEdit::OnTextChanged(const QString&) { if (this->palette() == m_DefaultPalette) this->setPalette(QPalette()); } void QmitkLineEdit::SetDefaultText(const QString& defaultText) { m_DefaultText = defaultText; } void QmitkLineEdit::ShowDefaultText(bool show) { this->blockSignals(true); if (show) { this->setPalette(m_DefaultPalette); this->setText(m_DefaultText); } else { this->setPalette(QPalette()); this->clear(); } this->blockSignals(false); } diff --git a/Modules/QtWidgetsExt/QmitkPointListModel.cpp b/Modules/QtWidgetsExt/QmitkPointListModel.cpp index 4e447c3e49..94c6b4eea0 100644 --- a/Modules/QtWidgetsExt/QmitkPointListModel.cpp +++ b/Modules/QtWidgetsExt/QmitkPointListModel.cpp @@ -1,334 +1,333 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkPointListModel.h" #include #include "mitkInteractionConst.h" #include "mitkPointOperation.h" #include "mitkRenderingManager.h" #include #include #include #include QmitkPointListModel::QmitkPointListModel( mitk::DataNode* pointSetNode, int t, QObject* parent ) :QAbstractListModel(parent), m_PointSetNode(NULL), m_PointSetModifiedObserverTag(0), m_PointSetDeletedObserverTag(0), m_TimeStep(t) { ObserveNewPointSet( pointSetNode ); } Qt::ItemFlags QmitkPointListModel::flags(const QModelIndex& /*index*/) const { // no editing so far, return default (enabled, selectable) return Qt::ItemIsSelectable | Qt::ItemIsEnabled; } QmitkPointListModel::~QmitkPointListModel() { this->ObserveNewPointSet( NULL ); } void QmitkPointListModel::SetPointSetNode( mitk::DataNode* pointSetNode ) { this->ObserveNewPointSet( pointSetNode ); QAbstractListModel::reset(); emit SignalUpdateSelection(); } mitk::PointSet* QmitkPointListModel::GetPointSet() const { return this->CheckForPointSetInNode(m_PointSetNode); } void QmitkPointListModel::SetTimeStep(int t) { m_TimeStep = t; QAbstractListModel::reset(); emit SignalUpdateSelection(); } int QmitkPointListModel::GetTimeStep() const { return m_TimeStep; } void QmitkPointListModel::ObserveNewPointSet( mitk::DataNode* pointSetNode ) { //remove old observers if (m_PointSetNode != NULL) { mitk::PointSet::Pointer oldPointSet = dynamic_cast(m_PointSetNode->GetData()); if (oldPointSet.IsNotNull()) { oldPointSet->RemoveObserver(m_PointSetModifiedObserverTag); oldPointSet->RemoveObserver(m_PointSetDeletedObserverTag); } } //get the new pointset mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(pointSetNode); m_PointSetNode = pointSetNode; if ( pointSet.IsNotNull()) { // add new observer for modified if necessary itk::ReceptorMemberCommand::Pointer modCommand = itk::ReceptorMemberCommand::New(); modCommand->SetCallbackFunction( this, &QmitkPointListModel::OnPointSetChanged ); m_PointSetModifiedObserverTag = pointSet->AddObserver( itk::ModifiedEvent(), modCommand ); // add new observer for detele if necessary itk::ReceptorMemberCommand::Pointer delCommand = itk::ReceptorMemberCommand::New(); delCommand->SetCallbackFunction( this, &QmitkPointListModel::OnPointSetDeleted ); m_PointSetDeletedObserverTag = pointSet->AddObserver( itk::DeleteEvent(), delCommand ); } else { m_PointSetModifiedObserverTag = 0; m_PointSetDeletedObserverTag = 0; } } void QmitkPointListModel::OnPointSetChanged(const itk::EventObject&) { QAbstractListModel::reset(); emit SignalUpdateSelection(); } void QmitkPointListModel::OnPointSetDeleted(const itk::EventObject&) { mitk::PointSet::Pointer ps = CheckForPointSetInNode(m_PointSetNode); if (ps) { ps->RemoveObserver(m_PointSetModifiedObserverTag); ps->RemoveObserver(m_PointSetDeletedObserverTag); } m_PointSetModifiedObserverTag = 0; m_PointSetDeletedObserverTag = 0; QAbstractListModel::reset(); } int QmitkPointListModel::rowCount(const QModelIndex&) const { mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode); if ( pointSet.IsNotNull() ) { return pointSet->GetSize(m_TimeStep); } else { return 0; } } QVariant QmitkPointListModel::data(const QModelIndex& index, int role) const { mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode); if ( pointSet.IsNull() ) { return QVariant(); } if ( !index.isValid() ) { return QVariant(); } if ( index.row() >= pointSet->GetSize(m_TimeStep) ) { return QVariant(); } if (role == Qt::DisplayRole) { mitk::PointSet::PointsContainer::ElementIdentifier id; mitk::PointSet::PointType p; bool pointFound = this->GetPointForModelIndex(index, p, id); if (pointFound == false) return QVariant(); QString s = QString("%0: (%1, %2, %3)") .arg( id, 3) .arg( p[0], 0, 'f', 3 ) .arg( p[1], 0, 'f', 3 ) .arg( p[2], 0, 'f', 3 ); return QVariant(s); } else { return QVariant(); } } QVariant QmitkPointListModel::headerData(int section, Qt::Orientation orientation, int role) const { if (role != Qt::DisplayRole) { return QVariant(); } if (orientation == Qt::Horizontal) { return QString("Coordinates").arg(section); } else { return QString("Row %1").arg(section); } } bool QmitkPointListModel::GetPointForModelIndex( const QModelIndex &index, mitk::PointSet::PointType& p, mitk::PointSet::PointIdentifier& id) const { mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode); if (pointSet.IsNull()) return false; if ((index.row() < 0) || (index.row() >= (int)pointSet->GetPointSet(m_TimeStep)->GetPoints()->Size())) return false; // get the nth. element, if it exists. // we can not use the index directly, because PointSet uses a map container, // where the index is not necessarily the same as the key. // Therefore we have to count the elements mitk::PointSet::PointsContainer::Iterator it = pointSet->GetPointSet(m_TimeStep)->GetPoints()->Begin(); for (int i = 0; i < index.row(); ++i) { ++it; if (it == pointSet->GetPointSet(m_TimeStep)->GetPoints()->End()) return false; } if (it != pointSet->GetPointSet(m_TimeStep)->GetPoints()->End()) // not at the end, { p = it->Value(); id = it->Index(); return true; } return false; } bool QmitkPointListModel::GetModelIndexForPointID(mitk::PointSet::PointIdentifier id, QModelIndex& index) const { mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode); if (pointSet.IsNull()) return false; mitk::PointSet::PointsContainer::Pointer points = pointSet->GetPointSet(m_TimeStep)->GetPoints(); if (points->IndexExists(id) == false) return false; unsigned int idx = 0; for (mitk::PointSet::PointsContainer::Iterator it = points->Begin(); it != points->End(); ++it) { if (it->Index() == id) // we found the correct element { index = this->index(idx); return true; } idx++; } return false; // nothing found } void QmitkPointListModel::MoveSelectedPointUp() { mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode); if (pointSet.IsNull()) return; mitk::PointSet::PointIdentifier selectedID; selectedID = pointSet->SearchSelectedPoint(m_TimeStep); - mitk::PointSet::PointType point = pointSet->GetPoint(selectedID, m_TimeStep); mitk::ScalarType tsInMS = pointSet->GetTimeGeometry()->TimeStepToTimePoint(m_TimeStep); mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTUP,tsInMS, pointSet->GetPoint(selectedID, m_TimeStep), selectedID, true); pointSet->ExecuteOperation(doOp); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // Workaround for update problem in Pointset/Mapper } void QmitkPointListModel::MoveSelectedPointDown() { mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode); if (pointSet.IsNull()) return; mitk::PointSet::PointIdentifier selectedID; selectedID = pointSet->SearchSelectedPoint(m_TimeStep); mitk::ScalarType tsInMS = pointSet->GetTimeGeometry()->TimeStepToTimePoint(m_TimeStep); mitk::PointOperation* doOp = new mitk::PointOperation(mitk::OpMOVEPOINTDOWN, tsInMS, pointSet->GetPoint(selectedID, m_TimeStep), selectedID, true); pointSet->ExecuteOperation(doOp); mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // Workaround for update problem in Pointset/Mapper } void QmitkPointListModel::RemoveSelectedPoint() { mitk::PointSet::Pointer pointSet = this->CheckForPointSetInNode(m_PointSetNode); if (pointSet.IsNull()) return; //get corresponding interactor to PointSet mitk::PointSetInteractor::Pointer interactor = dynamic_cast(m_PointSetNode->GetInteractor()); if (interactor.IsNull()) { if (m_PointSetNode->GetInteractor()==NULL && m_PointSetNode != NULL) //no Interactor set to node { interactor = mitk::PointSetInteractor::New("pointsetinteractor",m_PointSetNode); m_PointSetNode->SetInteractor(interactor); } else { MITK_WARN<<"Unexpected interactor found!\n"; return; } } //send a DEL event to pointsetinteractor const mitk::Event* delEvent = new mitk::Event(NULL, mitk::Type_KeyPress, mitk::BS_NoButton, mitk::BS_NoButton, mitk::Key_Delete); mitk::StateEvent* delStateEvent = new mitk::StateEvent(mitk::EIDDELETE, delEvent); interactor->HandleEvent(delStateEvent); delete delEvent; delete delStateEvent; mitk::RenderingManager::GetInstance()->RequestUpdateAll(); // Workaround for update problem in PointSet/Mapper } mitk::PointSet* QmitkPointListModel::CheckForPointSetInNode(mitk::DataNode* node) const { if (node != NULL) { mitk::PointSet::Pointer pointSet = dynamic_cast(node->GetData()); if (pointSet.IsNotNull()) return pointSet; } return NULL; } diff --git a/Modules/QtWidgetsExt/QmitkSliceWidget.cpp b/Modules/QtWidgetsExt/QmitkSliceWidget.cpp index 0ceee93a23..8c63eb2405 100644 --- a/Modules/QtWidgetsExt/QmitkSliceWidget.cpp +++ b/Modules/QtWidgetsExt/QmitkSliceWidget.cpp @@ -1,302 +1,296 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkSliceWidget.h" #include "QmitkStepperAdapter.h" #include "mitkNodePredicateDataType.h" #include #include #include QmitkSliceWidget::QmitkSliceWidget(QWidget* parent, const char* name, Qt::WindowFlags f) : QWidget(parent, f) { this->setupUi(this); if (name != 0) this->setObjectName(name); popUp = new QMenu(this); popUp->addAction("Axial"); popUp->addAction("Frontal"); popUp->addAction("Sagittal"); QObject::connect(popUp, SIGNAL(triggered(QAction*)), this, SLOT(ChangeView(QAction*)) ); setPopUpEnabled(false); m_SlicedGeometry = 0; m_View = mitk::SliceNavigationController::Axial; QHBoxLayout *hlayout = new QHBoxLayout(container); hlayout->setMargin(0); // create widget QString composedName("QmitkSliceWidget::"); if (!this->objectName().isEmpty()) composedName += this->objectName(); else composedName += "QmitkGLWidget"; m_RenderWindow = new QmitkRenderWindow(container, composedName); m_Renderer = m_RenderWindow->GetRenderer(); hlayout->addWidget(m_RenderWindow); new QmitkStepperAdapter(m_NavigatorWidget, m_RenderWindow->GetSliceNavigationController()->GetSlice(), "navigation"); SetLevelWindowEnabled(true); } mitk::VtkPropRenderer* QmitkSliceWidget::GetRenderer() { return m_Renderer; } QFrame* QmitkSliceWidget::GetSelectionFrame() { return SelectionFrame; } void QmitkSliceWidget::SetDataStorage( mitk::StandaloneDataStorage::Pointer storage) { m_DataStorage = storage; m_Renderer->SetDataStorage(m_DataStorage); } mitk::StandaloneDataStorage* QmitkSliceWidget::GetDataStorage() { return m_DataStorage; } void QmitkSliceWidget::SetData( mitk::DataStorage::SetOfObjects::ConstIterator it) { SetData(it->Value(), m_View); } void QmitkSliceWidget::SetData( mitk::DataStorage::SetOfObjects::ConstIterator it, mitk::SliceNavigationController::ViewDirection view) { SetData(it->Value(), view); } void QmitkSliceWidget::SetData(mitk::DataNode::Pointer node) { try { if (m_DataStorage.IsNotNull()) { m_DataStorage->Add(node); } } catch (...) { } SetData(node, m_View); } void QmitkSliceWidget::SetData(mitk::DataNode::Pointer node, mitk::SliceNavigationController::ViewDirection view) { mitk::Image::Pointer image = dynamic_cast(node->GetData()); if (image.IsNull()) { MITK_WARN << "QmitkSliceWidget data is not an image!"; return; } m_SlicedGeometry = image->GetSlicedGeometry(); this->InitWidget(view); } void QmitkSliceWidget::InitWidget( mitk::SliceNavigationController::ViewDirection viewDirection) { m_View = viewDirection; mitk::SliceNavigationController* controller = m_RenderWindow->GetSliceNavigationController(); if (viewDirection == mitk::SliceNavigationController::Axial) { controller->SetViewDirection( mitk::SliceNavigationController::Axial); } else if (viewDirection == mitk::SliceNavigationController::Frontal) { controller->SetViewDirection(mitk::SliceNavigationController::Frontal); } // init sagittal view else { controller->SetViewDirection(mitk::SliceNavigationController::Sagittal); } int currentPos = 0; if (m_RenderWindow->GetSliceNavigationController()) { currentPos = controller->GetSlice()->GetPos(); } if (m_SlicedGeometry.IsNull()) { return; } - // compute bounding box with respect to first images geometry - const mitk::BoundingBox::BoundsArrayType imageBounds = - m_SlicedGeometry->GetBoundingBox()->GetBounds(); - - mitk::Geometry3D::Pointer - geometry = - static_cast (m_SlicedGeometry->Clone().GetPointer()); + mitk::Geometry3D::Pointer geometry = + static_cast (m_SlicedGeometry->Clone().GetPointer()); const mitk::BoundingBox::Pointer boundingbox = - m_DataStorage->ComputeVisibleBoundingBox(GetRenderer(), NULL); + m_DataStorage->ComputeVisibleBoundingBox(GetRenderer(), NULL); + if (boundingbox->GetPoints()->Size() > 0) { //let's see if we have data with a limited live-span ... mitk::TimeBounds timebounds = m_DataStorage->ComputeTimeBounds( GetRenderer(), NULL); if (timebounds[1] < mitk::ScalarTypeNumericTraits::max()) { - mitk::ScalarType duration = timebounds[1] - timebounds[0]; - timebounds[1] = timebounds[0] + 1.0f; geometry->SetTimeBounds(timebounds); } mitk::ProportionalTimeGeometry::Pointer timeGeometry = mitk::ProportionalTimeGeometry::New(); timeGeometry->Initialize(geometry,1); if (const_cast (timeGeometry->GetBoundingBoxInWorld())->GetDiagonalLength2() >= mitk::eps) { controller->SetInputWorldTimeGeometry(timeGeometry); controller->Update(); } } GetRenderer()->GetDisplayGeometry()->Fit(); mitk::RenderingManager::GetInstance()->RequestUpdate( GetRenderer()->GetRenderWindow()); } void QmitkSliceWidget::UpdateGL() { GetRenderer()->GetDisplayGeometry()->Fit(); mitk::RenderingManager::GetInstance()->RequestUpdate( GetRenderer()->GetRenderWindow()); } void QmitkSliceWidget::mousePressEvent(QMouseEvent * e) { if (e->button() == Qt::RightButton && popUpEnabled) { popUp->popup(QCursor::pos()); } } void QmitkSliceWidget::wheelEvent(QWheelEvent * e) { int val = m_NavigatorWidget->GetPos(); if (e->orientation() * e->delta() > 0) { m_NavigatorWidget->SetPos(val + 1); } else { if (val > 0) m_NavigatorWidget->SetPos(val - 1); } } void QmitkSliceWidget::ChangeView(QAction* val) { if (val->text() == "Axial") { InitWidget(mitk::SliceNavigationController::Axial); } else if (val->text() == "Frontal") { InitWidget(mitk::SliceNavigationController::Frontal); } else if (val->text() == "Sagittal") { InitWidget(mitk::SliceNavigationController::Sagittal); } } void QmitkSliceWidget::setPopUpEnabled(bool b) { popUpEnabled = b; } QmitkSliderNavigatorWidget* QmitkSliceWidget::GetNavigatorWidget() { return m_NavigatorWidget; } void QmitkSliceWidget::SetLevelWindowEnabled(bool enable) { levelWindow->setEnabled(enable); if (!enable) { levelWindow->setMinimumWidth(0); levelWindow->setMaximumWidth(0); } else { levelWindow->setMinimumWidth(28); levelWindow->setMaximumWidth(28); } } bool QmitkSliceWidget::IsLevelWindowEnabled() { return levelWindow->isEnabled(); } QmitkRenderWindow* QmitkSliceWidget::GetRenderWindow() { return m_RenderWindow; } mitk::SliceNavigationController* QmitkSliceWidget::GetSliceNavigationController() const { return m_RenderWindow->GetSliceNavigationController(); } mitk::CameraRotationController* QmitkSliceWidget::GetCameraRotationController() const { return m_RenderWindow->GetCameraRotationController(); } mitk::BaseController* QmitkSliceWidget::GetController() const { return m_RenderWindow->GetController(); } diff --git a/Modules/QtWidgetsExt/QmitkVideoBackground.cpp b/Modules/QtWidgetsExt/QmitkVideoBackground.cpp index 968c8234d3..76d8d4c957 100644 --- a/Modules/QtWidgetsExt/QmitkVideoBackground.cpp +++ b/Modules/QtWidgetsExt/QmitkVideoBackground.cpp @@ -1,303 +1,303 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #include "QmitkVideoBackground.h" // MITK includes #include "mitkVtkLayerController.h" #include "mitkRenderingManager.h" // QT includes #include // itk includes #include // VTK includes #include #include #include #include #include #include #include #include #include #include #include #include QmitkVideoBackground::QmitkVideoBackground( QObject *parent ) : QObject(parent) , m_QTimer(new QTimer(this)) , m_VideoSource(0) , m_VideoSourceObserverTag(0) { this->ResetVideoBackground(); } -QmitkVideoBackground::QmitkVideoBackground(mitk::VideoSource* v, int TimerDelay) +QmitkVideoBackground::QmitkVideoBackground(mitk::VideoSource* v, int) : QObject(0) , m_QTimer(new QTimer(this)) , m_VideoSource(0) , m_VideoSourceObserverTag(0) { this->SetVideoSource( v ); this->ResetVideoBackground(); } void QmitkVideoBackground::ResetVideoBackground() { m_QTimer->setInterval(25); connect( m_QTimer, SIGNAL(timeout()), SLOT(UpdateVideo()) ); m_renderWindowVectorInfo.clear(); } QmitkVideoBackground::~QmitkVideoBackground() { this->Disable(); } void QmitkVideoBackground::AddRenderWindow(vtkRenderWindow* renderWindow ) { if(!renderWindow || !m_VideoSource) { MITK_WARN << "No Renderwindow or VideoSource set!"; return; } this->RemoveRenderWindow(renderWindow); vtkRenderer* videoRenderer = vtkRenderer::New(); vtkImageActor* videoActor = vtkImageActor::New(); vtkImageImport* videoImport = vtkImageImport::New(); videoImport->SetDataScalarTypeToUnsignedChar(); videoImport->SetNumberOfScalarComponents(3); if(m_VideoSource->GetImageWidth() == 0) m_VideoSource->FetchFrame(); videoImport->SetWholeExtent(0, m_VideoSource->GetImageWidth()-1, 0, m_VideoSource->GetImageHeight()-1, 0, 1-1); videoImport->SetDataExtentToWholeExtent(); VideoBackgroundVectorInfo v; v.renWin = renderWindow; v.videoRenderer = videoRenderer; v.videoActor = videoActor; v.videoImport = videoImport; // callback for the deletion of the renderwindow vtkSmartPointer deleteCallback = vtkSmartPointer::New(); deleteCallback->SetCallback ( QmitkVideoBackground::OnRenderWindowDelete ); deleteCallback->SetClientData(this); v.renderWindowObserverTag = renderWindow->AddObserver( vtkCommand::DeleteEvent, deleteCallback ); m_renderWindowVectorInfo.push_back(v); // completes the initialization this->Modified(); } void QmitkVideoBackground::RemoveRenderWindow( vtkRenderWindow* renderWindow ) { this->RemoveRenderWindow(renderWindow, true); } void QmitkVideoBackground::RemoveRenderWindow( vtkRenderWindow* renderWindow, bool removeObserver ) { // search for renderwindow and remove it for(RenderWindowVectorInfoType::iterator it = m_renderWindowVectorInfo.begin(); it != m_renderWindowVectorInfo.end(); it++) { if((*it).renWin == renderWindow) { mitk::VtkLayerController* layerController = mitk::VtkLayerController::GetInstance((*it).renWin); // unregister video backround renderer from renderwindow if( layerController ) layerController->RemoveRenderer((*it).videoRenderer); (*it).videoRenderer->Delete(); (*it).videoActor->Delete(); (*it).videoImport->Delete(); // remove listener if(removeObserver) renderWindow->RemoveObserver( (*it).renderWindowObserverTag ); m_renderWindowVectorInfo.erase(it); break; } } } bool QmitkVideoBackground::IsRenderWindowIncluded(vtkRenderWindow* renderWindow ) { for(RenderWindowVectorInfoType::iterator it = m_renderWindowVectorInfo.begin(); it != m_renderWindowVectorInfo.end(); it++) { if((*it).renWin == renderWindow) return true; } return false; } void QmitkVideoBackground::Pause() { m_QTimer->stop(); } void QmitkVideoBackground::Resume() { m_QTimer->start(); } /** * Enables drawing of the color Video background. * If you want to disable it, call the Disable() function. */ void QmitkVideoBackground::Enable() { UpdateVideo(); Modified(); m_QTimer->start(); } /** * Disables drawing of the color Video background. * If you want to enable it, call the Enable() function. */ void QmitkVideoBackground::Disable() { if ( this->IsEnabled() ) { mitk::VtkLayerController* layerController = 0; for(RenderWindowVectorInfoType::iterator it = m_renderWindowVectorInfo.begin(); it != m_renderWindowVectorInfo.end(); it++) { layerController = mitk::VtkLayerController::GetInstance((*it).renWin); if(layerController) layerController->RemoveRenderer((*it).videoRenderer); } m_QTimer->stop(); } } bool QmitkVideoBackground::IsEnabled() { return m_QTimer->isActive(); } void QmitkVideoBackground::UpdateVideo() { if( m_renderWindowVectorInfo.size() > 0 ) { unsigned char *src = 0; src = m_VideoSource->GetVideoTexture(); if(src) { for(RenderWindowVectorInfoType::iterator it = m_renderWindowVectorInfo.begin(); it != m_renderWindowVectorInfo.end(); it++) { (*it).videoImport->SetImportVoidPointer(src); (*it).videoImport->Modified(); (*it).videoImport->Update(); mitk::RenderingManager::GetInstance()->RequestUpdate((*it).renWin); } emit NewFrameAvailable ( m_VideoSource ); } else MITK_WARN << "No video texture available"; } } void QmitkVideoBackground::Modified() { // ensures registration of video backrounds in each renderwindow for(RenderWindowVectorInfoType::iterator it = m_renderWindowVectorInfo.begin(); it != m_renderWindowVectorInfo.end(); it++) { (*it).videoImport->Update(); (*it).videoActor->SetInputData((*it).videoImport->GetOutput()); (*it).videoRenderer->AddActor2D((*it).videoActor); (*it).videoRenderer->ResetCamera(); (*it).videoRenderer->InteractiveOff(); (*it).videoRenderer->GetActiveCamera()->ParallelProjectionOn(); (*it).videoRenderer->GetActiveCamera()->SetParallelScale(m_VideoSource->GetImageHeight()/2); mitk::VtkLayerController* layerController = mitk::VtkLayerController::GetInstance((*it).renWin); if( layerController && !layerController->IsRendererInserted((*it).videoRenderer) ) layerController->InsertBackgroundRenderer((*it).videoRenderer,true); } } void QmitkVideoBackground::SetVideoSource( mitk::VideoSource* videoSource ) { if( m_VideoSource == videoSource ) return; if( m_VideoSource ) m_VideoSource->RemoveObserver( m_VideoSourceObserverTag ); m_VideoSource = videoSource; if( m_VideoSource ) { itk::MemberCommand::Pointer _ModifiedCommand = itk::MemberCommand::New(); _ModifiedCommand->SetCallbackFunction(this, &QmitkVideoBackground::OnVideoSourceDelete); m_VideoSourceObserverTag = m_VideoSource->AddObserver(itk::DeleteEvent(), _ModifiedCommand); } } void QmitkVideoBackground::SetTimerDelay( int ms ) { m_QTimer->setInterval( ms ); } mitk::VideoSource* QmitkVideoBackground::GetVideoSource() { return m_VideoSource; } int QmitkVideoBackground::GetTimerDelay() { return m_QTimer->interval(); } -void QmitkVideoBackground::OnVideoSourceDelete( const itk::Object* caller, - const itk::EventObject &event ) +void QmitkVideoBackground::OnVideoSourceDelete(const itk::Object*, + const itk::EventObject&) { this->Disable(); // will only disable if enabled m_VideoSource = 0; } void QmitkVideoBackground::OnRenderWindowDelete( vtkObject * object, - unsigned long eid, + unsigned long, void* clientdata, void*) { QmitkVideoBackground* instance = static_cast( clientdata ); instance->RemoveRenderWindow( static_cast(object), false ); } diff --git a/Utilities/mbilog/mbilogTextDictionary.h b/Utilities/mbilog/mbilogTextDictionary.h index d4c6f8d43b..01b1dfbe3f 100644 --- a/Utilities/mbilog/mbilogTextDictionary.h +++ b/Utilities/mbilog/mbilogTextDictionary.h @@ -1,249 +1,249 @@ /*=================================================================== The Medical Imaging Interaction Toolkit (MITK) Copyright (c) German Cancer Research Center, Division of Medical and Biological Informatics. All rights reserved. This software is distributed WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See LICENSE.txt or http://www.mitk.org for details. ===================================================================*/ #ifndef _MBILOG_TEXTDICTIONARY_H_ #define _MBILOG_TEXTDICTIONARY_H_ namespace mbilog { /** \brief This is a dictionary to replace long names of classes, * modules, etc. to shorter versions in the console output. */ - static char *replace[] = + static const char *replace[] = { ".cpp", "", ".cxx", "", ".txx", "", ".h", "", ".hpp", "", ".hxx", "", ".c", "", "org.blueberry.", "", "org.mitk.gui.qt.", "", "org.mitk.", "", "qmitk", "", "mitk", "", "berry", "", "itk", "", "vtk", "", "qt", "", "object", "obj", "factory", "fac", "classes", "cls", "plugin", "plg", "widget", "wdgt", "interface", "itf", "service", "svc", "register", "reg", "perspective", "prs", "assessor", "ase", "atrophy", "atr", "bias", "bias", "field", "fld", "multi", "mlt", "contour", "cntr", "tools", "tls", "tool", "tl", "application", "app", "calculate", "calc", "subtract", "sub", "region", "reg", "tumor", "tum", "growing", "grow", "segmentation", "seg", "statistics", "stat", "imaging", "img", "image", "img", "diffusion", "dif", "registration", "reg", "navigation", "nav", "generation", "gen", "generator", "gen", "vector", "vec", "gradient", "grad", "flow", "flow", "paint", "pnt", "brush", "brsh", "volumetry", "vol", "volume", "vol", "mapper", "map", "filter", "flt", "surface", "sfc", "point", "pnt", "organ", "org", "multiple", "mlt", "corrector", "cor", "correction", "cor", "batch", "bat", "window", "wnd", "advisor", "adv", "editor", "edt", "material", "mat", "visualization", "vis", "measurement", "mes", "scene", "scn", "serialization", "ser", "deserializer", "dser", "serializer", "ser", "sandbox", "sb", "texture", "tex", "opengl", "ogl", "vessel", "vsl", "value", "val", "analysis", "ana", "patient", "pat", "body", "body", "diagnosis", "diag", "mesh", "mesh", "radial", "rad", "simple", "smp", "algorithms", "alg", "controllers", "con", "control", "con", "interactive", "ia", "interactions", "ia", "processing", "pro", "process", "pro", "rendering", "rnd", "renderer", "rnd", "render", "rnd", "datamanagement", "data", "management", "mng", "manager", "mng", "data", "data", "anatomy", "ana", "neuro", "neo", "automatic", "auto", "optimizer", "opt", "optimize", "opt", "binary", "bin", "liver", "liv", "lymph", "lym", "node", "node", "tree", "tree", "homogeneous", "hmgn", "threshold", "tsh", // "shapebased", "shp", "based", "bsd", "shape", "shp", "model", "mdl", "extension", "ext", "activator", "act", "dicom", "dicom", "browser", "brwr", "viewer", "view", "view", "view", "finder", "fnd", "indexer", "idx", "index", "idx", "rapid", "rpd", "gui", "gui", "slices", "slc", "slice", "slc", "about", "abt", "interpolator", "inp", "switcher", "swh", "planning", "plan", "planner", "plan", "plane", "pln", "plan", "plan", "workbench", "wrkbnc", "common", "com", "resection", "rsc", "translation", "trnsl", "rotation", "rot", "deformation", "dfrm", "shader", "shd", "repository", "rep", "initializer", "init", "dialog", "dlg", "download", "down", "upload", "up", "core", "core", "manual", "man", "leaf", "leaf", "internal", "int", "external", "ext", "platform", "pltfm", "method", "mthd", "pyramidal", "prmdl", "tracking", "trck", "track", "trck", "bspline", "bspl", "spline", "spl", "create", "crt", "erase", "ers", "auto", "auto", "crop", "crop", "file", "file", "io", "io", "2d", "2d", "3d", "3d", ".", "." }; } #endif