void VtkVisPipelineView::convertVTKToOGSMesh() { VtkVisPipelineItem* item = static_cast<VtkVisPipelineItem*>( static_cast<VtkVisPipeline*>(this->model())->getItem(this->selectionModel()->currentIndex())); vtkSmartPointer<vtkAlgorithm> algorithm = item->algorithm(); vtkUnstructuredGrid* grid(NULL); vtkUnstructuredGridAlgorithm* ugAlg = vtkUnstructuredGridAlgorithm::SafeDownCast(algorithm); if (ugAlg) grid = ugAlg->GetOutput(); else { // for old filetypes vtkGenericDataObjectReader* dataReader = vtkGenericDataObjectReader::SafeDownCast(algorithm); if (dataReader) grid = vtkUnstructuredGrid::SafeDownCast(dataReader->GetOutput()); else { // for new filetypes vtkXMLUnstructuredGridReader* xmlReader = vtkXMLUnstructuredGridReader::SafeDownCast(algorithm); grid = vtkUnstructuredGrid::SafeDownCast(xmlReader->GetOutput()); } } MeshLib::Mesh* mesh = MeshLib::VtkMeshConverter::convertUnstructuredGrid(grid); mesh->setName(item->data(0).toString().toStdString()); emit meshAdded(mesh); }
VtkAddFilterDialog::VtkAddFilterDialog( VtkVisPipeline* pipeline, QModelIndex parentIndex, QDialog* parent /*= 0*/ ) : QDialog(parent), _pipeline(pipeline), _parentIndex(parentIndex) { setupUi(this); filterListWidget->setSelectionMode(QAbstractItemView::SingleSelection); VtkVisPipelineItem* parentItem = static_cast<VtkVisPipelineItem*>(_pipeline->getItem(parentIndex)); vtkDataObject* parentDataObject = parentItem->algorithm()->GetOutputDataObject(0); int parentDataObjectType = parentDataObject->GetDataObjectType(); QVector<VtkFilterInfo> filterList = VtkFilterFactory::GetFilterList(); foreach(VtkFilterInfo filter, filterList) { // Check for suitable filters (see vtkDataSet inheritance diagram) int inputType = filter.inputDataObjectType; if ((inputType == parentDataObjectType) || (inputType == VTK_POINT_SET && parentDataObjectType != VTK_IMAGE_DATA) || (inputType == VTK_IMAGE_DATA && (parentDataObjectType == VTK_STRUCTURED_POINTS || parentDataObjectType == VTK_UNIFORM_GRID))) new QListWidgetItem(filter.readableName, filterListWidget); }
void VtkVisPipeline::showMeshElementQuality( InSituLib::VtkMappedMeshSource* source, MeshLib::MeshQualityType t, std::vector<double> const& quality) { if (!source || quality.empty()) return; int const nSources = this->_rootItem->childCount(); for (int i = 0; i < nSources; i++) { VtkVisPipelineItem* parentItem = static_cast<VtkVisPipelineItem*>(_rootItem->child(i)); if (parentItem->algorithm() != source) continue; QList<QVariant> itemData; itemData << "MeshQuality: " + QString::fromStdString( MeshQualityType2String(t)) << true; VtkCompositeFilter* filter = VtkFilterFactory::CreateCompositeFilter("VtkCompositeElementSelectionFilter", parentItem->transformFilter()); if (t == MeshLib::MeshQualityType::ELEMENTSIZE) { auto const range (std::minmax_element(quality.cbegin(), quality.cend())); static_cast<VtkCompositeElementSelectionFilter*>(filter)->setRange(*range.first, *range.second); } static_cast<VtkCompositeElementSelectionFilter*>(filter)->setSelectionArray("Selection", quality); VtkVisPointSetItem* item = new VtkVisPointSetItem(filter, parentItem, itemData); this->addPipelineItem(item, this->createIndex(i, 0, item)); break; } }
void VtkVisPipelineView::contextMenuEvent( QContextMenuEvent* event ) { QModelIndex index = selectionModel()->currentIndex(); if (index.isValid()) { // check object type VtkVisPipelineItem* item = static_cast<VtkVisPipelineItem*>(static_cast<VtkVisPipeline*>( this->model())->getItem(this->selectionModel()->currentIndex())); int objectType = item->algorithm()->GetOutputDataObject(0)->GetDataObjectType(); VtkAlgorithmProperties* vtkProps = item->getVtkProperties(); bool isSourceItem = (this->selectionModel()->currentIndex().parent().isValid()) ? 0 : 1; QMenu menu; QAction* addFilterAction = menu.addAction("Add filter..."); QAction* addLUTAction(NULL); QAction* addMeshingAction(NULL); if (objectType == VTK_IMAGE_DATA) { // this exception is needed as image object are only displayed in the vis-pipeline isSourceItem = false; addMeshingAction = menu.addAction("Convert Image to Mesh..."); connect(addMeshingAction, SIGNAL(triggered()), this, SLOT(showImageToMeshConversionDialog())); } else { addLUTAction = menu.addAction("Add color table..."); connect(addLUTAction, SIGNAL(triggered()), this, SLOT(addColorTable())); } QAction* addConvertToMeshAction(NULL); if (objectType == VTK_UNSTRUCTURED_GRID) { addConvertToMeshAction = menu.addAction("Convert to Mesh..."); connect(addConvertToMeshAction, SIGNAL(triggered()), this, SLOT(convertVTKToOGSMesh())); } menu.addSeparator(); QAction* exportVtkAction = menu.addAction("Export as VTK"); QAction* exportOsgAction = menu.addAction("Export as OpenSG"); QAction* removeAction = NULL; if (!isSourceItem || vtkProps->IsRemovable()) { removeAction = menu.addAction("Remove"); connect(removeAction, SIGNAL(triggered()), this, SLOT(removeSelectedPipelineItem())); } connect(addFilterAction, SIGNAL(triggered()), this, SLOT(addPipelineFilterItem())); connect(exportVtkAction, SIGNAL(triggered()), this, SLOT(exportSelectedPipelineItemAsVtk())); connect(exportOsgAction, SIGNAL(triggered()), this, SLOT(exportSelectedPipelineItemAsOsg())); menu.exec(event->globalPos()); } }
void VtkVisPipeline::removeSourceItem(StationTreeModel* model, const std::string &name) { for (int i = 0; i < _rootItem->childCount(); i++) { VtkVisPipelineItem* item = static_cast<VtkVisPipelineItem*>(getItem(index(i, 0))); if (item->algorithm() == model->vtkSource(name)) { removePipelineItem(index(i, 0)); return; } } }
void VtkVisPipeline::removeSourceItem(ProcessModel* model, const FiniteElement::ProcessType pcs_type, const FEMCondition::CondType cond_type) { for (int i = 0; i < _rootItem->childCount(); i++) { VtkVisPipelineItem* item = static_cast<VtkVisPipelineItem*>(getItem(index(i, 0))); if (item->algorithm() == model->vtkSource(pcs_type, cond_type)) { removePipelineItem(index(i, 0)); return; } } }
VtkVisPointSetItem::VtkVisPointSetItem( vtkAlgorithm* algorithm, TreeItem* parentItem, const QList<QVariant> data /*= QList<QVariant>()*/) : VtkVisPipelineItem(algorithm, parentItem, data), _mapper(nullptr), _transformFilter(nullptr), _onPointData(true), _activeArrayName("") { VtkVisPipelineItem* visParentItem = dynamic_cast<VtkVisPipelineItem*>(parentItem); if (parentItem->parentItem()) { // special case if parent is image but child is not (e.g. Image2BarChartFilter) if (dynamic_cast<vtkImageAlgorithm*>(visParentItem->algorithm())) _algorithm->SetInputConnection(visParentItem->algorithm()->GetOutputPort()); else { VtkVisPointSetItem* pointSetItem = dynamic_cast<VtkVisPointSetItem*>(parentItem); if (pointSetItem) _algorithm->SetInputConnection( pointSetItem->transformFilter()->GetOutputPort()); } } }
void VtkVisPipeline::removeSourceItem(MshModel* model, const QModelIndex &idx) { MshItem* sItem = static_cast<MshItem*>(model->getItem(idx)); for (int i = 0; i < _rootItem->childCount(); i++) { VtkVisPipelineItem* item = static_cast<VtkVisPipelineItem*>(getItem(index(i, 0))); if (item->algorithm() == sItem->vtkSource()) { removePipelineItem(index(i, 0)); return; } } }
void VtkVisPipeline::highlightGeoObject(const vtkPolyDataAlgorithm* source, int index) { this->removeHighlightedGeoObject(); int nSources = this->_rootItem->childCount(); for (int i = 0; i < nSources; i++) { VtkVisPipelineItem* parentItem = static_cast<VtkVisPipelineItem*>(_rootItem->child(i)); if (parentItem->algorithm() == source) { QList<QVariant> itemData; itemData << "Selected GeoObject" << true; VtkCompositeFilter* filter = VtkFilterFactory::CreateCompositeFilter( "VtkCompositeGeoObjectFilter", parentItem->transformFilter()); static_cast<VtkCompositeGeoObjectFilter*>(filter)->SetIndex(index); VtkVisPointSetItem* item = new VtkVisPointSetItem(filter, parentItem, itemData); QModelIndex parent_index = static_cast<TreeModel*>(this)->index(i, 0, QModelIndex()); _highlighted_geo_index = this->addPipelineItem(item, parent_index); break; } } }
void VtkVisPipeline::highlightMeshComponent(vtkUnstructuredGridAlgorithm const*const source, unsigned index, bool is_element) { int nSources = this->_rootItem->childCount(); for (int i = 0; i < nSources; i++) { VtkVisPipelineItem* parentItem = static_cast<VtkVisPipelineItem*>(_rootItem->child(i)); if (parentItem->algorithm() == source) { QList<QVariant> itemData; itemData << "Selected Mesh Component" << true; QList<QVariant> selected_index; selected_index << index << index; VtkCompositeFilter* filter (nullptr); if (is_element) { filter = VtkFilterFactory::CreateCompositeFilter("VtkCompositeElementSelectionFilter", parentItem->transformFilter()); static_cast<VtkCompositeElementSelectionFilter*>(filter)->setSelectionArray("vtkIdFilter_Ids"); static_cast<VtkCompositeElementSelectionFilter*>(filter)->SetUserVectorProperty("Threshold Between", selected_index); } else { filter = VtkFilterFactory::CreateCompositeFilter("VtkCompositeNodeSelectionFilter", parentItem->transformFilter()); std::vector<unsigned> indeces(1); indeces[0] = index; static_cast<VtkCompositeNodeSelectionFilter*>(filter)->setSelectionArray(indeces); } VtkVisPointSetItem* item = new VtkVisPointSetItem(filter, parentItem, itemData); QModelIndex parent_index = static_cast<TreeModel*>(this)->index(i, 0, QModelIndex()); _highlighted_mesh_component = this->addPipelineItem(item, parent_index); break; } } }
void VtkVisPipeline::checkMeshQuality(VtkMeshSource* source, MshQualityType::type t) { if (source) { const MeshLib::Mesh* mesh = source->GetMesh(); MeshLib::MeshQualityChecker* checker (NULL); if (t == MshQualityType::EDGERATIO) checker = new MeshLib::MeshQualityShortestLongestRatio(mesh); else if (t == MshQualityType::AREA) checker = new MeshLib::MeshQualityArea(mesh); else if (t == MshQualityType::VOLUME) checker = new MeshLib::MeshQualityVolume(mesh); else if (t == MshQualityType::EQUIANGLESKEW) checker = new MeshLib::MeshQualityEquiAngleSkew(mesh); else { std::cout << "Error in VtkVisPipeline::checkMeshQuality() - Unknown MshQualityType..." << std::endl; delete checker; return; } checker->check (); std::vector<double> quality (checker->getMeshQuality()); // transform area and volume criterion values to [0, 1] if (t == MshQualityType::AREA || t == MshQualityType::VOLUME) { try { MathLib::LinearIntervalInterpolation<double> lin_intpol(checker->getMinValue(), checker->getMaxValue(), 0, 1); const size_t n_quality(quality.size()); for (size_t k(0); k<n_quality; k++) quality[k] = lin_intpol(quality[k]); } catch (std::runtime_error& exception) { std::cout << "run time error: " << exception.what() << std::endl; } } int nSources = this->_rootItem->childCount(); for (int i = 0; i < nSources; i++) { VtkVisPipelineItem* parentItem = static_cast<VtkVisPipelineItem*>(_rootItem->child(i)); if (parentItem->algorithm() == source) { QList<QVariant> itemData; itemData << "MeshQuality: " + QString::fromStdString( MshQualityType2String(t)) << true; VtkCompositeFilter* filter = VtkFilterFactory::CreateCompositeFilter( "VtkCompositeSelectionFilter", parentItem->transformFilter()); static_cast<VtkCompositeSelectionFilter*>(filter)-> setSelectionArray(quality); VtkVisPointSetItem* item = new VtkVisPointSetItem(filter, parentItem, itemData); this->addPipelineItem(item, this->createIndex(i, 0, item)); break; } } // *** construct and write histogram // simple suggestion: number of classes with Sturges criterion size_t nclasses (static_cast<size_t>(1 + 3.3 * log (static_cast<float>(mesh->getNElements())))); // bool ok; // size_t size (static_cast<size_t>(QInputDialog::getInt(NULL, "OGS-Histogram", "number of histogram classes/spins (min: 1, max: 10000)", static_cast<int>(nclasses), 1, 10000, 1, &ok))); // if (ok) ... BASELIB::Histogram<double> histogram (checker->getHistogram(nclasses)); std::ofstream out ("mesh_histogram.txt"); if (out) { out << "# histogram depicts mesh quality criterion " << MshQualityType2String(t) << " for mesh " << source->GetMesh()->getName() << std::endl; nclasses = histogram.getNrBins(); std::vector<size_t> const& bin_cnts(histogram.getBinCounts()); const double min (histogram.getMinimum()); const double bin_width (histogram.getBinWidth()); for (size_t k(0); k < nclasses; k++) out << min+k*bin_width << " " << bin_cnts[k] << std::endl; out.close (); } else { std::cerr << "could not open file mesh_histgram.txt" << std::endl; } // size_t size (100); // std::vector<size_t> histogram (size,0); // checker->getHistogram(histogram); // std::ofstream out ("mesh_histogram.txt"); // const size_t histogram_size (histogram.size()); // for (size_t k(0); k < histogram_size; k++) // out << k / static_cast<double>(histogram_size) << " " << histogram[k] << // std::endl; // out.close (); delete checker; } }
void VtkVisImageItem::Initialize(vtkRenderer* renderer) { vtkImageAlgorithm* img = dynamic_cast<vtkImageAlgorithm*>(_algorithm); img->Update(); //VtkGeoImageSource* img = dynamic_cast<VtkGeoImageSource*>(_algorithm); double origin[3]; double spacing[3]; double range[2]; img->GetOutput()->GetOrigin(origin); img->GetOutput()->GetSpacing(spacing); //img->getRange(range); img->GetOutput()->GetPointData()->GetScalars()->GetRange(range); vtkImageShiftScale* scale = vtkImageShiftScale::New(); scale->SetOutputScalarTypeToUnsignedChar(); scale->SetInputConnection(img->GetOutputPort()); scale->SetShift(-range[0]); scale->SetScale(255.0/(range[1]-range[0])); _transformFilter = vtkImageChangeInformation::New(); _transformFilter->SetInputConnection(scale->GetOutputPort()); //double origin[3]; //img->getOrigin(origin); //double spacing = img->getSpacing(); //_transformFilter->SetOutputOrigin(origin2); //_transformFilter->SetOutputSpacing(spacing2); _transformFilter->Update(); _renderer = renderer; // Use a special vtkImageActor instead of vtkActor vtkImageActor* imageActor = vtkImageActor::New(); imageActor->SetInput(_transformFilter->GetOutput()); _actor = imageActor; _renderer->AddActor(_actor); // Set pre-set properties VtkAlgorithmProperties* vtkProps = dynamic_cast<VtkAlgorithmProperties*>(_algorithm); if (vtkProps) setVtkProperties(vtkProps); VtkVisPipelineItem* parentItem = dynamic_cast<VtkVisPipelineItem*>(this->parentItem()); while (parentItem) { VtkAlgorithmProperties* parentProps = dynamic_cast<VtkAlgorithmProperties*>(parentItem->algorithm()); if (parentProps) { VtkAlgorithmProperties* newProps = new VtkAlgorithmProperties(); newProps->SetScalarVisibility(parentProps->GetScalarVisibility()); newProps->SetTexture(parentProps->GetTexture()); setVtkProperties(newProps); vtkProps = newProps; parentItem = NULL; } else parentItem = dynamic_cast<VtkVisPipelineItem*>(parentItem->parentItem()); } // Set active scalar to the desired one from VtkAlgorithmProperties // or to match those of the parent. if (vtkProps) { if (vtkProps->GetActiveAttribute().length() > 0) this->SetActiveAttribute(vtkProps->GetActiveAttribute()); else { VtkVisPipelineItem* visParentItem = dynamic_cast<VtkVisPipelineItem*>(this->parentItem()); if (visParentItem) this->SetActiveAttribute(visParentItem->GetActiveAttribute()); if (vtkProps->GetTexture() != NULL) this->SetActiveAttribute("Solid Color"); } } }