Struct PNode 

pub struct PNode<T: Copy + PartialEq = bool, U: Unsigned + NumCast + Copy + Debug = u16> { /* private fields */ }

A node of a crate::PixelMap quadtree.

Implementations

impl<T: Copy + PartialEq, U: Unsigned + NumCast + Copy + Debug> PNode<T, U>

pub fn region(&self) -> &Region<U>

Obtain the region represented by this node.

pub fn dirty(&self) -> bool

Determine if this node is in a dirty state. This can be used to represent a modified node that needs to be manipulated in some way (i.e. written to an Image texture).

pub fn clear_dirty(&mut self)

Set the dirty state of this node to false.

pub fn value(&self) -> &T

Obtain this node’s value. Panics if this node is not Self::is_leaf().

pub fn children(&self) -> &Children<T, U>

Obtain an array of the children of this node. Panics if this node is Self::is_leaf().

pub fn is_leaf(&self) -> bool

Determine if this node is a leaf node. Leaves don’t have children.

pub fn is_leaf_parent(&self) -> bool

Determine if all immediate children of this node are leaf nodes.

pub fn node_fill_profile<F>(&self, predicate: F) -> CellFill

where F: FnMut(&PNode<T, U>) -> bool,

Determine how the node is filled (i.e. how child nodes are stored) based on the given predicate closure.

Leaf Nodes

A leaf node will be considered CellFill::Full if the predicate returns true for that node, otherwise CellFill::Empty.

Branch Nodes

A branch node will produce a CellFill that reflects the quadrant(s) that are leaf nodes and pass the predicate. In other words, any quadrants that are not represented by the returned CellFill are either a complex sub-tree of nodes, or do not pass the predicate.

pub fn node_fill_rect(&self, fill: CellFill) -> Option<URect>

If a rectangle can contour the given fill pattern without gaps, return that rectangle representation for this node’s region. Otherwise, return None.

Trait Implementations

impl<T: Clone + Copy + PartialEq, U: Clone + Unsigned + NumCast + Copy + Debug> Clone for PNode<T, U>

fn clone(&self) -> PNode<T, U>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Copy + PartialEq, U: Debug + Unsigned + NumCast + Copy + Debug> Debug for PNode<T, U>

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

Formats the value using the given formatter.

impl<T: PartialEq + Copy + PartialEq, U: PartialEq + Unsigned + NumCast + Copy + Debug> PartialEq for PNode<T, U>

fn eq(&self, other: &PNode<T, U>) -> 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<T: Copy + PartialEq, U: Unsigned + NumCast + Copy + Debug> StructuralPartialEq for PNode<T, U>