Struct ConvexSurfaceMesh2d 

pub struct ConvexSurfaceMesh2d { /* private fields */ }

The vertices and edges that make up a convex polygon.

ConvexPolytope::<2> and ConvexSurfaceMesh2d can both represent 2d convex polygons. The first is defined implicitly as the convex hull of a set of points. It stores the given point set without any modification, and can therefore be constructed quickly. The implicit convex hull is formed by SupportMapping during intersection tests of Convex(ConvexPolygon) with other Convex(_) types.

In contrast, ConvexSurfaceMesh2d explicitly computes the convex hull on construction. After construction, the vertices of the shape include only the points on the convex hull in a counter-clockwise order. Using this representation, ConvexSurfaceMesh2d is able to provide implementations of Volume, IsPointInside, and IntersectsAt. The native ConvexSurfaceMesh2d–ConvexSurfaceMesh2d intersection test is much faster than the generic Convex(ConvexPolygon) intersection test.

Examples

Construction:

use hoomd_geometry::shape::ConvexSurfaceMesh2d;

let triangle = ConvexSurfaceMesh2d::from_point_set([
    [1.0, -1.0].into(),
    [-1.0, -1.0].into(),
    [0.0, 1.0].into(),
])?;

Intersection tests:

use hoomd_geometry::{Convex, IntersectsAt, shape::ConvexSurfaceMesh2d};
use hoomd_vector::{Angle, Cartesian};
use std::f64::consts::PI;

let rectangle = ConvexSurfaceMesh2d::from_point_set([
    [-2.0, -1.0].into(),
    [2.0, -1.0].into(),
    [2.0, 1.0].into(),
    [-2.0, 1.0].into(),
])?;

assert!(!rectangle.intersects_at(
    &rectangle,
    &[0.0, 2.1].into(),
    &Angle::default()
));
assert!(rectangle.intersects_at(
    &rectangle,
    &[0.0, 2.1].into(),
    &Angle::from(PI / 2.0)
));

Implementations

impl ConvexSurfaceMesh2d

pub fn from_point_set<I>(points: I) -> Result<Self, Error>

where I: IntoIterator<Item = Cartesian<2>>,

Create an convex surface mesh from the convex hull of the given set of points.

The resulting shape contains a subset of the given points, including only the non-degenerate points on the convex hull. The result’s vertices are arranged in a counter-clockwise order.

Errors

• Error::DegeneratePolytope when there are fewer than 3 non-collinear points.

Example

use hoomd_geometry::shape::ConvexSurfaceMesh2d;

let equilateral_triangle = ConvexSurfaceMesh2d::from_point_set([
    [1.0, 0.0].into(),
    [0.5, f64::sqrt(3.0) / 2.0].into(),
    [-0.5, f64::sqrt(3.0) / 2.0].into(),
])?;

pub fn construct_convex_hull( points: Vec<Cartesian<2>>, ) -> Result<Vec<Cartesian<2>>, Error>

Compute the convex hull of points in two dimensions.

The resulting vector contains a subset of the given points, including only the non-degenerate points on the convex hull. The output vertices are arranged in a counter-clockwise order.

Errors

Returns Error if the input vertices do not form a convex body with 3 or more points.

Example

use hoomd_geometry::shape::ConvexSurfaceMesh2d;

let points = vec![
    [1.0, 0.0].into(),
    [0.5, f64::sqrt(3.0) / 2.0].into(),
    [-0.5, f64::sqrt(3.0) / 2.0].into(),
];

let hull_vertices = ConvexSurfaceMesh2d::construct_convex_hull(points)?;

pub fn vertices(&self) -> &[Cartesian<2>]

The vertices of the convex polygon in counter-clockwise order.

Trait Implementations

impl BoundingSphereRadius for ConvexSurfaceMesh2d

fn bounding_sphere_radius(&self) -> PositiveReal

Radius of a circle that bounds the shape.

The circle has the same local origin as the shape self.

Example

use approxim::assert_relative_eq;
use hoomd_geometry::{BoundingSphereRadius, shape::ConvexSurfaceMesh2d};

let triangle = ConvexSurfaceMesh2d::from_point_set([
    [1.0, -1.0].into(),
    [-1.0, -1.0].into(),
    [0.0, 1.0].into(),
])?;

let bounding_radius = triangle.bounding_sphere_radius();

assert_relative_eq!(bounding_radius.get(), 2.0_f64.sqrt());

impl Clone for ConvexSurfaceMesh2d

fn clone(&self) -> ConvexSurfaceMesh2d

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ConvexSurfaceMesh2d

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ConvexSurfaceMesh2d

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R> IntersectsAt<ConvexSurfaceMesh2d, Cartesian<2>, R> for ConvexSurfaceMesh2d

where RotationMatrix<2>: From<R>, R: Copy,

fn intersects_at(&self, other: &Self, v_ij: &Cartesian<2>, o_ij: &R) -> bool

Test convex polygon intersections using the separating planes method.

When the number of vertices is small, separating planes is significantly faster than the Xenocollide algorithm implemented for the Convex<ConvexPolygon> type, even though separating planes is $O(n^2)$.

Example

use hoomd_geometry::{IntersectsAt, shape::ConvexSurfaceMesh2d};
use hoomd_vector::{Angle, Cartesian};
use std::f64::consts::PI;

let rectangle = ConvexSurfaceMesh2d::from_point_set([
    [-2.0, -1.0].into(),
    [2.0, -1.0].into(),
    [2.0, 1.0].into(),
    [-2.0, 1.0].into(),
])?;

assert!(!rectangle.intersects_at(
    &rectangle,
    &[0.0, 2.1].into(),
    &Angle::default()
));
assert!(rectangle.intersects_at(
    &rectangle,
    &[0.0, 2.1].into(),
    &Angle::from(PI / 2.0)
));

fn approximate_separation_distance( &self, other: &S, v_ij: &V, o_ij: &R, resolution: PositiveReal, ) -> f64

where V: InnerProduct,

Approximate the amount of overlap between two shapes.

impl<R> IntersectsAtGlobal<ConvexSurfaceMesh2d, Cartesian<2>, R> for ConvexSurfaceMesh2d

where R: Rotation + Rotate<Cartesian<2>>, RotationMatrix<2>: From<R>,

fn intersects_at_global( &self, other: &Self, r_self: &Cartesian<2>, o_self: &R, r_other: &Cartesian<2>, o_other: &R, ) -> bool

Test whether the set of points in one shape intersects with the set of another (in the global frame).

impl IsPointInside<Cartesian<2>> for ConvexSurfaceMesh2d

fn is_point_inside(&self, point: &Cartesian<2>) -> bool

Check if a point is inside the convex polygon.

Example

use hoomd_geometry::{IsPointInside, shape::ConvexSurfaceMesh2d};

let triangle = ConvexSurfaceMesh2d::from_point_set([
    [1.0, -1.0].into(),
    [-1.0, -1.0].into(),
    [0.0, 1.0].into(),
])?;

assert!(triangle.is_point_inside(&[0.0, 0.0].into()));
assert!(triangle.is_point_inside(&[-0.9, -0.9].into()));
assert!(!triangle.is_point_inside(&[-1.5, 2.0].into()));

impl PartialEq for ConvexSurfaceMesh2d

fn eq(&self, other: &ConvexSurfaceMesh2d) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ConvexSurfaceMesh2d

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl SupportMapping<Cartesian<2>> for ConvexSurfaceMesh2d

fn support_mapping(&self, n: &Cartesian<2>) -> Cartesian<2>

Find the point on a shape that is the furthest in a given direction.

ConvexSurfaceMesh2d implements SupportMapping to enable intersection tests between mixed convex types.

Example

use hoomd_geometry::{
    Convex, IntersectsAt,
    shape::{Circle, ConvexSurfaceMesh2d, Sphero},
};
use hoomd_vector::{Angle, Cartesian};
use std::f64::consts::PI;

let circle = Convex(Circle {
    radius: 0.5.try_into()?,
});
let rectangle = ConvexSurfaceMesh2d::from_point_set([
    [-1.5, -1.0].into(),
    [1.5, -1.0].into(),
    [-1.5, 1.0].into(),
    [1.5, 1.0].into(),
])?;
let rounded_rectangle = Convex(Sphero {
    shape: rectangle,
    rounding_radius: 0.5.try_into()?,
});

assert!(rounded_rectangle.intersects_at(
    &circle,
    &[2.4, 0.0].into(),
    &Angle::default()
));
assert!(!rounded_rectangle.intersects_at(
    &circle,
    &[0.0, 2.4].into(),
    &Angle::default()
));
assert!(circle.intersects_at(
    &rounded_rectangle,
    &[0.0, 2.4].into(),
    &Angle::from(PI / 2.0)
));

impl<const MAX_VERTICES: usize> TryFrom<ConvexPolytope<2, MAX_VERTICES>> for ConvexSurfaceMesh2d

fn try_from( v: ConvexPolytope<2, MAX_VERTICES>, ) -> Result<ConvexSurfaceMesh2d, Error>

Construct the convex hull of a ConvexPolytope<2>.

Errors

• Error::DegeneratePolytope when there are fewer than 3 non-collinear points.

Example

Invalid conversion

use hoomd_geometry::shape::{ConvexPolygon, ConvexSurfaceMesh2d};

let equilateral_triangle = ConvexPolygon::regular(3);
let mesh = ConvexSurfaceMesh2d::try_from(equilateral_triangle)?;

type Error = Error

The type returned in the event of a conversion error.

impl Volume for ConvexSurfaceMesh2d

fn volume(&self) -> f64

Compute the area of the convex polygon.

Example

use approxim::assert_relative_eq;
use hoomd_geometry::{Volume, shape::ConvexSurfaceMesh2d};

let triangle = ConvexSurfaceMesh2d::from_point_set([
    [-1.0, -1.0].into(),
    [1.0, -1.0].into(),
    [1.0, 1.0].into(),
])?;

let area = triangle.volume();

assert_relative_eq!(area, 2.0);

impl StructuralPartialEq for ConvexSurfaceMesh2d