refactor: revert to simpler loss function definition

Author: jolars

crates/eunoia-wasm/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Johan Larsson
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

crates/eunoia-wasm/src/lib.rs

@@ -384,6 +384,9 @@ impl WasmRegion {
 #[wasm_bindgen]
 pub struct WasmRegionPolygons {
     regions: Vec<WasmRegion>,
+    pub loss: f64,
+    target_areas_json: String,
+    fitted_areas_json: String,
 }
 
 #[wasm_bindgen]
@@ -393,6 +396,16 @@ impl WasmRegionPolygons {
         self.regions.clone()
     }
 
+    #[wasm_bindgen(getter)]
+    pub fn target_areas_json(&self) -> String {
+        self.target_areas_json.clone()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn fitted_areas_json(&self) -> String {
+        self.fitted_areas_json.clone()
+    }
+
     #[wasm_bindgen(getter)]
     pub fn count(&self) -> usize {
         self.regions.len()
@@ -1362,8 +1375,25 @@ pub fn generate_region_polygons_circles(
         });
     }
 
+    // Get target and fitted areas, converting Combination keys to strings
+    let target_areas: std::collections::HashMap<String, f64> = layout
+        .requested()
+        .iter()
+        .map(|(k, v)| (k.to_string(), *v))
+        .collect();
+    let fitted_areas: std::collections::HashMap<String, f64> = layout
+        .fitted()
+        .iter()
+        .map(|(k, v)| (k.to_string(), *v))
+        .collect();
+
     Ok(WasmRegionPolygons {
         regions: wasm_regions,
+        loss: layout.loss(),
+        target_areas_json: serde_json::to_string(&target_areas)
+            .map_err(|e| JsValue::from_str(&format!("{}", e)))?,
+        fitted_areas_json: serde_json::to_string(&fitted_areas)
+            .map_err(|e| JsValue::from_str(&format!("{}", e)))?,
     })
 }
 
@@ -1443,7 +1473,24 @@ pub fn generate_region_polygons_ellipses(
         });
     }
 
+    // Get target and fitted areas, converting Combination keys to strings
+    let target_areas: std::collections::HashMap<String, f64> = layout
+        .requested()
+        .iter()
+        .map(|(k, v)| (k.to_string(), *v))
+        .collect();
+    let fitted_areas: std::collections::HashMap<String, f64> = layout
+        .fitted()
+        .iter()
+        .map(|(k, v)| (k.to_string(), *v))
+        .collect();
+
     Ok(WasmRegionPolygons {
         regions: wasm_regions,
+        loss: layout.loss(),
+        target_areas_json: serde_json::to_string(&target_areas)
+            .map_err(|e| JsValue::from_str(&format!("{}", e)))?,
+        fitted_areas_json: serde_json::to_string(&fitted_areas)
+            .map_err(|e| JsValue::from_str(&format!("{}", e)))?,
     })
 }

crates/eunoia/src/fitter/final_layout.rs

@@ -124,10 +124,9 @@ pub(crate) fn optimize_layout<S: DiagramShape + Copy + 'static>(
                 }
             }
 
-            let loss_fn = config.loss_type.create();
             let inner_cost = DiagramCost::<S> {
                 spec,
-                loss_fn,
+                loss_type: config.loss_type,
                 params_per_shape,
                 _shape: std::marker::PhantomData,
             };
@@ -176,10 +175,9 @@ pub(crate) fn optimize_layout<S: DiagramShape + Copy + 'static>(
                 simplex
             };
 
-            let loss_fn = config.loss_type.create();
             let cost_function = DiagramCost::<S> {
                 spec,
-                loss_fn,
+                loss_type: config.loss_type,
                 params_per_shape,
                 _shape: std::marker::PhantomData,
             };
@@ -194,10 +192,9 @@ pub(crate) fn optimize_layout<S: DiagramShape + Copy + 'static>(
         }
         Optimizer::Lbfgs => {
             // L-BFGS with numerical gradients
-            let loss_fn = config.loss_type.create();
             let cost_function_lbfgs = DiagramCost::<S> {
                 spec,
-                loss_fn,
+                loss_type: config.loss_type,
                 params_per_shape,
                 _shape: std::marker::PhantomData,
             };
@@ -217,10 +214,9 @@ pub(crate) fn optimize_layout<S: DiagramShape + Copy + 'static>(
         }
         Optimizer::ConjugateGradient => {
             // Conjugate Gradient with numerical gradients
-            let loss_fn = config.loss_type.create();
             let cost_function_cg = DiagramCost::<S> {
                 spec,
-                loss_fn,
+                loss_type: config.loss_type,
                 params_per_shape,
                 _shape: std::marker::PhantomData,
             };
@@ -249,7 +245,7 @@ pub(crate) fn optimize_layout<S: DiagramShape + Copy + 'static>(
 /// Computes the discrepancy between target exclusive areas and actual fitted areas.
 struct DiagramCost<'a, S: DiagramShape + Copy + 'static> {
     spec: &'a PreprocessedSpec,
-    loss_fn: Box<dyn crate::loss::LossFunction>,
+    loss_type: crate::loss::LossType,
     params_per_shape: usize,
     _shape: std::marker::PhantomData<S>,
 }
@@ -279,10 +275,18 @@ impl<'a, S: DiagramShape + Copy + 'static> CostFunction for DiagramCost<'a, S> {
         // Compute exclusive regions using shape-specific exact computation
         let exclusive_areas = S::compute_exclusive_regions(&shapes);
 
+        // Convert to vectors for loss computation
+        let mut fitted_vec = Vec::new();
+        let mut target_vec = Vec::new();
+
+        for (mask, &target_area) in &self.spec.exclusive_areas {
+            let fitted_area = exclusive_areas.get(mask).copied().unwrap_or(0.0);
+            fitted_vec.push(fitted_area);
+            target_vec.push(target_area);
+        }
+
         // Use the configured loss function
-        let error = self
-            .loss_fn
-            .evaluate(&exclusive_areas, &self.spec.exclusive_areas);
+        let error = self.loss_type.compute(&fitted_vec, &target_vec);
 
         Ok(error)
     }
@@ -455,10 +459,9 @@ mod tests {
 
         let preprocessed = spec.preprocess().unwrap();
 
-        let loss_fn = crate::loss::LossType::sse().create();
         let cost_fn = DiagramCost::<Circle> {
             spec: &preprocessed,
-            loss_fn,
+            loss_type: crate::loss::LossType::sse(),
             params_per_shape: Circle::n_params(),
             _shape: std::marker::PhantomData,
         };