Fix color export

Author: Yahiewi

jupytercad_freecad/freecad/jcad_converter.py

@@ -1,38 +1,73 @@
 import freecad as fc
+import OfflineRenderingUtils  # type: ignore[import]
 import base64
 import tempfile
-from .loader import FCStd
+# from .loader import FCStd
 import os
 
+from .loader import _hex_to_rgb
+from .props.base_prop import BaseProp
+from . import props as Props
 
-def convert_jcad_to_fcstd(jcad_dict: dict) -> 'fc.Document':
-    # 1) Spin up a brand‑new FreeCAD doc and write it out to a temp .FCStd
-    blank = fc.app.newDocument("__jcad_blank__")
-    blank.recompute()  # ensure it's fully initialized
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".FCStd") as tmp_blank:
-        blank.saveAs(tmp_blank.name)
-        tmp_blank.flush()
-    fc.app.closeDocument(blank.Name)
 
-    # 2) Read its bytes, encode as base64, give to FCStd loader
-    with open(tmp_blank.name, "rb") as f:
-        b64_blank = base64.b64encode(f.read()).decode("utf-8")
-    os.remove(tmp_blank.name)
+def export_jcad_to_fcstd(jcad_dict: dict) -> 'fc.Document':
+    doc = fc.app.newDocument("__jcad_export__")
+    doc.Meta = jcad_dict.get("metadata", {})
+    
+    prop_handlers = {
+        Cls.name(): Cls
+        for Cls in Props.__dict__.values()
+        if isinstance(Cls, type) and issubclass(Cls, BaseProp)
+    }
 
-    fcstd = FCStd()
-    fcstd._sources = b64_blank
+    # LOCAL variable for guidata (no function attribute)
+    guidata = {}
 
-    # 3) Replay your JCAD model into it
-    objs     = jcad_dict.get("objects", [])
-    opts     = jcad_dict.get("options", {})
-    meta     = jcad_dict.get("metadata", {})
-    fcstd.save(objs, opts, meta)
+    for jcad_obj in jcad_dict.get("objects", []):
+        shape_type = jcad_obj["shape"]
+        name = jcad_obj["name"]
+        params = jcad_obj.get("parameters", {})
+        opts = jcad_dict.get("options", {}).get(name, {})
 
-    # 4) Dump the new .FCStd and re‑open it
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".FCStd") as tmp_out:
-        tmp_out.write(base64.b64decode(fcstd.sources))
-        tmp_out.flush()
+        fc_obj = doc.addObject(shape_type, name)
 
-    doc = fc.app.openDocument(tmp_out.name)
-    return doc
+        for prop, jval in params.items():
+            if prop == "Color":
+                continue
+            if hasattr(fc_obj, prop):
+                t = fc_obj.getTypeIdOfProperty(prop)
+                Handler = prop_handlers.get(t)
+                if Handler:
+                    try:
+                        new_val = Handler.jcad_to_fc(
+                            jval,
+                            jcad_object=jcad_obj,
+                            fc_prop=getattr(fc_obj, prop),
+                            fc_object=fc_obj,
+                            fc_file=doc
+                        )
+                        if new_val is not None:
+                            setattr(fc_obj, prop, new_val)
+                    except Exception as e:
+                        print(f"Error setting {prop} on {name}: {e}")
 
+        # Build guidata entry
+        hexcol = params.get("Color") or opts.get("color") or "#808080"
+        rgb = _hex_to_rgb(hexcol)
+        guidata[name] = {
+            "ShapeColor": {"type": "App::PropertyColor", "value": rgb},
+            "Visibility": {"type": "App::PropertyBool", "value": opts.get("visible", True)}
+        }
+
+    doc.recompute()
+
+    with tempfile.NamedTemporaryFile(delete=False, suffix=".FCStd") as tmp:
+        tmp_path = tmp.name
+
+    OfflineRenderingUtils.save(
+        doc,
+        filename=tmp_path,
+        guidata=guidata
+    )
+
+    return fc.app.openDocument(tmp_path)

jupytercad_freecad/freecad/loader.py

@@ -31,7 +31,8 @@ def _rgb_to_hex(rgb):
 def _hex_to_rgb(hex_color):
     """Convert hex color string to an RGB tuple"""
     hex_color = hex_color.lstrip("#")
-    return tuple(int(hex_color[i : i + 2], 16) / 255.0 for i in (0, 2, 4))
+    result = tuple(int(hex_color[i : i + 2], 16) / 255.0 for i in (0, 2, 4))
+    return result
 
 
 def _guidata_to_options(guidata):
@@ -78,7 +79,6 @@ def _options_to_guidata(options):
         if "color" in data:
             rgb_value = _hex_to_rgb(data["color"])
             obj_data["ShapeColor"] = dict(type="App::PropertyColor", value=rgb_value)
-
         # Handle visibility property from JupyterCad to FreeCAD's Visibility
         if "visible" in data:
             obj_data["Visibility"] = dict(
@@ -189,6 +189,10 @@ def save(self, objects: List, options: Dict, metadata: Dict) -> None:
                 fc_obj = fc_file.getObject(py_obj["name"])
 
                 for prop, jcad_prop_value in py_obj["parameters"].items():
+                    # Skip Color property as it's handled separately through guidata
+                    if prop == "Color":
+                        continue
+                        
                     if hasattr(fc_obj, prop):
                         try:
                             prop_type = fc_obj.getTypeIdOfProperty(prop)
@@ -217,7 +221,6 @@ def save(self, objects: List, options: Dict, metadata: Dict) -> None:
                     new_hex_color = py_obj["parameters"]["Color"]
                 else:
                     new_hex_color = "#808080"  # Default to gray if no color is provided
-
                 if obj_name in self._guidata:
                     self._guidata[obj_name]["color"] = new_hex_color
                 else:

jupytercad_freecad/freecad/props/__init__.py

@@ -7,4 +7,4 @@
 from .property_link_list import *  # noqa
 from .property_map import *  # noqa
 from .property_partshape import *  # noqa
-from .property_placement import *  # noqa
+from .property_placement import *  # noqa

jupytercad_freecad/freecad/props/geometry/geom_circle.py

@@ -7,7 +7,7 @@
 with redirect_stdout_stderr():
     try:
         import freecad as fc
-        import Part
+        import Part as Part
     except ImportError:
         fc = None
 

jupytercad_freecad/freecad/props/geometry/geom_linesegment.py

@@ -7,7 +7,7 @@
 with redirect_stdout_stderr():
     try:
         import freecad as fc
-        import Part
+        import Part as Part
     except ImportError:
         fc = None
 

jupytercad_freecad/freecad/props/property_partshape.py

@@ -17,5 +17,28 @@ def fc_to_jcad(prop_value: Any, **kwargs) -> Any:
 
     @staticmethod
     def jcad_to_fc(prop_value: str, **kwargs) -> Any:
-        """PropertyPartShape is readonly"""
-        return None
+        try:
+            import freecad as fc
+            import Part as Part
+        except ImportError:
+            print("Error: FreeCAD or Part module could not be imported in jcad_to_fc.")
+            return None
+
+        if not prop_value:
+            print("Warning: jcad_to_fc received empty prop_value for PartShape.")
+            return None
+
+        try:
+            shape = Part.Shape()
+            # Use importBrepFromString as it's more specific for BREP strings
+            shape.importBrepFromString(prop_value) 
+            
+            if shape.isNull():
+                print(f"Warning: Reconstructed shape is Null after importBrepFromString. Input (first 100 chars): {prop_value[:100]}...")
+                return None # Return None if shape is Null
+
+            return shape
+        except Exception as e:
+            # Log the actual exception and part of the problematic string
+            print(f"Failed to rebuild BRep shape with importBrepFromString: {e}. Input (first 100 chars): {prop_value[:100]}...")
+            return None

jupytercad_freecad/handlers.py

@@ -1,13 +1,15 @@
 import json
 import base64
 from pathlib import Path
+import os
+import shutil
 
 from jupyter_server.base.handlers import APIHandler
 from jupyter_server.utils import url_path_join, ApiPath, to_os_path
 import tornado
 
 from jupytercad_freecad.freecad.loader import FCStd
-from jupytercad_freecad.freecad.jcad_converter import convert_jcad_to_fcstd
+from jupytercad_freecad.freecad.jcad_converter import export_jcad_to_fcstd
 
 class BackendCheckHandler(APIHandler):
     @tornado.web.authenticated
@@ -110,10 +112,17 @@ def post(self):
 
         # convert to FreeCAD document
         try:
-            doc = convert_jcad_to_fcstd(jcad_dict)
-            doc.saveAs(str(out_path))  # write .FCStd
+            doc = export_jcad_to_fcstd(jcad_dict)
+            
+            temp_fcstd_path = doc.FileName 
+            shutil.copy2(temp_fcstd_path, str(out_path))
+            
+            # Clean up the temporary file
+            if os.path.exists(temp_fcstd_path):
+                os.unlink(temp_fcstd_path)
+                
         except Exception as e:
-            self.log.error(f"Conversion to FCStd failed: {e}")
+            self.log.error(f"Error converting to FCStd: {e}")
             self.set_status(500)
             return self.finish(json.dumps({"error": str(e)}))