Shuenhoy/vtk-m
1
0
Fork 0
mirror of https://gitlab.kitware.com/vtk/vtk-m synced 2024-09-16 17:22:55 +00:00
Code Issues 2 Actions Packages Projects Releases Wiki Activity
fc570a75a5
vtk-m/vtkm/exec/ConnectivityStructured.h

158 lines
4.6 KiB
C
Raw Normal View History

re-do commmit.
2015-05-15 16:03:52 +00:00
//============================================================================
// Copyright (c) Kitware, Inc.
// All rights reserved.
// See LICENSE.txt for details.
conslidate the license statement
2019-04-15 23:24:21 +00:00
//
re-do commmit.
2015-05-15 16:03:52 +00:00
// 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.
//============================================================================
Roll connectivity information into CellSet in control environment Previously there was a Connectivity* structure for both the control environment and the execution environment. This was necessary before because the connectivity is explicit to the from and to topology elements, so you would get this structure from the appropriate call to CellSet*. However, the symantics are changed so that the type of connectivity is selected in the worklet's dispatcher. Thus, it is now much cleaner to manage the CellSet structure in the CellSet class itself and just have a single set of Connectivity* classes in the execution environment.
2015-08-02 21:59:44 +00:00
#ifndef vtk_m_exec_ConnectivityStructured_h
#define vtk_m_exec_ConnectivityStructured_h
move connectivity into their own files
2015-04-15 14:45:39 +00:00
Rename structured connectivity index conversion methods The structured connectivity classes are templated on two tags to determine what 2 incident topological elements are being accessed. Back in the day, these were called the "from" elements and "to" elements, as taken from VTK filter names like `PointDataToCellData`. However, these names were found to be very confusion, and after much debate they have been renamed to the visit element type and the incident element type. Meaning that a worklet is "visiting" elements of a particular type (such as visiting each cell) and can access "incident" elements of a particular type (such as the points incident on the cell). I found a few methods converting flat and logical indices using the old, confusing from/to convention. This changes them to the new convention.
2023-05-29 23:20:05 +00:00
#include <vtkm/Deprecated.h>
Change TopologyType identifiers from enumeration to tags. Previously, the items used to identify parts of topology like points, cells, faces, etc. were in an enumeration. However, they are only really used in template specialization, and it is easier to use tags in this case. So, change the enumeration to a set of tag structures. Also made the following changes: * Renamed TopologyType to TopologyElement, which is more indicative of what we are referring to. * Moved the structures from the vtkm::cont namespace to the vtkm namespace. There is no reason not to be able to use them from either the control or execution environments. * Added a VTKM_IS_TOPOLOGY_ELEMENT_TAG macro to do type checks on template arguments that are supposed to be topology element tags.
2015-07-31 19:59:37 +00:00
#include <vtkm/TopologyElementTag.h>
Move RegularStructure to ConnectivityStructuredInternals Also moved from vtkm namespace to vtkm::internal namespace. This change is to then move the structured connectivity classes to the cont and exec namespaces.
2015-07-31 21:48:06 +00:00
#include <vtkm/Types.h>
#include <vtkm/internal/ConnectivityStructuredInternals.h>
move connectivity into their own files
2015-04-15 14:45:39 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
namespace vtkm
{
namespace exec
{
added cell to node code.
2015-05-15 20:22:00 +00:00
Refactor topology mappings to clarify meaning. The `From` and `To` nomenclature for topology mapping has been confusing for both users and developers, especially at lower levels where the intention of mapping attributes from one element to another is easily conflated with the concept of mapping indices (which maps in the exact opposite direction). These identifiers have been renamed to `VisitTopology` and `IncidentTopology` to clarify the direction of the mapping. The order in which these template parameters are specified for `WorkletMapTopology` have also been reversed, since eventually there may be more than one `IncidentTopology`, and having `IncidentTopology` at the end will allow us to replace it with a variadic template parameter pack in the future. Other implementation details supporting these worklets, include `Fetch` tags, `Connectivity` classes, and methods on the various `CellSet` classes (such as `PrepareForInput` have also reversed their template arguments. These will need to be cautiously updated. The convenience implementations of `WorkletMapTopology` have been renamed for clarity as follows: ``` WorkletMapPointToCell --> WorkletVisitCellsWithPoints WorkletMapCellToPoint --> WorkletVisitPointsWithCells ``` The `ControlSignature` tags have been renamed as follows: ``` FieldInTo --> FieldInVisit FieldInFrom --> FieldInMap FromCount --> IncidentElementCount FromIndices --> IncidentElementIndices ```
2019-07-30 16:53:51 +00:00
template <typename VisitTopology, typename IncidentTopology, vtkm::IdComponent Dimension>
Roll connectivity information into CellSet in control environment Previously there was a Connectivity* structure for both the control environment and the execution environment. This was necessary before because the connectivity is explicit to the from and to topology elements, so you would get this structure from the appropriate call to CellSet*. However, the symantics are changed so that the type of connectivity is selected in the worklet's dispatcher. Thus, it is now much cleaner to manage the CellSet structure in the CellSet class itself and just have a single set of Connectivity* classes in the execution environment.
2015-08-02 21:59:44 +00:00
class ConnectivityStructured
Add regularStructure and modify regularconnnectivity
2015-05-14 16:22:39 +00:00
{
Refactor topology mappings to clarify meaning. The `From` and `To` nomenclature for topology mapping has been confusing for both users and developers, especially at lower levels where the intention of mapping attributes from one element to another is easily conflated with the concept of mapping indices (which maps in the exact opposite direction). These identifiers have been renamed to `VisitTopology` and `IncidentTopology` to clarify the direction of the mapping. The order in which these template parameters are specified for `WorkletMapTopology` have also been reversed, since eventually there may be more than one `IncidentTopology`, and having `IncidentTopology` at the end will allow us to replace it with a variadic template parameter pack in the future. Other implementation details supporting these worklets, include `Fetch` tags, `Connectivity` classes, and methods on the various `CellSet` classes (such as `PrepareForInput` have also reversed their template arguments. These will need to be cautiously updated. The convenience implementations of `WorkletMapTopology` have been renamed for clarity as follows: ``` WorkletMapPointToCell --> WorkletVisitCellsWithPoints WorkletMapCellToPoint --> WorkletVisitPointsWithCells ``` The `ControlSignature` tags have been renamed as follows: ``` FieldInTo --> FieldInVisit FieldInFrom --> FieldInMap FromCount --> IncidentElementCount FromIndices --> IncidentElementIndices ```
2019-07-30 16:53:51 +00:00
VTKM_IS_TOPOLOGY_ELEMENT_TAG(VisitTopology);
VTKM_IS_TOPOLOGY_ELEMENT_TAG(IncidentTopology);
Change TopologyType identifiers from enumeration to tags. Previously, the items used to identify parts of topology like points, cells, faces, etc. were in an enumeration. However, they are only really used in template specialization, and it is easier to use tags in this case. So, change the enumeration to a set of tag structures. Also made the following changes: * Renamed TopologyType to TopologyElement, which is more indicative of what we are referring to. * Moved the structures from the vtkm::cont namespace to the vtkm namespace. There is no reason not to be able to use them from either the control or execution environments. * Added a VTKM_IS_TOPOLOGY_ELEMENT_TAG macro to do type checks on template arguments that are supposed to be topology element tags.
2015-07-31 19:59:37 +00:00
Convert VTK-m over to use 'using' instead of 'typedef'
2017-08-16 15:34:21 +00:00
using InternalsType = vtkm::internal::ConnectivityStructuredInternals<Dimension>;
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
Convert VTK-m over to use 'using' instead of 'typedef'
2017-08-16 15:34:21 +00:00
using Helper =
Refactor topology mappings to clarify meaning. The `From` and `To` nomenclature for topology mapping has been confusing for both users and developers, especially at lower levels where the intention of mapping attributes from one element to another is easily conflated with the concept of mapping indices (which maps in the exact opposite direction). These identifiers have been renamed to `VisitTopology` and `IncidentTopology` to clarify the direction of the mapping. The order in which these template parameters are specified for `WorkletMapTopology` have also been reversed, since eventually there may be more than one `IncidentTopology`, and having `IncidentTopology` at the end will allow us to replace it with a variadic template parameter pack in the future. Other implementation details supporting these worklets, include `Fetch` tags, `Connectivity` classes, and methods on the various `CellSet` classes (such as `PrepareForInput` have also reversed their template arguments. These will need to be cautiously updated. The convenience implementations of `WorkletMapTopology` have been renamed for clarity as follows: ``` WorkletMapPointToCell --> WorkletVisitCellsWithPoints WorkletMapCellToPoint --> WorkletVisitPointsWithCells ``` The `ControlSignature` tags have been renamed as follows: ``` FieldInTo --> FieldInVisit FieldInFrom --> FieldInMap FromCount --> IncidentElementCount FromIndices --> IncidentElementIndices ```
2019-07-30 16:53:51 +00:00
vtkm::internal::ConnectivityStructuredIndexHelper<VisitTopology, IncidentTopology, Dimension>;
Move RegularStructure to ConnectivityStructuredInternals Also moved from vtkm namespace to vtkm::internal namespace. This change is to then move the structured connectivity classes to the cont and exec namespaces.
2015-07-31 21:48:06 +00:00
Add regularStructure and modify regularconnnectivity
2015-05-14 16:22:39 +00:00
public:
Convert VTK-m over to use 'using' instead of 'typedef'
2017-08-16 15:34:21 +00:00
using SchedulingRangeType = typename InternalsType::SchedulingRangeType;
Move RegularStructure to ConnectivityStructuredInternals Also moved from vtkm namespace to vtkm::internal namespace. This change is to then move the structured connectivity classes to the cont and exec namespaces.
2015-07-31 21:48:06 +00:00
Make connectivity structures trivially copyable It always worked to trivially copy these classes, but the compiler did not think so because copy constructors were defined. Change these constructors to be default so that the compler can properly check triviality.
2021-02-22 15:44:23 +00:00
ConnectivityStructured() = default;
Add regularStructure and modify regularconnnectivity
2015-05-14 16:22:39 +00:00
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
ConnectivityStructured(const InternalsType& src)
: Internals(src)
ExplicitConnectivity and RegularConnectivity can now upload to any device. Previously we had accidentally bound the PrepareForInput method to upload only to the default device adapter, which breaks the use case of allowing multiple simultaneous backends at runtime.
2015-05-29 14:16:14 +00:00
{
}
Redesign RegularStructure and RegularConnectivity to use vtkm::Vec. By having them use vtkm::Vec the code becomes safer ( no bad indexes on dim=2). Plus CellSetStructured becomes super simple.
2015-05-28 20:49:40 +00:00
Make connectivity structures trivially copyable It always worked to trivially copy these classes, but the compiler did not think so because copy constructors were defined. Change these constructors to be default so that the compler can properly check triviality.
2021-02-22 15:44:23 +00:00
ConnectivityStructured(const ConnectivityStructured& src) = default;
Redesign RegularStructure and RegularConnectivity to use vtkm::Vec. By having them use vtkm::Vec the code becomes safer ( no bad indexes on dim=2). Plus CellSetStructured becomes super simple.
2015-05-28 20:49:40 +00:00
MarchingCubes now uses Gradient fast paths when possible. When running on image data we now use central differences to compute the point gradient
2017-08-08 20:31:18 +00:00
VTKM_EXEC_CONT
Refactor topology mappings to clarify meaning. The `From` and `To` nomenclature for topology mapping has been confusing for both users and developers, especially at lower levels where the intention of mapping attributes from one element to another is easily conflated with the concept of mapping indices (which maps in the exact opposite direction). These identifiers have been renamed to `VisitTopology` and `IncidentTopology` to clarify the direction of the mapping. The order in which these template parameters are specified for `WorkletMapTopology` have also been reversed, since eventually there may be more than one `IncidentTopology`, and having `IncidentTopology` at the end will allow us to replace it with a variadic template parameter pack in the future. Other implementation details supporting these worklets, include `Fetch` tags, `Connectivity` classes, and methods on the various `CellSet` classes (such as `PrepareForInput` have also reversed their template arguments. These will need to be cautiously updated. The convenience implementations of `WorkletMapTopology` have been renamed for clarity as follows: ``` WorkletMapPointToCell --> WorkletVisitCellsWithPoints WorkletMapCellToPoint --> WorkletVisitPointsWithCells ``` The `ControlSignature` tags have been renamed as follows: ``` FieldInTo --> FieldInVisit FieldInFrom --> FieldInMap FromCount --> IncidentElementCount FromIndices --> IncidentElementIndices ```
2019-07-30 16:53:51 +00:00
ConnectivityStructured(
const ConnectivityStructured<IncidentTopology, VisitTopology, Dimension>& src)
MarchingCubes now uses Gradient fast paths when possible. When running on image data we now use central differences to compute the point gradient
2017-08-08 20:31:18 +00:00
: Internals(src.Internals)
{
}
Correct warnings found by GCC 9.2
2019-11-28 15:43:27 +00:00
ConnectivityStructured& operator=(const ConnectivityStructured& src) = default;
ConnectivityStructured& operator=(ConnectivityStructured&& src) = default;
Test and fix issues with WholeCellSetIn with structured grids
2017-07-28 21:02:05 +00:00
VTKM_EXEC
vtkm::Id GetNumberOfElements() const { return Helper::GetNumberOfElements(this->Internals); }
Convert VTK-m over to use 'using' instead of 'typedef'
2017-08-16 15:34:21 +00:00
using CellShapeTag = typename Helper::CellShapeTag;
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
CellShapeTag GetCellShape(vtkm::Id) const { return CellShapeTag(); }
Add regularStructure and modify regularconnnectivity
2015-05-14 16:22:39 +00:00
Test and fix issues with WholeCellSetIn with structured grids
2017-07-28 21:02:05 +00:00
template <typename IndexType>
VTKM_EXEC vtkm::IdComponent GetNumberOfIndices(const IndexType& index) const
{
return Helper::GetNumberOfIndices(this->Internals, index);
}
Convert VTK-m over to use 'using' instead of 'typedef'
2017-08-16 15:34:21 +00:00
using IndicesType = typename Helper::IndicesType;
Get FromIndices as unknown type. We want to be able to get topological connections where it is difficult to know how many values you get each time. In this change, the type of the vector holding the from indices is determined from the connectivity object, and the worklet does not know the type (it must be templated). Although you do not need to specify the max number for this value set (you still currently do for field values), we still need to change the type for explicit sets that uses something that does not rely on the Vec class. The cell-to-point method also needs a Vec wrapper that allows it to shorten the vector dynamically.
2015-08-11 05:38:23 +00:00
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
template <typename IndexType>
VTKM_EXEC IndicesType GetIndices(const IndexType& index) const
different approach for get indices.
2015-05-14 20:26:59 +00:00
{
Change Fetches to use ThreadIndices instead of Invocation. Previously, all Fetch objects received an Invocation object in their Load and Store methods. The point of this was that it allowed the Fetch to get data from any of the execution objects. However, every Fetch either just got data directly from its associated execution object or else used a secondary execution object (the input domain) to get indices into their own execution object. This left two potential areas for improvement. First, pulling data out of the Invocation object was unnecessarily complicated. It would be much nicer to get data directly from the associated execution object. Second, when getting index information from the input domain, it was often the case that extra computations were necessary (particularly on structured cell sets). There was no way to share the index information among Fetches, and therefore the computations were replicated. This change removes the Invocation from the Fetch Load and Store. Instead, it passes the associated execution object and a new object type called the ThreadIndices. The ThreadIndices are customized for the input domain and therefore have all the information needed for a redirected lookup. It is also a thread-local object so it can cache computed indices and save on computation time.
2015-10-07 18:14:00 +00:00
return Helper::GetIndices(this->Internals, index);
different approach for get indices.
2015-05-14 20:26:59 +00:00
}
add worklet test for regular
2015-05-18 21:08:15 +00:00
Rename structured connectivity index conversion methods The structured connectivity classes are templated on two tags to determine what 2 incident topological elements are being accessed. Back in the day, these were called the "from" elements and "to" elements, as taken from VTK filter names like `PointDataToCellData`. However, these names were found to be very confusion, and after much debate they have been renamed to the visit element type and the incident element type. Meaning that a worklet is "visiting" elements of a particular type (such as visiting each cell) and can access "incident" elements of a particular type (such as the points incident on the cell). I found a few methods converting flat and logical indices using the old, confusing from/to convention. This changes them to the new convention.
2023-05-29 23:20:05 +00:00
VTKM_EXEC_CONT SchedulingRangeType FlatToLogicalVisitIndex(vtkm::Id flatVisitIndex) const
{
return Helper::FlatToLogicalVisitIndex(this->Internals, flatVisitIndex);
}
VTKM_EXEC_CONT SchedulingRangeType FlatToLogicalIncidentIndex(vtkm::Id flatIncidentIndex) const
{
return Helper::FlatToLogicalIncidentIndex(this->Internals, flatIncidentIndex);
}
VTKM_EXEC_CONT vtkm::Id LogicalToFlatVisitIndex(
const SchedulingRangeType& logicalVisitIndex) const
{
return Helper::LogicalToFlatVisitIndex(this->Internals, logicalVisitIndex);
}
VTKM_EXEC_CONT vtkm::Id LogicalToFlatIncidentIndex(
const SchedulingRangeType& logicalIncidentIndex) const
{
return Helper::LogicalToFlatIncidentIndex(this->Internals, logicalIncidentIndex);
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
Rename structured connectivity index conversion methods The structured connectivity classes are templated on two tags to determine what 2 incident topological elements are being accessed. Back in the day, these were called the "from" elements and "to" elements, as taken from VTK filter names like `PointDataToCellData`. However, these names were found to be very confusion, and after much debate they have been renamed to the visit element type and the incident element type. Meaning that a worklet is "visiting" elements of a particular type (such as visiting each cell) and can access "incident" elements of a particular type (such as the points incident on the cell). I found a few methods converting flat and logical indices using the old, confusing from/to convention. This changes them to the new convention.
2023-05-29 23:20:05 +00:00
VTKM_DEPRECATED(2.1, "Use FlatToLogicalIncidentIndex.")
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
SchedulingRangeType FlatToLogicalFromIndex(vtkm::Id flatFromIndex) const
Add specialization of topology map fetch for regular point coords In the special case where you are loading the point coordinates for a structured grid in a point to cell map (an important use case), create a VecRectilinearPointCoordinates rather than build a Vec of the values. This will activate the cell specalizations in previous commits. These changes also added some flat-to-logical index conversion and vice versa in ConnectivityStructuredInternals. This change also fixed a bug in getting cells attached to points in 2D grids. (Actually, technically someone else fixed it and checked it in first. The changes were merged during a rebase.) I also added a specalization to Vec for 1D that implicitly converts between the 1D Vec and the component. This can be convenient when templating on the Vec length.
2015-09-02 18:08:25 +00:00
{
Rename structured connectivity index conversion methods The structured connectivity classes are templated on two tags to determine what 2 incident topological elements are being accessed. Back in the day, these were called the "from" elements and "to" elements, as taken from VTK filter names like `PointDataToCellData`. However, these names were found to be very confusion, and after much debate they have been renamed to the visit element type and the incident element type. Meaning that a worklet is "visiting" elements of a particular type (such as visiting each cell) and can access "incident" elements of a particular type (such as the points incident on the cell). I found a few methods converting flat and logical indices using the old, confusing from/to convention. This changes them to the new convention.
2023-05-29 23:20:05 +00:00
return this->FlatToLogicalIncidentIndex(flatFromIndex);
Add specialization of topology map fetch for regular point coords In the special case where you are loading the point coordinates for a structured grid in a point to cell map (an important use case), create a VecRectilinearPointCoordinates rather than build a Vec of the values. This will activate the cell specalizations in previous commits. These changes also added some flat-to-logical index conversion and vice versa in ConnectivityStructuredInternals. This change also fixed a bug in getting cells attached to points in 2D grids. (Actually, technically someone else fixed it and checked it in first. The changes were merged during a rebase.) I also added a specalization to Vec for 1D that implicitly converts between the 1D Vec and the component. This can be convenient when templating on the Vec length.
2015-09-02 18:08:25 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
Rename structured connectivity index conversion methods The structured connectivity classes are templated on two tags to determine what 2 incident topological elements are being accessed. Back in the day, these were called the "from" elements and "to" elements, as taken from VTK filter names like `PointDataToCellData`. However, these names were found to be very confusion, and after much debate they have been renamed to the visit element type and the incident element type. Meaning that a worklet is "visiting" elements of a particular type (such as visiting each cell) and can access "incident" elements of a particular type (such as the points incident on the cell). I found a few methods converting flat and logical indices using the old, confusing from/to convention. This changes them to the new convention.
2023-05-29 23:20:05 +00:00
VTKM_DEPRECATED(2.1, "Use LogicalToFlatIncidentIndex.")
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Id LogicalToFlatFromIndex(const SchedulingRangeType& logicalFromIndex) const
Add specialization of topology map fetch for regular point coords In the special case where you are loading the point coordinates for a structured grid in a point to cell map (an important use case), create a VecRectilinearPointCoordinates rather than build a Vec of the values. This will activate the cell specalizations in previous commits. These changes also added some flat-to-logical index conversion and vice versa in ConnectivityStructuredInternals. This change also fixed a bug in getting cells attached to points in 2D grids. (Actually, technically someone else fixed it and checked it in first. The changes were merged during a rebase.) I also added a specalization to Vec for 1D that implicitly converts between the 1D Vec and the component. This can be convenient when templating on the Vec length.
2015-09-02 18:08:25 +00:00
{
Rename structured connectivity index conversion methods The structured connectivity classes are templated on two tags to determine what 2 incident topological elements are being accessed. Back in the day, these were called the "from" elements and "to" elements, as taken from VTK filter names like `PointDataToCellData`. However, these names were found to be very confusion, and after much debate they have been renamed to the visit element type and the incident element type. Meaning that a worklet is "visiting" elements of a particular type (such as visiting each cell) and can access "incident" elements of a particular type (such as the points incident on the cell). I found a few methods converting flat and logical indices using the old, confusing from/to convention. This changes them to the new convention.
2023-05-29 23:20:05 +00:00
return this->LogicalToFlatIncidentIndex(logicalFromIndex);
Add specialization of topology map fetch for regular point coords In the special case where you are loading the point coordinates for a structured grid in a point to cell map (an important use case), create a VecRectilinearPointCoordinates rather than build a Vec of the values. This will activate the cell specalizations in previous commits. These changes also added some flat-to-logical index conversion and vice versa in ConnectivityStructuredInternals. This change also fixed a bug in getting cells attached to points in 2D grids. (Actually, technically someone else fixed it and checked it in first. The changes were merged during a rebase.) I also added a specalization to Vec for 1D that implicitly converts between the 1D Vec and the component. This can be convenient when templating on the Vec length.
2015-09-02 18:08:25 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
Rename structured connectivity index conversion methods The structured connectivity classes are templated on two tags to determine what 2 incident topological elements are being accessed. Back in the day, these were called the "from" elements and "to" elements, as taken from VTK filter names like `PointDataToCellData`. However, these names were found to be very confusion, and after much debate they have been renamed to the visit element type and the incident element type. Meaning that a worklet is "visiting" elements of a particular type (such as visiting each cell) and can access "incident" elements of a particular type (such as the points incident on the cell). I found a few methods converting flat and logical indices using the old, confusing from/to convention. This changes them to the new convention.
2023-05-29 23:20:05 +00:00
VTKM_DEPRECATED(2.1, "Use FlatToLogicalVisitIndex.")
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
SchedulingRangeType FlatToLogicalToIndex(vtkm::Id flatToIndex) const
Add specialization of topology map fetch for regular point coords In the special case where you are loading the point coordinates for a structured grid in a point to cell map (an important use case), create a VecRectilinearPointCoordinates rather than build a Vec of the values. This will activate the cell specalizations in previous commits. These changes also added some flat-to-logical index conversion and vice versa in ConnectivityStructuredInternals. This change also fixed a bug in getting cells attached to points in 2D grids. (Actually, technically someone else fixed it and checked it in first. The changes were merged during a rebase.) I also added a specalization to Vec for 1D that implicitly converts between the 1D Vec and the component. This can be convenient when templating on the Vec length.
2015-09-02 18:08:25 +00:00
{
Rename structured connectivity index conversion methods The structured connectivity classes are templated on two tags to determine what 2 incident topological elements are being accessed. Back in the day, these were called the "from" elements and "to" elements, as taken from VTK filter names like `PointDataToCellData`. However, these names were found to be very confusion, and after much debate they have been renamed to the visit element type and the incident element type. Meaning that a worklet is "visiting" elements of a particular type (such as visiting each cell) and can access "incident" elements of a particular type (such as the points incident on the cell). I found a few methods converting flat and logical indices using the old, confusing from/to convention. This changes them to the new convention.
2023-05-29 23:20:05 +00:00
return this->FlatToLogicalVisitIndex(flatToIndex);
Add specialization of topology map fetch for regular point coords In the special case where you are loading the point coordinates for a structured grid in a point to cell map (an important use case), create a VecRectilinearPointCoordinates rather than build a Vec of the values. This will activate the cell specalizations in previous commits. These changes also added some flat-to-logical index conversion and vice versa in ConnectivityStructuredInternals. This change also fixed a bug in getting cells attached to points in 2D grids. (Actually, technically someone else fixed it and checked it in first. The changes were merged during a rebase.) I also added a specalization to Vec for 1D that implicitly converts between the 1D Vec and the component. This can be convenient when templating on the Vec length.
2015-09-02 18:08:25 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
Rename structured connectivity index conversion methods The structured connectivity classes are templated on two tags to determine what 2 incident topological elements are being accessed. Back in the day, these were called the "from" elements and "to" elements, as taken from VTK filter names like `PointDataToCellData`. However, these names were found to be very confusion, and after much debate they have been renamed to the visit element type and the incident element type. Meaning that a worklet is "visiting" elements of a particular type (such as visiting each cell) and can access "incident" elements of a particular type (such as the points incident on the cell). I found a few methods converting flat and logical indices using the old, confusing from/to convention. This changes them to the new convention.
2023-05-29 23:20:05 +00:00
VTKM_DEPRECATED(2.1, "Use LogicalToFlatVisitIndex.")
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Id LogicalToFlatToIndex(const SchedulingRangeType& logicalToIndex) const
Add specialization of topology map fetch for regular point coords In the special case where you are loading the point coordinates for a structured grid in a point to cell map (an important use case), create a VecRectilinearPointCoordinates rather than build a Vec of the values. This will activate the cell specalizations in previous commits. These changes also added some flat-to-logical index conversion and vice versa in ConnectivityStructuredInternals. This change also fixed a bug in getting cells attached to points in 2D grids. (Actually, technically someone else fixed it and checked it in first. The changes were merged during a rebase.) I also added a specalization to Vec for 1D that implicitly converts between the 1D Vec and the component. This can be convenient when templating on the Vec length.
2015-09-02 18:08:25 +00:00
{
Rename structured connectivity index conversion methods The structured connectivity classes are templated on two tags to determine what 2 incident topological elements are being accessed. Back in the day, these were called the "from" elements and "to" elements, as taken from VTK filter names like `PointDataToCellData`. However, these names were found to be very confusion, and after much debate they have been renamed to the visit element type and the incident element type. Meaning that a worklet is "visiting" elements of a particular type (such as visiting each cell) and can access "incident" elements of a particular type (such as the points incident on the cell). I found a few methods converting flat and logical indices using the old, confusing from/to convention. This changes them to the new convention.
2023-05-29 23:20:05 +00:00
return this->LogicalToFlatVisitIndex(logicalToIndex);
Add specialization of topology map fetch for regular point coords In the special case where you are loading the point coordinates for a structured grid in a point to cell map (an important use case), create a VecRectilinearPointCoordinates rather than build a Vec of the values. This will activate the cell specalizations in previous commits. These changes also added some flat-to-logical index conversion and vice versa in ConnectivityStructuredInternals. This change also fixed a bug in getting cells attached to points in 2D grids. (Actually, technically someone else fixed it and checked it in first. The changes were merged during a rebase.) I also added a specalization to Vec for 1D that implicitly converts between the 1D Vec and the component. This can be convenient when templating on the Vec length.
2015-09-02 18:08:25 +00:00
}
Remove exports for header-only functions/methods Change the VTKM_CONT_EXPORT to VTKM_CONT. (Likewise for EXEC and EXEC_CONT.) Remove the inline from these macros so that they can be applied to everything, including implementations in a library. Because inline is not declared in these modifies, you have to add the keyword to functions and methods where the implementation is not inlined in the class.
2016-10-19 22:42:58 +00:00
VTKM_EXEC_CONT
clang-format: apply to the entire tree
2017-05-18 14:29:41 +00:00
vtkm::Vec<vtkm::Id, Dimension> GetPointDimensions() const
adding rendering from other branch
2016-01-20 22:40:54 +00:00
{
return this->Internals.GetPointDimensions();
}
Simplify using CellSetPermutation by providing a default permutation type. Previously you had to explicitly state you wanted a CellSetPermutation with an ArrayHanlde of Id's, now that is done automatically.
2016-04-08 17:49:51 +00:00
Add CellNeighborhood
2020-07-15 20:41:32 +00:00
VTKM_EXEC_CONT
vtkm::Vec<vtkm::Id, Dimension> GetCellDimensions() const
{
return this->Internals.GetCellDimensions();
}
Implement extents support Adds a variable `GlobalPointIndexStart` to `CellSetStructured`. Adding this to the cell-set, instead of the coordinate system, enables this feature for different types of datasets like uniform grid, rectilinear, etc., with this one change. The extents can be computed using `GlobalPointIndexStart` and `PointDimensions`.
2018-12-03 20:56:45 +00:00
VTKM_EXEC_CONT
SchedulingRangeType GetGlobalPointIndexStart() const
{
return this->Internals.GetGlobalPointIndexStart();
}
Refactor topology mappings to clarify meaning. The `From` and `To` nomenclature for topology mapping has been confusing for both users and developers, especially at lower levels where the intention of mapping attributes from one element to another is easily conflated with the concept of mapping indices (which maps in the exact opposite direction). These identifiers have been renamed to `VisitTopology` and `IncidentTopology` to clarify the direction of the mapping. The order in which these template parameters are specified for `WorkletMapTopology` have also been reversed, since eventually there may be more than one `IncidentTopology`, and having `IncidentTopology` at the end will allow us to replace it with a variadic template parameter pack in the future. Other implementation details supporting these worklets, include `Fetch` tags, `Connectivity` classes, and methods on the various `CellSet` classes (such as `PrepareForInput` have also reversed their template arguments. These will need to be cautiously updated. The convenience implementations of `WorkletMapTopology` have been renamed for clarity as follows: ``` WorkletMapPointToCell --> WorkletVisitCellsWithPoints WorkletMapCellToPoint --> WorkletVisitPointsWithCells ``` The `ControlSignature` tags have been renamed as follows: ``` FieldInTo --> FieldInVisit FieldInFrom --> FieldInMap FromCount --> IncidentElementCount FromIndices --> IncidentElementIndices ```
2019-07-30 16:53:51 +00:00
friend class ConnectivityStructured<IncidentTopology, VisitTopology, Dimension>;
MarchingCubes now uses Gradient fast paths when possible. When running on image data we now use central differences to compute the point gradient
2017-08-08 20:31:18 +00:00
Add regularStructure and modify regularconnnectivity
2015-05-14 16:22:39 +00:00
private:
Move RegularStructure to ConnectivityStructuredInternals Also moved from vtkm namespace to vtkm::internal namespace. This change is to then move the structured connectivity classes to the cont and exec namespaces.
2015-07-31 21:48:06 +00:00
InternalsType Internals;
move connectivity into their own files
2015-04-15 14:45:39 +00:00
};
Roll connectivity information into CellSet in control environment Previously there was a Connectivity* structure for both the control environment and the execution environment. This was necessary before because the connectivity is explicit to the from and to topology elements, so you would get this structure from the appropriate call to CellSet*. However, the symantics are changed so that the type of connectivity is selected in the worklet's dispatcher. Thus, it is now much cleaner to manage the CellSet structure in the CellSet class itself and just have a single set of Connectivity* classes in the execution environment.
2015-08-02 21:59:44 +00:00
}
} // namespace vtkm::exec
move connectivity into their own files
2015-04-15 14:45:39 +00:00
Roll connectivity information into CellSet in control environment Previously there was a Connectivity* structure for both the control environment and the execution environment. This was necessary before because the connectivity is explicit to the from and to topology elements, so you would get this structure from the appropriate call to CellSet*. However, the symantics are changed so that the type of connectivity is selected in the worklet's dispatcher. Thus, it is now much cleaner to manage the CellSet structure in the CellSet class itself and just have a single set of Connectivity* classes in the execution environment.
2015-08-02 21:59:44 +00:00
#endif //vtk_m_exec_ConnectivityStructured_h
Reference in New Issue Copy Permalink