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::addColorTable()
{
VtkVisPipelineItem* item (
static_cast<VtkVisPipelineItem*>(static_cast<VtkVisPipeline*>(this->model())->
getItem(this->selectionModel()->currentIndex())) );
const QString array_name = item->GetActiveAttribute();
QSettings settings;
QString filename = QFileDialog::getOpenFileName(this, "Select color table",
settings.value("lastOpenedLutFileDirectory"). toString(),
"Color table files (*.xml);;");
QFileInfo fi(filename);
if (fi.suffix().toLower() == "xml")
{
VtkVisPointSetItem* pointSetItem = dynamic_cast<VtkVisPointSetItem*>(item);
if (pointSetItem)
{
VtkAlgorithmProperties* props = pointSetItem->getVtkProperties();
if (props)
{
props->SetLookUpTable(array_name, filename);
item->SetActiveAttribute(array_name);
emit requestViewUpdate();
}
}
else
QMessageBox::warning(NULL, "Color lookup table could not be applied.",
"Color lookup tables can only be applied to VtkVisPointSetItem.");
QDir dir = QDir(filename);
settings.setValue("lastOpenedLutFileDirectory", dir.absolutePath());
}
}
void VtkVisPipelineView::selectionChanged( const QItemSelection &selected,
const QItemSelection &deselected )
{
QTreeView::selectionChanged(selected, deselected);
if (selected.empty())
return;
QModelIndex index = *selected.indexes().begin();
if (index.isValid())
{
VtkVisPipelineItem* item = static_cast<VtkVisPipelineItem*>(index.internalPointer());
emit actorSelected(item->actor());
emit itemSelected(item);
if (item->transformFilter())
emit dataObjectSelected(vtkDataObject::SafeDownCast(
item->transformFilter()->GetOutputDataObject(0)));
}
else
{
emit actorSelected(NULL);
emit itemSelected(NULL);
emit dataObjectSelected(NULL);
}
}
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);
}
void VtkVisTabWidget::on_scaleZ_textChanged(const QString &text)
{
bool ok = true;
double scale = text.toDouble(&ok);
// If z scale becomes zero, the object becomes invisible
if (ok && scale != 0.0)
{
_item->setScale(1.0, 1.0, scale);
for (int i = 0; i < _item->childCount(); i++)
{
VtkVisPipelineItem* childItem = _item->child(i);
if (childItem)
{
VtkCompositeColorByHeightFilter* colorFilter =
dynamic_cast<VtkCompositeColorByHeightFilter*>
(childItem->compositeFilter());
if (colorFilter)
VtkColorByHeightFilter::SafeDownCast(
colorFilter->GetOutputAlgorithm())->
SetTableRangeScaling(scale);
}
}
emit requestViewUpdate();
}
}
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;
}
}
}
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::setGlobalBackfaceCulling(bool enable) const
{
// iterate over all source items
for (int i = 0; i < _rootItem->childCount(); ++i)
{
VtkVisPipelineItem* item = static_cast<VtkVisPipelineItem*>(_rootItem->child(i));
item->setBackfaceCulling(enable);
// recursively set on all child items
item->setBackfaceCullingOnChildren(enable);
}
emit vtkVisPipelineChanged();
}
void VtkVisPipeline::setGlobalSuperelevation(double factor) const
{
// iterate over all source items
for (int i = 0; i < _rootItem->childCount(); ++i)
{
VtkVisPipelineItem* item = static_cast<VtkVisPipelineItem*>(_rootItem->child(i));
item->setScale(1.0, 1.0, factor);
// recursively set on all child items
item->setScaleOnChildren(1.0, 1.0, 1.0);
}
emit vtkVisPipelineChanged();
}
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::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 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");
}
}
}
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 VtkVisPointSetItem::Initialize(vtkRenderer* renderer)
{
// TODO vtkTransformFilter creates a new copy of the point coordinates which
// conflicts with VtkMappedMeshSource. Find a workaround!
_transformFilter = vtkTransformFilter::New();
vtkSmartPointer<vtkTransform> transform = vtkSmartPointer<vtkTransform>::New();
transform->Identity();
_transformFilter->SetTransform(transform);
_transformFilter->SetInputConnection(_algorithm->GetOutputPort());
_transformFilter->Update();
_renderer = renderer;
_mapper = QVtkDataSetMapper::New();
_mapper->InterpolateScalarsBeforeMappingOff();
_mapper->SetColorModeToMapScalars();
_mapper->SetInputConnection(_transformFilter->GetOutputPort());
_actor = vtkActor::New();
static_cast<vtkActor*>(_actor)->SetMapper(_mapper);
_renderer->AddActor(_actor);
// Determine the right pre-set properties
// Order is: _algorithm, _compositeFilter, create a new one with props copied from parent
VtkAlgorithmProperties* vtkProps = dynamic_cast<VtkAlgorithmProperties*>(_algorithm);
if (!vtkProps)
{
vtkProps = dynamic_cast<VtkAlgorithmProperties*>(_compositeFilter);
// Copy properties from parent or create a new VtkAlgorithmProperties
if (!vtkProps)
{
VtkVisPipelineItem* parentItem = dynamic_cast<VtkVisPipelineItem*>(this->parentItem());
while (parentItem)
{
VtkAlgorithmProperties* parentProps = nullptr;
if(dynamic_cast<VtkVisPointSetItem*>(parentItem))
parentProps = dynamic_cast<VtkVisPointSetItem*>(parentItem)->getVtkProperties();
if (parentProps)
{
vtkProps = new VtkAlgorithmProperties(); // TODO memory leak?
vtkProps->SetScalarVisibility(parentProps->GetScalarVisibility());
vtkProps->SetTexture(parentProps->GetTexture());
vtkProps->SetActiveAttribute(parentProps->GetActiveAttribute());
parentItem = nullptr;
}
else
parentItem = dynamic_cast<VtkVisPipelineItem*>(parentItem->parentItem());
}
// Has no parents
if (!vtkProps)
vtkProps = new VtkAlgorithmProperties(); // TODO memory leak?
}
}
_vtkProps = vtkProps;
if (vtkProps->GetActiveAttribute().length() == 0)
{
// Get first scalar and set it to active
QStringList arrayNames = this->getScalarArrayNames();
if (arrayNames.length() > 0)
vtkProps->SetActiveAttribute(arrayNames[0]);
else
vtkProps->SetActiveAttribute("Solid Color");
}
this->setVtkProperties(vtkProps);
this->SetActiveAttribute(vtkProps->GetActiveAttribute());
// Set global backface culling
QSettings settings;
bool backfaceCulling = settings.value("globalCullBackfaces", 0).toBool();
this->setBackfaceCulling(backfaceCulling);
// Set the correct threshold range
if (dynamic_cast<VtkCompositeThresholdFilter*>(this->_compositeFilter) )
{
double range[2];
this->GetRangeForActiveAttribute(range);
QList<QVariant> thresholdRangeList;
thresholdRangeList.push_back(range[0]);
thresholdRangeList.push_back(range[1]);
dynamic_cast<VtkCompositeFilter*>(this->_compositeFilter)
->SetUserVectorProperty("Range", thresholdRangeList);
}
// Show edges on meshes
if (dynamic_cast<MeshLib::VtkMappedMeshSource*>(this->_algorithm))
_vtkProps->GetProperties()->SetEdgeVisibility(1);
}
