Selection and Data Analysis

There has been much work done already on selection in ParaViewIII. Previous discussion includes Selection_Use_Cases, Selection_In_ParaQ, Selection, Selection_Implementation and Integrating_Interactive_Selection. Several improvements need to be made before the upcoming full release in order to improve useability and fully support quantitative analysis. To put it simply, we want ParaView to have intuitive selection capabilities (note the plural) and we want it to be easy to filter and/or perform quantitative analysis on the results of a selection. Previous discussion of quantitative analysis in paraview includes Plotting Parallel Data (PGraph), PGraph_Implementation, Plot_Data_Pipeline, Statistics_View, Plot_View_Management, Data_Analysis_Design and Client_Side_Delivery.

The feature wish list

• Pick point in space (on surface) or type coords in.

• Picking by global ids, pedigree id, proc+cell/pt id.
  • choose a list of IDs manually. We'll start by letting user pick a single id.
  • manually refine the list of selected ids
  • extend the element inspector to do this (or possibly the Statistics_View). We need to use ranges so that we don't explode millions of entries on a big dataset. This is especially true with frustum selection.

• Frustum (volume/deep) selection - this was in long long ago. It used vtkFrustumExtractor to extract all pts/cells in a frustum. GUI interface to choose what type of selection through a tiny model drop down next to selection button. {surface, frustum, or single point}

• Proposed updates to element inspector:
  • ids shown
  • enter in an id (or ids)
  • tab formating
  • grouped ranges instead of one line per element.

• Tie histogram to selection - choose bars in histogram and use the output as input to a threshold filter.

• Saving and reusing selection:
  • after making a selection we should be able to reuse it
    • ex 1) applying a filter to just the output of the selection
    • ex 2) changing the resolution of a source that was selected and getting more cells out
  • Should we save output of selection or input of selection? If we save the input to selection for surface selection, the results will be meaningless if the camera has been changed.We will save the output of the selection operator and reextract as necessary see [[Selection Types].

• Show selections in the pipeline view so we can apply multiple filters to the output of a selection. State saving and restoring may become an issue. We need to save all inputs to the selection to recreate.

• Need to be able to make props unpickable in the gui somehow.
  • low level picking classes can do this, need to expose the pickable property on the GUI
  • pipeline browser - seems natural to relate this to the EYE
  • for masking the existing pickable property will not be enough (if unpickable it is ignored entirely). Need a new actor flag that says render me as background/invisible or with ids.

• Data analysis - output of a selection should be immedately available for quantitative discovery.
  • many filters will produce 1D rectgrid, all of which can be plotted
  • polydata with one vertex - example output of vtkMinMax
  • prefered/compatible viewtypes in XML say what output of each filter/source can and prefers to be. Have icons in pipeline browser that lets you hide/show each one.

• Anchoring selection in space or to ids (plot vals at location over time or plot vals of an id over time).

• Choice of interpolation or using nearest neighbor (probe vs pick).

• On screen id and value labelling - draw ids in the render window.
  • Have to be careful to use global ids in parallel for piece invariance.
  • Have to be careful not to clutter view with too much text - n% of pixels get a label.
  • Great to be able to display any particular attribute value (not just ids).

• Have to be able to select blocks within a multiblock dataset.

• Multiple selections sub selections, refining selections, adding too selections. These shouldn't be hard to implement because the vtkSelection structure is a tree structure.

Selection Types

A vtkSelection is an abstract container for selection information. It is structured as a tree where each node has an vtkDataArray containing data, a vtkInformation object containing keys which explain the meaning of the data, and pointers to child nodes. The output of the color buffer selection algorithm (vtkVisibleCellSelector) contains nodes that have processor and actor indices and data arrays that contain cell and point indices. Paraview transforms this into nodes that contain client server ids and cell and point ids. To support the new features we are going to add to selection we need to flesh out the selection data structure to contain additional types of selection information and add additional selection extraction and conversion filters.

The proposed expansion to the content of the selection types are:

• Ids - These are mostly supported at present.
  • surface ids (aka output of visiblecellselector) proc+cell/pt ids
  • client server ids
  • globalids or pedigreeids similar to ids
• Frustum - bounds of a region of 3D space.
• Point in space - a single surface or interior point.
• Thresholds - data attribute values which can be extracted with a vtkThreshold filter.

Furthermore we will move vtkSelection from being a subclass of vtkObject to vtkDataObject. This will allow use to easily pass selections through the pipeline and make it easier to create filters that manipulate selections. This should help to streamline our existing selection and extraction infrastructure and make it more easy to add features in the future. In the future it is likely that vtkPicker and its subclasses will become filters that produce vtkSelections.

Extraction Filters

The user will create selections in several ways.

• selecting a point on the screen (similar to hitting 'p' in ParaView2's picker)
• drawing a rubber band on the screen, which will create a frustum or id type selection.
• entering ids in a form
• clicking on bars in a histogram view

These selections will then be saved and the data they identify will be extracted by running one of several new filters. An extraction filter will take two inputs, a data set and an vtkSelection, and produce some output. A selection conversion filter will take in vtkSelections and produce a modified selection. Two examples are selection intersection and selection union filters. Each selection filter can inspect the selection meaning keys and decide if it can handle to given selection. A frustum extraction filter will not produce any output when given a vtkSelection node with threshold information. In ParaView3, each selectable dataset will be attached to one or more selection algorithms and on each output these algorithms will produce new datasets.

Note that each extraction filter takes 1 dataset and 1 selection as input. In the cases where multiple datasets are selected, ParaView will create and maintain multiple extraction filters. The following diagram shows the planned set of extraction filters and their major features.

One goal of this redesign is to clarify how an application decides what objects are connected to what selection ids. In general the interpretation of the selection contents within various applications is the responsibility of the application developer. For example, at the VTK level there is presently a bare minimum level of support for finding the particular data set corresponding to an actor Id by calling vtkVisibleCellSelector's GetActorFromId(). This relies on a lookup table that the vtkRenderer builds only during the color buffer selection render pass. It must be used very carefully to ensure correctness. ParaViewIII does this correctly and its selection code maps that pointer to a client server id that corresponds to a particular algorithm's output. With selections and extraction filters linked directly to vtkDataSets, it is hoped that application developers will have an easier job of reliably interpretating a selection result.

There seems to be an awful lot of different filters to do pretty much the same thing. At worst, it looks like there can be a separate filter for each possible selection-type data-type pair. There appears to be separate filters to use if the selection happens to be ids, frustums, or thresholds.

I recommend building into the vtkSelection class a query mechanism that filters and other components can use to get the selected cells. For example, there could be a method that takes a vtkDataSet and a vtkTypeIdArray and fills the array with all the (local) ids of cells in vtkDataSet that are marked by the vtkSelection. That way, the extract filter can be agnostic to the type of selection being employed. At worst, there would need to be one type of extract filter for every type of input, and these filters could actually be combined into a single filter that changed its behavior based on the input type.

--Ken 17:10, 7 Feb 2007 (EST)

Integration with the GUI

The section will eventually describe how selection results are given to the client and used by the GUI.