creates the kinetic partition of the bounding box of the polygons given as input data.
The kinetic partition can either be initialized by using the default constructor Kinetic_space_partition_3(), insert() to provide input data and initialize() to prepare the partition or by using the constructor with input parameters.
identifies the support of a face in the exported linear cell complex, which is either an input polygon, identified by a non-negative number, a side of the bounding box in the rotated coordinate system or a face of the octree used to partition the scene.
Write timing and internal information to std::cout.
Type: bool
Default: false
Use the oriented bounding box instead of the axis-aligned bounding box. While the z direction is maintained, the x axis is aligned with the largest variation in the horizontal plane.
Type: bool
Default: false
Factor for extension of the bounding box of the input data to be used for the partition. Must be larger than 1.0.
Type: FT
Default: 1.1
The maximal depth of the octree for subdividing the kinetic partition before initialization.
Type: std::size_t
Default: 3
A node in the octree is only split if the contained number of primitives is larger and the maximal depth is not yet reached.
Volume and face attributes defined in the model KineticLCCItems are filled. The volume index is in the range [0, number of volumes -1] The input polygon index of a face refers to the input polygon the face originates from. If the face originates from several coplanar input polygons, one of them is provided.
initializes the kinetic partition and propagates the kinetic polygons.
The input polygons are separated using an octree. Afterwards, the kinetic partition of each octree leaf is computed. Each leaf are computed independently and, if ConcurrencyTag is Parallel_tag, in parallel.
In contrast to calling initialize() and partition(), the kinetic data structure of each leaf is created right before its propagation and released after its finalization. Hence, the memory consumption is considerably lower. To compute another partition, e.g., with a different k, init_and_partition() has to be called again.
Note
In the parallel version, several kinetic data structures exist at the same time, one per running thread. Thus, the memory consumption is higher than in the sequential version.
Use the oriented bounding box instead of the axis-aligned bounding box. While the z direction is maintained, the x axis is aligned with the largest variation in the horizontal plane.
Type: bool
Default: false
Factor for extension of the bounding box of the input data to be used for the partition. Must be larger than 1.0.
Type: FT
Default: 1.1
The maximal depth of the octree for subdividing the kinetic partition before initialization.
Type: std::size_t
Default: 3
A node in the octree is only split if the contained number of primitives is larger and the maximal depth is not yet reached.
Type: std::size_t
Default: 40
Precondition
input data has been provided via insert() and k != 0.
The input polygons are separated using an octree. Afterwards, the kinetic data structure of each octree leaf is initialized. The leaves are initialized independently and, if ConcurrencyTag is Parallel_tag, in parallel.
The initialized kinetic data structures are kept. Hence, partition() can be called several times afterwards, e.g., with different values of k, without initializing again.
Note
The initialized kinetic data structures of all octree leaves exist at the same time. If only a single partition is needed, init_and_partition() has a considerably lower memory consumption.
Use the oriented bounding box instead of the axis-aligned bounding box. While the z direction is maintained, the x axis is aligned with the largest variation in the horizontal plane.
Type: bool
Default: false
Factor for extension of the bounding box of the input data to be used for the partition. Must be larger than 1.0.
Type: FT
Default: 1.1
The maximal depth of the octree for subdividing the kinetic partition before initialization.
Type: std::size_t
Default: 3
A node in the octree is only split if the contained number of primitives is larger and the maximal depth is not yet reached.
provides the index of the plane of each input polygon into input_planes().
Polygons that are coplanar up to a small tolerance share a plane and thus have the same index. Degenerate polygons, i.e., polygons with less than three vertices or with collinear vertices, are dropped when inserted. Their index is std::size_t(-1).
Returns
vector of plane indices, one for each inserted polygon.
Polygons that are coplanar up to a small tolerance share a plane. Thus, each plane occurs only once. The planes are indexed by input_plane_indices() and by the input plane index stored in the face attributes of the linear cell complex, see get_linear_cell_complex().
A plane is fitted to the vertices of each polygon and the polygon is replaced by the convex hull of its vertices projected onto the plane. Polygons that are coplanar up to a small tolerance relative to their extent get the same plane, which is fitted to the vertices of all of them. This avoids very thin volumes between nearly coplanar polygons. Degenerate polygons, i.e., polygons with less than three vertices or with collinear vertices, are dropped.
Coplanar polygons share a support plane in the partition and expand separately. Pieces of several coplanar polygons that lie in the same face of the arrangement of the intersection lines within the support plane at the beginning are merged into their convex hull. A face of the partition originating from several coplanar polygons refers to one of them as its input polygon, see get_linear_cell_complex().
propagates the kinetic polygons in the initialized partition.
The kinetic partitions of the octree leaves are computed independently and, if ConcurrencyTag is Parallel_tag, in parallel. The kinetic data structures initialized by initialize() are restored after the propagation of each leaf. Hence, partition() can be called several times with different values of k. The result of a previous call is replaced.
Note
In the parallel version, the state of several kinetic data structures is copied at the same time, one per running thread. Thus, the memory consumption is higher than in the sequential version.
1.17.0