Struct bvh::aabb::AABB

pub struct AABB {
    pub min: Point3<f32>,
    pub max: Point3<f32>,
}

AABB struct.

Fields

min: Point3<f32>

Minimum coordinates

max: Point3<f32>

Maximum coordinates

Methods

impl AABB

fn with_bounds(min: Point3<f32>, max: Point3<f32>) -> AABB

Creates a new AABB with the given bounds.

Examples

use bvh::aabb::AABB;
use bvh::nalgebra::Point3;

let aabb = AABB::with_bounds(Point3::new(-1.0,-1.0,-1.0), Point3::new(1.0,1.0,1.0));
assert_eq!(aabb.min.x, -1.0);
assert_eq!(aabb.max.z, 1.0);

fn empty() -> AABB

Creates a new empty AABB.

Examples

use bvh::aabb::AABB;

let aabb = AABB::empty();
let min = &aabb.min;
let max = &aabb.max;

// For any point
let x = rand::random();
let y = rand::random();
let z = rand::random();

// An empty AABB should not contain it
assert!(x < min.x && y < min.y && z < min.z);
assert!(max.x < x && max.y < y && max.z < z);

fn contains(&self, p: &Point3<f32>) -> bool

Returns true if the Point3 is inside the AABB.

Examples

use bvh::aabb::AABB;
use bvh::nalgebra::Point3;

let aabb = AABB::with_bounds(Point3::new(-1.0,-1.0,-1.0), Point3::new(1.0,1.0,1.0));
let point_inside = Point3::new(0.125,-0.25,0.5);
let point_outside = Point3::new(1.0,-2.0,4.0);

assert!(aabb.contains(&point_inside));
assert!(!aabb.contains(&point_outside));

fn approx_contains_eps(&self, p: &Point3<f32>, epsilon: f32) -> bool

Returns true if the Point3 is approximately inside the AABB with respect to some epsilon.

Examples

use bvh::EPSILON;
use bvh::aabb::AABB;
use bvh::nalgebra::Point3;

let aabb = AABB::with_bounds(Point3::new(-1.0,-1.0,-1.0), Point3::new(1.0,1.0,1.0));
let point_barely_inside = Point3::new(1.0000001,-1.0000001,1.000000001);
let point_outside = Point3::new(1.0,-2.0,4.0);

assert!(aabb.approx_contains_eps(&point_barely_inside, EPSILON));
assert!(!aabb.approx_contains_eps(&point_outside, EPSILON));

fn join(&self, other: &AABB) -> AABB

Returns a new minimal AABB which contains both this AABB and other. The result is the convex hull of the both AABBs.

Examples

use bvh::aabb::AABB;
use bvh::nalgebra::Point3;

let aabb1 = AABB::with_bounds(Point3::new(-101.0,0.0,0.0), Point3::new(-100.0,1.0,1.0));
let aabb2 = AABB::with_bounds(Point3::new(100.0,0.0,0.0), Point3::new(101.0,1.0,1.0));
let joint = aabb1.join(&aabb2);

let point_inside_aabb1 = Point3::new(-100.5,0.5,0.5);
let point_inside_aabb2 = Point3::new(100.5,0.5,0.5);
let point_inside_joint = Point3::new(0.0,0.5,0.5);


assert!(joint.contains(&point_inside_aabb1));
assert!(joint.contains(&point_inside_aabb2));
assert!(joint.contains(&point_inside_joint));

fn grow(&self, other: &Point3<f32>) -> AABB

Returns a new minimal AABB which contains both this AABB and the Point3 other.

Examples

use bvh::aabb::AABB;
use bvh::nalgebra::Point3;

let point1 = Point3::new(0.0,0.0,0.0);
let point2 = Point3::new(1.0,1.0,1.0);
let point3 = Point3::new(2.0,2.0,2.0);

let aabb = AABB::empty();
assert!(!aabb.contains(&point1));

let aabb1 = aabb.grow(&point1);
assert!(aabb1.contains(&point1));

let aabb2 = aabb.grow(&point2);
assert!(aabb2.contains(&point2));
assert!(!aabb2.contains(&point3));

fn join_bounded<T: Bounded>(&self, other: &T) -> AABB

Returns a new minimal AABB which contains both this AABB and the Bounded other.

Examples

use bvh::aabb::{AABB, Bounded};
use bvh::nalgebra::Point3;

struct Something;

impl Bounded for Something {
    fn aabb(&self) -> AABB {
        let point1 = Point3::new(0.0,0.0,0.0);
        let point2 = Point3::new(1.0,1.0,1.0);
        AABB::with_bounds(point1, point2)
    }
}

let aabb = AABB::empty();
let something = Something;
let aabb1 = aabb.join_bounded(&something);

let center = something.aabb().center();
assert!(aabb1.contains(&center));

fn size(&self) -> Vector3<f32>

Returns the size of this AABB in all three dimensions.

Examples

use bvh::aabb::AABB;
use bvh::nalgebra::Point3;

let aabb = AABB::with_bounds(Point3::new(-1.0,-1.0,-1.0), Point3::new(1.0,1.0,1.0));
let size = aabb.size();
assert!(size.x == 2.0 && size.y == 2.0 && size.z == 2.0);

fn center(&self) -> Point3<f32>

Returns the center Point3 of the AABB.

Examples

use bvh::aabb::AABB;
use bvh::nalgebra::Point3;

let min = Point3::new(41.0,41.0,41.0);
let max = Point3::new(43.0,43.0,43.0);

let aabb = AABB::with_bounds(min, max);
let center = aabb.center();
assert!(center.x == 42.0 && center.y == 42.0 && center.z == 42.0);

fn surface_area(&self) -> f32

Returns the total surface area of this AABB.

Examples

use bvh::aabb::AABB;
use bvh::nalgebra::Point3;

let min = Point3::new(41.0,41.0,41.0);
let max = Point3::new(43.0,43.0,43.0);

let aabb = AABB::with_bounds(min, max);
let surface_area = aabb.surface_area();
assert!(surface_area == 24.0);

fn volume(&self) -> f32

Returns the volume of this AABB.

Examples

use bvh::aabb::AABB;
use bvh::nalgebra::Point3;

let min = Point3::new(41.0,41.0,41.0);
let max = Point3::new(43.0,43.0,43.0);

let aabb = AABB::with_bounds(min, max);
let volume = aabb.volume();
assert!(volume == 8.0);

fn largest_axis(&self) -> usize

Returns the axis along which the AABB is stretched the most.

Examples

use bvh::aabb::{AABB, X_AXIS};
use bvh::nalgebra::Point3;

let min = Point3::new(-100.0,0.0,0.0);
let max = Point3::new(100.0,0.0,0.0);

let aabb = AABB::with_bounds(min, max);
let axis = aabb.largest_axis();
assert!(axis == X_AXIS);

Trait Implementations

impl Debug for AABB

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl Copy for AABB

impl Clone for AABB

fn clone(&self) -> AABB

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Default for AABB

Default instance for AABBs. Returns an AABB which is empty().

fn default() -> AABB

Returns the "default value" for a type.

impl Index<usize> for AABB

Make AABBs indexable. aabb[0] gives a reference to the minimum bound. All other indices return a reference to the maximum bound.

Examples

use bvh::aabb::AABB;
use bvh::nalgebra::Point3;

let min = Point3::new(3.0,4.0,5.0);
let max = Point3::new(123.0,123.0,123.0);

let aabb = AABB::with_bounds(min, max);
assert_eq!(aabb[0], min);
assert_eq!(aabb[1], max);

type Output = Point3<f32>

The returned type after indexing

fn index(&self, index: usize) -> &Point3<f32>

The method for the indexing (Foo[Bar]) operation

impl Bounded for AABB

Implementation of [Bounded] for AABB.

Examples

use bvh::aabb::{AABB, Bounded};
use bvh::nalgebra::Point3;

let point_a = Point3::new(3.0,4.0,5.0);
let point_b = Point3::new(17.0,18.0,19.0);
let aabb = AABB::empty().grow(&point_a).grow(&point_b);

let aabb_aabb = aabb.aabb();

assert_eq!(aabb_aabb.min, aabb.min);
assert_eq!(aabb_aabb.max, aabb.max);

fn aabb(&self) -> AABB

Returns the geometric bounds of this object in the form of an [AABB].