Merge pull request #27 from mattatz/develop

Serialization features

Author: mattatz

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "curvo"
-version = "0.1.30"
+version = "0.1.31"
 authors = ["Masatatsu Nakamura <[email protected]"]
 edition = "2021"
 keywords = ["nurbs", "modeling", "graphics", "3d"]

Cargo.toml

@@ -273,3 +273,119 @@ where
         self.spans.reverse();
     }
 }
+
+#[cfg(feature = "serde")]
+impl<T, D: DimName> serde::Serialize for CompoundCurve<T, D>
+where
+    T: FloatingPoint + serde::Serialize,
+    DefaultAllocator: Allocator<D>,
+    <DefaultAllocator as nalgebra::allocator::Allocator<D>>::Buffer<T>: serde::Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        use serde::ser::SerializeStruct;
+        let mut state = serializer.serialize_struct("CompoundCurve", 1)?;
+        state.serialize_field("spans", &self.spans)?;
+        state.end()
+    }
+}
+
+#[cfg(feature = "serde")]
+impl<'de, T, D: DimName> serde::Deserialize<'de> for CompoundCurve<T, D>
+where
+    T: FloatingPoint + serde::Deserialize<'de>,
+    DefaultAllocator: Allocator<D>,
+    <DefaultAllocator as nalgebra::allocator::Allocator<D>>::Buffer<T>: serde::Deserialize<'de>,
+{
+    fn deserialize<S>(deserializer: S) -> Result<Self, S::Error>
+    where
+        S: serde::Deserializer<'de>,
+    {
+        use serde::de::{self, MapAccess, Visitor};
+
+        #[derive(Debug)]
+        enum Field {
+            Spans,
+        }
+
+        impl<'de> serde::Deserialize<'de> for Field {
+            fn deserialize<S>(deserializer: S) -> Result<Self, S::Error>
+            where
+                S: serde::Deserializer<'de>,
+            {
+                struct FieldVisitor;
+
+                impl<'de> Visitor<'de> for FieldVisitor {
+                    type Value = Field;
+
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                        formatter.write_str("`control_points` or `degree` or `knots`")
+                    }
+
+                    fn visit_str<E>(self, value: &str) -> Result<Field, E>
+                    where
+                        E: de::Error,
+                    {
+                        match value {
+                            "spans" => Ok(Field::Spans),
+                            _ => Err(de::Error::unknown_field(value, FIELDS)),
+                        }
+                    }
+                }
+
+                deserializer.deserialize_identifier(FieldVisitor)
+            }
+        }
+
+        struct CompoundCurveVisitor<T, D>(std::marker::PhantomData<(T, D)>);
+
+        impl<T, D> CompoundCurveVisitor<T, D> {
+            pub fn new() -> Self {
+                CompoundCurveVisitor(std::marker::PhantomData)
+            }
+        }
+
+        impl<'de, T, D: DimName> Visitor<'de> for CompoundCurveVisitor<T, D>
+        where
+            T: FloatingPoint + serde::Deserialize<'de>,
+            DefaultAllocator: Allocator<D>,
+            <DefaultAllocator as nalgebra::allocator::Allocator<D>>::Buffer<T>:
+                serde::Deserialize<'de>,
+        {
+            type Value = CompoundCurve<T, D>;
+
+            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                formatter.write_str("struct CompoundCurve")
+            }
+
+            fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
+            where
+                V: MapAccess<'de>,
+            {
+                let mut spans = None;
+                while let Some(key) = map.next_key()? {
+                    match key {
+                        Field::Spans => {
+                            if spans.is_some() {
+                                return Err(de::Error::duplicate_field("spans"));
+                            }
+                            spans = Some(map.next_value()?);
+                        }
+                    }
+                }
+                let spans = spans.ok_or_else(|| de::Error::missing_field("spans"))?;
+
+                Ok(Self::Value { spans })
+            }
+        }
+
+        const FIELDS: &[&str] = &["spans"];
+        deserializer.deserialize_struct(
+            "CompoundCurve",
+            FIELDS,
+            CompoundCurveVisitor::<T, D>::new(),
+        )
+    }
+}

src/region/compound_curve.rs

@@ -10,6 +10,7 @@ use crate::{
 
 /// A closed region bounded by a single exterior curve and zero or more interior curves.
 #[derive(Clone, Debug, PartialEq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Region<T: FloatingPoint> {
     exterior: CompoundCurve<T, Const<3>>,
     interiors: Vec<CompoundCurve<T, Const<3>>>,

src/region/mod.rs

@@ -7,6 +7,9 @@ use nalgebra::{Point3, Vector3};
 #[test]
 #[cfg(feature = "serde")]
 fn test_curve_serialization() {
+    use curvo::prelude::CompoundCurve;
+    use nalgebra::{U3, U4};
+
     let curve =
         NurbsCurve3D::try_circle(&Point3::origin(), &Vector3::x(), &Vector3::y(), 1.).unwrap();
     let json = serde_json::to_string_pretty(&curve).unwrap();
@@ -26,6 +29,14 @@ fn test_curve_serialization() {
     );
     assert_eq!(curve.degree(), der.degree());
     assert_relative_eq!(curve.knots().as_slice(), der.knots().as_slice());
+
+    let compound = CompoundCurve::new(vec![curve.clone()]);
+    let json = serde_json::to_string_pretty(&compound).unwrap();
+    let der: CompoundCurve<f64, U4> = serde_json::from_str(&json).unwrap();
+    compound.spans().iter().enumerate().for_each(|(i, span)| {
+        let o = &der.spans()[i];
+        assert_relative_eq!(span.knots().as_slice(), o.knots().as_slice());
+    });
 }
 
 #[test]