You can not select more than 25 topics
			Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
		
		
		
		
		
			
		
			
				
					
					
						
							54 lines
						
					
					
						
							2.1 KiB
						
					
					
				
			
		
		
		
			
			
			
				
					
				
				
					
				
			
		
		
	
	
							54 lines
						
					
					
						
							2.1 KiB
						
					
					
				
								#pragma once
							 | 
						|
								
							 | 
						|
								#include <array>
							 | 
						|
								
							 | 
						|
								#include <macros.h>
							 | 
						|
								#include <container/stl_alias.hpp>
							 | 
						|
								
							 | 
						|
								/**
							 | 
						|
								 * A plane is defined by the barycentric plane equation:
							 | 
						|
								 *     f0 * b0 + f1 * b1 + f2 * b2 + f3 * b3 = 0 // For 3D
							 | 
						|
								 * where the b's are the barycentric variables, and f's are the
							 | 
						|
								 * plane equation coefficients.  We store the f's for each plane.
							 | 
						|
								 */
							 | 
						|
								using plane_t = std::array<double, 4>;
							 | 
						|
								
							 | 
						|
								/**
							 | 
						|
								 * A point is represented as the intersection of planes.  We store the index
							 | 
						|
								 * of the plane here.
							 | 
						|
								 */
							 | 
						|
								using point_t = std::array<uint32_t, 3>;
							 | 
						|
								
							 | 
						|
								static constexpr uint32_t INVALID_INDEX = std::numeric_limits<uint32_t>::max();
							 | 
						|
								
							 | 
						|
								struct arrangement_t {
							 | 
						|
								    /* vertex descriptor */
							 | 
						|
								    stl_vector_mp<point_t> vertices{};
							 | 
						|
								
							 | 
						|
								    /* face descriptor */
							 | 
						|
								    struct face_descriptor {
							 | 
						|
								        stl_vector_mp<uint32_t> vertices{}; ///< An ordered list of boundary vertices. The face is always oriented
							 | 
						|
								                                            ///< counterclockwise when viewed from the positive side of the supporting plane.
							 | 
						|
								        uint32_t                supporting_plane{INVALID_INDEX}; ///< Plane index of the supporting plane.
							 | 
						|
								        uint32_t                positive_cell{INVALID_INDEX};    ///< The cell index on the positive side of this face.
							 | 
						|
								        uint32_t                negative_cell{INVALID_INDEX};    ///< The cell index on the negative side of this face.
							 | 
						|
								    };
							 | 
						|
								
							 | 
						|
								    stl_vector_mp<face_descriptor> faces{};                      ///< A set of boundary vertex indices in no particular order.
							 | 
						|
								
							 | 
						|
								    /* cell descriptor */
							 | 
						|
								    struct cell_descriptor {
							 | 
						|
								        stl_vector_mp<uint32_t> faces{};
							 | 
						|
								    };
							 | 
						|
								
							 | 
						|
								    stl_vector_mp<cell_descriptor> cells{}; ///< A set of boundary face indices in no particular order.
							 | 
						|
								
							 | 
						|
								    /* Note: the following structure is only non-empty if input planes contain duplicates. */
							 | 
						|
								    stl_vector_mp<uint32_t>                unique_plane_indices{};
							 | 
						|
								    stl_vector_mp<stl_vector_mp<uint32_t>> unique_planes{};
							 | 
						|
								    stl_vector_mp<bool>                    unique_plane_orientations{};
							 | 
						|
								};
							 | 
						|
								
							 | 
						|
								IA_API bool          load_lut();
							 | 
						|
								IA_API void          lut_print_test();
							 | 
						|
								IA_API arrangement_t compute_arrangement(const stl_vector_mp<plane_t>& planes);
							 |