diff --git a/Applications/ParaView/ParaViewFilters.xml b/Applications/ParaView/ParaViewFilters.xml index 33a878e..137ac3a 100644 --- a/Applications/ParaView/ParaViewFilters.xml +++ b/Applications/ParaView/ParaViewFilters.xml @@ -106,6 +106,7 @@ + diff --git a/Applications/StreamingParaView/streamingMainWindow.cxx b/Applications/StreamingParaView/streamingMainWindow.cxx index 050e93e..ebbbaa8 100644 --- a/Applications/StreamingParaView/streamingMainWindow.cxx +++ b/Applications/StreamingParaView/streamingMainWindow.cxx @@ -47,7 +47,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "pqApplicationCore.h" #include "pqCustomDisplayPolicy.h" -#include +#include #include #include diff --git a/Plugins/CoProcessingScriptGenerator/pqCPExportStateWizard.cxx b/Plugins/CoProcessingScriptGenerator/pqCPExportStateWizard.cxx index bf8c141..4f2aab3 100644 --- a/Plugins/CoProcessingScriptGenerator/pqCPExportStateWizard.cxx +++ b/Plugins/CoProcessingScriptGenerator/pqCPExportStateWizard.cxx @@ -144,7 +144,8 @@ pqCPExportStateWizard::pqCPExportStateWizard( this->Internals = new pqInternals(); this->Internals->setupUi(this); ::ActiveWizard = NULL; - this->setOption(QWizard::NoCancelButton, false); + // the mac style does not have a cancel button so we want to not use it + this->setWizardStyle(ModernStyle); QObject::connect(this->Internals->allInputs, SIGNAL(itemSelectionChanged()), this, SLOT(updateAddRemoveButton())); diff --git a/Qt/ApplicationComponents/pqSaveStateReaction.cxx b/Qt/ApplicationComponents/pqSaveStateReaction.cxx index 40c6832..df8afd3 100644 --- a/Qt/ApplicationComponents/pqSaveStateReaction.cxx +++ b/Qt/ApplicationComponents/pqSaveStateReaction.cxx @@ -63,7 +63,7 @@ void pqSaveStateReaction::saveState() { pqFileDialog fileDialog(NULL, pqCoreUtilities::mainWidget(), - tr("Save State File"), QString(), + tr("Load State File"), QString(), tr("ParaView state file (*.pvsm);;All files (*)")); fileDialog.setObjectName("FileSaveServerStateDialog"); fileDialog.setFileMode(pqFileDialog::AnyFile); diff --git a/Qt/Components/Resources/UI/pqDisplayProxyEditor.ui b/Qt/Components/Resources/UI/pqDisplayProxyEditor.ui index 1d0bf2c..2f7c5c7 100644 --- a/Qt/Components/Resources/UI/pqDisplayProxyEditor.ui +++ b/Qt/Components/Resources/UI/pqDisplayProxyEditor.ui @@ -581,13 +581,43 @@ - + + Subdivision + + + + + + + Nonlinear faces are approximated with flat polygons. This parameter controls how many times to subdivide nonlinear surface cells. Higher subdivisions generate closer approximations but take more memory and rendering time. Subdivision is recursive, so the number of output polygons can grow exponentially with this parameter. + + + 4 + + + + + + + Qt::Horizontal + + + + 40 + 20 + + + + + + + Volume mapper - + <html><head><meta name="qrichtext" content="1" /></head><body style=" white-space: pre-wrap; font-family:Sans Serif; font-size:9pt; font-weight:400; font-style:normal; text-decoration:none;"><p style=" margin-top:0px; margin-bottom:0px; margin-left:0px; margin-right:0px; -qt-block-indent:0; text-indent:0px;">Choose the mapper to use for volume rendering.</p></body></html> @@ -1123,6 +1153,7 @@ StylePointSize StyleLineWidth Opacity + NonlinearSubdivisionLevel SelectedMapperIndex EdgeColor SpecularIntensity diff --git a/Qt/Components/pqDisplayProxyEditor.cxx b/Qt/Components/pqDisplayProxyEditor.cxx index 64cfa25..bc3f83b 100644 --- a/Qt/Components/pqDisplayProxyEditor.cxx +++ b/Qt/Components/pqDisplayProxyEditor.cxx @@ -390,6 +390,15 @@ void pqDisplayProxyEditor::setRepresentation(pqPipelineRepresentation* repr) "value", SIGNAL(editingFinished()), reprProxy, reprProxy->GetProperty("Opacity")); + // setup of nonlinear subdivision + if (reprProxy->GetProperty("NonlinearSubdivisionLevel")) + { + this->Internal->Links->addPropertyLink( + this->Internal->NonlinearSubdivisionLevel, + "value", SIGNAL(valueChanged(int)), + reprProxy, reprProxy->GetProperty("NonlinearSubdivisionLevel")); + } + // setup for map scalars this->Internal->Links->addPropertyLink( this->Internal->ColorMapScalars, "checked", SIGNAL(stateChanged(int)), diff --git a/Qt/Core/pqContextView.cxx b/Qt/Core/pqContextView.cxx index 6077334..c03277b 100644 --- a/Qt/Core/pqContextView.cxx +++ b/Qt/Core/pqContextView.cxx @@ -283,12 +283,6 @@ void pqContextView::selectionChanged() opPort->getSource()->getProxy()); vtkSMSourceProxy* selectionSource = opPort->getSelectionInput(); - int selectionType = vtkSelectionNode::POINT; - if (QString(opPort->getDataClassName()) == "vtkTable") - { - selectionType = vtkSelectionNode::ROW; - } - if (!selectionSource) { vtkSMProxyManager* pxm = vtkSMProxyManager::GetProxyManager(); @@ -296,7 +290,7 @@ void pqContextView::selectionChanged() vtkSMSourceProxy::SafeDownCast(pxm->NewProxy("sources", "IDSelectionSource")); selectionSource->SetConnectionID(pqRepr->getServer()->GetConnectionID()); selectionSource->SetServers(vtkProcessModule::DATA_SERVER); - vtkSMPropertyHelper(selectionSource, "FieldType").Set(selectionType); + vtkSMPropertyHelper(selectionSource, "FieldType").Set(vtkSelectionNode::POINT); selectionSource->UpdateVTKObjects(); } else diff --git a/Qt/Core/pqSpreadSheetViewModel.cxx b/Qt/Core/pqSpreadSheetViewModel.cxx index 1e443b8..51a711a 100644 --- a/Qt/Core/pqSpreadSheetViewModel.cxx +++ b/Qt/Core/pqSpreadSheetViewModel.cxx @@ -309,8 +309,7 @@ void pqSpreadSheetViewModel::updateSelectionForBlock(vtkIdType blockNumber) vtkSMSpreadSheetRepresentationProxy* repr = this->Internal->Representation; if (repr && (this->Internal->getFieldType() == vtkDataObject::FIELD_ASSOCIATION_CELLS || - this->Internal->getFieldType() == vtkDataObject::FIELD_ASSOCIATION_POINTS || - this->Internal->getFieldType() == vtkDataObject::FIELD_ASSOCIATION_ROWS) ) + this->Internal->getFieldType() == vtkDataObject::FIELD_ASSOCIATION_POINTS)) { // If we are showing only the selected items, then there's not point in // highlighting the selected items, since all items are selected. So we diff --git a/Servers/Filters/CMakeLists.txt b/Servers/Filters/CMakeLists.txt index acf0a71..2adaebd 100644 --- a/Servers/Filters/CMakeLists.txt +++ b/Servers/Filters/CMakeLists.txt @@ -70,6 +70,7 @@ SET(Filters_SRCS vtkIntegrateAttributes.cxx vtkIntegrateFlowThroughSurface.cxx vtkInteractorStyleTransferFunctionEditor.cxx + vtkPVIsoVolume.cxx vtkKdTreeGenerator.cxx vtkKdTreeManager.cxx vtkMergeArrays.cxx @@ -96,7 +97,6 @@ SET(Filters_SRCS vtkPSciVizMultiCorrelativeStats.cxx vtkPSciVizPCAStats.cxx vtkPSciVizKMeans.cxx - vtkPVAMRDualClip.cxx vtkPVAnimationScene.cxx vtkPVArrayCalculator.cxx vtkPVArrowSource.cxx @@ -129,6 +129,7 @@ SET(Filters_SRCS vtkPVMain.cxx vtkPVMergeTables.cxx vtkPVNullSource.cxx + vtkPVRecoverGeometryWireframe.cxx vtkPVRenderViewProxy.cxx vtkPVScalarBarActor.cxx vtkPVSelectionSource.cxx diff --git a/Servers/Filters/Testing/Cxx/CMakeLists.txt b/Servers/Filters/Testing/Cxx/CMakeLists.txt index c5495f5..067caee 100644 --- a/Servers/Filters/Testing/Cxx/CMakeLists.txt +++ b/Servers/Filters/Testing/Cxx/CMakeLists.txt @@ -35,7 +35,7 @@ IF (VTK_USE_DISPLAY AND VTK_DATA_ROOT AND PARAVIEW_DATA_ROOT) # Enable these after the transfer function can take the vtkTable histograms. #TestTransferFunctionEditor #TestTransferFunctionEditor2 -TestPVAMRDualClip +TestPVIsoVolume ) FOREACH(name ${ServersFiltersImage_SRCS}) ADD_EXECUTABLE(${name} ${name}.cxx) diff --git a/Servers/Filters/Testing/Cxx/TestPVAMRDualClip.cxx b/Servers/Filters/Testing/Cxx/TestPVAMRDualClip.cxx deleted file mode 100644 index 314fe7e..0000000 --- a/Servers/Filters/Testing/Cxx/TestPVAMRDualClip.cxx +++ /dev/null @@ -1,89 +0,0 @@ -#include "vtkActor.h" -#include "vtkDataSetSurfaceFilter.h" -#include "vtkDummyController.h" -#include "vtkPolyDataMapper.h" -#include "vtkPVGeometryFilter.h" -#include "vtkPVAMRDualClip.h" -#include "vtkRegressionTestImage.h" -#include "vtkRenderer.h" -#include "vtkRenderWindow.h" -#include "vtkRenderWindowInteractor.h" -#include "vtkSmartPointer.h" -#include "vtkSpyPlotReader.h" -#include "vtkTestUtilities.h" - -int main(int argc, char* argv[]) -{ - int retVal = 0; - - typedef vtkSmartPointer vtkDataSetSurfaceFilterRefPtr; - typedef vtkSmartPointer vtkPVAMRDualClipRefPtr; - typedef vtkSmartPointer vtkSpyPlotReaderRefPtr; - typedef vtkSmartPointer vtkPolyDataMapperRefPtr; - typedef vtkSmartPointer vtkActorRefPtr; - typedef vtkSmartPointer vtkRenderRefPtr; - typedef vtkSmartPointer vtkRenderWindowRefPtr; - typedef vtkSmartPointer vtkDummyControllerRefPtr; - typedef vtkSmartPointer vtkPVGeometryFilterRefPtr; - typedef vtkSmartPointer vtkRenderWindowInteractorRefPtr; - - const char* fname = - vtkTestUtilities::ExpandDataFileName(argc, argv, "Data/SPCTH/restarted/spcth.0"); - - if(!fname) - { - return retVal; - } - - vtkDummyControllerRefPtr controller (vtkDummyControllerRefPtr::New()); - vtkMultiProcessController::SetGlobalController(controller); - - vtkSpyPlotReaderRefPtr reader = vtkSpyPlotReaderRefPtr::New(); - reader->SetFileName(fname); - reader->SetGlobalController(controller); - reader->MergeXYZComponentsOn(); - reader->DownConvertVolumeFractionOn(); - reader->DistributeFilesOn(); - reader->SetCellArrayStatus("Material volume fraction - 3", 1); - reader->Update(); - - vtkPVAMRDualClipRefPtr filter = vtkPVAMRDualClipRefPtr::New(); - filter->SetInput(reader->GetOutputDataObject(0)); - filter->SetVolumeFractionSurfaceValue(0.1); - filter->SetEnableMergePoints(1); - filter->SetEnableDegenerateCells(1); - filter->SetEnableMultiProcessCommunication(1); - filter->AddInputCellArrayToProcess("Material volume fraction - 3"); - filter->Update(); - - vtkPVGeometryFilterRefPtr surface (vtkPVGeometryFilterRefPtr::New()); - surface->SetUseOutline(0); - surface->SetInput(filter->GetOutputDataObject(0)); - surface->Update(); - - vtkPolyDataMapperRefPtr mapper (vtkPolyDataMapperRefPtr::New()); - mapper->SetInput(surface->GetOutput()); - mapper->Update(); - - vtkActorRefPtr actor (vtkActorRefPtr::New()); - actor->SetMapper(mapper); - - vtkRenderRefPtr renderer (vtkRenderRefPtr::New()); - renderer->AddActor(actor); - renderer->ResetCamera(); - - vtkRenderWindowRefPtr renWin (vtkRenderWindowRefPtr::New()); - renWin->AddRenderer(renderer); - - vtkRenderWindowInteractorRefPtr iren (vtkRenderWindowInteractorRefPtr::New()); - iren->SetRenderWindow(renWin); - - retVal = vtkRegressionTestImage(renWin); - if(retVal == vtkRegressionTester::DO_INTERACTOR) - { - iren->Start(); - retVal = vtkRegressionTester::PASSED; - } - - return (retVal == vtkRegressionTester::PASSED) ? 0 : 1; -} diff --git a/Servers/Filters/Testing/Cxx/TestPVIsoVolume.cxx b/Servers/Filters/Testing/Cxx/TestPVIsoVolume.cxx new file mode 100644 index 0000000..a952949 --- /dev/null +++ b/Servers/Filters/Testing/Cxx/TestPVIsoVolume.cxx @@ -0,0 +1,91 @@ + +#include "vtkActor.h" +#include "vtkDataSetSurfaceFilter.h" +#include "vtkDummyController.h" +#include "vtkPolyDataMapper.h" +#include "vtkPVGeometryFilter.h" +#include "vtkPVIsoVolume.h" +#include "vtkRegressionTestImage.h" +#include "vtkRenderer.h" +#include "vtkRenderWindow.h" +#include "vtkRenderWindowInteractor.h" +#include "vtkSmartPointer.h" +#include "vtkSpyPlotReader.h" +#include "vtkTestUtilities.h" + +int main(int argc, char* argv[]) +{ + int retVal = 0; + + typedef vtkSmartPointer vtkDataSetSurfaceFilterRefPtr; + typedef vtkSmartPointer vtkPVIsoVolumeRefPtr; + typedef vtkSmartPointer vtkSpyPlotReaderRefPtr; + typedef vtkSmartPointer vtkPolyDataMapperRefPtr; + typedef vtkSmartPointer vtkActorRefPtr; + typedef vtkSmartPointer vtkRenderRefPtr; + typedef vtkSmartPointer vtkRenderWindowRefPtr; + typedef vtkSmartPointer vtkDummyControllerRefPtr; + typedef vtkSmartPointer vtkPVGeometryFilterRefPtr; + typedef vtkSmartPointer vtkRenderWindowInteractorRefPtr; + + const char* fname = + vtkTestUtilities::ExpandDataFileName(argc, argv, "Data/SPCTH/restarted/spcth.0"); + + if(!fname) + { + return retVal; + } + + vtkDummyControllerRefPtr controller (vtkDummyControllerRefPtr::New()); + vtkMultiProcessController::SetGlobalController(controller); + + vtkSpyPlotReaderRefPtr reader = vtkSpyPlotReaderRefPtr::New(); + reader->SetFileName(fname); + reader->SetGlobalController(controller); + reader->MergeXYZComponentsOn(); + reader->DownConvertVolumeFractionOn(); + reader->DistributeFilesOn(); + reader->SetCellArrayStatus("Material volume fraction - 3", 1); + reader->Update(); + + vtkPVIsoVolumeRefPtr filter = vtkPVIsoVolumeRefPtr::New(); + filter->SetInput(reader->GetOutputDataObject(0)); + filter->SetVolumeFractionSurfaceValue(0.1); + filter->SetEnableMergePoints(1); + filter->SetEnableDegenerateCells(1); + filter->SetEnableMultiProcessCommunication(1); + filter->AddInputCellArrayToProcess("Material volume fraction - 3"); + filter->Update(); + + vtkPVGeometryFilterRefPtr surface (vtkPVGeometryFilterRefPtr::New()); + surface->SetUseOutline(0); + surface->SetInput(filter->GetOutputDataObject(0)); + surface->Update(); + + vtkPolyDataMapperRefPtr mapper (vtkPolyDataMapperRefPtr::New()); + mapper->SetInput(surface->GetOutput()); + mapper->Update(); + + vtkActorRefPtr actor (vtkActorRefPtr::New()); + actor->SetMapper(mapper); + + vtkRenderRefPtr renderer (vtkRenderRefPtr::New()); + renderer->AddActor(actor); + renderer->ResetCamera(); + + vtkRenderWindowRefPtr renWin (vtkRenderWindowRefPtr::New()); + renWin->AddRenderer(renderer); + + vtkRenderWindowInteractorRefPtr iren (vtkRenderWindowInteractorRefPtr::New()); + iren->SetRenderWindow(renWin); + + retVal = vtkRegressionTestImage(renWin); + if(retVal == vtkRegressionTester::DO_INTERACTOR) + { + iren->Start(); + retVal = vtkRegressionTester::PASSED; + } + + return (retVal == vtkRegressionTester::PASSED) ? 0 : 1; +} + diff --git a/Servers/Filters/vtkPVAMRDualClip.cxx b/Servers/Filters/vtkPVAMRDualClip.cxx deleted file mode 100644 index 59e7e69..0000000 --- a/Servers/Filters/vtkPVAMRDualClip.cxx +++ /dev/null @@ -1,97 +0,0 @@ -#include "vtkPVAMRDualClip.h" - -#include "vtkHierarchicalBoxDataSet.h" -#include "vtkInformation.h" -#include "vtkInformationVector.h" -#include "vtkMultiBlockDataSet.h" -#include "vtkObjectFactory.h" - -#include "vtkCompositeDataIterator.h" - -#include // STL required. -#include // STL required. - -vtkCxxRevisionMacro(vtkPVAMRDualClip, "1.1"); -vtkStandardNewMacro(vtkPVAMRDualClip); - -const double PV_AMR_SURFACE_VALUE_UNSIGNED_CHAR=255; - -//----------------------------------------------------------------------------- -class vtkPVAMRDualClipInternal -{ -public: - - vtkstd::vector CellArrays; -}; - -//----------------------------------------------------------------------------- -vtkPVAMRDualClip::vtkPVAMRDualClip() : - vtkAMRDualClip(), - VolumeFractionSurfaceValue(1.0) -{ - this->Implementation = new vtkPVAMRDualClipInternal(); -} - -//----------------------------------------------------------------------------- -vtkPVAMRDualClip::~vtkPVAMRDualClip() -{ - if(this->Implementation) - { - delete this->Implementation; - this->Implementation = 0; - } -} - -//----------------------------------------------------------------------------- -void vtkPVAMRDualClip::PrintSelf(ostream &os, vtkIndent indent) -{ - this->Superclass::PrintSelf(os, indent); -} - -//----------------------------------------------------------------------------- -int vtkPVAMRDualClip::RequestData(vtkInformation* vtkNotUsed(request), - vtkInformationVector** inputVector, - vtkInformationVector* outputVector) -{ - vtkInformation* inInfo = inputVector[0]->GetInformationObject(0); - vtkHierarchicalBoxDataSet* hbdsInput=vtkHierarchicalBoxDataSet::SafeDownCast( - inInfo->Get(vtkDataObject::DATA_OBJECT())); - - vtkInformation *outInfo; - outInfo = outputVector->GetInformationObject(0); - vtkMultiBlockDataSet* mbdsOutput0 = vtkMultiBlockDataSet::SafeDownCast( - outInfo->Get(vtkDataObject::DATA_OBJECT())); - - - this->SetIsoValue(this->VolumeFractionSurfaceValue * - PV_AMR_SURFACE_VALUE_UNSIGNED_CHAR); - - size_t noOfArrays = this->Implementation->CellArrays.size(); - for(size_t i=0; i < noOfArrays; ++i) - { - vtkMultiBlockDataSet* out = this->DoRequestData( - hbdsInput, this->Implementation->CellArrays[i].c_str()); - - if(out) - { - /// Assign the name to the block by the array name. - mbdsOutput0->SetBlock(i, out); - out->Delete(); - } - } - return 1; -} - -//----------------------------------------------------------------------------- -void vtkPVAMRDualClip::AddInputCellArrayToProcess(const char* name) -{ - this->Implementation->CellArrays.push_back(vtkstd::string(name)); - this->Modified(); -} - -//----------------------------------------------------------------------------- -void vtkPVAMRDualClip::ClearInputCellArrayToProcess() -{ - this->Implementation->CellArrays.clear(); - this->Modified(); -} diff --git a/Servers/Filters/vtkPVAMRDualClip.h b/Servers/Filters/vtkPVAMRDualClip.h deleted file mode 100644 index c1f1213..0000000 --- a/Servers/Filters/vtkPVAMRDualClip.h +++ /dev/null @@ -1,68 +0,0 @@ -/*========================================================================= - - Program: ParaView - Module: vtkPVAMRDualClip.h - - Copyright (c) Kitware, Inc. - All rights reserved. - See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details. - - This software is distributed WITHOUT ANY WARRANTY; without even - the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR - PURPOSE. See the above copyright notice for more information. - -=========================================================================*/ -// .NAME vtkPVAMRDualClip - Generates contour given one or more cell array -// and a volume fraction value. -// -// .SECTION Description -// -// .SEE vtkAMRDualClip -// - -#ifndef __vtkPVAMRDualClip_h -#define __vtkPVAMRDualClip_h - -#include "vtkAMRDualClip.h" - -// Forware declaration. -class vtkPVAMRDualClipInternal; - -class VTK_EXPORT vtkPVAMRDualClip : public vtkAMRDualClip -{ -public: - static vtkPVAMRDualClip* New(); - vtkTypeRevisionMacro(vtkPVAMRDualClip,vtkAMRDualClip); - void PrintSelf(ostream& os, vtkIndent indent); - - vtkPVAMRDualClip(); - ~vtkPVAMRDualClip(); - - // Description: - // Add to list of cell arrays which are used for generating contours. - void AddInputCellArrayToProcess(const char* name); - void ClearInputCellArrayToProcess(); - - // Description: - // Get / Set volume fraction value. - vtkGetMacro(VolumeFractionSurfaceValue, double); - vtkSetMacro(VolumeFractionSurfaceValue, double); - - //BTX - virtual int RequestData(vtkInformation*, vtkInformationVector**, - vtkInformationVector*); - -private: - vtkPVAMRDualClip(const vtkPVAMRDualClip&); // Not implemented. - void operator=(const vtkPVAMRDualClip&); // Not implemented. - - //ETX - -protected: - - double VolumeFractionSurfaceValue; - - vtkPVAMRDualClipInternal* Implementation; -}; - -#endif // __vtkPVAMRDualClip_h diff --git a/Servers/Filters/vtkPVExtractSelection.cxx b/Servers/Filters/vtkPVExtractSelection.cxx index e7d2da8..c542828 100644 --- a/Servers/Filters/vtkPVExtractSelection.cxx +++ b/Servers/Filters/vtkPVExtractSelection.cxx @@ -28,12 +28,10 @@ #include "vtkSelection.h" #include "vtkSelectionNode.h" #include "vtkSmartPointer.h" -#include "vtkTable.h" -#include "vtkGraph.h" #include -class vtkPVExtractSelection::vtkSelectionNodeVector : +class vtkPVExtractSelection::vtkSelectionNodeVector : public vtkstd::vector > { }; @@ -84,7 +82,7 @@ int vtkPVExtractSelection::RequestDataObject( { vtkInformation* info = outputVector->GetInformationObject(i); vtkSelection *selOut = vtkSelection::GetData(info); - if (!selOut || !selOut->IsA("vtkSelection")) + if (!selOut || !selOut->IsA("vtkSelection")) { vtkDataObject* newOutput = vtkSelection::New(); if (!newOutput) @@ -119,20 +117,15 @@ int vtkPVExtractSelection::RequestData( vtkCompositeDataSet* cdInput = vtkCompositeDataSet::SafeDownCast(inputDO); vtkCompositeDataSet* cdOutput = vtkCompositeDataSet::GetData(outputVector, 0); - vtkDataObject *dataObjectOutput = vtkDataObject::GetData(outputVector, 0); + vtkDataSet *geomOutput = vtkDataSet::GetData(outputVector, 0); //make an ids selection for the second output - //we can do this because all of the extractSelectedX filters produce - //arrays called "vtkOriginalXIds" that record what input cells produced + //we can do this because all of the extractSelectedX filters produce + //arrays called "vtkOriginalXIds" that record what input cells produced //each output cell, at least as long as PRESERVE_TOPOLOGY is off - //when we start allowing PreserveTopology, this will have to instead run + //when we start allowing PreserveTopology, this will have to instead run //through the vtkInsidedNess arrays, and for every on entry, record the //entries index - // - // TODO: The ExtractSelectedGraph filter does not produce the vtkOriginalXIds, - // so to add support for vtkGraph selection in ParaView the filter will have - // to be extended. This requires test cases in ParaView to confirm it functions - // as expected. vtkSelection *output = vtkSelection::SafeDownCast( outputVector->GetInformationObject(1)->Get(vtkDataObject::DATA_OBJECT())); @@ -182,9 +175,9 @@ int vtkPVExtractSelection::RequestData( // vtkSelection instances correctly to help identify the block they came // from. vtkCompositeDataIterator* iter = cdInput->NewIterator(); - vtkHierarchicalBoxDataIterator* hbIter = + vtkHierarchicalBoxDataIterator* hbIter = vtkHierarchicalBoxDataIterator::SafeDownCast(iter); - for (iter->InitTraversal(); !iter->IsDoneWithTraversal(); + for (iter->InitTraversal(); !iter->IsDoneWithTraversal(); iter->GoToNextItem()) { vtkSelectionNode* curSel = this->LocateSelection(iter->GetCurrentFlatIndex(), @@ -195,18 +188,18 @@ int vtkPVExtractSelection::RequestData( hbIter->GetCurrentIndex(), sel); } - dataObjectOutput = vtkDataObject::SafeDownCast(cdOutput->GetDataSet(iter)); + geomOutput = vtkDataSet::SafeDownCast(cdOutput->GetDataSet(iter)); vtkSelectionNodeVector curOVector; - if (curSel && dataObjectOutput) + if (curSel && geomOutput) { - this->RequestDataInternal(curOVector, dataObjectOutput, curSel); + this->RequestDataInternal(curOVector, geomOutput, curSel); } for (vtkSelectionNodeVector::iterator giter = non_composite_nodes.begin(); giter != non_composite_nodes.end(); ++giter) { - this->RequestDataInternal(curOVector, dataObjectOutput, giter->GetPointer()); + this->RequestDataInternal(curOVector, geomOutput, giter->GetPointer()); } for (vtkSelectionNodeVector::iterator viter = curOVector.begin(); @@ -221,12 +214,12 @@ int vtkPVExtractSelection::RequestData( } iter->Delete(); } - else if (dataObjectOutput) // and not composite dataset. + else if (geomOutput) { unsigned int numNodes = sel->GetNumberOfNodes(); for (unsigned int i = 0; i < numNodes; i++) { - this->RequestDataInternal(oVector, dataObjectOutput, sel->GetNode(i)); + this->RequestDataInternal(oVector, geomOutput, sel->GetNode(i)); } } @@ -274,7 +267,7 @@ vtkSelectionNode* vtkPVExtractSelection::LocateSelection(unsigned int composite_ if (node) { if (node->GetProperties()->Has(vtkSelectionNode::COMPOSITE_INDEX()) && - node->GetProperties()->Get(vtkSelectionNode::COMPOSITE_INDEX()) == + node->GetProperties()->Get(vtkSelectionNode::COMPOSITE_INDEX()) == static_cast(composite_index)) { return node; @@ -286,27 +279,23 @@ vtkSelectionNode* vtkPVExtractSelection::LocateSelection(unsigned int composite_ //---------------------------------------------------------------------------- void vtkPVExtractSelection::RequestDataInternal(vtkSelectionNodeVector& outputs, - vtkDataObject* dataObjectOutput, vtkSelectionNode* sel) + vtkDataSet* geomOutput, vtkSelectionNode* sel) { // DON'T CLEAR THE outputs. - vtkDataSet* ds = vtkDataSet::SafeDownCast(dataObjectOutput); - vtkTable* table = vtkTable::SafeDownCast(dataObjectOutput); - vtkGraph* graph = vtkGraph::SafeDownCast(dataObjectOutput); - int ft = vtkSelectionNode::CELL; if (sel && sel->GetProperties()->Has(vtkSelectionNode::FIELD_TYPE())) { ft = sel->GetProperties()->Get(vtkSelectionNode::FIELD_TYPE()); } - if (ds && ft == vtkSelectionNode::CELL) + if (geomOutput && ft == vtkSelectionNode::CELL) { vtkSelectionNode* output = vtkSelectionNode::New(); output->GetProperties()->Copy(sel->GetProperties(), /*deep=*/1); output->SetContentType(vtkSelectionNode::INDICES); vtkIdTypeArray *oids = vtkIdTypeArray::SafeDownCast( - ds->GetCellData()->GetArray("vtkOriginalCellIds")); + geomOutput->GetCellData()->GetArray("vtkOriginalCellIds")); if (oids) { output->SetSelectionList(oids); @@ -316,15 +305,14 @@ void vtkPVExtractSelection::RequestDataInternal(vtkSelectionNodeVector& outputs, } // no else, since original point indices are always passed. - if (ds && ( - ft == vtkSelectionNode::CELL || ft == vtkSelectionNode::POINT)) + if (geomOutput) { vtkSelectionNode* output = vtkSelectionNode::New(); output->GetProperties()->Copy(sel->GetProperties(), /*deep=*/1); output->SetFieldType(vtkSelectionNode::POINT); output->SetContentType(vtkSelectionNode::INDICES); vtkIdTypeArray* oids = vtkIdTypeArray::SafeDownCast( - ds->GetPointData()->GetArray("vtkOriginalPointIds")); + geomOutput->GetPointData()->GetArray("vtkOriginalPointIds")); if (oids) { output->SetSelectionList(oids); @@ -332,32 +320,6 @@ void vtkPVExtractSelection::RequestDataInternal(vtkSelectionNodeVector& outputs, } output->Delete(); } - - if (table && ft == vtkSelectionNode::ROW) - { - vtkSelectionNode* output = vtkSelectionNode::New(); - output->GetProperties()->Copy(sel->GetProperties(), /*deep=*/1); - output->SetFieldType(vtkSelectionNode::ROW); - output->SetContentType(vtkSelectionNode::INDICES); - vtkIdTypeArray* oids = vtkIdTypeArray::SafeDownCast( - table->GetRowData()->GetArray("vtkOriginalRowIds")); - if (oids) - { - output->SetSelectionList(oids); - outputs.push_back(output); - } - output->Delete(); - } - - // The ExtractSelectedGraph filter does not produce the vtkOriginal*Ids array, - // it will need extending to be able to follow the same pattern (with some - // test cases to verify functionality). - if (graph && ft == vtkSelectionNode::VERTEX) - { - } - if (graph && ft == vtkSelectionNode::EDGE) - { - } } //---------------------------------------------------------------------------- diff --git a/Servers/Filters/vtkPVExtractSelection.h b/Servers/Filters/vtkPVExtractSelection.h index 93517ad..b8eedaf 100644 --- a/Servers/Filters/vtkPVExtractSelection.h +++ b/Servers/Filters/vtkPVExtractSelection.h @@ -29,9 +29,6 @@ // cells in the subset with the original data set. This is used, for instance, // by ParaView's Spreadsheet view. // -// Output port 2 -- is simply the input vtkSelection (set on input port number -// 1). -// // .SECTION See Also // vtkExtractSelection vtkSelection @@ -84,8 +81,7 @@ private: class vtkSelectionNodeVector; void RequestDataInternal(vtkSelectionNodeVector& outputs, - vtkDataObject* dataObjectOutput, - vtkSelectionNode* sel); + vtkDataSet* geomOutput, vtkSelectionNode* sel); // Returns the combined content type for the selection. int GetContentType(vtkSelection* sel); diff --git a/Servers/Filters/vtkPVGeometryFilter.cxx b/Servers/Filters/vtkPVGeometryFilter.cxx index 13a956f..47d7333 100644 --- a/Servers/Filters/vtkPVGeometryFilter.cxx +++ b/Servers/Filters/vtkPVGeometryFilter.cxx @@ -14,10 +14,12 @@ =========================================================================*/ #include "vtkPVGeometryFilter.h" +#include "vtkAlgorithmOutput.h" #include "vtkAppendPolyData.h" #include "vtkCallbackCommand.h" #include "vtkCellArray.h" #include "vtkCellData.h" +#include "vtkCellTypes.h" #include "vtkCleanArrays.h" #include "vtkCommand.h" #include "vtkCompositeDataIterator.h" @@ -42,6 +44,7 @@ #include "vtkPointData.h" #include "vtkPolyData.h" #include "vtkPolygon.h" +#include "vtkPVRecoverGeometryWireframe.h" #include "vtkRectilinearGrid.h" #include "vtkRectilinearGridOutlineFilter.h" #include "vtkSmartPointer.h" @@ -52,14 +55,17 @@ #include "vtkTimerLog.h" #include "vtkUnsignedCharArray.h" #include "vtkUnsignedIntArray.h" -#include "vtkAlgorithmOutput.h" #include "vtkUnstructuredGrid.h" +#include "vtkUnstructuredGridGeometryFilter.h" #include #include #include #include +#define VTK_CREATE(type, name) \ + vtkSmartPointer name = vtkSmartPointer::New() + vtkCxxRevisionMacro(vtkPVGeometryFilter, "1.105"); vtkStandardNewMacro(vtkPVGeometryFilter); @@ -131,10 +137,13 @@ vtkPVGeometryFilter::vtkPVGeometryFilter () this->UseOutline = 1; this->UseStrips = 0; this->GenerateCellNormals = 1; + this->NonlinearSubdivisionLevel = 1; this->DataSetSurfaceFilter = vtkDataSetSurfaceFilter::New(); this->GenericGeometryFilter=vtkGenericGeometryFilter::New(); - + this->UnstructuredGridGeometryFilter=vtkUnstructuredGridGeometryFilter::New(); + this->RecoverWireframeFilter = vtkPVRecoverGeometryWireframe::New(); + // Setup a callback for the internal readers to report progress. this->InternalProgressObserver = vtkCallbackCommand::New(); this->InternalProgressObserver->SetCallback( @@ -162,13 +171,31 @@ vtkPVGeometryFilter::vtkPVGeometryFilter () //---------------------------------------------------------------------------- vtkPVGeometryFilter::~vtkPVGeometryFilter () { - if(this->DataSetSurfaceFilter) + // Be careful how you delete these so that you don't foul up the garbage + // collector. + if (this->DataSetSurfaceFilter) { - this->DataSetSurfaceFilter->Delete(); + vtkDataSetSurfaceFilter *tmp = this->DataSetSurfaceFilter; + this->DataSetSurfaceFilter = NULL; + tmp->Delete(); } - if(this->GenericGeometryFilter!=0) + if (this->GenericGeometryFilter) { - this->GenericGeometryFilter->Delete(); + vtkGenericGeometryFilter *tmp = this->GenericGeometryFilter; + this->GenericGeometryFilter = NULL; + tmp->Delete(); + } + if (this->UnstructuredGridGeometryFilter) + { + vtkUnstructuredGridGeometryFilter *tmp=this->UnstructuredGridGeometryFilter; + this->UnstructuredGridGeometryFilter = NULL; + tmp->Delete(); + } + if (this->RecoverWireframeFilter) + { + vtkPVRecoverGeometryWireframe *tmp = this->RecoverWireframeFilter; + this->RecoverWireframeFilter = NULL; + tmp->Delete(); } this->OutlineSource->Delete(); this->InternalProgressObserver->Delete(); @@ -1067,10 +1094,160 @@ void vtkPVGeometryFilter::UnstructuredGridExecute( if (!this->UseOutline) { this->OutlineFlag = 0; + + bool handleSubdivision = false; + if (this->NonlinearSubdivisionLevel > 0) + { + // Check to see if the data actually has nonlinear cells. Handling + // nonlinear cells adds unnecessary work if we only have linear cells. + vtkUnsignedCharArray *types = input->GetCellTypesArray(); + vtkIdType numCells = input->GetNumberOfCells(); + for (vtkIdType i = 0; i < numCells; i++) + { + if (!vtkCellTypes::IsLinear(types->GetValue(i))) + { + handleSubdivision = true; + break; + } + } + } + + vtkSmartPointer facePtIds2OriginalPtIds; + + if (handleSubdivision) + { + // Use the vtkUnstructuredGridGeometryFilter to extract 2D surface cells + // from the geometry. This is important to extract an appropriate + // wireframe in vtkPVRecoverGeometryWireframe. Also, at the time of this + // writing vtkDataSetSurfaceFilter only properly subdivides 2D cells past + // level 1. + VTK_CREATE(vtkUnstructuredGrid, inputClone); + inputClone->ShallowCopy(input); + this->UnstructuredGridGeometryFilter->SetInput(inputClone); + + // Let the vtkUnstructuredGridGeometryFilter record from which point and + // cell each face comes from in the standard vtkOriginalCellIds array. + this->UnstructuredGridGeometryFilter->SetPassThroughCellIds( + this->PassThroughCellIds); + this->UnstructuredGridGeometryFilter->SetPassThroughPointIds( + this->PassThroughPointIds); + + // Observe the progress of the internal filter. + // TODO: Make the consecutive internal filter execution have monotonically + // increasing progress rather than restarting for every internal filter. + this->UnstructuredGridGeometryFilter->AddObserver( + vtkCommand::ProgressEvent, + this->InternalProgressObserver); + this->UnstructuredGridGeometryFilter->Update(); + // The internal filter finished. Remove the observer. + this->UnstructuredGridGeometryFilter->RemoveObserver( + this->InternalProgressObserver); + + this->UnstructuredGridGeometryFilter->SetInput(NULL); + + // Feed the extracted surface as the input to the rest of the processing. + input->ShallowCopy(this->UnstructuredGridGeometryFilter->GetOutput()); + + // Keep a handle to the vtkOriginalPointIds array. We might need it. + facePtIds2OriginalPtIds = vtkIdTypeArray::SafeDownCast( + input->GetPointData()->GetArray("vtkOriginalPointIds")); + + // Flag the data set surface filter to record original cell ids, but do it + // in a specially named array that vtkPVRecoverGeometryWireframe will + // recognize. Note that because the data set comes from + // UnstructuredGridGeometryFilter, the ids will represent the faces rather + // than the original cells, which is important. + this->DataSetSurfaceFilter->PassThroughCellIdsOn(); + this->DataSetSurfaceFilter->SetOriginalCellIdsName( + vtkPVRecoverGeometryWireframe::ORIGINAL_FACE_IDS()); + + if (this->PassThroughPointIds) + { + if (this->NonlinearSubdivisionLevel <= 1) + { + // Do not allow the vtkDataSetSurfaceFilter create an array of + // original cell ids; it will overwrite the correct array from the + // vtkUnstructuredGridGeometryFilter. + this->DataSetSurfaceFilter->PassThroughPointIdsOff(); + } + else + { + // vtkDataSetSurfaceFilter is going to strip the vtkOriginalPointIds + // created by the vtkPVUnstructuredGridGeometryFilter because it + // cannot interpolate the ids. Make the vtkDataSetSurfaceFilter make + // its own original ids array. We will resolve them later. + this->DataSetSurfaceFilter->PassThroughPointIdsOn(); + } + } + } + if (input->GetNumberOfCells() > 0) { this->DataSetSurfaceFilter->UnstructuredGridExecute(input, output); } + + if (handleSubdivision) + { + // Restore state of DataSetSurfaceFilter. + this->DataSetSurfaceFilter->SetPassThroughCellIds( + this->PassThroughCellIds); + this->DataSetSurfaceFilter->SetOriginalCellIdsName(NULL); + this->DataSetSurfaceFilter->SetPassThroughPointIds( + this->PassThroughPointIds); + + // Now use vtkPVRecoverGeometryWireframe to create an edge flag attribute + // that will cause the wireframe to be rendered correctly. + VTK_CREATE(vtkPolyData, nextStageInput); + nextStageInput->ShallowCopy(output); // Yes output is correct. + this->RecoverWireframeFilter->SetInput(nextStageInput); + + // Observe the progress of the internal filter. + // TODO: Make the consecutive internal filter execution have monotonically + // increasing progress rather than restarting for every internal filter. + this->RecoverWireframeFilter->AddObserver( + vtkCommand::ProgressEvent, + this->InternalProgressObserver); + this->RecoverWireframeFilter->Update(); + // The internal filter finished. Remove the observer. + this->RecoverWireframeFilter->RemoveObserver( + this->InternalProgressObserver); + + this->RecoverWireframeFilter->SetInput(NULL); + + // Get what should be the final output. + output->ShallowCopy(this->RecoverWireframeFilter->GetOutput()); + + if (this->PassThroughPointIds && (this->NonlinearSubdivisionLevel > 1)) + { + // The output currently has a vtkOriginalPointIds array that maps points + // to the data containing only the faces. Correct this to point to the + // original data set. + vtkIdTypeArray *polyPtIds2FacePtIds = vtkIdTypeArray::SafeDownCast( + output->GetPointData()->GetArray("vtkOriginalPointIds")); + if (!facePtIds2OriginalPtIds || !polyPtIds2FacePtIds) + { + vtkErrorMacro(<< "Missing original point id arrays."); + return; + } + vtkIdType numPts = polyPtIds2FacePtIds->GetNumberOfTuples(); + VTK_CREATE(vtkIdTypeArray, polyPtIds2OriginalPtIds); + polyPtIds2OriginalPtIds->SetName("vtkOriginalPointIds"); + polyPtIds2OriginalPtIds->SetNumberOfComponents(1); + polyPtIds2OriginalPtIds->SetNumberOfTuples(numPts); + for (vtkIdType polyPtId = 0; polyPtId < numPts; polyPtId++) + { + vtkIdType facePtId = polyPtIds2FacePtIds->GetValue(polyPtId); + vtkIdType originalPtId = -1; + if (facePtId >= 0) + { + originalPtId = facePtIds2OriginalPtIds->GetValue(facePtId); + } + polyPtIds2OriginalPtIds->SetValue(polyPtId, originalPtId); + } + output->GetPointData()->AddArray(polyPtIds2OriginalPtIds); + } + } + return; } @@ -1193,6 +1370,10 @@ void vtkPVGeometryFilter::ReportReferences(vtkGarbageCollector* collector) "DataSetSurfaceFilter"); vtkGarbageCollectorReport(collector, this->GenericGeometryFilter, "GenericGeometryFilter"); + vtkGarbageCollectorReport(collector, this->UnstructuredGridGeometryFilter, + "UnstructuredGridGeometryFilter"); + vtkGarbageCollectorReport(collector, this->RecoverWireframeFilter, + "RecoverWireframeFilter"); } //---------------------------------------------------------------------------- @@ -1213,6 +1394,8 @@ void vtkPVGeometryFilter::PrintSelf(ostream& os, vtkIndent indent) os << indent << "UseStrips: " << (this->UseStrips?"on":"off") << endl; os << indent << "GenerateCellNormals: " << (this->GenerateCellNormals?"on":"off") << endl; + os << indent << "NonlinearSubdivisionLevel: " + << this->NonlinearSubdivisionLevel << endl; os << indent << "Controller: " << this->Controller << endl; os << indent << "PassThroughCellIds: " @@ -1306,3 +1489,20 @@ void vtkPVGeometryFilter::RemoveGhostCells(vtkPolyData* output) output->RemoveGhostCells(1); } } + +//----------------------------------------------------------------------------- +void vtkPVGeometryFilter::SetNonlinearSubdivisionLevel(int newvalue) +{ + if (this->NonlinearSubdivisionLevel != newvalue) + { + this->NonlinearSubdivisionLevel = newvalue; + + if (this->DataSetSurfaceFilter) + { + this->DataSetSurfaceFilter->SetNonlinearSubdivisionLevel( + this->NonlinearSubdivisionLevel); + } + + this->Modified(); + } +} diff --git a/Servers/Filters/vtkPVGeometryFilter.h b/Servers/Filters/vtkPVGeometryFilter.h index f9e4485..9fb7be2 100644 --- a/Servers/Filters/vtkPVGeometryFilter.h +++ b/Servers/Filters/vtkPVGeometryFilter.h @@ -34,9 +34,11 @@ class vtkInformationVector; class vtkCompositeDataSet; class vtkMultiProcessController; class vtkOutlineSource; +class vtkPVRecoverGeometryWireframe; class vtkRectilinearGrid; class vtkStructuredGrid; class vtkUnstructuredGrid; +class vtkUnstructuredGridGeometryFilter; class VTK_EXPORT vtkPVGeometryFilter : public vtkPolyDataAlgorithm { @@ -79,6 +81,15 @@ public: vtkBooleanMacro(GenerateCellNormals, int); // Description: + // Nonlinear faces are approximated with flat polygons. This parameter + // controls how many times to subdivide nonlinear surface cells. Higher + // subdivisions generate closer approximations but take more memory and + // rendering time. Subdivision is recursive, so the number of output polygons + // can grow exponentially with this parameter. + virtual void SetNonlinearSubdivisionLevel(int); + vtkGetMacro(NonlinearSubdivisionLevel, int); + + // Description: // Set and get the controller. virtual void SetController(vtkMultiProcessController*); vtkGetObjectMacro(Controller, vtkMultiProcessController); @@ -159,11 +170,14 @@ protected: int UseOutline; int UseStrips; int GenerateCellNormals; + int NonlinearSubdivisionLevel; vtkMultiProcessController* Controller; vtkOutlineSource *OutlineSource; vtkDataSetSurfaceFilter* DataSetSurfaceFilter; vtkGenericGeometryFilter *GenericGeometryFilter; + vtkUnstructuredGridGeometryFilter *UnstructuredGridGeometryFilter; + vtkPVRecoverGeometryWireframe *RecoverWireframeFilter; int CheckAttributes(vtkDataObject* input); diff --git a/Servers/Filters/vtkPVIsoVolume.cxx b/Servers/Filters/vtkPVIsoVolume.cxx new file mode 100644 index 0000000..e7b235c --- /dev/null +++ b/Servers/Filters/vtkPVIsoVolume.cxx @@ -0,0 +1,97 @@ +#include "vtkPVIsoVolume.h" + +#include "vtkHierarchicalBoxDataSet.h" +#include "vtkInformation.h" +#include "vtkInformationVector.h" +#include "vtkMultiBlockDataSet.h" +#include "vtkObjectFactory.h" + +#include "vtkCompositeDataIterator.h" + +#include // STL required. +#include // STL required. + +vtkCxxRevisionMacro(vtkPVIsoVolume, "1.1"); +vtkStandardNewMacro(vtkPVIsoVolume); + +const double PV_AMR_SURFACE_VALUE_UNSIGNED_CHAR=255; + +//----------------------------------------------------------------------------- +class vtkPVIsoVolumeInternal +{ +public: + + vtkstd::vector CellArrays; +}; + +//----------------------------------------------------------------------------- +vtkPVIsoVolume::vtkPVIsoVolume() : + vtkAMRDualClip(), + VolumeFractionSurfaceValue(1.0) +{ + this->Implementation = new vtkPVIsoVolumeInternal(); +} + +//----------------------------------------------------------------------------- +vtkPVIsoVolume::~vtkPVIsoVolume() +{ + if(this->Implementation) + { + delete this->Implementation; + this->Implementation = 0; + } +} + +//----------------------------------------------------------------------------- +void vtkPVIsoVolume::PrintSelf(ostream &os, vtkIndent indent) +{ + this->Superclass::PrintSelf(os, indent); +} + +//----------------------------------------------------------------------------- +int vtkPVIsoVolume::RequestData(vtkInformation* vtkNotUsed(request), + vtkInformationVector** inputVector, + vtkInformationVector* outputVector) +{ + vtkInformation* inInfo = inputVector[0]->GetInformationObject(0); + vtkHierarchicalBoxDataSet* hbdsInput=vtkHierarchicalBoxDataSet::SafeDownCast( + inInfo->Get(vtkDataObject::DATA_OBJECT())); + + vtkInformation *outInfo; + outInfo = outputVector->GetInformationObject(0); + vtkMultiBlockDataSet* mbdsOutput0 = vtkMultiBlockDataSet::SafeDownCast( + outInfo->Get(vtkDataObject::DATA_OBJECT())); + + + this->SetIsoValue(this->VolumeFractionSurfaceValue * + PV_AMR_SURFACE_VALUE_UNSIGNED_CHAR); + + size_t noOfArrays = this->Implementation->CellArrays.size(); + for(size_t i=0; i < noOfArrays; ++i) + { + vtkMultiBlockDataSet* out = this->DoRequestData( + hbdsInput, this->Implementation->CellArrays[i].c_str()); + + if(out) + { + /// Assign the name to the block by the array name. + mbdsOutput0->SetBlock(i, out); + out->Delete(); + } + } + return 1; +} + +//----------------------------------------------------------------------------- +void vtkPVIsoVolume::AddInputCellArrayToProcess(const char* name) +{ + this->Implementation->CellArrays.push_back(vtkstd::string(name)); + this->Modified(); +} + +//----------------------------------------------------------------------------- +void vtkPVIsoVolume::ClearInputCellArrayToProcess() +{ + this->Implementation->CellArrays.clear(); + this->Modified(); +} diff --git a/Servers/Filters/vtkPVIsoVolume.h b/Servers/Filters/vtkPVIsoVolume.h new file mode 100644 index 0000000..029c58c --- /dev/null +++ b/Servers/Filters/vtkPVIsoVolume.h @@ -0,0 +1,68 @@ +/*========================================================================= + + Program: ParaView + Module: vtkPVIsoVolume.h + + Copyright (c) Kitware, Inc. + All rights reserved. + See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notice for more information. + +=========================================================================*/ +// .NAME vtkPVIsoVolume - Generates contour given one or more cell array +// and a volume fraction value. +// +// .SECTION Description +// +// .SEE vtkAMRDualClip +// + +#ifndef __vtkPVIsoVolume_h +#define __vtkPVIsoVolume_h + +#include "vtkAMRDualClip.h" + +// Forware declaration. +class vtkPVIsoVolumeInternal; + +class VTK_EXPORT vtkPVIsoVolume : public vtkAMRDualClip +{ +public: + static vtkPVIsoVolume* New(); + vtkTypeRevisionMacro(vtkPVIsoVolume,vtkAMRDualClip); + void PrintSelf(ostream& os, vtkIndent indent); + + vtkPVIsoVolume(); + ~vtkPVIsoVolume(); + + // Description: + // Add to list of cell arrays which are used for generating contours. + void AddInputCellArrayToProcess(const char* name); + void ClearInputCellArrayToProcess(); + + // Description: + // Get / Set volume fraction value. + vtkGetMacro(VolumeFractionSurfaceValue, double); + vtkSetMacro(VolumeFractionSurfaceValue, double); + + //BTX + virtual int RequestData(vtkInformation*, vtkInformationVector**, + vtkInformationVector*); + +private: + vtkPVIsoVolume(const vtkPVIsoVolume&); // Not implemented. + void operator=(const vtkPVIsoVolume&); // Not implemented. + + //ETX + +protected: + + double VolumeFractionSurfaceValue; + + vtkPVIsoVolumeInternal* Implementation; +}; + +#endif // __vtkPVIsoVolume_h diff --git a/Servers/Filters/vtkPVRecoverGeometryWireframe.cxx b/Servers/Filters/vtkPVRecoverGeometryWireframe.cxx new file mode 100644 index 0000000..acc35f3 --- /dev/null +++ b/Servers/Filters/vtkPVRecoverGeometryWireframe.cxx @@ -0,0 +1,308 @@ +// -*- c++ -*- +/*========================================================================= + + Program: Visualization Toolkit + Module: $RCSfile: pqBlotDialog.h,v $ + + Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen + All rights reserved. + See Copyright.txt or http://www.kitware.com/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notice for more information. + +=========================================================================*/ +/*------------------------------------------------------------------------- + Copyright 2009 Sandia Corporation. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +-------------------------------------------------------------------------*/ + +#include "vtkPVRecoverGeometryWireframe.h" + +#include "vtkCellArray.h" +#include "vtkCellData.h" +#include "vtkIdTypeArray.h" +#include "vtkObjectFactory.h" +#include "vtkPointData.h" +#include "vtkPolyData.h" +#include "vtkUnsignedCharArray.h" + +#include "vtkSmartPointer.h" +#define VTK_CREATE(type, name) \ + vtkSmartPointer name = vtkSmartPointer::New() + +#include +#include +#include + +static const unsigned char NO_EDGE_FLAG = static_cast(-1); + +//============================================================================= +namespace vtkPVRecoverGeometryWireframeNamespace +{ + // Description: + // Simple class used internally to define an edge based on the endpoints. The + // endpoints are canonically identified by the lower and higher values. + class EdgeEndpoints + { + public: + EdgeEndpoints() : MinEndPoint(-1), MaxEndPoint(-1) {} + EdgeEndpoints(vtkIdType endpointA, vtkIdType endpointB) + : MinEndPoint((endpointA < endpointB) ? endpointA : endpointB), + MaxEndPoint((endpointA < endpointB) ? endpointB : endpointA) + {} + const vtkIdType MinEndPoint; + const vtkIdType MaxEndPoint; + inline bool operator==(const EdgeEndpoints &other) const { + return ( (this->MinEndPoint == other.MinEndPoint) + && (this->MaxEndPoint == other.MaxEndPoint) ); + } + }; + struct EdgeEndpointsHash { + public: + size_t operator()(const EdgeEndpoints &edge) const { + return static_cast(edge.MinEndPoint + edge.MaxEndPoint); + } + }; + + // Description: + // Holds the information necessary for the facet this edge came from. + class EdgeInformation + { + public: + vtkIdType OriginalFaceId; + vtkIdType *StartPointIdP; + }; + + // Description: + // A map from edge endpoints to the information about that edge. + typedef vtksys::hash_map + EdgeMapType; + + void RecordEdgeFlag(vtkPolyData *output, const EdgeInformation &edgeInfo, + vtkUnsignedCharArray *edgeFlagArray, unsigned char flag, + vtkIdType *duplicatePointMap) + { + vtkIdType pt = edgeInfo.StartPointIdP[0]; + if (edgeFlagArray->GetValue(pt) == flag) + { + // Edge flag already set correctly. Nothing to do. + return; + } + if (edgeFlagArray->GetValue(pt) == NO_EDGE_FLAG) + { + // Nothing has set the edge flag yet. Just set it and return. + edgeFlagArray->SetValue(pt, flag); + return; + } + + // If we are here then some other cell has already put a flag on this + // point different than ours. We have to adjust our cell topology to + // use a duplicate point. + if (duplicatePointMap[pt] == -1) + { + // No duplicate made. We need to make one. + vtkPoints *points = output->GetPoints(); + double coords[3]; + points->GetPoint(pt, coords); + vtkIdType newPt = points->InsertNextPoint(coords); + duplicatePointMap[pt] = newPt; + // Copying attributes from yourself seems weird, but is valid. + vtkPointData *pd = output->GetPointData(); + pd->CopyData(pd, pt, newPt); + edgeFlagArray->InsertValue(newPt, flag); + } + edgeInfo.StartPointIdP[0] = duplicatePointMap[pt]; + } +} +using namespace vtkPVRecoverGeometryWireframeNamespace; + +//============================================================================= +vtkCxxRevisionMacro(vtkPVRecoverGeometryWireframe, "$Revision$"); +vtkStandardNewMacro(vtkPVRecoverGeometryWireframe); + +//----------------------------------------------------------------------------- +vtkPVRecoverGeometryWireframe::vtkPVRecoverGeometryWireframe() +{ +} + +vtkPVRecoverGeometryWireframe::~vtkPVRecoverGeometryWireframe() +{ +} + +void vtkPVRecoverGeometryWireframe::PrintSelf(ostream &os, vtkIndent indent) +{ + this->Superclass::PrintSelf(os, indent); +} + +//----------------------------------------------------------------------------- +int vtkPVRecoverGeometryWireframe::RequestData( + vtkInformation *vtkNotUsed(request), + vtkInformationVector **inputVector, + vtkInformationVector *outputVector) +{ + vtkPolyData *input = vtkPolyData::GetData(inputVector[0]); + vtkPolyData *output = vtkPolyData::GetData(outputVector); + + vtkIdType npts, *pts; + vtkstd::vector originalPts; + + if (!input->GetCellData()->HasArray(ORIGINAL_FACE_IDS())) + { + // Did not find the field used to identify the face each linear patch comes + // from. The original data was probably linear so using all the edges + // should be OK (and is at least the best we can do), so just pass the data. + output->ShallowCopy(input); + return 1; + } + + vtkIdTypeArray *faceIds = vtkIdTypeArray::SafeDownCast( + input->GetCellData()->GetAbstractArray(ORIGINAL_FACE_IDS())); + if (!faceIds) + { + vtkErrorMacro(<< ORIGINAL_FACE_IDS() << " array is not of expected type."); + return 0; + } + + // Shallow copy the cell data. All the cells get copied to output. + output->GetCellData()->PassData(input->GetCellData()); + + // Deep copy the point information and be ready to add points. + VTK_CREATE(vtkPoints, points); + points->DeepCopy(input->GetPoints()); + output->SetPoints(points); + vtkPointData *inputPD = input->GetPointData(); + vtkPointData *outputPD = output->GetPointData(); + outputPD->CopyAllocate(inputPD); + vtkIdType numOriginalPoints = points->GetNumberOfPoints(); + for (vtkIdType i = 0; i < numOriginalPoints; i++) + { + outputPD->CopyData(inputPD, i, i); + } + + // Create an edge flag array. + VTK_CREATE(vtkUnsignedCharArray, edgeflags); + edgeflags->SetName("vtkEdgeFlags"); + outputPD->AddArray(edgeflags); + outputPD->SetActiveAttribute("vtkEdgeFlags", vtkDataSetAttributes::EDGEFLAG); + edgeflags->SetNumberOfComponents(1); + edgeflags->SetNumberOfTuples(numOriginalPoints); + vtkstd::fill(edgeflags->GetPointer(0), + edgeflags->GetPointer(numOriginalPoints), NO_EDGE_FLAG); + + // Some (probably many) points will have to be duplicated because different + // cells will need different edge flags. This array maps the original + // point id to the duplicate id. + vtkstd::vector duplicatePointMap(numOriginalPoints); + vtkstd::fill(duplicatePointMap.begin(), duplicatePointMap.end(), -1); + + // Shallow copy the verts. Set the edge flags to true. + vtkCellArray *inputVerts = input->GetVerts(); + output->SetVerts(inputVerts); + for (inputVerts->InitTraversal(); inputVerts->GetNextCell(npts, pts); ) + { + for (vtkIdType i = 0; i < npts; i++) + { + edgeflags->SetValue(pts[i], 1); + } + } + + // Shallow copy the lines. Set the edge flags to true. + vtkCellArray *inputLines = input->GetLines(); + output->SetLines(inputLines); + for (inputLines->InitTraversal(); inputLines->GetNextCell(npts, pts); ) + { + // No need to set edge flag for last index. + for (vtkIdType i = 0; i < npts-1; i++) + { + edgeflags->SetValue(pts[i], 1); + } + } + + // Shallow copy the triangle strips. Set the edge flags to true. + vtkCellArray *inputStrips = input->GetStrips(); + output->SetStrips(inputStrips); + for (inputStrips->InitTraversal(); inputStrips->GetNextCell(npts, pts); ) + { + for (vtkIdType i = 0; i < npts; i++) + { + edgeflags->SetValue(pts[i], 1); + } + } + + // Deep copy the polygons because we will be changing some indices when we + // duplicate points. + VTK_CREATE(vtkCellArray, outputPolys); + outputPolys->DeepCopy(input->GetPolys()); + output->SetPolys(outputPolys); + + // Iterate over all the input facets and see which edge interfaces belonged to + // different faces. We do that by recording the original face id in a map. + // When we find a pair of edges, we turn on the appropriate edge flag if they + // came from different faces, or turn it off if they came from the same face. + EdgeMapType edgeMap; + vtkIdType inputCellId + = inputVerts->GetNumberOfCells() + inputLines->GetNumberOfCells(); + for (outputPolys->InitTraversal(); outputPolys->GetNextCell(npts, pts); + inputCellId++) + { + if ((inputCellId%1000) == 0) + { + this->UpdateProgress(static_cast(inputCellId) + /input->GetNumberOfCells()); + if (this->GetAbortExecute()) return 0; + } + // Record the original points of the polygon. As we iterate over edges, + // we may change the indices, but we allways compare edges by the original + // indices. + originalPts.resize(npts); + vtkstd::copy(pts, pts+npts, originalPts.begin()); + vtkIdType originalFace = faceIds->GetValue(inputCellId); + for (vtkIdType i = 0; i < npts; i++) + { + EdgeEndpoints edge(originalPts[i], originalPts[(i+1)%npts]); + EdgeInformation edgeInfo; + edgeInfo.OriginalFaceId = originalFace; + edgeInfo.StartPointIdP = &pts[i]; + + EdgeMapType::iterator edgeMatch = edgeMap.find(edge); + if (edgeMatch == edgeMap.end()) + { + // Not encountered yet. Add to the map. + edgeMap.insert(vtkstd::make_pair(edge, edgeInfo)); + } + else + { + // The edge flag is true if the edge connects two different faces. + unsigned char eflag = static_cast( + edgeMatch->second.OriginalFaceId != originalFace); + RecordEdgeFlag(output, edgeMatch->second, edgeflags, eflag, + &duplicatePointMap.at(0)); + RecordEdgeFlag(output, edgeInfo, edgeflags, eflag, + &duplicatePointMap.at(0)); + // Remove the edge from the map since we already found the pair. + edgeMap.erase(edgeMatch); + } + } // For each edge + } // For each cell. + + // Everything left in the edge map has no match. It must necessarily be + // on the outside of a face. + for (EdgeMapType::iterator iter = edgeMap.begin(); + iter != edgeMap.end(); iter++) + { + RecordEdgeFlag(output, iter->second, edgeflags, 1, + &duplicatePointMap.at(0)); + } + + // If any points are unmarked, set some edge flag on them (although they + // are probably not referenced by any cell). + for (vtkIdType i = 0; i < numOriginalPoints; i++) + { + if (edgeflags->GetValue(i) == NO_EDGE_FLAG) edgeflags->SetValue(i, 1); + } + + return 1; +} diff --git a/Servers/Filters/vtkPVRecoverGeometryWireframe.h b/Servers/Filters/vtkPVRecoverGeometryWireframe.h new file mode 100644 index 0000000..6d1d569 --- /dev/null +++ b/Servers/Filters/vtkPVRecoverGeometryWireframe.h @@ -0,0 +1,73 @@ +// -*- c++ -*- +/*========================================================================= + + Program: Visualization Toolkit + Module: $RCSfile: pqBlotDialog.h,v $ + + Copyright (c) Ken Martin, Will Schroeder, Bill Lorensen + All rights reserved. + See Copyright.txt or http://www.kitware.com/Copyright.htm for details. + + This software is distributed WITHOUT ANY WARRANTY; without even + the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR + PURPOSE. See the above copyright notice for more information. + +=========================================================================*/ +/*------------------------------------------------------------------------- + Copyright 2009 Sandia Corporation. + Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation, + the U.S. Government retains certain rights in this software. +-------------------------------------------------------------------------*/ + +// .NAME vtkPVRecoverGeometryWireframe - Get corrected wireframe from tesselated facets +// +// .SECTION Description +// +// When vtkPVGeometryFilter tessellates nonlinear faces into linear +// approximations, it introduces edges in the middle of the facets of the +// original mesh (as any valid tessellation would). To correct for this, +// vtkPVGeometryFilter also writes out some fields that allows use to identify +// the edges that are actually part of the original mesh. This filter works in +// conjunction with vtkPVGeometryFilter by taking its output, adding an edge +// flag and making the appropriate adjustments so that rendering with line +// fill mode will make the correct wireframe. +// +// .SECTION See Also +// vtkPVGeometryFilter +// + +#ifndef __vtkPVRecoverGeometryWireframe_h +#define __vtkPVRecoverGeometryWireframe_h + +#include "vtkPolyDataAlgorithm.h" + +class VTK_EXPORT vtkPVRecoverGeometryWireframe : public vtkPolyDataAlgorithm +{ +public: + vtkTypeRevisionMacro(vtkPVRecoverGeometryWireframe, vtkPolyDataAlgorithm); + static vtkPVRecoverGeometryWireframe *New(); + virtual void PrintSelf(ostream &os, vtkIndent indent); + + // Description: + // In order to determine which edges existed in the original data, we need an + // identifier on each cell determining which face (not cell) it originally + // came from. The ids should be put in a cell data array with this name. The + // existance of this field is also a signal that this wireframe extraction is + // necessary. + static const char *ORIGINAL_FACE_IDS() + { return "vtkPVRecoverWireframeOriginalFaceIds"; } + +protected: + vtkPVRecoverGeometryWireframe(); + ~vtkPVRecoverGeometryWireframe(); + + virtual int RequestData(vtkInformation *request, + vtkInformationVector **inputVector, + vtkInformationVector *outputVector); + +private: + vtkPVRecoverGeometryWireframe(const vtkPVRecoverGeometryWireframe &); // Not implemented + void operator=(const vtkPVRecoverGeometryWireframe &); // Not implemented +}; + +#endif //__vtkPVRecoverGeometryWireframe_h diff --git a/Servers/ServerManager/Resources/filters.xml b/Servers/ServerManager/Resources/filters.xml index 9b92034..efd7835 100644 --- a/Servers/ServerManager/Resources/filters.xml +++ b/Servers/ServerManager/Resources/filters.xml @@ -1545,6 +1545,26 @@ The Extract Surface filter extracts the polygons forming the outer surface of th If the value of this property is set to 1, internal surfaces along process boundaries will be removed. NOTE: Enabling this option might cause multiple executions of the data source because more information is needed to remove internal surfaces. + + + + + If the input is an unstructured grid with nonlinear faces, this + parameter determines how many times the face is subdivided into + linear faces. If 0, the output is the equivalent of its linear + couterpart (and the midpoints determining the nonlinear + interpolation are discarded). If 1, the nonlinear face is + triangulated based on the midpoints. If greater than 1, the + triangulated pieces are recursively subdivided to reach the + desired subdivision. Setting the value to greater than 1 may + cause some point data to not be passed even if no quadratic faces + exist. This option has no effect if the input is not an + unstructured grid. + + @@ -2086,7 +2106,7 @@ attributes of the fragments. - + + - + @@ -7364,6 +7385,20 @@ Tessellate a higher-order dataset. Toggle whether to generate an outline or a surface. + + + + Nonlinear faces are approximated with flat polygons. This + parameter controls how many times to subdivide nonlinear surface + cells. Higher subdivisions generate closer approximations but + take more memory and rendering time. Subdivision is recursive, + so the number of output polygons can grow exponentially with this + parameter. + + @@ -7127,6 +7127,7 @@ + @@ -7992,6 +7993,7 @@ + diff --git a/Servers/ServerManager/Resources/utilities.xml b/Servers/ServerManager/Resources/utilities.xml index b25bbb3..0b02b60 100644 --- a/Servers/ServerManager/Resources/utilities.xml +++ b/Servers/ServerManager/Resources/utilities.xml @@ -460,7 +460,7 @@ name="Bounds" command="SetBounds" number_of_elements="6" - default_values="0 1 0 1 0 1" > + default_values="none" > epsilon: +if abs(clip.ClipType.Radius - 0.25) > 0.000001: fail("Clip sphere radius is incorrect.") if sphere not in group.Input or clip not in group.Input: fail("Group has wrong inputs.") if GetDisplayProperties(group).Representation != "Surface With Edges": fail("Group representation is incorrect") -if abs(view.Background[1] - 0) > epsilon or abs(view.Background[2] - 1) > epsilon: +if view.Background[1] != 0 or view.Background[2] != 1: fail("View has incorrect background color") if len(view.Representations) != 1: fail("First view has incorrect number of representations.") diff --git a/VTK b/VTK index 46a8f04..2d1be1b 160000 --- a/VTK +++ b/VTK @@ -1 +1 @@ -Subproject commit 46a8f04a3d6084d18136ac6e51c3eb2685907497 +Subproject commit 2d1be1be9bf769839685a2205ecf34a4f19cb660