Enum Field2D

pub enum Field2D<B: Backend> {
    Circle {
        r: Tensor<B, 2, Float>,
        device: B::Device,
    },
    Ellipse {
        a: Tensor<B, 2, Float>,
        b: Tensor<B, 2, Float>,
        device: B::Device,
    },
    Line {
        normal: Tensor<B, 2, Float>,
        device: B::Device,
    },
    Cylinder {
        r: Tensor<B, 2, Float>,
        device: B::Device,
    },
}

Represents a 2D geometric shape that can be converted into a Isosurface.

Variants

Circle

A circle defined by its radius

Fields

r: Tensor<B, 2, Float>

device: B::Device

Ellipse

An ellipse defined by its semi-major and semi-minor axes and center.

Fields

a: Tensor<B, 2, Float>

b: Tensor<B, 2, Float>

device: B::Device

Line

Line in 2D space

Fields

normal: Tensor<B, 2, Float>

device: B::Device

Cylinder

A cylinder in 2D space (infinite circle)

Fields

r: Tensor<B, 2, Float>

device: B::Device

Implementations

impl<B: Backend> Field2D<B>

pub fn circle(r: f32, device: B::Device) -> Self

Allocate a circle ScalarField in the given device’s memory.

pub fn ellipse(a: f32, b: f32, device: B::Device) -> Self

Allocate an ellipse ScalarField in the given device’s memory.

pub fn line(normal: NVector<2>, device: B::Device) -> Self

Allocate a line ScalarField in the given device’s memory.

pub fn cylinder(r: f32, device: B::Device) -> Self

Allocate a cylinder ScalarField in the given device’s memory. This is equivalent to a hypercylinder in 2D space.

Trait Implementations

impl<B: Clone + Backend> Clone for Field2D<B>

where B::Device: Clone,

fn clone(&self) -> Field2D<B>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<B: Debug + Backend> Debug for Field2D<B>

where B::Device: Debug,

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

Formats the value using the given formatter.

impl<B: Backend> IntoIsosurface<2, B> for Field2D<B>

fn into_isosurface(self, constant: f32) -> Isosurface<2, B>

Converts the object into a Isosurface<N, B>.

impl<B: Backend> RayField<2, B> for Field2D<B>

fn solve(&self, rays: Rays<B, 2>, constant: Scalars<B>) -> RayCastResult<B, 2>

Analytically solves for ray intersections with the isosurface at given constants.

impl<B: Backend> ScalarField<2, B> for Field2D<B>

fn evaluate(&self, points: Origins<B, 2>) -> Scalars<B>

Evaluates the scalar field at a collection of points.

fn device(&self) -> &B::Device

Get the device on which the scalar field is allocated.