Skip to content

Project OpenGeode

namespace geode

Namespaces

Records

Functions

geode_assertion_failed

cpp
void geode_assertion_failed(basic_string_view condition, basic_string_view message, basic_string_view file, int line)
void geode_assertion_failed(basic_string_view condition, basic_string_view message, basic_string_view file, int line)

geode_lippincott

cpp
int geode_lippincott()
int geode_lippincott()

Try to catch several exception types. Always return 1.

throw_lippincott

cpp
void throw_lippincott()
void throw_lippincott()

Catch all exceptions and rethrow an OpenGeodeException

operator""_uc

cpp
unsigned char operator""_uc(unsigned long long arg)
unsigned char operator""_uc(unsigned long long arg)

to_string

cpp
basic_string to_string(basic_string_view view)
basic_string to_string(basic_string_view view)

to_array

cpp
std::array<T, sizeof...(Args)> to_array(Args &&... args)
std::array<T, sizeof...(Args)> to_array(Args &&... args)

register_basic_serialize_pcontext

cpp
void register_basic_serialize_pcontext(PContext & context)
void register_basic_serialize_pcontext(PContext & context)

Register all the information needed by Bitsery to serialize the objects in the basic library.

context [in] The context where to register this information.

warning The context can be used only once per archive.

register_basic_deserialize_pcontext

cpp
void register_basic_deserialize_pcontext(PContext & context)
void register_basic_deserialize_pcontext(PContext & context)

Register all the information needed by Bitsery to deserialize the objects in the basic library.

context [in] The context where to register this information.

warning The context can be used only once per archive.

concatenate

cpp
void concatenate(Container & container, const Container & values)
void concatenate(Container & container, const Container & values)

concatenate

cpp
void concatenate(Container & container, Container && values)
void concatenate(Container & container, Container && values)

delete_vector_elements

cpp
index_t delete_vector_elements(const DeleteContainer & to_delete, ValueContainer & values)
index_t delete_vector_elements(const DeleteContainer & to_delete, ValueContainer & values)

Delete some elements from a given vector.

to_delete [in] Vector of the same size than values. If to_delete[i] is true the i-th element is deleted, else the element is kept.

values [in] Vector in which perform deletions.

return The number of deleted elements

extract_vector_elements

cpp
ValueContainer extract_vector_elements(const DeleteContainer & to_keep, const ValueContainer & in_values)
ValueContainer extract_vector_elements(const DeleteContainer & to_keep, const ValueContainer & in_values)

Create a new vector containing only some elements from a given vector.

to_keep [in] Vector of the same size than in_values. If to_keep[i] is true the i-th element is kept.

in_values [in] Vector in which perform deletions.

return A vector containing only kept elements of in_values

sort_unique

cpp
void sort_unique(Container & container)
void sort_unique(Container & container)

Modify the container by removing every duplicated values inside

Container Type of container.

container [in] container in which perform the search.

sort_unique

cpp
void sort_unique(Container & container, Comparison comp)
void sort_unique(Container & container, Comparison comp)

permute

cpp
void permute(Container & data, Span permutation)
void permute(Container & data, Span permutation)

old2new_permutation

cpp
vector old2new_permutation(Span permutation)
vector old2new_permutation(Span permutation)

register_geode_builder

cpp
void register_geode_builder()
void register_geode_builder()

register_geometry_serialize_pcontext

cpp
void register_geometry_serialize_pcontext(PContext & context)
void register_geometry_serialize_pcontext(PContext & context)

Register all the information needed by Bitsery to serialize the objects in the geometry library.

context [in] The context where to register this information.

warning The context can be used only once per archive.

register_geometry_deserialize_pcontext

cpp
void register_geometry_deserialize_pcontext(PContext & context)
void register_geometry_deserialize_pcontext(PContext & context)

Register all the information needed by Bitsery to deserialize the objects in the geometry library.

context [in] The context where to register this information.

warning The context can be used only once per archive.

register_image_serialize_pcontext

cpp
void register_image_serialize_pcontext(PContext & context)
void register_image_serialize_pcontext(PContext & context)

Register all the information needed by Bitsery to serialize the objects in the image library.

context [in] The context where to register this information.

warning The context can be used only once per archive.

register_image_deserialize_pcontext

cpp
void register_image_deserialize_pcontext(PContext & context)
void register_image_deserialize_pcontext(PContext & context)

Register all the information needed by Bitsery to deserialize the objects in the image library.

context [in] The context where to register this information.

warning The context can be used only once per archive.

filename_with_extension

cpp
path filename_with_extension(const std::filesystem::path & path)
path filename_with_extension(const std::filesystem::path & path)

filename_without_extension

cpp
path filename_without_extension(const std::filesystem::path & path)
path filename_without_extension(const std::filesystem::path & path)

filepath_without_extension

cpp
path filepath_without_extension(const std::filesystem::path & path)
path filepath_without_extension(const std::filesystem::path & path)

filepath_without_filename

cpp
path filepath_without_filename(const std::filesystem::path & path)
path filepath_without_filename(const std::filesystem::path & path)

extension_from_filename

cpp
basic_string_view extension_from_filename(basic_string_view filename)
basic_string_view extension_from_filename(basic_string_view filename)

expand_predefined_folders

cpp
basic_string expand_predefined_folders(basic_string_view path)
basic_string expand_predefined_folders(basic_string_view path)
cpp
void print_available_extensions(basic_string_view type)
void print_available_extensions(basic_string_view type)

load_raster_image

cpp
RasterImage<dimension> load_raster_image(basic_string_view filename)
RasterImage<dimension> load_raster_image(basic_string_view filename)

API function for loading an RasterImage. The adequate loader is called depending on the filename extension. Default data structure implémentation is used.

filename [in] Path to the file to load.

check_raster_image_missing_files

cpp
typename RasterImageInput<dimension>::MissingFiles check_raster_image_missing_files(basic_string_view filename)
typename RasterImageInput<dimension>::MissingFiles check_raster_image_missing_files(basic_string_view filename)

is_raster_image_loadable

cpp
bool is_raster_image_loadable(basic_string_view filename)
bool is_raster_image_loadable(basic_string_view filename)

save_raster_image

cpp
vector save_raster_image(const RasterImage<dimension> & raster, basic_string_view filename)
vector save_raster_image(const RasterImage<dimension> & raster, basic_string_view filename)

API function for saving a RasterImage. The adequate saver is called depending on the given filename extension.

raster [in] RasterImage to save.

filename [in] Path to the file where save the RasterImage.

is_raster_image_saveable

cpp
bool is_raster_image_saveable(const RasterImage<dimension> & raster, basic_string_view filename)
bool is_raster_image_saveable(const RasterImage<dimension> & raster, basic_string_view filename)

are_mesh_elements_included

cpp
bool are_mesh_elements_included(const MeshElementsInclusion<MeshElementType> & inclusion)
bool are_mesh_elements_included(const MeshElementsInclusion<MeshElementType> & inclusion)

are_mesh_elements_included

cpp
bool are_mesh_elements_included(const MeshElementsInclusion<MeshElementType> & inclusion, const SkipMeshElement & skip)
bool are_mesh_elements_included(const MeshElementsInclusion<MeshElementType> & inclusion, const SkipMeshElement & skip)

register_mesh_serialize_pcontext

cpp
void register_mesh_serialize_pcontext(PContext & context)
void register_mesh_serialize_pcontext(PContext & context)

Register all the information needed by Bitsery to serialize the objects in the mesh library.

context [in] The context where to register this information.

warning The context can be used only once per archive.

register_mesh_deserialize_pcontext

cpp
void register_mesh_deserialize_pcontext(PContext & context)
void register_mesh_deserialize_pcontext(PContext & context)

Register all the information needed by Bitsery to deserialize the objects in the mesh library.

context [in] The context where to register this information.

warning The context can be used only once per archive.

point_point_distance

cpp
double point_point_distance(const Point<dimension> & point0, const Point<dimension> & point1)
double point_point_distance(const Point<dimension> & point0, const Point<dimension> & point1)

Compute the Euclidean distance between a two points

point_segment_distance

cpp
double point_segment_distance(const Point<dimension> & point, const Segment<dimension> & segment)
double point_segment_distance(const Point<dimension> & point, const Segment<dimension> & segment)

Compute the smallest distance between a point and a segment

segment_segment_distance

cpp
std::tuple<double, Point<dimension>, Point<dimension> > segment_segment_distance(const Segment<dimension> & segment0, const Segment<dimension> & segment1)
std::tuple<double, Point<dimension>, Point<dimension> > segment_segment_distance(const Segment<dimension> & segment0, const Segment<dimension> & segment1)

Compute the smallest distance between two segments

return a tuple containing: - the smallest distance. - the closest point on the first segment. - the closest point on the second segment.

segment_line_distance

cpp
std::tuple<double, Point<dimension>, Point<dimension> > segment_line_distance(const Segment<dimension> & segment, const InfiniteLine<dimension> & line)
std::tuple<double, Point<dimension>, Point<dimension> > segment_line_distance(const Segment<dimension> & segment, const InfiniteLine<dimension> & line)

point_line_distance

cpp
double point_line_distance(const Point<dimension> & point, const InfiniteLine<dimension> & line)
double point_line_distance(const Point<dimension> & point, const InfiniteLine<dimension> & line)

Compute the smallest distance between a point and an infinite line

point_line_signed_distance

cpp
double point_line_signed_distance(const Point2D & point, const InfiniteLine2D & line)
double point_line_signed_distance(const Point2D & point, const InfiniteLine2D & line)

Compute the smallest signed distance between a point and an infinite line in 2D

point_triangle_distance

cpp
std::tuple<double, Point<dimension> > point_triangle_distance(const Point<dimension> & point, const Triangle<dimension> & triangle)
std::tuple<double, Point<dimension> > point_triangle_distance(const Point<dimension> & point, const Triangle<dimension> & triangle)

Compute the smallest distance between a point and a triangle

return a tuple containing: - the smallest distance. - the closest point on the triangle.

point_triangle_signed_distance

cpp
tuple point_triangle_signed_distance(const Point3D & point, const Triangle3D & triangle)
tuple point_triangle_signed_distance(const Point3D & point, const Triangle3D & triangle)

Compute the signed distance between a point and a triangle

return a tuple containing: - the smallest distance. - the closest point on the triangle.

details the sign is given by the triangle normal (positive if in the same plane).

line_triangle_distance

cpp
std::tuple<double, Point3D, Point3D> line_triangle_distance(const InfiniteLine3D & line, const Triangle3D & triangle)
std::tuple<double, Point3D, Point3D> line_triangle_distance(const InfiniteLine3D & line, const Triangle3D & triangle)

Compute the smallest distance between an infinite line and a triangle

return a tuple containing: - the smallest distance. - the closest point on the line. - the closest point on the triangle.

segment_triangle_distance

cpp
std::tuple<double, Point3D, Point3D> segment_triangle_distance(const Segment3D & segment, const Triangle3D & triangle)
std::tuple<double, Point3D, Point3D> segment_triangle_distance(const Segment3D & segment, const Triangle3D & triangle)

Compute the smallest distance between an segment and a triangle

return a tuple containing: - the smallest distance. - the closest point on the segment. - the closest point on the triangle.

triangle_triangle_distance

cpp
std::tuple<double, Point3D, Point3D> triangle_triangle_distance(const Triangle3D & triangle0, const Triangle3D & triangle1)
std::tuple<double, Point3D, Point3D> triangle_triangle_distance(const Triangle3D & triangle0, const Triangle3D & triangle1)

Compute the smallest distance between two triangles

return a tuple containing: - the smallest distance. - the closest point on the first triangle. - the closest point on the second triangle.

triangle_triangle_distance_between_non_conformal_parts

cpp
std::optional<std::tuple<double, Point3D, Point3D> > triangle_triangle_distance_between_non_conformal_parts(const Triangle3D & triangle0, const Triangle3D & triangle1)
std::optional<std::tuple<double, Point3D, Point3D> > triangle_triangle_distance_between_non_conformal_parts(const Triangle3D & triangle0, const Triangle3D & triangle1)

Compute the smallest distance between two triangles

details if the two triangles are the same, return nullopt. Only non conformal part of triangles are considered in computation of distance, i.e. if the triangle have a common point, it iterates on opposite segment, if the triangle have a common edge, it computes distance with the opposite point

return a tuple containing: - the smallest distance. - the closest point on the first triangle. - the closest point on the second triangle.

point_tetrahedron_distance

cpp
tuple point_tetrahedron_distance(const Point3D & point, const Tetrahedron & tetra)
tuple point_tetrahedron_distance(const Point3D & point, const Tetrahedron & tetra)

Compute the distance between a point and a tetrahedron

return a tuple containing: - the smallest distance. - the nearest point on the tetrahedron.

point_plane_distance

cpp
tuple point_plane_distance(const Point3D & point, const Plane & plane)
tuple point_plane_distance(const Point3D & point, const Plane & plane)

Compute the distance between a point and a plane

return a tuple containing: - the smallest distance. - the nearest point on the plane.

point_plane_signed_distance

cpp
tuple point_plane_signed_distance(const Point3D & point, const Plane & plane)
tuple point_plane_signed_distance(const Point3D & point, const Plane & plane)

Compute the signed distance between a point and a plane

return a tuple containing: - the signed distance (sign is given by the plane normal direction). - the nearest point on the plane.

point_sphere_distance

cpp
std::tuple<double, Point<dimension> > point_sphere_distance(const Point<dimension> & point, const Sphere<dimension> & sphere)
std::tuple<double, Point<dimension> > point_sphere_distance(const Point<dimension> & point, const Sphere<dimension> & sphere)

Compute the smallest distance between a point and a sphere

return a tuple containing: - the smallest distance. - the closest point on the sphere.

point_sphere_signed_distance

cpp
std::tuple<double, Point<dimension> > point_sphere_signed_distance(const Point<dimension> & point, const Sphere<dimension> & sphere)
std::tuple<double, Point<dimension> > point_sphere_signed_distance(const Point<dimension> & point, const Sphere<dimension> & sphere)

Compute the smallest signed distance between a point and a sphere

return a tuple containing: - the smallest signed distance. - the closest point on the sphere.

details the sign is positive outside the sphere, negative inside.

point_ball_distance

cpp
std::tuple<double, Point<dimension> > point_ball_distance(const Point<dimension> & point, const Ball<dimension> & sphere)
std::tuple<double, Point<dimension> > point_ball_distance(const Point<dimension> & point, const Ball<dimension> & sphere)

Compute the smallest distance between a point and a ball

return a tuple containing: - the smallest distance. - the closest point on the ball.

details Result is always positive or null. If point is inside the ball, the returned distance is 0.

point_circle_distance

cpp
tuple point_circle_distance(const Point3D & point, const Circle & circle)
tuple point_circle_distance(const Point3D & point, const Circle & circle)

Compute the smallest distance between a point and a circle

return a tuple containing: - the smallest distance. - the closest point on the circle.

point_circle_signed_distance

cpp
tuple point_circle_signed_distance(const Point3D & point, const Circle & circle)
tuple point_circle_signed_distance(const Point3D & point, const Circle & circle)

Compute the smallest signed distance between a point and a circle

return a tuple containing: - the smallest signed distance. - the closest point on the circle.

details the sign is positive outside the circle, negative inside.

point_disk_distance

cpp
tuple point_disk_distance(const Point3D & point, const Disk & disk)
tuple point_disk_distance(const Point3D & point, const Disk & disk)

Compute the smallest distance between a point and a disk

return a tuple containing: - the smallest distance. - the closest point on the disk.

details Result is always positive or null. If point is inside the disk, the returned distance is 0.

point_ellipse_distance

cpp
std::tuple<double, Point<dimension> > point_ellipse_distance(const Point<dimension> & point, const Ellipse<dimension> & ellipse)
std::tuple<double, Point<dimension> > point_ellipse_distance(const Point<dimension> & point, const Ellipse<dimension> & ellipse)

Compute the smallest distance between a point and an ellipse

return a tuple containing: - the smallest distance. - the closest point on the ellipse.

triangle_area

cpp
double triangle_area(const Triangle<dimension> & triangle)
double triangle_area(const Triangle<dimension> & triangle)

Compute the (positive) area of a triangle

triangle [in] Triangle to compute area

triangle_signed_area

cpp
double triangle_signed_area(const Triangle2D & triangle)
double triangle_signed_area(const Triangle2D & triangle)

Compute the signed area of a triangle

triangle [in] Triangle to compute area returned area is positive if the triangle vertices are ordered counter-clockwise, negative if clockwise.

triangle_signed_area

cpp
double triangle_signed_area(const Triangle3D & triangle, const Vector3D & direction)
double triangle_signed_area(const Triangle3D & triangle, const Vector3D & direction)

Compute the signed area of a 3D triangle

triangle [in] Triangle to compute area

direction [in] Direction used to determined the sign of returned area: positive if the triangle normal is in the same direction than direction, negative if the triangle normal is in the opposition direction.

tetrahedron_signed_volume

cpp
double tetrahedron_signed_volume(const Tetrahedron & tetra)
double tetrahedron_signed_volume(const Tetrahedron & tetra)

Compute the signed volume of a tetrahedron

tetrahedron_volume

cpp
double tetrahedron_volume(const Tetrahedron & tetra)
double tetrahedron_volume(const Tetrahedron & tetra)

Compute the (positive) volume of a tetrahedron

save_triangulated_surface

cpp
vector save_triangulated_surface(const TriangulatedSurface<dimension> & triangulated_surface, basic_string_view filename)
vector save_triangulated_surface(const TriangulatedSurface<dimension> & triangulated_surface, basic_string_view filename)

API function for saving a TriangulatedSurface. The adequate saver is called depending on the given filename extension.

triangulated_surface [in] TriangulatedSurface to save.

filename [in] Path to the file where save the TriangulatedSurface.

is_triangulated_surface_saveable

cpp
bool is_triangulated_surface_saveable(const TriangulatedSurface<dimension> & triangulated_surface, basic_string_view filename)
bool is_triangulated_surface_saveable(const TriangulatedSurface<dimension> & triangulated_surface, basic_string_view filename)

perpendicular

cpp
Vector perpendicular(const Vector2D & v)
Vector perpendicular(const Vector2D & v)

Return a 2D vector perpendicular to the given one

dot_perpendicular

cpp
double dot_perpendicular(const Vector2D & v0, const Vector2D & v1)
double dot_perpendicular(const Vector2D & v0, const Vector2D & v1)

Compute the dot product between a 2D vector p and another 2D vector perpendicular to p

lexicographic_mapping

cpp
vector lexicographic_mapping(absl::Span<const Point<dimension> > points)
vector lexicographic_mapping(absl::Span<const Point<dimension> > points)

morton_mapping

cpp
vector morton_mapping(absl::Span<const Point<dimension> > points)
vector morton_mapping(absl::Span<const Point<dimension> > points)

point_side_to_segment

cpp
SIDE point_side_to_segment(const Point2D & point, const Segment2D & segment)
SIDE point_side_to_segment(const Point2D & point, const Segment2D & segment)

Return the point side to a segment.

point_side_to_line

cpp
SIDE point_side_to_line(const Point2D & point, const InfiniteLine2D & line)
SIDE point_side_to_line(const Point2D & point, const InfiniteLine2D & line)

Return the point side to a line.

point_side_to_plane

cpp
SIDE point_side_to_plane(const Point3D & point, const Plane & plane)
SIDE point_side_to_plane(const Point3D & point, const Plane & plane)

Return the point side to a plane.

point_side_to_triangle

cpp
SIDE point_side_to_triangle(const Point3D & point, const Triangle3D & triangle)
SIDE point_side_to_triangle(const Point3D & point, const Triangle3D & triangle)

Return the point side to a 3D triangle.

point_segment_position

cpp
POSITION point_segment_position(const Point<dimension> & point, const Segment<dimension> & segment)
POSITION point_segment_position(const Point<dimension> & point, const Segment<dimension> & segment)

Return the position of a point on a segment: inside, outside or on segment vertex.

point_triangle_position

cpp
POSITION point_triangle_position(const Point<dimension> & point, const Triangle<dimension> & triangle)
POSITION point_triangle_position(const Point<dimension> & point, const Triangle<dimension> & triangle)

Return the position of a point in a triangle: inside, outside, on a triangle vertex or an edge.

point_tetrahedron_position

cpp
POSITION point_tetrahedron_position(const Point3D & point, const Tetrahedron & tetra)
POSITION point_tetrahedron_position(const Point3D & point, const Tetrahedron & tetra)

Return the position of a point in a tetrahedron: inside, outside, on a tetra vertex, an edge or a facet.

are_points_aligned

cpp
bool are_points_aligned(const Point<dimension> & point0, const Point<dimension> & point1, const Point<dimension> & point2)
bool are_points_aligned(const Point<dimension> & point0, const Point<dimension> & point1, const Point<dimension> & point2)

Return true if the three points are exactly aligned.

point_segment_position_exact

cpp
POSITION point_segment_position_exact(const Point3D & point, const Segment3D & segment)
POSITION point_segment_position_exact(const Point3D & point, const Segment3D & segment)

point_segment_position_exact

cpp
POSITION point_segment_position_exact(const Point2D & point, const Segment2D & segment)
POSITION point_segment_position_exact(const Point2D & point, const Segment2D & segment)

point_segment_position_exact

cpp
POSITION point_segment_position_exact(const Point1D & point, const Segment1D & segment)
POSITION point_segment_position_exact(const Point1D & point, const Segment1D & segment)

point_triangle_position_all_zero

cpp
POSITION point_triangle_position_all_zero(const Point<dimension> & point, const Triangle<dimension> & triangle)
POSITION point_triangle_position_all_zero(const Point<dimension> & point, const Triangle<dimension> & triangle)

point_triangle_position_exact

cpp
POSITION point_triangle_position_exact(const Point2D & point, const Triangle2D & triangle)
POSITION point_triangle_position_exact(const Point2D & point, const Triangle2D & triangle)

compute_determinants

cpp
POSITION compute_determinants(const Point3D & point, const Triangle3D & triangle, const Vector3D & third_vector)
POSITION compute_determinants(const Point3D & point, const Triangle3D & triangle, const Vector3D & third_vector)

point_triangle_position_exact

cpp
POSITION point_triangle_position_exact(const Point3D & point, const Triangle3D & triangle)
POSITION point_triangle_position_exact(const Point3D & point, const Triangle3D & triangle)

point_tetrahedron_position_exact

cpp
POSITION point_tetrahedron_position_exact(const Point3D & point, const Tetrahedron & tetra)
POSITION point_tetrahedron_position_exact(const Point3D & point, const Tetrahedron & tetra)

point_triangle_position

cpp
POSITION point_triangle_position(const Point2D & point, const Triangle2D & triangle)
POSITION point_triangle_position(const Point2D & point, const Triangle2D & triangle)

point_triangle_position

cpp
POSITION point_triangle_position(const Point3D & point, const Triangle3D & triangle)
POSITION point_triangle_position(const Point3D & point, const Triangle3D & triangle)

are_points_aligned

cpp
bool are_points_aligned(const Point2D & point0, const Point2D & point1, const Point2D & point2)
bool are_points_aligned(const Point2D & point0, const Point2D & point1, const Point2D & point2)

are_points_aligned

cpp
bool are_points_aligned(const Point3D & point0, const Point3D & point1, const Point3D & point2)
bool are_points_aligned(const Point3D & point0, const Point3D & point1, const Point3D & point2)

point_segment_projection

cpp
Point<dimension> point_segment_projection(const Point<dimension> & point, const Segment<dimension> & segment)
Point<dimension> point_segment_projection(const Point<dimension> & point, const Segment<dimension> & segment)

Return the projection of a point on a segment

point [in] the point to project

segment [in] the segment

point_line_projection

cpp
Point<dimension> point_line_projection(const Point<dimension> & point, const InfiniteLine<dimension> & line)
Point<dimension> point_line_projection(const Point<dimension> & point, const InfiniteLine<dimension> & line)

Return the projection of a point on a line

point [in] the point to project

line [in] the line

point_triangle_projection

cpp
Point<dimension> point_triangle_projection(const Point<dimension> & point, const Triangle<dimension> & triangle)
Point<dimension> point_triangle_projection(const Point<dimension> & point, const Triangle<dimension> & triangle)

Return the projection of a point on a triangle

point [in] the point to project

triangle [in] the triangle

point_plane_projection

cpp
Point point_plane_projection(const Point3D & point, const Plane & plane)
Point point_plane_projection(const Point3D & point, const Plane & plane)

Return the projection of a point on a plane

point [in] the point to project

plane [in] the plane

tetrahedron_aspect_ratio

cpp
double tetrahedron_aspect_ratio(const Tetrahedron & tetra)
double tetrahedron_aspect_ratio(const Tetrahedron & tetra)

tetrahedron_volume_to_edge_ratio

cpp
double tetrahedron_volume_to_edge_ratio(const Tetrahedron & tetra)
double tetrahedron_volume_to_edge_ratio(const Tetrahedron & tetra)

tetrahedron_collapse_aspect_ratio

cpp
double tetrahedron_collapse_aspect_ratio(const Tetrahedron & tetra)
double tetrahedron_collapse_aspect_ratio(const Tetrahedron & tetra)

radial_sort

cpp
FixedArray radial_sort(const Segment3D & segment, Span points)
FixedArray radial_sort(const Segment3D & segment, Span points)

tetrahedron_barycentric_coordinates

cpp
array tetrahedron_barycentric_coordinates(const Point3D & point, const Tetrahedron & tetrahedron)
array tetrahedron_barycentric_coordinates(const Point3D & point, const Tetrahedron & tetrahedron)

Compute the barycentric coordinates of a point with regards to a tetrahedron.

return an array containing the parametric coordinates corresponding to the tetrahedron vertices.

exceptionif the tetrahedron is degenerated

safe_tetrahedron_barycentric_coordinates

cpp
array safe_tetrahedron_barycentric_coordinates(const Point3D & point, const Tetrahedron & tetrahedron)
array safe_tetrahedron_barycentric_coordinates(const Point3D & point, const Tetrahedron & tetrahedron)

Compute the barycentric coordinates of a point with regards to a tetrahedron. If tetrahedron is degenerated, computation fallbacks onto its largest facet.

return an array containing the parametric coordinates corresponding to the tetrahedron vertices.

triangle_barycentric_coordinates

cpp
array triangle_barycentric_coordinates(const Point<dimension> & point, const Triangle<dimension> & triangle)
array triangle_barycentric_coordinates(const Point<dimension> & point, const Triangle<dimension> & triangle)

Compute barycentric coordinates of a point with regards to a triangle.

return an array containing the parametric coordinates corresponding to the triangle vertices.

exceptionif the triangle is degenerated

safe_triangle_barycentric_coordinates

cpp
array safe_triangle_barycentric_coordinates(const Point<dimension> & point, const Triangle<dimension> & triangle)
array safe_triangle_barycentric_coordinates(const Point<dimension> & point, const Triangle<dimension> & triangle)

Compute barycentric coordinates of a point with regards to a triangle. If triangle is degenerated, computation fallbacks onto its longest segment.

return an array containing the parametric coordinates corresponding to the triangle vertices.

segment_barycentric_coordinates

cpp
array segment_barycentric_coordinates(const Point<dimension> & point, const Segment<dimension> & segment)
array segment_barycentric_coordinates(const Point<dimension> & point, const Segment<dimension> & segment)

Compute barycentric coordinates of a point with regards to a segment.

return an array containing the parametric coordinates corresponding to the segment vertices.

exceptionif the segment is degenerated

safe_segment_barycentric_coordinates

cpp
array safe_segment_barycentric_coordinates(const Point<dimension> & point, const Segment<dimension> & segment)
array safe_segment_barycentric_coordinates(const Point<dimension> & point, const Segment<dimension> & segment)

Compute barycentric coordinates of a point with regards to a segment. If segment is degenerated, computation fallbacks onto its vertices.

return an array containing the parametric coordinates corresponding to the segment vertices.

register_geode_mesh_output

cpp
void register_geode_mesh_output()
void register_geode_mesh_output()

save_edged_curve

cpp
vector save_edged_curve(const EdgedCurve<dimension> & edged_curve, basic_string_view filename)
vector save_edged_curve(const EdgedCurve<dimension> & edged_curve, basic_string_view filename)

API function for saving a EdgedCurve. The adequate saver is called depending on the given filename extension.

edged_curve [in] EdgedCurve to save.

filename [in] Path to the file where save the EdgedCurve.

is_edged_curve_saveable

cpp
bool is_edged_curve_saveable(const EdgedCurve<dimension> & edged_curve, basic_string_view filename)
bool is_edged_curve_saveable(const EdgedCurve<dimension> & edged_curve, basic_string_view filename)

save_graph

cpp
vector save_graph(const Graph & graph, basic_string_view filename)
vector save_graph(const Graph & graph, basic_string_view filename)

API function for saving a Graph. The adequate saver is called depending on the given filename extension.

graph [in] Graph to save.

filename [in] Path to the file where save the Graph.

is_graph_saveable

cpp
bool is_graph_saveable(const Graph & graph, basic_string_view filename)
bool is_graph_saveable(const Graph & graph, basic_string_view filename)

save_hybrid_solid

cpp
vector save_hybrid_solid(const HybridSolid<dimension> & hybrid_solid, basic_string_view filename)
vector save_hybrid_solid(const HybridSolid<dimension> & hybrid_solid, basic_string_view filename)

API function for saving a HybridSolid. The adequate saver is called depending on the given filename extension.

hybrid_solid [in] HybridSolid to save.

filename [in] Path to the file where save the HybridSolid.

is_hybrid_solid_saveable

cpp
bool is_hybrid_solid_saveable(const HybridSolid<dimension> & hybrid_solid, basic_string_view filename)
bool is_hybrid_solid_saveable(const HybridSolid<dimension> & hybrid_solid, basic_string_view filename)

save_point_set

cpp
vector save_point_set(const PointSet<dimension> & point_set, basic_string_view filename)
vector save_point_set(const PointSet<dimension> & point_set, basic_string_view filename)

API function for saving a PointSet. The adequate saver is called depending on the given filename extension.

point_set [in] PointSet to save.

filename [in] Path to the file where save the PointSet.

is_point_set_saveable

cpp
bool is_point_set_saveable(const PointSet<dimension> & point_set, basic_string_view filename)
bool is_point_set_saveable(const PointSet<dimension> & point_set, basic_string_view filename)

save_polygonal_surface

cpp
vector save_polygonal_surface(const PolygonalSurface<dimension> & polygonal_surface, basic_string_view filename)
vector save_polygonal_surface(const PolygonalSurface<dimension> & polygonal_surface, basic_string_view filename)

API function for saving a PolygonalSurface. The adequate saver is called depending on the given filename extension. const PolygonalSurface< dimension >& polygonal_surface,

edged_curve [in] PolygonalSurface to save.

filename [in] Path to the file where save the PolygonalSurface.

is_polygonal_surface_saveable

cpp
bool is_polygonal_surface_saveable(const PolygonalSurface<dimension> & polygonal_surface, basic_string_view filename)
bool is_polygonal_surface_saveable(const PolygonalSurface<dimension> & polygonal_surface, basic_string_view filename)

save_polyhedral_solid

cpp
vector save_polyhedral_solid(const PolyhedralSolid<dimension> & polyhedral_solid, basic_string_view filename)
vector save_polyhedral_solid(const PolyhedralSolid<dimension> & polyhedral_solid, basic_string_view filename)

API function for saving a PolyhedralSolid. The adequate saver is called depending on the given filename extension.

polyhedral_solid [in] PolyhedralSolid to save.

filename [in] Path to the file where save the PolyhedralSolid.

is_polyhedral_solid_saveable

cpp
bool is_polyhedral_solid_saveable(const PolyhedralSolid<dimension> & polyhedral_solid, basic_string_view filename)
bool is_polyhedral_solid_saveable(const PolyhedralSolid<dimension> & polyhedral_solid, basic_string_view filename)

save_regular_grid

cpp
vector save_regular_grid(const RegularGrid<dimension> & regular_grid, basic_string_view filename)
vector save_regular_grid(const RegularGrid<dimension> & regular_grid, basic_string_view filename)

API function for saving a RegularGrid. The adequate saver is called depending on the given filename extension.

regular_grid [in] RegularGrid to save.

filename [in] Path to the file where save the RegularGrid.

is_regular_grid_saveable

cpp
bool is_regular_grid_saveable(const RegularGrid<dimension> & regular_grid, basic_string_view filename)
bool is_regular_grid_saveable(const RegularGrid<dimension> & regular_grid, basic_string_view filename)

save_tetrahedral_solid

cpp
vector save_tetrahedral_solid(const TetrahedralSolid<dimension> & tetrahedral_solid, basic_string_view filename)
vector save_tetrahedral_solid(const TetrahedralSolid<dimension> & tetrahedral_solid, basic_string_view filename)

API function for saving a TetrahedralSolid. The adequate saver is called depending on the given filename extension.

tetrahedral_solid [in] TetrahedralSolid to save.

filename [in] Path to the file where save the TetrahedralSolid.

is_tetrahedral_solid_saveable

cpp
bool is_tetrahedral_solid_saveable(const TetrahedralSolid<dimension> & tetrahedral_solid, basic_string_view filename)
bool is_tetrahedral_solid_saveable(const TetrahedralSolid<dimension> & tetrahedral_solid, basic_string_view filename)

save_vertex_set

cpp
vector save_vertex_set(const VertexSet & vertex_set, basic_string_view filename)
vector save_vertex_set(const VertexSet & vertex_set, basic_string_view filename)

API function for saving a VertexSet. The adequate saver is called depending on the given filename extension.

vertex_set [in] VertexSet to save.

filename [in] Path to the file where save the VertexSet.

is_vertex_set_saveable

cpp
bool is_vertex_set_saveable(const VertexSet & vertex_set, basic_string_view filename)
bool is_vertex_set_saveable(const VertexSet & vertex_set, basic_string_view filename)

save_light_regular_grid

cpp
vector save_light_regular_grid(const LightRegularGrid<dimension> & light_regular_grid, basic_string_view filename)
vector save_light_regular_grid(const LightRegularGrid<dimension> & light_regular_grid, basic_string_view filename)

API function for saving a LightRegularGrid. The adequate saver is called depending on the given filename extension.

light_regular_grid [in] LightRegularGrid to save.

filename [in] Path to the file where save the LightRegularGrid.

is_light_regular_grid_saveable

cpp
bool is_light_regular_grid_saveable(const LightRegularGrid<dimension> & light_regular_grid, basic_string_view filename)
bool is_light_regular_grid_saveable(const LightRegularGrid<dimension> & light_regular_grid, basic_string_view filename)

load_regular_grid

cpp
std::unique_ptr<RegularGrid<dimension> > load_regular_grid(const MeshImpl & impl, basic_string_view filename)
std::unique_ptr<RegularGrid<dimension> > load_regular_grid(const MeshImpl & impl, basic_string_view filename)

API function for loading an RegularGrid. The adequate loader is called depending on the filename extension.

impl [in] Data structure implementation.

filename [in] Path to the file to load.

load_regular_grid

cpp
std::unique_ptr<RegularGrid<dimension> > load_regular_grid(basic_string_view filename)
std::unique_ptr<RegularGrid<dimension> > load_regular_grid(basic_string_view filename)

API function for loading a RegularGrid. The adequate loader is called depending on the filename extension.

filename [in] Path to the file to load.

check_regular_grid_missing_files

cpp
typename RegularGridInput<dimension>::MissingFiles check_regular_grid_missing_files(basic_string_view filename)
typename RegularGridInput<dimension>::MissingFiles check_regular_grid_missing_files(basic_string_view filename)

is_regular_grid_loadable

cpp
bool is_regular_grid_loadable(basic_string_view filename)
bool is_regular_grid_loadable(basic_string_view filename)

load_vertex_set

cpp
unique_ptr load_vertex_set(const MeshImpl & impl, basic_string_view filename)
unique_ptr load_vertex_set(const MeshImpl & impl, basic_string_view filename)

API function for loading an VertexSet. The adequate loader is called depending on the filename extension.

impl [in] Data structure implementation.

filename [in] Path to the file to load.

load_vertex_set

cpp
unique_ptr load_vertex_set(basic_string_view filename)
unique_ptr load_vertex_set(basic_string_view filename)

API function for loading an VertexSet. The adequate loader is called depending on the filename extension. Default data structure implémentation is used.

filename [in] Path to the file to load.

check_vertex_set_missing_files

cpp
MissingFiles check_vertex_set_missing_files(basic_string_view filename)
MissingFiles check_vertex_set_missing_files(basic_string_view filename)

is_vertex_set_loadable

cpp
bool is_vertex_set_loadable(basic_string_view filename)
bool is_vertex_set_loadable(basic_string_view filename)

load_tetrahedral_solid

cpp
std::unique_ptr<TetrahedralSolid<dimension> > load_tetrahedral_solid(const MeshImpl & impl, basic_string_view filename)
std::unique_ptr<TetrahedralSolid<dimension> > load_tetrahedral_solid(const MeshImpl & impl, basic_string_view filename)

API function for loading an TetrahedralSolid. The adequate loader is called depending on the filename extension.

impl [in] Data structure implementation.

filename [in] Path to the file to load.

load_tetrahedral_solid

cpp
std::unique_ptr<TetrahedralSolid<dimension> > load_tetrahedral_solid(basic_string_view filename)
std::unique_ptr<TetrahedralSolid<dimension> > load_tetrahedral_solid(basic_string_view filename)

API function for loading an TetrahedralSolid. The adequate loader is called depending on the filename extension. Default data structure implémentation is used.

filename [in] Path to the file to load.

check_tetrahedral_solid_missing_files

cpp
typename TetrahedralSolidInput<dimension>::MissingFiles check_tetrahedral_solid_missing_files(basic_string_view filename)
typename TetrahedralSolidInput<dimension>::MissingFiles check_tetrahedral_solid_missing_files(basic_string_view filename)

is_tetrahedral_solid_loadable

cpp
bool is_tetrahedral_solid_loadable(basic_string_view filename)
bool is_tetrahedral_solid_loadable(basic_string_view filename)

load_triangulated_surface

cpp
std::unique_ptr<TriangulatedSurface<dimension> > load_triangulated_surface(const MeshImpl & impl, basic_string_view filename)
std::unique_ptr<TriangulatedSurface<dimension> > load_triangulated_surface(const MeshImpl & impl, basic_string_view filename)

API function for loading an TriangulatedSurface. The adequate loader is called depending on the filename extension.

impl [in] Data structure implementation.

filename [in] Path to the file to load.

load_triangulated_surface

cpp
std::unique_ptr<TriangulatedSurface<dimension> > load_triangulated_surface(basic_string_view filename)
std::unique_ptr<TriangulatedSurface<dimension> > load_triangulated_surface(basic_string_view filename)

API function for loading an TriangulatedSurface. The adequate loader is called depending on the filename extension. Default data structure implémentation is used.

filename [in] Path to the file to load.

check_triangulated_surface_missing_files

cpp
typename TriangulatedSurfaceInput<dimension>::MissingFiles check_triangulated_surface_missing_files(basic_string_view filename)
typename TriangulatedSurfaceInput<dimension>::MissingFiles check_triangulated_surface_missing_files(basic_string_view filename)

is_triangulated_surface_loadable

cpp
bool is_triangulated_surface_loadable(basic_string_view filename)
bool is_triangulated_surface_loadable(basic_string_view filename)

segment_segment_intersection_detection

cpp
pair segment_segment_intersection_detection(const Segment2D & segment0, const Segment2D & segment1)
pair segment_segment_intersection_detection(const Segment2D & segment0, const Segment2D & segment1)

Detect if there is an intersection between two 2D segments

return the position of the intersection on the two segments. Returns outside-outside if there is no intersection or parallel-pallel if all points are colinear

colinear_segment_segment_intersection_detection

cpp
pair colinear_segment_segment_intersection_detection(const Segment2D & segment0, const Segment2D & segment1)
pair colinear_segment_segment_intersection_detection(const Segment2D & segment0, const Segment2D & segment1)

Detect the configuration between two 2D colinear segments

return the position of the intersection on the two segments. Returns parallel-pallel if there is segment overlap

segment_line_intersection_detection

cpp
POSITION segment_line_intersection_detection(const Segment2D & segment, const InfiniteLine2D & line)
POSITION segment_line_intersection_detection(const Segment2D & segment, const InfiniteLine2D & line)

Detect if there is an intersection between a line and a segment

return the position of the intersection on the segment. Returns outside if there is no intersection or all points are colinear

line_triangle_intersection_detection

cpp
POSITION line_triangle_intersection_detection(const InfiniteLine3D & line, const Triangle3D & triangle)
POSITION line_triangle_intersection_detection(const InfiniteLine3D & line, const Triangle3D & triangle)

Detect if there is an intersection between a line and a triangle

return the position of the intersection on the triangle. Returns outside if there is no intersection or the line is coplanar with the triangle

segment_triangle_intersection_detection

cpp
pair segment_triangle_intersection_detection(const Segment3D & segment, const Triangle3D & triangle)
pair segment_triangle_intersection_detection(const Segment3D & segment, const Triangle3D & triangle)

Detect if there is an intersection between a segment and a triangle

return the position of the intersection on the segment and on the triangle. Returns outside if there is no intersection or the segment is coplanar with the triangle

segment_plane_intersection_detection

cpp
POSITION segment_plane_intersection_detection(const Segment3D & segment, const Plane & plane)
POSITION segment_plane_intersection_detection(const Segment3D & segment, const Plane & plane)

Detect if there is an intersection between a segment and a plane

return the position of the intersection on the segment. Returns outside if there is no intersection or the segment is coplanar with the plane

repair_polygon_orientations

cpp
void repair_polygon_orientations(SurfaceMesh<dimension> & mesh)
void repair_polygon_orientations(SurfaceMesh<dimension> & mesh)

repair_polygon_orientations

cpp
void repair_polygon_orientations(const SurfaceMesh<dimension> & mesh, SurfaceMeshBuilder<dimension> & builder)
void repair_polygon_orientations(const SurfaceMesh<dimension> & mesh, SurfaceMeshBuilder<dimension> & builder)

is_zip_file

cpp
bool is_zip_file(basic_string_view file)
bool is_zip_file(basic_string_view file)

register_model_serialize_pcontext

cpp
void register_model_serialize_pcontext(PContext & context)
void register_model_serialize_pcontext(PContext & context)

Register all the information needed by Bitsery to serialize the objects in the model library.

context [in] The context where to register this information.

warning The context can be used only once per archive.

register_model_deserialize_pcontext

cpp
void register_model_deserialize_pcontext(PContext & context)
void register_model_deserialize_pcontext(PContext & context)

Register all the information needed by Bitsery to deserialize the objects in the model library.

context [in] The context where to register this information.

warning The context can be used only once per archive.

load_brep

cpp
BRep load_brep(basic_string_view filename)
BRep load_brep(basic_string_view filename)

API function for loading a BoundaryRepresentation. The adequate loader is called depending on the filename extension.

filename [in] Path to the file to load.

return Loaded BRep.

check_brep_missing_files

cpp
MissingFiles check_brep_missing_files(basic_string_view filename)
MissingFiles check_brep_missing_files(basic_string_view filename)

is_brep_loadable

cpp
bool is_brep_loadable(basic_string_view filename)
bool is_brep_loadable(basic_string_view filename)

save_brep

cpp
vector save_brep(const BRep & brep, basic_string_view filename)
vector save_brep(const BRep & brep, basic_string_view filename)

API function for saving a BoundaryRepresentation. The adequate saver is called depending on the given filename extension.

brep [in] BRep to save.

filename [in] Path to the file where save the brep.

is_brep_saveable

cpp
bool is_brep_saveable(const BRep & brep, basic_string_view filename)
bool is_brep_saveable(const BRep & brep, basic_string_view filename)

load_section

cpp
Section load_section(basic_string_view filename)
Section load_section(basic_string_view filename)

API function for loading a Section. The adequate loader is called depending on the filename extension.

filename [in] Path to the file to load.

return Loaded Section.

check_section_missing_files

cpp
MissingFiles check_section_missing_files(basic_string_view filename)
MissingFiles check_section_missing_files(basic_string_view filename)

is_section_loadable

cpp
bool is_section_loadable(basic_string_view filename)
bool is_section_loadable(basic_string_view filename)

save_section

cpp
vector save_section(const Section & section, basic_string_view filename)
vector save_section(const Section & section, basic_string_view filename)

API function for saving a Section. The adequate saver is called depending on the given filename extension.

section [in] Section to save.

filename [in] Path to the file where save the section.

is_section_saveable

cpp
bool is_section_saveable(const Section & section, basic_string_view filename)
bool is_section_saveable(const Section & section, basic_string_view filename)

create_lines_aabb_tree

cpp
tuple create_lines_aabb_tree(const BRep & model)
tuple create_lines_aabb_tree(const BRep & model)

create_surfaces_aabb_tree

cpp
tuple create_surfaces_aabb_tree(const BRep & model)
tuple create_surfaces_aabb_tree(const BRep & model)

create_blocks_aabb_tree

cpp
tuple create_blocks_aabb_tree(const BRep & model)
tuple create_blocks_aabb_tree(const BRep & model)

create_lines_aabb_tree

cpp
tuple create_lines_aabb_tree(const Section & model)
tuple create_lines_aabb_tree(const Section & model)

create_surfaces_aabb_tree

cpp
tuple create_surfaces_aabb_tree(const Section & model)
tuple create_surfaces_aabb_tree(const Section & model)

create_line_meshes_aabb_trees

cpp
ModelMeshesAABBTree create_line_meshes_aabb_trees(const BRep & model)
ModelMeshesAABBTree create_line_meshes_aabb_trees(const BRep & model)

create_surface_meshes_aabb_trees

cpp
ModelMeshesAABBTree create_surface_meshes_aabb_trees(const BRep & model)
ModelMeshesAABBTree create_surface_meshes_aabb_trees(const BRep & model)

create_block_meshes_aabb_trees

cpp
ModelMeshesAABBTree create_block_meshes_aabb_trees(const BRep & model)
ModelMeshesAABBTree create_block_meshes_aabb_trees(const BRep & model)

create_line_meshes_aabb_trees

cpp
ModelMeshesAABBTree create_line_meshes_aabb_trees(const Section & model)
ModelMeshesAABBTree create_line_meshes_aabb_trees(const Section & model)

create_surface_meshes_aabb_trees

cpp
ModelMeshesAABBTree create_surface_meshes_aabb_trees(const Section & model)
ModelMeshesAABBTree create_surface_meshes_aabb_trees(const Section & model)

create_aabb_tree

cpp
AABBTree<dimension> create_aabb_tree(const EdgedCurve<dimension> & mesh)
AABBTree<dimension> create_aabb_tree(const EdgedCurve<dimension> & mesh)

create_aabb_tree

cpp
AABBTree<dimension> create_aabb_tree(const SolidMesh<dimension> & mesh)
AABBTree<dimension> create_aabb_tree(const SolidMesh<dimension> & mesh)

create_aabb_tree

cpp
AABBTree<dimension> create_aabb_tree(const SurfaceMesh<dimension> & mesh)
AABBTree<dimension> create_aabb_tree(const SurfaceMesh<dimension> & mesh)

edge_unique_vertices

cpp
array edge_unique_vertices(const Section & section, const Line2D & line, index_t edge)
array edge_unique_vertices(const Section & section, const Line2D & line, index_t edge)

edge_unique_vertices

cpp
array edge_unique_vertices(const Section & section, const Surface2D & surface, const PolygonEdge & edge)
array edge_unique_vertices(const Section & section, const Surface2D & surface, const PolygonEdge & edge)

edge_unique_vertices

cpp
array edge_unique_vertices(const BRep & brep, const Line3D & line, index_t edge)
array edge_unique_vertices(const BRep & brep, const Line3D & line, index_t edge)

edge_unique_vertices

cpp
array edge_unique_vertices(const BRep & brep, const Surface3D & surface, const PolygonEdge & edge)
array edge_unique_vertices(const BRep & brep, const Surface3D & surface, const PolygonEdge & edge)

edge_unique_vertices

cpp
array edge_unique_vertices(const BRep & brep, const Block3D & block, const PolyhedronFacetEdge & edge)
array edge_unique_vertices(const BRep & brep, const Block3D & block, const PolyhedronFacetEdge & edge)

component_mesh_edges

cpp
SectionComponentMeshEdges component_mesh_edges(const Section & section, const std::array<index_t, 2> & edge_unique_vertices)
SectionComponentMeshEdges component_mesh_edges(const Section & section, const std::array<index_t, 2> & edge_unique_vertices)

component_mesh_edges

cpp
SectionComponentMeshEdges component_mesh_edges(const Section & section, const Line2D & line, index_t edge)
SectionComponentMeshEdges component_mesh_edges(const Section & section, const Line2D & line, index_t edge)

component_mesh_edges

cpp
SectionComponentMeshEdges component_mesh_edges(const Section & section, const Surface2D & surface, const PolygonEdge & edge)
SectionComponentMeshEdges component_mesh_edges(const Section & section, const Surface2D & surface, const PolygonEdge & edge)

component_mesh_edges

cpp
BRepComponentMeshEdges component_mesh_edges(const BRep & brep, const std::array<index_t, 2> & edge_unique_vertices)
BRepComponentMeshEdges component_mesh_edges(const BRep & brep, const std::array<index_t, 2> & edge_unique_vertices)

component_mesh_edges

cpp
BRepComponentMeshEdges component_mesh_edges(const BRep & brep, const Line3D & line, index_t edge)
BRepComponentMeshEdges component_mesh_edges(const BRep & brep, const Line3D & line, index_t edge)

component_mesh_edges

cpp
BRepComponentMeshEdges component_mesh_edges(const BRep & brep, const Surface3D & surface, const PolygonEdge & edge)
BRepComponentMeshEdges component_mesh_edges(const BRep & brep, const Surface3D & surface, const PolygonEdge & edge)

component_mesh_edges

cpp
BRepComponentMeshEdges component_mesh_edges(const BRep & brep, const Block3D & block, const PolyhedronFacetEdge & edge)
BRepComponentMeshEdges component_mesh_edges(const BRep & brep, const Block3D & block, const PolyhedronFacetEdge & edge)

component_mesh_vertex_generic

cpp
ComponentMeshVertexGeneric<dimension> component_mesh_vertex_generic(Span unique_vertices)
ComponentMeshVertexGeneric<dimension> component_mesh_vertex_generic(Span unique_vertices)

component_mesh_vertex_generic

cpp
ComponentMeshVertexGeneric<dimension> component_mesh_vertex_generic(Span unique_vertices, const ComponentType & type)
ComponentMeshVertexGeneric<dimension> component_mesh_vertex_generic(Span unique_vertices, const ComponentType & type)

component_mesh_vertex_pairs

cpp
flat_hash_map component_mesh_vertex_pairs(Span unique_vertices0, Span unique_vertices1)
flat_hash_map component_mesh_vertex_pairs(Span unique_vertices0, Span unique_vertices1)

component_mesh_vertex_pairs

cpp
flat_hash_map component_mesh_vertex_pairs(Span unique_vertices0, Span unique_vertices1, const ComponentType & type)
flat_hash_map component_mesh_vertex_pairs(Span unique_vertices0, Span unique_vertices1, const ComponentType & type)

component_mesh_vertex_triplets

cpp
flat_hash_map component_mesh_vertex_triplets(Span unique_vertices0, Span unique_vertices1, Span unique_vertices2)
flat_hash_map component_mesh_vertex_triplets(Span unique_vertices0, Span unique_vertices1, Span unique_vertices2)

component_mesh_vertex_triplets

cpp
flat_hash_map component_mesh_vertex_triplets(Span unique_vertices0, Span unique_vertices1, Span unique_vertices2, const ComponentType & type)
flat_hash_map component_mesh_vertex_triplets(Span unique_vertices0, Span unique_vertices1, Span unique_vertices2, const ComponentType & type)

component_mesh_vertex_tuple

cpp
ComponentMeshVertexGeneric<dimension> component_mesh_vertex_tuple(UniqueVertices... unique_vertices)
ComponentMeshVertexGeneric<dimension> component_mesh_vertex_tuple(UniqueVertices... unique_vertices)

component_mesh_vertex_tuple

cpp
ComponentMeshVertexGeneric<dimension> component_mesh_vertex_tuple(UniqueVertices... unique_vertices, const ComponentType & type)
ComponentMeshVertexGeneric<dimension> component_mesh_vertex_tuple(UniqueVertices... unique_vertices, const ComponentType & type)

polygon_unique_vertices

cpp
InlinedVector polygon_unique_vertices(const Section & model, const Surface2D & surface, index_t polygon_id)
InlinedVector polygon_unique_vertices(const Section & model, const Surface2D & surface, index_t polygon_id)

polygon_unique_vertices

cpp
InlinedVector polygon_unique_vertices(const BRep & model, const Surface3D & surface, index_t polygon_id)
InlinedVector polygon_unique_vertices(const BRep & model, const Surface3D & surface, index_t polygon_id)

polygon_unique_vertices

cpp
InlinedVector polygon_unique_vertices(const BRep & model, const Block3D & block, const PolyhedronFacet & facet)
InlinedVector polygon_unique_vertices(const BRep & model, const Block3D & block, const PolyhedronFacet & facet)

component_mesh_polygons

cpp
SectionComponentMeshPolygons component_mesh_polygons(const Section & section, const PolygonVertices & polygon_unique_vertices)
SectionComponentMeshPolygons component_mesh_polygons(const Section & section, const PolygonVertices & polygon_unique_vertices)

component_mesh_polygons

cpp
SectionComponentMeshPolygons component_mesh_polygons(const Section & section, const Surface2D & surface, index_t polygon_id)
SectionComponentMeshPolygons component_mesh_polygons(const Section & section, const Surface2D & surface, index_t polygon_id)

component_mesh_polygons

cpp
BRepComponentMeshPolygons component_mesh_polygons(const BRep & brep, const PolygonVertices & polygon_unique_vertices)
BRepComponentMeshPolygons component_mesh_polygons(const BRep & brep, const PolygonVertices & polygon_unique_vertices)

component_mesh_polygons

cpp
BRepComponentMeshPolygons component_mesh_polygons(const BRep & brep, const Surface3D & surface, index_t polygon_id)
BRepComponentMeshPolygons component_mesh_polygons(const BRep & brep, const Surface3D & surface, index_t polygon_id)

component_mesh_polygons

cpp
BRepComponentMeshPolygons component_mesh_polygons(const BRep & brep, const Block3D & block, const PolyhedronFacet & facet)
BRepComponentMeshPolygons component_mesh_polygons(const BRep & brep, const Block3D & block, const PolyhedronFacet & facet)

block_mesh_polyhedra_from_surface_polygon

cpp
InlinedVector block_mesh_polyhedra_from_surface_polygon(const BRep & model, const Block3D & block, const Surface3D & surface, index_t polygon_id)
InlinedVector block_mesh_polyhedra_from_surface_polygon(const BRep & model, const Block3D & block, const Surface3D & surface, index_t polygon_id)

block_vertices_from_surface_polygon

cpp
InlinedVector block_vertices_from_surface_polygon(const BRep & model, const Block3D & block, const Surface3D & surface, index_t polygon_id)
InlinedVector block_vertices_from_surface_polygon(const BRep & model, const Block3D & block, const Surface3D & surface, index_t polygon_id)

oriented_block_vertices_from_surface_polygon

cpp
BlockPolyhedraFacetVertices oriented_block_vertices_from_surface_polygon(const BRep & model, const Block3D & block, const Surface3D & surface, index_t polygon_id)
BlockPolyhedraFacetVertices oriented_block_vertices_from_surface_polygon(const BRep & model, const Block3D & block, const Surface3D & surface, index_t polygon_id)

surface_vertices_from_line_edge

cpp
InlinedVector surface_vertices_from_line_edge(const BRep & model, const Surface3D & surface, const Line3D & line, index_t edge_id)
InlinedVector surface_vertices_from_line_edge(const BRep & model, const Surface3D & surface, const Line3D & line, index_t edge_id)

oriented_surface_vertices_from_line_edge

cpp
SurfacePolygonsEdgeVertices oriented_surface_vertices_from_line_edge(const BRep & model, const Surface3D & surface, const Line3D & line, index_t edge_id)
SurfacePolygonsEdgeVertices oriented_surface_vertices_from_line_edge(const BRep & model, const Surface3D & surface, const Line3D & line, index_t edge_id)

surface_vertices_from_line_edge

cpp
InlinedVector surface_vertices_from_line_edge(const Section & model, const Surface2D & surface, const Line2D & line, index_t edge_id)
InlinedVector surface_vertices_from_line_edge(const Section & model, const Surface2D & surface, const Line2D & line, index_t edge_id)

oriented_surface_vertices_from_line_edge

cpp
SurfacePolygonsEdgeVertices oriented_surface_vertices_from_line_edge(const Section & model, const Surface2D & surface, const Line2D & line, index_t edge_id)
SurfacePolygonsEdgeVertices oriented_surface_vertices_from_line_edge(const Section & model, const Surface2D & surface, const Line2D & line, index_t edge_id)

polyhedron_unique_vertices

cpp
InlinedVector polyhedron_unique_vertices(const BRep & model, const Block3D & block, index_t polyhedron_id)
InlinedVector polyhedron_unique_vertices(const BRep & model, const Block3D & block, index_t polyhedron_id)

component_mesh_polyhedra

cpp
vector component_mesh_polyhedra(const BRep & brep, const PolyhedronVertices & polyhedron_unique_vertices)
vector component_mesh_polyhedra(const BRep & brep, const PolyhedronVertices & polyhedron_unique_vertices)

block_volume

cpp
double block_volume(const BRep & brep, const Block3D & block)
double block_volume(const BRep & brep, const Block3D & block)

block_bounding_box

cpp
BoundingBox block_bounding_box(const BRep & brep, const Block3D & block)
BoundingBox block_bounding_box(const BRep & brep, const Block3D & block)

surface_area

cpp
double surface_area(const Surface<dimension> & surface)
double surface_area(const Surface<dimension> & surface)

convert_brep_into_section

cpp
tuple convert_brep_into_section(const BRep & brep, index_t axis_to_remove)
tuple convert_brep_into_section(const BRep & brep, index_t axis_to_remove)

convert_section_into_brep

cpp
tuple convert_section_into_brep(const Section & section, index_t axis_to_add, double axis_coordinate)
tuple convert_section_into_brep(const Section & section, index_t axis_to_add, double axis_coordinate)

extrude_section_to_brep

cpp
BRep extrude_section_to_brep(const Section & section, const SectionExtruderOptions & options)
BRep extrude_section_to_brep(const Section & section, const SectionExtruderOptions & options)

convert_edged_curve3d_into_2d

cpp
unique_ptr convert_edged_curve3d_into_2d(const EdgedCurve3D & curve3d, index_t axis_to_remove)
unique_ptr convert_edged_curve3d_into_2d(const EdgedCurve3D & curve3d, index_t axis_to_remove)

convert_edged_curve2d_into_3d

cpp
unique_ptr convert_edged_curve2d_into_3d(const EdgedCurve2D & curve2d, index_t axis_to_add, double axis_coordinate)
unique_ptr convert_edged_curve2d_into_3d(const EdgedCurve2D & curve2d, index_t axis_to_add, double axis_coordinate)

merge_edged_curves

cpp
std::unique_ptr<EdgedCurve<dimension> > merge_edged_curves(absl::Span<const std::reference_wrapper<const EdgedCurve<dimension> > > curves)
std::unique_ptr<EdgedCurve<dimension> > merge_edged_curves(absl::Span<const std::reference_wrapper<const EdgedCurve<dimension> > > curves)

convert_point_set3d_into_2d

cpp
unique_ptr convert_point_set3d_into_2d(const PointSet3D & point_set3d, index_t axis_to_remove)
unique_ptr convert_point_set3d_into_2d(const PointSet3D & point_set3d, index_t axis_to_remove)

convert_point_set2d_into_3d

cpp
unique_ptr convert_point_set2d_into_3d(const PointSet2D & point_set2d, index_t axis_to_add, double axis_coordinate)
unique_ptr convert_point_set2d_into_3d(const PointSet2D & point_set2d, index_t axis_to_add, double axis_coordinate)

convert_surface_mesh_into_polygonal_surface

cpp
std::unique_ptr<PolygonalSurface<dimension> > convert_surface_mesh_into_polygonal_surface(const SurfaceMesh<dimension> & surface)
std::unique_ptr<PolygonalSurface<dimension> > convert_surface_mesh_into_polygonal_surface(const SurfaceMesh<dimension> & surface)

convert_surface_mesh_into_triangulated_surface

cpp
std::optional<std::unique_ptr<TriangulatedSurface<dimension> > > convert_surface_mesh_into_triangulated_surface(const SurfaceMesh<dimension> & surface)
std::optional<std::unique_ptr<TriangulatedSurface<dimension> > > convert_surface_mesh_into_triangulated_surface(const SurfaceMesh<dimension> & surface)

convert_grid_into_triangulated_surface

cpp
std::unique_ptr<TriangulatedSurface2D> convert_grid_into_triangulated_surface(const Grid2D & grid)
std::unique_ptr<TriangulatedSurface2D> convert_grid_into_triangulated_surface(const Grid2D & grid)

convert_grid_into_densified_triangulated_surface

cpp
std::unique_ptr<TriangulatedSurface2D> convert_grid_into_densified_triangulated_surface(const Grid2D & grid, Span cells_to_densify)
std::unique_ptr<TriangulatedSurface2D> convert_grid_into_densified_triangulated_surface(const Grid2D & grid, Span cells_to_densify)

triangulate_surface_mesh

cpp
void triangulate_surface_mesh(SurfaceMesh<dimension> & surface)
void triangulate_surface_mesh(SurfaceMesh<dimension> & surface)

triangulate_surface_mesh

cpp
void triangulate_surface_mesh(const SurfaceMesh<dimension> & surface, SurfaceMeshBuilder<dimension> & builder)
void triangulate_surface_mesh(const SurfaceMesh<dimension> & surface, SurfaceMeshBuilder<dimension> & builder)

convert_surface_mesh2d_into_3d

cpp
unique_ptr convert_surface_mesh2d_into_3d(const SurfaceMesh2D & surface2d, index_t axis_to_add, double axis_coordinate)
unique_ptr convert_surface_mesh2d_into_3d(const SurfaceMesh2D & surface2d, index_t axis_to_add, double axis_coordinate)

convert_surface_mesh3d_into_2d

cpp
unique_ptr convert_surface_mesh3d_into_2d(const SurfaceMesh3D & surface3d, index_t axis_to_remove)
unique_ptr convert_surface_mesh3d_into_2d(const SurfaceMesh3D & surface3d, index_t axis_to_remove)

convert_polygonal_surface2d_into_3d

cpp
std::unique_ptr<PolygonalSurface3D> convert_polygonal_surface2d_into_3d(const PolygonalSurface2D & surface2d, index_t axis_to_add, double axis_coordinate)
std::unique_ptr<PolygonalSurface3D> convert_polygonal_surface2d_into_3d(const PolygonalSurface2D & surface2d, index_t axis_to_add, double axis_coordinate)

convert_polygonal_surface3d_into_2d

cpp
std::unique_ptr<PolygonalSurface2D> convert_polygonal_surface3d_into_2d(const PolygonalSurface3D & surface3d, index_t axis_to_remove)
std::unique_ptr<PolygonalSurface2D> convert_polygonal_surface3d_into_2d(const PolygonalSurface3D & surface3d, index_t axis_to_remove)

convert_triangulated_surface2d_into_3d

cpp
std::unique_ptr<TriangulatedSurface3D> convert_triangulated_surface2d_into_3d(const TriangulatedSurface2D & surface2d, index_t axis_to_add, double axis_coordinate)
std::unique_ptr<TriangulatedSurface3D> convert_triangulated_surface2d_into_3d(const TriangulatedSurface2D & surface2d, index_t axis_to_add, double axis_coordinate)

convert_triangulated_surface3d_into_2d

cpp
std::unique_ptr<TriangulatedSurface2D> convert_triangulated_surface3d_into_2d(const TriangulatedSurface3D & surface3d, index_t axis_to_remove)
std::unique_ptr<TriangulatedSurface2D> convert_triangulated_surface3d_into_2d(const TriangulatedSurface3D & surface3d, index_t axis_to_remove)

merge_surface_meshes

cpp
std::unique_ptr<SurfaceMesh<dimension> > merge_surface_meshes(absl::Span<const std::reference_wrapper<const SurfaceMesh<dimension> > > surfaces)
std::unique_ptr<SurfaceMesh<dimension> > merge_surface_meshes(absl::Span<const std::reference_wrapper<const SurfaceMesh<dimension> > > surfaces)

load_edged_curve

cpp
std::unique_ptr<EdgedCurve<dimension> > load_edged_curve(const MeshImpl & impl, basic_string_view filename)
std::unique_ptr<EdgedCurve<dimension> > load_edged_curve(const MeshImpl & impl, basic_string_view filename)

API function for loading an EdgedCurve. The adequate loader is called depending on the filename extension.

impl [in] Data structure implementation.

filename [in] Path to the file to load.

load_edged_curve

cpp
std::unique_ptr<EdgedCurve<dimension> > load_edged_curve(basic_string_view filename)
std::unique_ptr<EdgedCurve<dimension> > load_edged_curve(basic_string_view filename)

API function for loading an EdgedCurve. The adequate loader is called depending on the filename extension. Default data structure implémentation is used.

filename [in] Path to the file to load.

check_edged_curve_missing_files

cpp
typename EdgedCurveInput<dimension>::MissingFiles check_edged_curve_missing_files(basic_string_view filename)
typename EdgedCurveInput<dimension>::MissingFiles check_edged_curve_missing_files(basic_string_view filename)

is_edged_curve_loadable

cpp
bool is_edged_curve_loadable(basic_string_view filename)
bool is_edged_curve_loadable(basic_string_view filename)

load_graph

cpp
unique_ptr load_graph(const MeshImpl & impl, basic_string_view filename)
unique_ptr load_graph(const MeshImpl & impl, basic_string_view filename)

API function for loading an Graph. The adequate loader is called depending on the filename extension.

impl [in] Data structure implementation.

filename [in] Path to the file to load.

load_graph

cpp
unique_ptr load_graph(basic_string_view filename)
unique_ptr load_graph(basic_string_view filename)

API function for loading an Graph. The adequate loader is called depending on the filename extension. Default data structure implémentation is used.

filename [in] Path to the file to load.

check_graph_missing_files

cpp
MissingFiles check_graph_missing_files(basic_string_view filename)
MissingFiles check_graph_missing_files(basic_string_view filename)

is_graph_loadable

cpp
bool is_graph_loadable(basic_string_view filename)
bool is_graph_loadable(basic_string_view filename)

load_hybrid_solid

cpp
std::unique_ptr<HybridSolid<dimension> > load_hybrid_solid(const MeshImpl & impl, basic_string_view filename)
std::unique_ptr<HybridSolid<dimension> > load_hybrid_solid(const MeshImpl & impl, basic_string_view filename)

API function for loading an HybridSolid. The adequate loader is called depending on the filename extension.

impl [in] Data structure implementation.

filename [in] Path to the file to load.

load_hybrid_solid

cpp
std::unique_ptr<HybridSolid<dimension> > load_hybrid_solid(basic_string_view filename)
std::unique_ptr<HybridSolid<dimension> > load_hybrid_solid(basic_string_view filename)

API function for loading an HybridSolid. The adequate loader is called depending on the filename extension. Default data structure implémentation is used.

filename [in] Path to the file to load.

check_hybrid_solid_missing_files

cpp
typename HybridSolidInput<dimension>::MissingFiles check_hybrid_solid_missing_files(basic_string_view filename)
typename HybridSolidInput<dimension>::MissingFiles check_hybrid_solid_missing_files(basic_string_view filename)

is_hybrid_solid_loadable

cpp
bool is_hybrid_solid_loadable(basic_string_view filename)
bool is_hybrid_solid_loadable(basic_string_view filename)

load_light_regular_grid

cpp
LightRegularGrid<dimension> load_light_regular_grid(basic_string_view filename)
LightRegularGrid<dimension> load_light_regular_grid(basic_string_view filename)

API function for loading an LightRegularGrid. The adequate loader is called depending on the filename extension.

filename [in] Path to the file to load.

check_light_regular_grid_missing_files

cpp
typename LightRegularGridInput<dimension>::MissingFiles check_light_regular_grid_missing_files(basic_string_view filename)
typename LightRegularGridInput<dimension>::MissingFiles check_light_regular_grid_missing_files(basic_string_view filename)

is_light_regular_grid_loadable

cpp
bool is_light_regular_grid_loadable(basic_string_view filename)
bool is_light_regular_grid_loadable(basic_string_view filename)

register_geode_mesh

cpp
void register_geode_mesh()
void register_geode_mesh()

rotate

cpp
Point rotate(const Point3D & point, const Vector3D & axis, double angle)
Point rotate(const Point3D & point, const Vector3D & axis, double angle)

Rotate a Point3D by an angle around an axis

point [in] The point to rotate.

axis [in] Axis for the rotation (not null but not necessary normalized).

angle [in] Rotation angle expresses in radians.

tetrahedron_volume_sign

cpp
SIDE tetrahedron_volume_sign(const Tetrahedron & tetra)
SIDE tetrahedron_volume_sign(const Tetrahedron & tetra)

Return the sign of a tetrahedron volume.

triangle_area_sign

cpp
SIDE triangle_area_sign(const Triangle2D & triangle)
SIDE triangle_area_sign(const Triangle2D & triangle)

Return the sign of a 2D triangle area.

triangle_area_sign

cpp
SIDE triangle_area_sign(const Triangle3D & triangle, local_index_t axis)
SIDE triangle_area_sign(const Triangle3D & triangle, local_index_t axis)

Return the sign of a 3D triangle area aligned on X- Y- or Z-axis.

point_triangle_distance

cpp
tuple point_triangle_distance(const Point3D & point, const Triangle3D & triangle)
tuple point_triangle_distance(const Point3D & point, const Triangle3D & triangle)

point_triangle_distance

cpp
tuple point_triangle_distance(const Point2D & point, const Triangle2D & triangle)
tuple point_triangle_distance(const Point2D & point, const Triangle2D & triangle)

Bisector

cpp
double Bisector(const geode::index_t number_of_components, const std::array<double, dimension> & locE, const std::array<double, dimension> & locY, std::array<double, dimension> & locX)
double Bisector(const geode::index_t number_of_components, const std::array<double, dimension> & locE, const std::array<double, dimension> & locY, std::array<double, dimension> & locX)

SqrDistanceSpecial

cpp
std::tuple<double, std::array<double, dimension> > SqrDistanceSpecial(const std::array<double, dimension> & extents, const std::array<double, dimension> & query_point_coordinates)
std::tuple<double, std::array<double, dimension> > SqrDistanceSpecial(const std::array<double, dimension> & extents, const std::array<double, dimension> & query_point_coordinates)

SquaredDistance

cpp
std::tuple<double, Point<dimension> > SquaredDistance(const Ellipse<dimension> & ellipse, const std::array<double, dimension> & query_point_coordinates)
std::tuple<double, Point<dimension> > SquaredDistance(const Ellipse<dimension> & ellipse, const std::array<double, dimension> & query_point_coordinates)

line_plane_intersection

cpp
IntersectionResult line_plane_intersection(const InfiniteLine3D & line, const Plane & plane)
IntersectionResult line_plane_intersection(const InfiniteLine3D & line, const Plane & plane)

Compute the intersection between a plane and an infinite line

return an optional of the intersection.

line_sphere_intersection

cpp
IntersectionResult<absl::InlinedVector<Point<dimension>, 2> > line_sphere_intersection(const InfiniteLine<dimension> & line, const Sphere<dimension> & sphere)
IntersectionResult<absl::InlinedVector<Point<dimension>, 2> > line_sphere_intersection(const InfiniteLine<dimension> & line, const Sphere<dimension> & sphere)

Compute the intersection(s) between a sphere and an infinite line

return an optional of the intersection points.

segment_sphere_intersection

cpp
IntersectionResult<absl::InlinedVector<Point<dimension>, 2> > segment_sphere_intersection(const Segment<dimension> & segment, const Sphere<dimension> & sphere)
IntersectionResult<absl::InlinedVector<Point<dimension>, 2> > segment_sphere_intersection(const Segment<dimension> & segment, const Sphere<dimension> & sphere)

Compute the intersection(s) between a (n-1)-sphere and a segment in n-dimension space.

return an optional of the intersection points.

segment_plane_intersection

cpp
IntersectionResult segment_plane_intersection(const Segment3D & segment, const Plane & plane)
IntersectionResult segment_plane_intersection(const Segment3D & segment, const Plane & plane)

Compute the intersection between a plane and a segment

return an optional of the intersection point.

warning if the segment is included in the plane nothing is returned

segment_triangle_intersection

cpp
IntersectionResult segment_triangle_intersection(const Segment3D & segment, const Triangle3D & triangle)
IntersectionResult segment_triangle_intersection(const Segment3D & segment, const Triangle3D & triangle)

Compute the intersection of a segment and a triangle

return an optional of the intersection point.

warning if the segment is included in the triangle plane nothing is returned

line_triangle_intersection

cpp
IntersectionResult line_triangle_intersection(const InfiniteLine3D & line, const Triangle3D & triangle)
IntersectionResult line_triangle_intersection(const InfiniteLine3D & line, const Triangle3D & triangle)

Compute the intersection of a line and a triangle

return an optional of the intersection point.

warning if the segment is included in the triangle plane nothing is returned

line_line_intersection

cpp
IntersectionResult line_line_intersection(const InfiniteLine2D & line0, const InfiniteLine2D & line1)
IntersectionResult line_line_intersection(const InfiniteLine2D & line0, const InfiniteLine2D & line1)

Compute the intersection between two infinite lines

return an optional of the intersection point.

segment_segment_intersection

cpp
IntersectionResult segment_segment_intersection(const Segment2D & segment0, const Segment2D & segment1)
IntersectionResult segment_segment_intersection(const Segment2D & segment0, const Segment2D & segment1)

Compute the intersection between two segments

return an optional of the intersection point.

segment_line_intersection

cpp
IntersectionResult segment_line_intersection(const Segment2D & segment, const InfiniteLine2D & line)
IntersectionResult segment_line_intersection(const Segment2D & segment, const InfiniteLine2D & line)

Compute the intersection between a segment and an infinite line

return an optional of the intersection point.

segment_cylinder_intersection

cpp
IntersectionResult segment_cylinder_intersection(const Segment3D & segment, const Cylinder & cylinder)
IntersectionResult segment_cylinder_intersection(const Segment3D & segment, const Cylinder & cylinder)

Compute the intersection between a segment and a cylinder

return an optional of the intersection points.

line_cylinder_intersection

cpp
IntersectionResult line_cylinder_intersection(const InfiniteLine3D & line, const Cylinder & cylinder)
IntersectionResult line_cylinder_intersection(const InfiniteLine3D & line, const Cylinder & cylinder)

Compute the intersection between a line and a cylinder

return an optional of the intersection points.

triangle_circle_intersection

cpp
IntersectionResult triangle_circle_intersection(const Triangle3D & triangle, const Circle & circle)
IntersectionResult triangle_circle_intersection(const Triangle3D & triangle, const Circle & circle)

Compute the intersection between a triangle and a circle

return an optional of the intersection points.

plane_circle_intersection

cpp
IntersectionResult plane_circle_intersection(const Plane & plane, const Circle & circle)
IntersectionResult plane_circle_intersection(const Plane & plane, const Circle & circle)

Compute the intersection between a plane and a circle

return an optional of the intersection points.

plane_plane_intersection

cpp
IntersectionResult plane_plane_intersection(const Plane & plane0, const Plane & plane1)
IntersectionResult plane_plane_intersection(const Plane & plane0, const Plane & plane1)

Compute the intersection between two planes

return an optional of the intersection line.

segment_ellipse_intersection

cpp
IntersectionResult<absl::InlinedVector<Point<dimension>, 2> > segment_ellipse_intersection(const Segment<dimension> & segment, const Ellipse<dimension> & ellipse)
IntersectionResult<absl::InlinedVector<Point<dimension>, 2> > segment_ellipse_intersection(const Segment<dimension> & segment, const Ellipse<dimension> & ellipse)

Compute the intersection between a segment and an ellipse

return an optional of the intersection points.

line_ellipse_intersection

cpp
IntersectionResult<absl::InlinedVector<Point<dimension>, 2> > line_ellipse_intersection(const InfiniteLine<dimension> & line, const Ellipse<dimension> & ellipse)
IntersectionResult<absl::InlinedVector<Point<dimension>, 2> > line_ellipse_intersection(const InfiniteLine<dimension> & line, const Ellipse<dimension> & ellipse)

Compute the intersection between a line and an ellipse

return an optional of the intersection points.

file_exists

cpp
bool file_exists(basic_string_view file_path)
bool file_exists(basic_string_view file_path)

check_keyword

cpp
void check_keyword(std::ifstream & file, basic_string_view keyword)
void check_keyword(std::ifstream & file, basic_string_view keyword)

line_starts_with

cpp
bool line_starts_with(std::ifstream & file, basic_string_view check)
bool line_starts_with(std::ifstream & file, basic_string_view check)

goto_keyword

cpp
basic_string goto_keyword(std::ifstream & file, basic_string_view word)
basic_string goto_keyword(std::ifstream & file, basic_string_view word)

goto_keywords

cpp
basic_string goto_keywords(std::ifstream & file, Span words)
basic_string goto_keywords(std::ifstream & file, Span words)

goto_keyword_if_it_exists

cpp
optional goto_keyword_if_it_exists(std::ifstream & file, basic_string_view word)
optional goto_keyword_if_it_exists(std::ifstream & file, basic_string_view word)

next_keyword_if_it_exists

cpp
optional next_keyword_if_it_exists(std::ifstream & file, basic_string_view word)
optional next_keyword_if_it_exists(std::ifstream & file, basic_string_view word)

string_split

cpp
std::vector<std::string_view> string_split(basic_string_view string)
std::vector<std::string_view> string_split(basic_string_view string)

string_starts_with

cpp
bool string_starts_with(basic_string_view string, basic_string_view check)
bool string_starts_with(basic_string_view string, basic_string_view check)

string_to_index

cpp
index_t string_to_index(basic_string_view string)
index_t string_to_index(basic_string_view string)

string_to_int

cpp
int string_to_int(basic_string_view string)
int string_to_int(basic_string_view string)

string_to_float

cpp
float string_to_float(basic_string_view string)
float string_to_float(basic_string_view string)

string_to_double

cpp
double string_to_double(basic_string_view string)
double string_to_double(basic_string_view string)

register_geode_mesh_input

cpp
void register_geode_mesh_input()
void register_geode_mesh_input()

build_grid_from_bbox_target_length_and_maximum_cell_number

cpp
LightRegularGrid<dimension> build_grid_from_bbox_target_length_and_maximum_cell_number(const BoundingBox<dimension> & bbox, double target_cell_length, index_t max_nb_cells)
LightRegularGrid<dimension> build_grid_from_bbox_target_length_and_maximum_cell_number(const BoundingBox<dimension> & bbox, double target_cell_length, index_t max_nb_cells)

convert_solid_mesh_into_tetrahedral_solid

cpp
optional convert_solid_mesh_into_tetrahedral_solid(const SolidMesh3D & solid)
optional convert_solid_mesh_into_tetrahedral_solid(const SolidMesh3D & solid)

convert_grid_into_tetrahedral_solid

cpp
unique_ptr convert_grid_into_tetrahedral_solid(const Grid3D & grid)
unique_ptr convert_grid_into_tetrahedral_solid(const Grid3D & grid)

convert_grid_into_hybrid_solid

cpp
unique_ptr convert_grid_into_hybrid_solid(const Grid3D & grid)
unique_ptr convert_grid_into_hybrid_solid(const Grid3D & grid)

convert_grid_into_densified_tetrahedral_solid

cpp
unique_ptr convert_grid_into_densified_tetrahedral_solid(const Grid3D & grid, Span cells_to_densify)
unique_ptr convert_grid_into_densified_tetrahedral_solid(const Grid3D & grid, Span cells_to_densify)

convert_solid_mesh_into_hybrid_solid

cpp
optional convert_solid_mesh_into_hybrid_solid(const SolidMesh3D & solid)
optional convert_solid_mesh_into_hybrid_solid(const SolidMesh3D & solid)

merge_solid_meshes

cpp
unique_ptr merge_solid_meshes(Span solids)
unique_ptr merge_solid_meshes(Span solids)

create_edged_curve_coordinate_system

cpp
void create_edged_curve_coordinate_system(const EdgedCurve<dimension> & mesh, EdgedCurveBuilder<dimension> & builder, basic_string_view new_coordinate_system_name, const CoordinateSystem2D & input, const CoordinateSystem2D & output)
void create_edged_curve_coordinate_system(const EdgedCurve<dimension> & mesh, EdgedCurveBuilder<dimension> & builder, basic_string_view new_coordinate_system_name, const CoordinateSystem2D & input, const CoordinateSystem2D & output)

create_point_set_coordinate_system

cpp
void create_point_set_coordinate_system(const PointSet<dimension> & mesh, PointSetBuilder<dimension> & builder, basic_string_view new_coordinate_system_name, const CoordinateSystem2D & input, const CoordinateSystem2D & output)
void create_point_set_coordinate_system(const PointSet<dimension> & mesh, PointSetBuilder<dimension> & builder, basic_string_view new_coordinate_system_name, const CoordinateSystem2D & input, const CoordinateSystem2D & output)

create_surface_mesh_coordinate_system

cpp
void create_surface_mesh_coordinate_system(const SurfaceMesh<dimension> & mesh, SurfaceMeshBuilder<dimension> & builder, basic_string_view new_coordinate_system_name, const CoordinateSystem2D & input, const CoordinateSystem2D & output)
void create_surface_mesh_coordinate_system(const SurfaceMesh<dimension> & mesh, SurfaceMeshBuilder<dimension> & builder, basic_string_view new_coordinate_system_name, const CoordinateSystem2D & input, const CoordinateSystem2D & output)

create_solid_mesh_coordinate_system

cpp
void create_solid_mesh_coordinate_system(const SolidMesh<dimension> & mesh, SolidMeshBuilder<dimension> & builder, basic_string_view new_coordinate_system_name, const CoordinateSystem2D & input, const CoordinateSystem2D & output)
void create_solid_mesh_coordinate_system(const SolidMesh<dimension> & mesh, SolidMeshBuilder<dimension> & builder, basic_string_view new_coordinate_system_name, const CoordinateSystem2D & input, const CoordinateSystem2D & output)

load_polygonal_surface

cpp
std::unique_ptr<PolygonalSurface<dimension> > load_polygonal_surface(const MeshImpl & impl, basic_string_view filename)
std::unique_ptr<PolygonalSurface<dimension> > load_polygonal_surface(const MeshImpl & impl, basic_string_view filename)

API function for loading an PolygonalSurface. The adequate loader is called depending on the filename extension.

impl [in] Data structure implementation.

filename [in] Path to the file to load.

load_polygonal_surface

cpp
std::unique_ptr<PolygonalSurface<dimension> > load_polygonal_surface(basic_string_view filename)
std::unique_ptr<PolygonalSurface<dimension> > load_polygonal_surface(basic_string_view filename)

API function for loading an PolygonalSurface. The adequate loader is called depending on the filename extension. Default data structure implémentation is used.

filename [in] Path to the file to load.

check_polygonal_surface_missing_files

cpp
typename PolygonalSurfaceInput<dimension>::MissingFiles check_polygonal_surface_missing_files(basic_string_view filename)
typename PolygonalSurfaceInput<dimension>::MissingFiles check_polygonal_surface_missing_files(basic_string_view filename)

is_polygonal_surface_loadable

cpp
bool is_polygonal_surface_loadable(basic_string_view filename)
bool is_polygonal_surface_loadable(basic_string_view filename)

load_point_set

cpp
std::unique_ptr<PointSet<dimension> > load_point_set(const MeshImpl & impl, basic_string_view filename)
std::unique_ptr<PointSet<dimension> > load_point_set(const MeshImpl & impl, basic_string_view filename)

API function for loading an PointSet. The adequate loader is called depending on the filename extension.

impl [in] Data structure implementation.

filename [in] Path to the file to load.

load_point_set

cpp
std::unique_ptr<PointSet<dimension> > load_point_set(basic_string_view filename)
std::unique_ptr<PointSet<dimension> > load_point_set(basic_string_view filename)

API function for loading an PointSet. The adequate loader is called depending on the filename extension. Default data structure implémentation is used.

filename [in] Path to the file to load.

check_point_set_missing_files

cpp
typename PointSetInput<dimension>::MissingFiles check_point_set_missing_files(basic_string_view filename)
typename PointSetInput<dimension>::MissingFiles check_point_set_missing_files(basic_string_view filename)

is_point_set_loadable

cpp
bool is_point_set_loadable(basic_string_view filename)
bool is_point_set_loadable(basic_string_view filename)

load_polyhedral_solid

cpp
std::unique_ptr<PolyhedralSolid<dimension> > load_polyhedral_solid(const MeshImpl & impl, basic_string_view filename)
std::unique_ptr<PolyhedralSolid<dimension> > load_polyhedral_solid(const MeshImpl & impl, basic_string_view filename)

API function for loading an PolyhedralSolid. The adequate loader is called depending on the filename extension.

impl [in] Data structure implementation.

filename [in] Path to the file to load.

load_polyhedral_solid

cpp
std::unique_ptr<PolyhedralSolid<dimension> > load_polyhedral_solid(basic_string_view filename)
std::unique_ptr<PolyhedralSolid<dimension> > load_polyhedral_solid(basic_string_view filename)

API function for loading an PolyhedralSolid. The adequate loader is called depending on the filename extension. Default data structure implémentation is used.

filename [in] Path to the file to load.

check_polyhedral_solid_missing_files

cpp
typename PolyhedralSolidInput<dimension>::MissingFiles check_polyhedral_solid_missing_files(basic_string_view filename)
typename PolyhedralSolidInput<dimension>::MissingFiles check_polyhedral_solid_missing_files(basic_string_view filename)

is_polyhedral_solid_loadable

cpp
bool is_polyhedral_solid_loadable(basic_string_view filename)
bool is_polyhedral_solid_loadable(basic_string_view filename)

euclidean_distance_transform

cpp
shared_ptr euclidean_distance_transform(const Grid<dimension> & grid, absl::Span<const typename Grid<dimension>::CellIndices> grid_cell_ids, basic_string_view distance_map_name)
shared_ptr euclidean_distance_transform(const Grid<dimension> & grid, absl::Span<const typename Grid<dimension>::CellIndices> grid_cell_ids, basic_string_view distance_map_name)

API function for creating and computing the euclidean distance map from rasterized objects. It computes the exact euclidean distance map.

grid [in] Regular grid on which the euclidean distance map is computed.

grid_cell_ids [in] Rasterization of every objects from which the distance will be computed.

distance_map_name [in] Name of the attribute to store the map on the

cpp
*grid.*
*grid.*

exceptionif the attribute named

distance_map_name cannot be accessed.

return the created attribute

compute_surface_scalar_function_gradient

cpp
basic_string compute_surface_scalar_function_gradient(const SurfaceMesh<dimension> & mesh, basic_string_view scalar_function_name)
basic_string compute_surface_scalar_function_gradient(const SurfaceMesh<dimension> & mesh, basic_string_view scalar_function_name)

compute_solid_scalar_function_gradient

cpp
basic_string compute_solid_scalar_function_gradient(const SolidMesh3D & mesh, basic_string_view scalar_function_name)
basic_string compute_solid_scalar_function_gradient(const SolidMesh3D & mesh, basic_string_view scalar_function_name)

hausdorff_distance

cpp
double hausdorff_distance(const TriangulatedSurface3D & mesh_A, const TriangulatedSurface3D & mesh_B)
double hausdorff_distance(const TriangulatedSurface3D & mesh_A, const TriangulatedSurface3D & mesh_B)

rasterize_segment

cpp
std::vector<typename Grid<dimension>::CellIndices> rasterize_segment(const Grid<dimension> & grid, const Segment<dimension> & segment)
std::vector<typename Grid<dimension>::CellIndices> rasterize_segment(const Grid<dimension> & grid, const Segment<dimension> & segment)

conservative_rasterize_segment

cpp
std::vector<typename Grid<dimension>::CellIndices> conservative_rasterize_segment(const Grid<dimension> & grid, const Segment<dimension> & segment)
std::vector<typename Grid<dimension>::CellIndices> conservative_rasterize_segment(const Grid<dimension> & grid, const Segment<dimension> & segment)

conservative_rasterize_triangle

cpp
std::vector<typename Grid<dimension>::CellIndices> conservative_rasterize_triangle(const Grid<dimension> & grid, const Triangle<dimension> & triangle)
std::vector<typename Grid<dimension>::CellIndices> conservative_rasterize_triangle(const Grid<dimension> & grid, const Triangle<dimension> & triangle)

rasterize_tetrahedron

cpp
vector rasterize_tetrahedron(const Grid3D & grid, const Tetrahedron & tetrahedron)
vector rasterize_tetrahedron(const Grid3D & grid, const Tetrahedron & tetrahedron)

rasterize_closed_surface

cpp
vector rasterize_closed_surface(const Grid3D & grid, const TriangulatedSurface3D & closed_surface)
vector rasterize_closed_surface(const Grid3D & grid, const TriangulatedSurface3D & closed_surface)

surface_radial_sort

cpp
SortedSurfaces surface_radial_sort(const BRep & brep, const Line3D & line)
SortedSurfaces surface_radial_sort(const BRep & brep, const Line3D & line)

find_intersections_with_boundaries

cpp
flat_hash_map find_intersections_with_boundaries(const InfiniteLine3D & infinite_line, const BRep & brep, const Block3D & block)
flat_hash_map find_intersections_with_boundaries(const InfiniteLine3D & infinite_line, const BRep & brep, const Block3D & block)

is_point_inside_block

cpp
bool is_point_inside_block(const BRep & brep, const Block3D & block, const Point3D & point)
bool is_point_inside_block(const BRep & brep, const Block3D & block, const Point3D & point)

is_point_inside_closed_surface

cpp
bool is_point_inside_closed_surface(const SurfaceMesh3D & surface, const Point3D & point)
bool is_point_inside_closed_surface(const SurfaceMesh3D & surface, const Point3D & point)

block_containing_point

cpp
optional block_containing_point(const BRep & brep, const Point3D & point)
optional block_containing_point(const BRep & brep, const Point3D & point)

convert_surface_mesh

cpp
void convert_surface_mesh(const Section & model, SectionBuilder & builder, const geode::Surface2D & surface, const geode::MeshType & mesh_type)
void convert_surface_mesh(const Section & model, SectionBuilder & builder, const geode::Surface2D & surface, const geode::MeshType & mesh_type)

convert_surface_mesh

cpp
void convert_surface_mesh(const BRep & model, BRepBuilder & builder, const geode::Surface3D & surface, const geode::MeshType & mesh_type)
void convert_surface_mesh(const BRep & model, BRepBuilder & builder, const geode::Surface3D & surface, const geode::MeshType & mesh_type)

convert_surface_meshes_into_triangulated_surfaces

cpp
void convert_surface_meshes_into_triangulated_surfaces(const BRep & brep, BRepBuilder & builder)
void convert_surface_meshes_into_triangulated_surfaces(const BRep & brep, BRepBuilder & builder)

convert_surface_meshes_into_triangulated_surfaces

cpp
void convert_surface_meshes_into_triangulated_surfaces(const Section & section, SectionBuilder & builder)
void convert_surface_meshes_into_triangulated_surfaces(const Section & section, SectionBuilder & builder)

convert_block_mesh

cpp
void convert_block_mesh(const BRep & model, BRepBuilder & builder, const Block3D & block, const MeshType & new_mesh_type)
void convert_block_mesh(const BRep & model, BRepBuilder & builder, const Block3D & block, const MeshType & new_mesh_type)

convert_block_meshes_into_tetrahedral_solids

cpp
void convert_block_meshes_into_tetrahedral_solids(const BRep & brep, BRepBuilder & builder)
void convert_block_meshes_into_tetrahedral_solids(const BRep & brep, BRepBuilder & builder)

triangulate_surface_meshes

cpp
void triangulate_surface_meshes(const BRep & brep, BRepBuilder & builder)
void triangulate_surface_meshes(const BRep & brep, BRepBuilder & builder)

triangulate_surface_meshes

cpp
void triangulate_surface_meshes(const Section & section, SectionBuilder & builder)
void triangulate_surface_meshes(const Section & section, SectionBuilder & builder)

convert_surface_meshes_into_triangulated_surfaces

cpp
void convert_surface_meshes_into_triangulated_surfaces(BRep & brep)
void convert_surface_meshes_into_triangulated_surfaces(BRep & brep)

convert_section_into_curve

cpp
tuple convert_section_into_curve(const Section & section)
tuple convert_section_into_curve(const Section & section)

convert_section_into_surface

cpp
tuple convert_section_into_surface(const Section & section)
tuple convert_section_into_surface(const Section & section)

convert_brep_into_curve

cpp
tuple convert_brep_into_curve(const BRep & brep)
tuple convert_brep_into_curve(const BRep & brep)

convert_brep_into_surface

cpp
tuple convert_brep_into_surface(const BRep & brep)
tuple convert_brep_into_surface(const BRep & brep)

convert_brep_into_solid

cpp
tuple convert_brep_into_solid(const BRep & brep)
tuple convert_brep_into_solid(const BRep & brep)

create_brep_coordinate_system

cpp
void create_brep_coordinate_system(const BRep & model, BRepBuilder & builder, basic_string_view new_coordinate_system_name, const CoordinateSystem2D & input, const CoordinateSystem2D & output)
void create_brep_coordinate_system(const BRep & model, BRepBuilder & builder, basic_string_view new_coordinate_system_name, const CoordinateSystem2D & input, const CoordinateSystem2D & output)

create_section_coordinate_system

cpp
void create_section_coordinate_system(const Section & model, SectionBuilder & builder, basic_string_view new_coordinate_system_name, const CoordinateSystem2D & input, const CoordinateSystem2D & output)
void create_section_coordinate_system(const Section & model, SectionBuilder & builder, basic_string_view new_coordinate_system_name, const CoordinateSystem2D & input, const CoordinateSystem2D & output)

set_brep_active_coordinate_system

cpp
void set_brep_active_coordinate_system(const BRep & model, BRepBuilder & builder, basic_string_view coordinate_system_name)
void set_brep_active_coordinate_system(const BRep & model, BRepBuilder & builder, basic_string_view coordinate_system_name)

set_section_active_coordinate_system

cpp
void set_section_active_coordinate_system(const Section & model, SectionBuilder & builder, basic_string_view coordinate_system_name)
void set_section_active_coordinate_system(const Section & model, SectionBuilder & builder, basic_string_view coordinate_system_name)

filter_brep_components_with_regards_to_blocks

cpp
vector filter_brep_components_with_regards_to_blocks(BRep & brep)
vector filter_brep_components_with_regards_to_blocks(BRep & brep)

filter_section_components_with_regards_to_surfaces

cpp
vector filter_section_components_with_regards_to_surfaces(Section & section)
vector filter_section_components_with_regards_to_surfaces(Section & section)

brep_coordinate_reference_systems

cpp
FixedArray brep_coordinate_reference_systems(const BRep & brep)
FixedArray brep_coordinate_reference_systems(const BRep & brep)

section_coordinate_reference_systems

cpp
FixedArray section_coordinate_reference_systems(const Section & section)
FixedArray section_coordinate_reference_systems(const Section & section)

brep_active_coordinate_reference_systems

cpp
FixedArray brep_active_coordinate_reference_systems(const BRep & brep)
FixedArray brep_active_coordinate_reference_systems(const BRep & brep)

section_active_coordinate_reference_systems

cpp
FixedArray section_active_coordinate_reference_systems(const Section & section)
FixedArray section_active_coordinate_reference_systems(const Section & section)

Enums

| enum class POSITION |

--

| outside | | inside | | vertex0 | | vertex1 | | vertex2 | | vertex3 | | edge0 | | edge1 | | edge2 | | edge01 | | edge02 | | edge03 | | edge12 | | edge13 | | edge23 | | facet0 | | facet1 | | facet2 | | facet3 | | parallel |

| enum class SIDE |

--

| positive | | negative | | zero |

| enum class INTERSECTION_TYPE |

--

| none | | intersect | | parallel | | incorrect |

Geode-solutions' documentation website