1. 27 May, 2019 1 commit
  2. 14 Feb, 2019 1 commit
    • Mathieu Westphal's avatar
      Adds a new vtk dataType vtkExplicitStructuredGrid and related filters: · 8af35b88
      Mathieu Westphal authored
      * The new class vtkExplicitStructuredGrid
      * Two new filter vtkImageDataToExplicitStructuredGrid and vtkUnstructuredGridExplicitStructuredGrid for converting to the new type
      * A new filter vtkExplicitStructuredGridToUnstructuredGrid for converting from the new type
      * A new filter vtkExplicitStructuredGridCrop , as a first filter specific to the new type
      * A few tests for these filters
      
      ```
       /* vtkExplicitStructuredGrid is a data object that is a concrete implementation
       * of vtkDataSet. vtkExplicitStructuredGrid represents a geometric structure
       * that is a topologically regular array of hexahedron. The topology is that of
       * a cube that has been subdivided into a regular array of smaller cubes.
       * Each cell can be addressed with i-j-k indices, however neighbor hexahedrons
       * does not necessarily share a face and hexahedron can be blanked (turned-off).
       *
       * Like unstructured grid, vtkExplicitStructuredGrid has explicit point coordinates
       * and cell to point indexing.
       * Unlike unstructured grid, vtkExplicitStructuredGrid does not keep a cell type
       * list as all cells are known to be hexahedra.
       * vtkExplicitStructuredGrid can take advantage of its layout to perform operations
       * based on the i, j, k parameters, similar to structured grid. This makes some
       * operations faster on this class, without loosing the flexibility of the
       * cell -> points mapping.
       * The most common use of this class would be in situations where you have all
       * hexahedra but the points used by the cells are not exactly defined by the
       * i, j, k parameters. One example of this is a structured grid with a half voxel
       * shift occurring in the middle of it such as with a geologic fault.
       *
       * The order and number of points is arbitrary.
       * The order and number of cells must match that specified by the dimensions
       * of the grid minus 1, because in vtk structured datasets the dimensions
       * correspond to the points.
       * The cells order increases in i fastest (from 0 <= i <= dims[0] - 2),
       * then j (0 <= j <= dims[1] - 2), then k ( 0 <= k <= dims[2] - 2) where dims[]
       * are the dimensions of the grid in the i-j-k topological directions.
       * The number of cells is (dims[0] - 1) * (dims[1] - 1) * (dims[2] - 1).
       */
      
      ```
      8af35b88
  3. 10 Feb, 2019 1 commit
  4. 13 Jan, 2019 1 commit
  5. 08 Jan, 2019 1 commit
  6. 03 Dec, 2018 1 commit
  7. 31 Oct, 2018 1 commit
    • Will Schroeder's avatar
      Added high-performance contouring algorithm · c809ae19
      Will Schroeder authored
      This filter is a specialized, threaded, high-performance
      implementation of an isocontouring algorithm for unstructured
      grids. In particular, it generates output triangles from 3D linear
      cells: vtkTetrahedron, vtkHexahedron, vtkVoxel, vtkWedge, and
      vtkPyramid.
      
      The commit includes supporting classes for edge-based point merging
      of coincident points, and modification to some VTK cells in order
      to extract edge and case tables in support of isocontouring.
      c809ae19
  8. 11 Jul, 2018 1 commit
    • Utkarsh Ayachit's avatar
      Refactor vtkDataSetAttributes::FieldList · f4662727
      Utkarsh Ayachit authored
      Refactoring vtkDataSetAttributes::FieldList to make the implementation
      more readable and also better handle cases where attributes are not
      named consistently across mutliple inputs.
      f4662727
  9. 14 Jun, 2018 1 commit
    • Will Schroeder's avatar
      SMP Parallel algorithm for Voronoi tessellation · b02011db
      Will Schroeder authored
      This is a novel, threaded, parallel algorithm for 2D Voronoi
      tessellation. Currently this is in experimental stage but while work is
      continuing the filter is useful as is. Basically the algorithm is
      parallelized over tiles (i.e., generating points). It depends on a
      locator to retrieve sorted, close points to a generating point,
      using these point neighbors to perform repeated clipping to produce
      the convex Voronoi tile.
      b02011db
  10. 22 May, 2018 1 commit
    • Berk Geveci's avatar
      Introduced new composite datasets for partitioned data. · 0f6d8394
      Berk Geveci authored
      This is the first step in our attempt to create next
      generation composite datasets for partitioned data and
      arbitrary dataset collections. The main idea is that
      partitioned datasets are instances of
      vtkPartitionedDataSet, which is a vector of datasets.
      It is required that these datasets are compatible, i.e.
      can be processed by the same type of filters together.
      This is similar to vtkMultiPieceDataSet but will
      formalize that partition concept further. The second
      new data type is vtkPartitionedDataSetCollection. This
      is a vector of vtkPartitionedDataSets. It can be an
      arbitrary collection but is not a tree like its
      predecessor vtkMultiBlockDataSet. Any further grouping
      of the blocks will be done by the use of SIL data
      structures, which will be supported later.
      
      Also added basic IO support for these data types.
      0f6d8394
  11. 23 Feb, 2018 1 commit
  12. 25 Jan, 2018 1 commit
  13. 14 Dec, 2017 1 commit
  14. 13 Dec, 2017 1 commit
  15. 11 Dec, 2017 2 commits
  16. 06 Dec, 2017 1 commit
  17. 15 Nov, 2017 1 commit
  18. 21 Sep, 2017 1 commit
    • T.J. Corona's avatar
      Add Lagrange polynomial higher-order cells to VTK. · cc5101a8
      T.J. Corona authored
      This commit adds support for Lagrange cells of the following shape:
      curve, triangle, quadrilateral, tetrahedron, hexahedron, and wedge.
      The new cell types may have arbitrary order, up to a compile-time maximum of 10.
      The maximum may be changed easily.
      The order is inferred from the number of points defining the cell
      and is assumed to be the same along each coordinate axis.
      
      Visualization operations that cells must provide (contouring, clipping, cutting)
      are implemented by approximating each higher-order cell as a collection of
      multi-linear "primitive" cells of the same shape.
      
      Note that the wedge element, when asked for boundary faces, returns faces
      with outward-pointing normals. This is not the same convention as vtkWedge
      but is the same as other VTK cell shapes.
      
      See the vtkCellTypeSource class in vtkFiltersSources for an example of how
      cell connectivity is specified. In general, the shape corner points are
      specified first, matching the linear cell counterparts. Then points on
      edges and faces bounding the shape are listed. Finally, interior points
      are listed. This will allow simpler connectivity entries in the future
      where points on edges and faces may only require 2 numbers each instead
      of a number proportional to the order raised to the parametric dimension
      of the boundary.
      
      T. J. Corona provided the triangle and tetrahedron implementations.
      cc5101a8
  19. 12 Sep, 2017 1 commit
  20. 18 Aug, 2017 1 commit
  21. 08 Aug, 2017 1 commit
    • Philippe P. Pébaÿ's avatar
      Full revision and extension of support for hypertreegrid objects and filters · 61908bd7
      Philippe P. Pébaÿ authored
      In this commit, we provide a complete revision and extension of support for
      hypertreegrid objects and filters, hereby entirely superseding the first
      versions thereof which we developed in 2011-2012.
      When compared to those obtained by constructing an intermediate
      unstructured mesh with fully described connectivity, this new structure
      demonstrates a gain of at least 80% in terms of memory footprint,
      with a better rendering while retaining similar execution speed.
      
      All ancillary structures such as cursors and supercursors have also
      been entirely refactored, for the sake of performance as well as of
      ease of maintenance. Existing native filters, i.e., that operate
      directly on hypertreegrid objects, have been revised accordingly.
      In addition, several new native filters have been added, together with
      a large set of non-regression tests and baseline images.
      
      This commit also implements an adaptive approach in order to accelerate the
      rendering of 2-dimensional hypertreegrids, hereby solving the problem posed
      by the loss of interactivity that occurs when dealing with large and/or
      deeply refined meshes. Specifically, view parameters are taken into account,
      in order to: on one hand, avoid creating surface elements that are
      outside of  the view area; on the other hand, utilize level-of-detail
      properties to cull those cells that are deemed too small to be visible
      with respect to the given view parameters. This adaptive approach typically
      results in a massive increase in rendering performance.
      
      Please refer to the following articles for a comprehensive description:
      https://arxiv.org/abs/1702.04852
      https://arxiv.org/abs/1703.00212
      61908bd7
  22. 11 Jul, 2017 1 commit
    • Will Schroeder's avatar
      Initial commit of threaded, bin-based cell locator. · 8a57e8a8
      Will Schroeder authored
      This commit is the initial set of classes and implementation for
      a new cell locator. It uses a threaded implementation to support
      high-performance construction of the locator. It is based on a
      uniform binning and vtkSMPTools.
      8a57e8a8
  23. 08 Mar, 2016 1 commit
  24. 04 Mar, 2016 1 commit
  25. 27 Jan, 2016 1 commit
  26. 04 Jan, 2016 1 commit
    • Will Schroeder's avatar
      Modernized vtkSortDataArray, threaded the sort · 332071f7
      Will Schroeder authored
      Cleaned up and modernized vtkSortDataArray. Using std::sort and
      threaded the sort operation (with vtkSMPTools). Removed static
      variable that made it non-thread-safe. Added the ability to sort
      in ascending as well as descending order. Expanded and improved
      the test TestSortDataArray.
      
      Note that the code handles vtkStdString and vtkVariant.
      
      Note also: various types of arrays, including the vtkIdList, needed
      to be expanded so the SetArray() (or equivalent operation to
      specify the under-the-hood array to use). This is so the sort
      can swap out the data once the data is shuffled.
      332071f7
  27. 23 Nov, 2015 1 commit
  28. 22 Nov, 2015 2 commits
    • Will Schroeder's avatar
      Separated templated code; created wrappable class · ceb86646
      Will Schroeder authored
      A templated static cell links class was created for performance
      and memory reasons. However, to enhance usability, a instantiated
      version based on vtkIdType was created so that it could be accessed
      from wrapped languages (e.g., Python).
      ceb86646
    • Will Schroeder's avatar
      New class to create links from points to cells · 82a6c1dc
      Will Schroeder authored
      This is a threaded implementation of cell links construction. This
      class generates links from each point to all of the cells that use
      it. It is non-incremental, meaning that it it built once (statically)
      and if the underlying topology changes, it must be built again.
      82a6c1dc
  29. 12 Nov, 2015 1 commit
    • Will Schroeder's avatar
      Added new class vtkStaticPointLocator · 590bac48
      Will Schroeder authored
      A new class for constructing a point locator. The class is threaded
      and templated for performance. It is a static locator, meaning that
      it can only be built once (and incremental insertion is not allowed).
      The code also specially treats 32-bit versus 64-bit id types for
      performance and to reduce memory consumption.
      
      Additional documentation and code enhancements were made to related
      classes. A minor bug in vtkPointLocator related to not using the
      right distance measure (dist2 vs maxDist2) was also corrected.
      590bac48
  30. 22 Sep, 2015 1 commit
    • David Gobbi's avatar
      Wrap many more classes with python. · e6f75b9a
      David Gobbi authored
      This makes the python wrappers ignore WRAP_EXCLUDE, and instead use
      the new property WRAP_EXCLUDE_PYTHON that excludes fewer classes.
      The WRAP_SPECIAL flag, which used to act as a whitelist for python,
      has been removed.
      
      Because this change causes classes to be wrapped in python by default,
      some third-party VTK packages might break until they modify their own
      CMakeLists.txt files to add WRAP_EXCLUDE_PYTHON where necessary.
      e6f75b9a
  31. 05 Sep, 2015 1 commit
    • Marcus D. Hanwell's avatar
      Added vtkAtom and vtkBond back to wrap exclude · 78dc4ae8
      Marcus D. Hanwell authored
      Thanks to David Gobbi again, these still need to be in WRAP_EXLUDE
      so that the wrappers ignore them, and then added to WRAP_SPECIAL so
      that the Python wrappers can wrap them. This should fix the issues
      seen on the dashboards introduced by this branch.
      78dc4ae8
  32. 04 Sep, 2015 1 commit
  33. 24 Aug, 2015 1 commit
  34. 02 Jul, 2015 1 commit
  35. 31 Mar, 2015 1 commit
    • Dan Lipsa's avatar
      Redesign "vtkGhostLevels" arrays and related ghost functionalties. · 4dee0274
      Dan Lipsa authored
      
      Co-authored-by: default avatarYuanxin Liu <leo.liu@kitware.com>
      Co-authored-by: Berk Geveci's avatarBerk Geveci <berk.geveci@kitware.com>
      
       -The semantics of each unsigned char in the ghost arrays changes:
        Instead of storing a numeric value representing how far a cell is
        from the boundary, it is now a bit field specified by
        vtkDataSetAttributes::CellGhostTypes and
        vtkDataSetAttributes::PointGhostTypes.  The bit field is consistent
        with VisIt specs.
      
      - Previously, filters strip all ghost cells they request from upstream
        before finalizing the output. This is no longer done.
      
      - vtkUniform grids previously supported blanking through member arrays
        vtkUniformGrid::CellVisibility and
        vtkUniformGrid::PointVisibility. These arrays are removed and the
        blanking functionality are supported through the new ghost arrays
        instead.
      
      - the "vtkGhostLevel" arrays for cell and point data are renamed to
        vtkDataSetAttributes::GhostArrayName() ("vtkGhostType").
      
      - the version for VTK Legacy files is increased to 4.0 and the version for
        VTK XML files is increased to 2.0. When reading older files we
        convert vtkGhostLevels array to vtkGhostType.
      4dee0274
  36. 25 Mar, 2015 1 commit
  37. 24 Mar, 2015 1 commit
  38. 04 Nov, 2014 1 commit