Struct MunsellPoint 

pub struct MunsellPoint {
    pub hue1: String,
    pub hue2: String,
    pub chroma: f64,
    pub value: f64,
    pub is_open_chroma: bool,
}

Represents a point in Munsell color space for polygon definition.

Fields

hue1: String

Starting hue boundary (e.g., “1R”)

hue2: String

Ending hue boundary (e.g., “4R”)

chroma: f64

Chroma coordinate (can be >15 for open-ended regions)

value: f64

Value coordinate (0-10)

is_open_chroma: bool

Whether this represents an open-ended chroma region

Implementations

impl MunsellPoint

pub fn new( hue1: String, hue2: String, chroma: f64, value: f64, is_open_chroma: bool, ) -> Self

Create a new Munsell point for polygon boundary definition.

Arguments

• hue1 - Starting hue boundary (e.g., “1R”)
• hue2 - Ending hue boundary (e.g., “4R”)
• chroma - Chroma coordinate value
• value - Value coordinate (0-10)
• is_open_chroma - Whether this represents an open-ended chroma region

Examples

use munsellspace::MunsellPoint;
 
let point = MunsellPoint::new(
    "5R".to_string(), 
    "10R".to_string(), 
    14.0, 
    6.0, 
    false
);
assert_eq!(point.chroma, 14.0);
assert_eq!(point.value, 6.0);

pub fn parse_chroma(chroma_str: &str) -> (f64, bool)

Parse chroma value from string, handling “>15” open-ended notation.

Arguments

• chroma_str - Chroma value as string (e.g., “12.0” or “>15”)

Returns

Tuple of (chroma_value, is_open_ended)

Examples

use munsellspace::MunsellPoint;
 
let (chroma, open) = MunsellPoint::parse_chroma("12.5");
assert_eq!(chroma, 12.5);
assert!(!open);
 
let (chroma, open) = MunsellPoint::parse_chroma(">15");
assert_eq!(chroma, 15.0);
assert!(open);

Trait Implementations

impl Clone for MunsellPoint

fn clone(&self) -> MunsellPoint

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MunsellPoint

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for MunsellPoint

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for MunsellPoint

fn eq(&self, other: &MunsellPoint) -> 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 MunsellPoint

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MunsellPoint