This project is mirrored from https://gitlab.kitware.com/vtk/vtk-m.git. Pull mirroring updated .
  1. 13 Dec, 2017 1 commit
  2. 21 Sep, 2017 1 commit
    • Corona, Thomas Joseph's avatar
      Add Lagrange polynomial higher-order cells to VTK. · cc5101a8
      Corona, Thomas Joseph 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
  3. 12 Sep, 2017 1 commit
  4. 18 Aug, 2017 1 commit
  5. 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
  6. 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
  7. 08 Mar, 2016 1 commit
  8. 04 Mar, 2016 1 commit
  9. 27 Jan, 2016 1 commit
  10. 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
  11. 23 Nov, 2015 1 commit
  12. 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
  13. 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
  14. 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
  15. 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
  16. 04 Sep, 2015 1 commit
  17. 24 Aug, 2015 1 commit
  18. 02 Jul, 2015 1 commit
  19. 31 Mar, 2015 1 commit
    • Lipsa, Dan's avatar
      Redesign "vtkGhostLevels" arrays and related ghost functionalties. · 4dee0274
      Lipsa, Dan authored
      
      Co-authored-by: default avatarYuanxin Liu <leo.liu@kitware.com>
      Co-authored-by: default 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
  20. 25 Mar, 2015 1 commit
  21. 24 Mar, 2015 1 commit
  22. 04 Nov, 2014 1 commit
  23. 29 Oct, 2014 1 commit
    • Ben Boeckel's avatar
      vtkInformationDataObjectKey: move to CommonDataModel · 6b4ea15f
      Ben Boeckel authored
      It requires vtkDataObject which is in vtkCommonDataModel, but adding the
      dependency link creates a circular dependency graph. Instead, move the
      implementations of the convenience methods to the correct library and
      export them from there.
      
      Change-Id: I8bf68670aff5f703688cf9cbae83e683bd457f0f
      6b4ea15f
  24. 03 Jul, 2014 1 commit
    • Ben Boeckel's avatar
      vtkAMRUtilities: split out vtkParallelAMRUtilities · e64416c6
      Ben Boeckel authored
      This is split so that vtkIOXML loses its dependency on vtkFiltersAMR
      which drags in vtkParallelCore. The parallel-related code can instead be
      split out and the core utilities be moved into Common/DataModel.
      
      Change-Id: I621cc40f2afb1831d25e0701a0075ad88dc3e149
      e64416c6
  25. 21 May, 2014 2 commits
    • George Zagaris's avatar
      ENH: Update extract structured data filters · 296ace04
      George Zagaris authored
      This commit updates the extract/sub-sample structured data filters
      to reflect the changes of refactoring the piece and extent in VTK.
      Namely, vtkExtractGrid, vtkExtractVOI and vtkExtractRectilinearGrid,
      which operate on vtkStructuredGrid, vtkImageData, and vtkRectilinearGrid
      respectively, are updated.
      
      These datatypes, albeit different, they share common functionality. To
      avoid replicating essentially the same code in all of these three classes,
      a helper class, called vtkExtractStructuredGridHelper, is introduced. This
      new class is part of VTK's vtkCommonDataModel module since it needs to be
      used by both the vtkImagingCore and vtkFiltersExtraction module.
      
      One minor caveat, is that Imaging algorithms/tests require that the origin
      of the image to be retained and that the output extent is w.r.t.
      to the input extent, when there is no sub-sampling. For that reason,
      when there is no sub-sampling vtkExtractVOI, will yield an output extent
      that is with respect to the origin. All other filters re-number the
      output extent starting from zero. The output extent is always re-numbered
      when the data is sub-sampled.
      
      Change-Id: I26fe5a115032333db9814987a6c9dc949e51ef52
      296ace04
    • Berk Geveci's avatar
      Cleaned up extent translators. · 19e69143
      Berk Geveci authored
      - Removed unused extent translator subclasses
      - Removed unnecessary refereces to the extent translator
      - Moved extent translator into Common/ExecutionModel
      
      Change-Id: Idc53dd66891297b1f6a06ea3eb1baf394cb24b20
      19e69143
  26. 21 Nov, 2013 1 commit
  27. 02 Oct, 2013 2 commits
  28. 19 Sep, 2013 1 commit
    • David C. Lonie's avatar
      Add vtkCellIterator for traversing cells in data sets. · 6c430b58
      David C. Lonie authored
      This provides a generic method for traversing cells in
      subclasses of vtkDataSet. Three implementations of the
      vtkCellIterator interface are provided:
      
      * vtkDataSetCellIterator: Use vtkDataSet API to look up cells
        using random access.
      * vtkPointSetCellIterator: Use the vtkPointSet API to look up
        cells using random access. Advantage over
        vtkDataSetCellIterator is that points are looked up as a batch
        operation.
      * vtkUnstructuredGridCellIterator: Use the vtkUnstructuredGrid
        internals to perform efficient sequential iteration without
        vtkCellLinks.
      
      Change-Id: I5893dab945115721d2291b2eff83bf7e71632230
      6c430b58
  29. 13 Sep, 2013 1 commit
    • Burlen Loring's avatar
      Surface LIC : parallelization & fine tuning features · ad4dddfc
      Burlen Loring authored
      * Parallelization:
      Support for Multiblock datasets and MPI parallel usage. Three compositing
      strategies are provided, with a heuristic to automatically make a reasonable
      selection between them. [1] INPLACE, [2] INPLACE_DISJOINT, [3] BALANCED.
      The inplace strategy processes data where it falls given its parallel domain
      decomposition and projection to the screen. For simple surfaces such as
      slices where ranks/blocks data does not overlap in screen space this is the
      most efficient approach. However where ranks/blocks data have large amount
      of screen space overlap, this approach has high communication/compositing
      and overhead and a large amount of redundant computation that's discarded.
      The inplace-disjoint strategy was designed to address these issues. It
      leaves data inplace as much as possible but will assign pixels to ranks
      uniquely eliminating redundant computation. The communication costs are
      the same as the inplace strategy however they are split into two temporally
      disjoint parts with computation in between which tends to reduce congestion
      and contention. The balanced strategy divides the screen into equally sized
      disjoint regions and assigns each rank a region. This strategy can suffer
      from load balancing issues, and because no account is made of the initial
      data distribution it may have higher communication/compositing costs than
      the others. The parallel implementations have been tested with IceT in
      ParaView. The compositors uses non-blocking mpi communications, MPI
      subarrays for describing non-contoguous memory extents, and communicates
      efficiently by pasing mpi gpu mapped memory via extensions made to
      vtkPixelBufferObject. An object factory is used to override the serial
      objects with their parallel counterparts  when the parallel module is
      linked.
      
      * Contrast and Color Contrast Enhancement:
      The new contrast enhancement feature increases both dynamic range contrast
      while preserving patterns in the LIC. Contrast enhancment is implemented using
      histogram stretching. The color contrast enhancement is made in HSL space on
      the L channel to minimize color distortions. During the "enhanced" LIC mode
      contrast enhancement is also applied after the first pass of LIC compution.
      This helps strengthen streaking patterns.
      
      * Enhanced scalar color shading:
      A new mode has been added to the shader that shades surface geometry combining
      both LIC and scalar colors. The new shader produces bright colors without
      diminishing the visibility of the LIC by multiplying colored lit surface with
      computed LIC texture. The original blending implementation is left in place
      as it works well in many situations.
      
      * Noise texture customization:
      A new noise texture generator has been added to improve control over "streaking"
      in the convolved texture. The noise textures produced are fully customizable over
      9 degrees of freedom. [1] Noise distribution (Gaussian, Uniform, Perlin); [2] Noise
      texture size [3] Noise grain size [4,5] Min/max noise values [6] Number of noise
      levels; [7] Impulse noise probability; [8] Impulse noise background color; [9]
      Noise generator seed
      
      * Fragment masking controls:
      The new fragment masking provides controls over the color and intensity of masked
      fragments and their blending with scalars. Fragments are masked by threshold |V|<t,
      where t is a user specified threshold value, and V are mask vectors. Masking vectors
      can be optionally projected onto the surface or passed through un-modified so that
      threshold is provided in the original vector units and matches scalar color shading.
      
      * Vector Normalization Control:
      The new vector normalization control lets the user turn on and off normalization
      in the integrator. Disabling normalization can help highlight relative strengths
      in strongly varying regions of a flow field by making the amount of smoothing that
      occurs during convolution proportional to the flow strength.
      
      * Antialiasing:
      An optional anti-aliasing stage was added. In some cases the CE and EE stages
      produce streaks with sharp jagged transitions from black to white. The AA stage
      can be used to soften the result and smooth sharp transitions.
      
      * Optimizations:
      The implementation has been split into 8 major steps with the result of each stage
      cached in a texture.[1] Vector projection and lighting calculation; [2] Gather;
      [3] Compositingand guard pixel generation; [4] LIC Computation; [5] Scatter;
      [6] Scalar coloring; [7] Color contrast enhance; [8] Depth test. During user
      interaction stages that do not have modfied paramters or input data can be skiped
      using the cahced result instead.  This can save large amount of time for expensive
      operations such as projecting vectors, computing the LIC etc. Classes
      were added to simplify monitoring of various system paramters that would trigger
      an update, such as changes to lights, modelview or projection matrices, background
      color, etc. A new framebuffer object has been introduced, designed specifically
      for efficient buffer ping-pong, as well as efficiency improvements for setting
      shader unfiorms on inner parts of buffer ping-pong loops.
      
      * Porting and Testing:
      The code has been ported to Apple + ATI systems, and to OS Mesa with the gallium
      llvmpipe state tracker. A number of ctests have been introduced to excersize the
      new features. Parallel features have testing coverage in ParaView.
      
      Change-Id: I26f90a4e1e4e204289d38993d1e32fe5493b7a0d
      ad4dddfc
  30. 26 Mar, 2013 1 commit
  31. 22 Mar, 2013 1 commit
    • Marcus D. Hanwell's avatar
      Move the Python wrapping to the end · 34903fe1
      Marcus D. Hanwell authored
      This moves the Python wrapping to the end of the build process, using
      the information exported by the module files.
      
      Change-Id: I711382f79fc1fdb15cd80c87f55dd2f97a2c5cd8
      34903fe1
  32. 22 Nov, 2012 1 commit
  33. 24 Oct, 2012 1 commit
    • David Gobbi's avatar
      ENH: Make the wrappers detect abstract classes automatically. · 62700fbe
      David Gobbi authored
      Deprecate the "--abstract" and "--concrete" options for wrapper
      tools.  Also deprecate specifying an output file without "-o",
      and remove the old "infile [hintsfile] concrete outfile" calling
      convention, which hasn't been used since VTK 5.6 and was broken.
      
      The wrappers now ignore the ABSTRACT property in cmake, instead
      they automatically detect concrete classes by searching for the
      New() method.
      
      Some classes were marked as ABSTRACT, even though they had a New()
      method that returned a valid instance.  The ABSTRACT property
      has been removed from these classes, for consistency.
      
      Note that the vtkInstantiator classes still rely on the ABSTRACT
      property, so the ABSTRACT property cannot yet be removed from the
      cmake files.
      
      Change-Id: I05ebf42e69367fd4ce7256864a25d1f0c16ed4b8
      62700fbe
  34. 04 Oct, 2012 1 commit
    • Johan Andruejol's avatar
      REFACTOR: Move vtkTuple to Common/Math · 9d3012d2
      Johan Andruejol authored
      This move is necessary to be able to derive vtkQuaternion from
      vtkTuple and be able to use vtkQuaternion in the class
      vtkQuaternionInterpolator (in Common/Math)
      
      This will not change anything for the other classes in Common/DataModel
      as they depend on vtkCommonMath.
      
      Change-Id: I06b6c64119304b6241ae41c44aeb0aec2c5af886
      9d3012d2
  35. 03 Sep, 2012 1 commit
  36. 24 Aug, 2012 1 commit
    • Yuanxin Liu's avatar
      AMR classes: major data structure changes · 8fc6cf25
      Yuanxin Liu authored
      The main motivation for the changes is to improve the efficiency
      of AMR data structures by replacing the data set containers and meta
      data representation with new data structures.
      
      First, the meta data associated with the AMR data is moved from
      vtkInformation to a new class vtkAMRInformation so that they do not
      have to be deep copied. Related changes also include:
      
      - Before, when the LOAD_REQUESTED_BLOCKS() key is not set, the reader
        would recompute AMR meta data based on the requested blocks.  This
        is no longer done: meta data always represents what is on file.
        The reason is to avoid the sensitive meta data computation that
        depends on connectivitiy of the requested blocks.
      
      - Processor ranks are no longer stored in the meta data. Filters
        can easily generate them by using
        vtkAMRUtilities::DistributeProcessInformation
      
      - There used to be two types of 1D indices used to reference blocks in
        an AMR: vtkOverlappingAMR::GetFlatIndex and
        vtkOverlappingAMR::GetCompositeIndex. Now only the latter is used.
        The "other" 1D index is file type specific so now only the readers
        reference them (vtkAMRInformation::GetAMRBlockSourceIndex())
      
      - To make it easy to traversal the bounding boxes in the meta data. A
        new key vtkObject::BOUNDING_BOX() has been added that works with
        vtkOverlappingAMRDataIterator. See its use in vtkCompositeCutter for
        an example.
      
      - In a multiprocess setting, vtkAMRSliceFilter for each process computes
        the complete meta data to avoid communication
      
      - Many functions in vtkAMRUtilities are removed because they provide
        support for computing meta data from data sets. In the new design,
        meta information is always created before data sets are constructed.
      
      Second, VtkUniformGridAMR now use a more compact representation of the grid
      blocks than the tree implementation done previously. To facilicate
      this, vtkCompositeDataSet now becomes a fully abstract class and all
      concrete implementation gest pushed to the class vtkDataObjectTree.
      In the new implementation, the non-null blocks are stored in an stl
      vector. So traversing them (using vtkUniformGridAMRDataIterator) is
      efficient.
      - The AMRBox has been reduced to store only the lower and upper
        corners.  Information such as origin and spacing are moved to the
        container class vtkAMRInformation, since they are often common to
        all boxes or boxes on the same level.
      
      - File reoganization: - AMR File readers are moved from Filters/AMR to
        IO/AMR - AMR algorithms (vtk*AMR*Algorithm) are moved from
        Filters/General to Common/ExecutionModel
      
      Finally, tkAMRVolumeWrapper is moved from filters to rendering.
      The dependency on vtkAMRResampler and vtkParallelCore makes it
      difficult for it go to Rendering/Volume so a new module
      Rendering/VolumeAMR is created.
      
      Change-Id: Id73d214e6a5ac4d4a08fde5d979365f46edfa390
      8fc6cf25
  37. 20 Aug, 2012 1 commit
    • David Thompson's avatar
      Color mapping using only annotated values. · ee78433e
      David Thompson authored
      This patch implements an "indexed" color mode for `vtkLookupTable`.
      When `IndexedLookup` is true, the scalar range and log/linear settings are disabled;
      `MapScalars` and `MapValue` require an exact match to an annotated value
      in order to return a valid color.
      All other values are mapped to `NanColor`.
      
      Change-Id: I9805ab6b4398db479c0ae6b0d239886850c2e187
      ee78433e