ocp-vscode 1.2.2__tar.gz → 2.0.2__tar.gz

{ocp_vscode-1.2.2 → ocp_vscode-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ocp_vscode
-Version: 1.2.2
+Version: 2.0.2
 Summary: OCP CAD Viewer for VSCode
 Home-page: https://github.com/bernhard-42/vscode-ocp-cad-viewer
 Author: Bernhard Walter
@@ -18,4 +18,4 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.9
 License-File: LICENSE
 
-An extension to show OCP cad CAD objects (CadQuery, build123d) in VS Code via pythreejs
+An extension to show OCP cad CAD objects (CadQuery, build123d) in VS Code via threejs

{ocp_vscode-1.2.2 → ocp_vscode-2.0.2}/README.md

@@ -6,7 +6,7 @@ _OCP CAD Viewer_ for VS Code is an extension to show [CadQuery](https://github.c
 
 ### Prerequisites
 
--   A fairly recent version of Microsoft VS Code, e.g. 1.76.0 or newer
+-   A fairly recent version of Microsoft VS Code, e.g. 1.84.0 or newer
 -   The [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python) installed in VS Code
 -   Necessary tools:
     -   `python` and `pip` available in the Python enviroment that will be used for CAD development
@@ -19,14 +19,9 @@ _OCP CAD Viewer_ for VS Code is an extension to show [CadQuery](https://github.c
 -   For VSCodium, the extension is not available in the VS code market place. You need to download the the vsix file from the [release folder](https://github.com/bernhard-42/vscode-ocp-cad-viewer/releases) and install it manually.
 -   Currently, on a Silicon Mac (ARM CPU), _OCP_ and _CadQuery_ can only be installed via `mamba` and Python 3.9 or 3.10. Prepare an environment with `mamba create -n code_cad python=3.9` or `mamba create -n code_cad python=3.10`.
 
-### Breaking changes from v1.0.0
-
--   IPython and the ipython extensions are not supported any more out of the box. Instead the Microsoft's Jupyter extension with ipykernel is supported. If you have the installation configs in your local VS Code settings.json file, you might want to remove the ipython installation commands.
--   For the color maps, `CM` is replaced by `ColorMap` (to resolve the conflict with build123d `CM`)
-
 ### Installation
 
-1. Open the VS Code Marketplace, and search and install _OCP CAD Viewer 1.2.2_.
+1. Open the VS Code Marketplace, and search and install _OCP CAD Viewer 2.0.2_.
 
     Afterwards the OCP viewer is available in the VS Code sidebar:
 
@@ -176,14 +171,23 @@ You can also use "Library Manager" in the _OCP CAD Viewer_ sidebar to manage the
 
 ## Changes
 
-v1.2.2
+v2.0.2
+
+-   Fix .ocp_vscode detection on Windows
+-   Fix showing ShapeList[Vector]
+-   Viewer now starts when VS Code opens with a build123d/cadquery Python file
+
+v2.0.1
+
+-   Introduce a workspace configuration `initialPort` for OCP CAD Viewer
+-   Change the warning about used port to an auto vanishing info
+
+v2.0.0
 
--   Replace the boolean values for `reset_camera` with the `Camera` enum; `reset_camera` now supports `Camera.RESET` (works like `True` before), `Camera.CENTER` (works like `False` before) and `Camera.KEEP` (additionally keeps the pan location). See best practices for details.
--   Replace the values for `collapse` with the `Collapse` enum: `Collapse.ALL` (was `"C"`), `Collapse.None` (was `"E"`), `Collapse.LEAVES` (was `"1"` or `1`) and `Collapse.Root` (was `"R"`)
--   Added a button to toggle the output panel for OCP CAD Viewer
--   Visual debug is on by default now (workspace setting `WatchByDefault` to `true`)
--   Changed behavior of ` show` during debug session: `show` will be executed, however, visual debug step omitted
--   Do not show Jupyter variables `_`, `__`, `_1`, `_2`, ... in `show_all`
--   Fix an error where the orientation marker was partly or fully moved outside its view due to panning of the object ([vscode-ocp-cad-viewer issue #22](https://github.com/bernhard-42/vscode-ocp-cad-viewer/issues/22))
+-   Introduce **measure mode**. Use `set_defaults(measure_tools=True)` or `show(obj, measure_tools=True)` or the global workspace confiv of OCP CAD Viewer to turn it on. This release added a Python backend process that communicates with the viewer for providing correct BRep measurement info.
+-   **Autostart** viewer: When opening or saving a Python file that includes `import cadquery`, `import build123d`, `from cadquery import` or `from build123d import`, the viewer gets started if it is not already running. Use `OcpCadViewer.autostart` configuration of workspace config to turn this feature off.
+-   **Environment variable OCP_PORT** is supported. It will be used by the viewer and the `show*` clients as the port for OCP CAD Viewer. This variable can be set on the command line or in `launch.json` (`"env": {"OCP_PORT": "3999"}`).
+-   **Modifier keys can now be remapped** `key={"shift": "shiftKey", "ctrl": "ctrlKey", "meta": "metaKey"}`. Valid keys are `shift`, `ctrl` and `meta`. Valid values are `shiftKey`, `ctrlKey`, `metaKey` (command on Mac and Windows on Windows) and `altKey` (option on Mac and Alt on Windows).
+-   `CAMERA.KEEP` and `CAMERA.CENTER` now **persist the viewer across execution sessions**. If you want to reset at every beginning, use `show(objs, reset_camer=Camera.RESET)` as the first show command.
 
 full change log see [Changes.md](./Changes.md)

{ocp_vscode-1.2.2 → ocp_vscode-2.0.2}/ocp_vscode/__init__.py

@@ -13,10 +13,33 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+__version__ = "2.0.0"
 
+import json
 from .show import *
 from .config import *
 from .comms import *
 
 from .colors import *
 from .animation import Animation
+
+from pathlib import Path
+from os import environ
+
+try:
+    port = int(environ.get("OCP_PORT", "0"))
+    if port > 0:
+        set_port(port)
+    else:
+        current_path = Path.cwd()
+        for path in current_path.parents:
+            file_path = path / ".ocp_vscode"
+            if file_path.exists():
+                with open(file_path, "r") as f:
+                    port = json.load(f)["port"]
+                    set_port(port)
+                    break
+except:
+    pass
+
+del environ

ocp_vscode-2.0.2/ocp_vscode/backend.py

@@ -0,0 +1,410 @@
+from dataclasses import dataclass, asdict, fields
+import argparse
+import sys
+import traceback
+import base64
+from ocp_vscode.comms import listener, MessageType, send_response
+from build123d import (
+    Axis,
+    CenterOf,
+    GeomType,
+    Location,
+    Plane,
+    Vector,
+    Vertex,
+    Edge,
+    Face,
+    Solid,
+    Shape,
+    Compound,
+    Location,
+)
+from build123d.topology import downcast
+from ocp_tessellate.tessellator import (
+    face_mapper,
+    edge_mapper,
+    vertex_mapper,
+    get_faces,
+    get_edges,
+    get_vertices,
+)
+from ocp_tessellate.ocp_utils import make_compound, deserialize, tq_to_loc
+from ocp_tessellate.trace import Trace, dump_face, dump_edge, dump_vertex
+
+
+class SelectedCenterInfo:
+    """
+    Stores the information message about what as been used as center for the measurement
+    """
+
+    vertex = "Reference point has been taken as vertex location"
+    circular = "Reference point has been taken as the center of the circle or ellipse"
+    geom = "Reference point has been taken as the center of the geometry"
+    cylinder = "Reference point has been taken as the center of the cylinder"
+
+
+def print_to_stdout(*msg):
+    """
+    Write the given message to the stdout
+    """
+    print(*msg, flush=True, file=sys.stdout)
+
+
+def error_handler(func):
+    def wrapper(*args, **kwargs):
+        try:
+            func(*args, **kwargs)
+        except Exception as ex:
+            print_to_stdout(ex)
+            traceback.print_exception(*sys.exc_info(), file=sys.stdout)
+
+    return wrapper
+
+
+@dataclass
+class Tool:
+    Distance = "DistanceMeasurement"
+    Properties = "PropertiesMeasurement"
+    Angle = "AngleMeasurement"
+
+
+def set_precision(instance, decimals=2):
+    """
+    Set the precision of all float fields of the dataclass to the given number of decimals
+    """
+    for field in fields(instance):
+        if field.type == float:
+            value = getattr(instance, field.name)
+            if value is not None:
+                setattr(instance, field.name, round(value, decimals))
+        elif isinstance(getattr(instance, field.name), tuple):
+            # Handle tuple fields
+            old_tuple = getattr(instance, field.name)
+            new_tuple = tuple(
+                round(elem, decimals) if isinstance(elem, float) else elem
+                for elem in old_tuple
+            )
+            setattr(instance, field.name, new_tuple)
+
+
+@dataclass
+class Response:
+    type: str = "backend_response"
+
+
+@dataclass
+class MeasureReponse(Response):
+    center_info: str = ""  # a string telling the frontend how the reference points used for the measurement were chosen
+    subtype: str = "tool_response"
+
+
+@dataclass
+class DistanceResponse(MeasureReponse):
+    tool_type: Tool = Tool.Distance
+    point1: tuple = None
+    point2: tuple = None
+    distance: float = None
+
+
+@dataclass
+class PropertiesResponse(MeasureReponse):
+    tool_type: Tool = Tool.Properties
+    center: tuple = None
+    vertex_coords: tuple = None
+    length: float = None
+    width: float = None
+    area: float = None
+    volume: float = None
+    radius: float = None
+    geom_type: str = None
+
+
+@dataclass
+class AngleResponse(MeasureReponse):
+    tool_type: Tool = Tool.Angle
+    angle: float = None
+    point1: tuple = None
+    point2: tuple = None
+
+
+class ViewerBackend:
+    """
+    Represents the backend of the viewer, it listens to the websocket and handles the events
+    It's job is to send responses to the vscode extension that goes through the three cad viewer view.
+    The reponses holds all the data needed to display the measurements.
+    """
+
+    def __init__(self, port: int) -> None:
+        self.port = port
+        self.model = None
+        self.activated_tool = None
+        self.filter_type = "none"  # The current active selection filter
+
+    def start(self):
+        """
+        Start the backend
+        """
+        print("Viewer backend started")
+        listener(self.handle_event)()
+
+    @error_handler
+    def handle_event(self, message, event_type: MessageType):
+        """
+        Handle the event received from the websocket
+        Dispatch the event to the appropriate handler
+        """
+        if event_type == MessageType.data:
+            self.load_model(message)
+        elif event_type == MessageType.updates:
+            changes = message
+
+            if "activeTool" in changes:
+                active_tool = changes.get("activeTool")
+
+                if active_tool != "None":
+                    self.activated_tool = active_tool
+                else:
+                    self.activated_tool = None
+
+            if self.activated_tool is not None:
+                self.handle_activated_tool(changes)
+
+    def handle_activated_tool(self, changes):
+        """
+        Handle the activated tool, there is a special behavior for each tool
+        """
+        if not "selectedShapeIDs" in changes:
+            return
+
+        selectedObjs = changes["selectedShapeIDs"]
+        if self.activated_tool == Tool.Distance and len(selectedObjs) == 2:
+            shape_id1 = changes["selectedShapeIDs"][0]
+            shape_id2 = changes["selectedShapeIDs"][1]
+            self.handle_distance(shape_id1, shape_id2)
+
+        elif self.activated_tool == Tool.Properties and len(selectedObjs) == 1:
+            shape_id = changes["selectedShapeIDs"][0]
+            self.handle_properties(shape_id)
+
+        elif self.activated_tool == Tool.Angle and len(selectedObjs) == 2:
+            shape_id1 = changes["selectedShapeIDs"][0]
+            shape_id2 = changes["selectedShapeIDs"][1]
+            self.handle_angle(shape_id1, shape_id2)
+
+    def load_model(self, raw_model):
+        """Read the transfered model from websocket"""
+
+        def walk(model, trace):
+            for v in model["parts"]:
+                if v.get("parts") is not None:
+                    walk(v, trace)
+                else:
+                    id = v["id"]
+                    loc = (
+                        Location().wrapped if v["loc"] is None else tq_to_loc(*v["loc"])
+                    )
+                    shape = [
+                        deserialize(base64.b64decode(s.encode("utf-8")))
+                        for s in v["shape"]
+                    ]
+                    compound = make_compound(shape) if len(shape) > 1 else shape[0]
+                    self.model[id] = Compound(compound.Moved(loc))
+                    faces = get_faces(compound)
+                    for i, face in enumerate(faces):
+                        trace.face(f"{id}/faces/faces_{i}", face)
+
+                        self.model[f"{id}/faces/faces_{i}"] = Face(face.Moved(loc))
+                    edges = get_edges(compound)
+                    for i, edge in enumerate(edges):
+                        trace.edge(f"{id}/edges/edges_{i}", edge)
+
+                        self.model[f"{id}/edges/edges_{i}"] = (
+                            Edge(edge) if loc is None else Edge(edge.Moved(loc))
+                        )
+                    vertices = get_vertices(compound)
+                    for i, vertex in enumerate(vertices):
+                        trace.vertex(f"{id}/vertices/vertex{i}", vertex)
+
+                        self.model[f"{id}/vertices/vertices{i}"] = (
+                            Vertex(vertex)
+                            if loc is None
+                            else Vertex(downcast(vertex.Moved(loc)))
+                        )
+
+        self.model = {}
+        trace = Trace("ocp-vscode-backend.log")
+        walk(raw_model, trace)
+        trace.close()
+
+    def handle_properties(self, shape_id):
+        """
+        Request the properties of the object with the given id
+        """
+        print_to_stdout(f"Identifier received '{shape_id}'")
+
+        shape = self.model[shape_id]
+
+        response = PropertiesResponse()
+
+        if isinstance(shape, Vertex):
+            response.vertex_coords = shape.to_tuple()
+
+        elif isinstance(shape, Edge):
+            response.radius = shape.radius if shape.geom_type() in ["CIRCLE"] else None
+            response.length = shape.length
+
+        elif isinstance(shape, Face):
+            if shape.geom_type() == "CYLINDER":
+                circle = shape.edges().filter_by(GeomType.CIRCLE).first
+                response.radius = circle.radius
+
+            response.length = shape.length
+            response.width = shape.width
+            response.area = shape.area
+
+        elif isinstance(shape, (Solid, Compound)):
+            response.volume = shape.volume
+
+        geom_type = shape.geom_type().capitalize()
+        response.geom_type = geom_type if geom_type != "Vertex" else None
+        center, info = self.get_center(shape, False)
+        response.center = center.to_tuple()
+        response.vertex_coords = response.center
+        response.center_info = f"{shape_id} : {info}"
+
+        set_precision(response)
+
+        send_response(asdict(response), self.port)
+        print_to_stdout(f"Data sent {response}")
+
+    def handle_angle(self, id1, id2):
+        """
+        Request the angle between the two objects that have the given ids
+        """
+        print_to_stdout(f"Identifiers received '{id1}', '{id2}'")
+
+        shape1: Shape = self.model[id1]
+        shape2: Shape = self.model[id2]
+        first = (
+            Plane(shape1)
+            if isinstance(shape1, Face)
+            else Plane(shape1 @ 0, z_dir=shape1.normal())
+            if isinstance(shape1, Edge) and shape1.geom_type() in ["CIRCLE", "ELLIPSE"]
+            else shape1 % 0
+        )
+        second = (
+            Plane(shape2)
+            if isinstance(shape2, Face)
+            else Plane(shape2 @ 0, z_dir=shape2.normal())
+            if isinstance(shape2, Edge) and shape2.geom_type() in ["CIRCLE", "ELLIPSE"]
+            else shape2 % 0
+        )
+        if type(first) == type(second) == Plane:
+            angle = first.z_dir.get_angle(second.z_dir)
+        elif type(first) == type(second) == Vector:
+            angle = first.get_angle(second)
+        else:
+            vector = first if isinstance(first, Vector) else second
+            plane = first if isinstance(first, Plane) else second
+
+            angle = 90 - plane.z_dir.get_angle(vector)
+        angle = abs(angle)
+        point1, info1 = self.get_center(shape1, True)
+        point2, info2 = self.get_center(shape2, True)
+        center_info = f"{id1} : {info1}\n{id2} : {info2}"
+        response = AngleResponse(
+            center_info=center_info,
+            angle=angle,
+            point1=point1.to_tuple(),
+            point2=point2.to_tuple(),
+        )
+        set_precision(response)
+        send_response(asdict(response), self.port)
+        print_to_stdout(f"Data sent {response}")
+
+    def get_center(
+        self, shape: Shape, for_distance=True
+    ) -> tuple[Vector, SelectedCenterInfo]:
+        """
+        Returns the center vector of the given shape
+        Center of the shape depends on the type of the shape and the tool used
+        For instance, circle edge center will be on the edge for properties tool
+        but at the center of the circle for distance tool
+        """
+        if isinstance(shape, Vertex):
+            return shape.center(), SelectedCenterInfo.vertex
+        elif isinstance(shape, Edge):
+            if shape.geom_type() in [
+                GeomType.CIRCLE,
+                GeomType.ELLIPSE,
+                "CIRCLE",
+                "ELLIPSE",
+            ]:
+                if for_distance:
+                    return shape.arc_center, SelectedCenterInfo.circular
+                else:
+                    return shape.center(), SelectedCenterInfo.geom
+
+        elif isinstance(shape, Face):
+            if shape.geom_type() in [GeomType.CYLINDER, "CYLINDER"]:
+                if not for_distance:
+                    return shape.center(), SelectedCenterInfo.geom
+
+                extremity_edges = shape.edges().filter_by(GeomType.CIRCLE)
+                if len(extremity_edges) == 2:
+                    return (
+                        extremity_edges.first.arc_center
+                        - (
+                            extremity_edges.first.arc_center
+                            - extremity_edges.last.arc_center
+                        )
+                        / 2,
+                        SelectedCenterInfo.cylinder,
+                    )
+                else:
+                    try:
+                        return (
+                            extremity_edges.first.arc_center,
+                            SelectedCenterInfo.cylinder,
+                        )
+                    except IndexError:
+                        # cylinder might have bspline extremity edges hence the list would be empty
+                        # in that case we default to geom center
+                        pass
+
+        return shape.center(), SelectedCenterInfo.geom
+
+    def handle_distance(self, id1, id2):
+        """
+        Request the distance between the two objects that have the given ids
+        """
+        print_to_stdout(f"Identifiers received '{id1}', '{id2}'")
+
+        shape1: Shape = self.model[id1]
+        shape2: Shape = self.model[id2]
+        p1, info1 = self.get_center(shape1)
+        p2, info2 = self.get_center(shape2)
+        center_info = f"{id1} : {info1}\n{id2} : {info2}"
+        dist = (p2 - p1).length
+        response = DistanceResponse(
+            center_info=center_info,
+            point1=p1.to_tuple(),
+            point2=p2.to_tuple(),
+            distance=dist,
+        )
+        set_precision(response)
+        send_response(asdict(response), self.port)
+        print_to_stdout(f"Data sent {response}")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser("OCP Viewer Backend")
+    parser.add_argument(
+        "--port", type=int, required=True, help="Port the viewer listens to"
+    )
+    args = parser.parse_args()
+    backend = ViewerBackend(args.port)
+    try:
+        backend.start()
+    except Exception as ex:
+        print(ex)

{ocp_vscode-1.2.2 → ocp_vscode-2.0.2}/ocp_vscode/comms.py

@@ -1,7 +1,14 @@
+import base64
 import enum
 from websockets.sync.client import connect
 import orjson as json
 from ocp_tessellate.utils import Timer
+from ocp_tessellate.ocp_utils import (
+    is_topods_shape,
+    is_toploc_location,
+    serialize,
+    loc_to_tq,
+)
 
 CMD_URL = "ws://127.0.0.1"
 CMD_PORT = 3939
@@ -16,9 +23,28 @@ class MessageType(enum.IntEnum):
     command = 2
     updates = 3
     listen = 4
+    backend = 5
+    backend_response = 6
+    config = 7
 
 
-__all__ = ["send_data", "send_command", "set_port", "get_port", "listener"]
+__all__ = [
+    "send_data",
+    "send_command",
+    "send_response",
+    "set_port",
+    "get_port",
+    "listener",
+]
+
+
+def default(obj):
+    if is_topods_shape(obj):
+        return base64.b64encode(serialize(obj)).decode("utf-8")
+    elif is_toploc_location(obj):
+        return loc_to_tq(obj)
+    else:
+        raise TypeError(f"Object of type {type(obj)} is not JSON serializable")
 
 
 def get_port():
@@ -35,13 +61,21 @@ def _send(data, message_type, port=None, timeit=False):
         port = CMD_PORT
     try:
         with Timer(timeit, "", "json dumps", 1):
-            j = json.dumps(data)
+            j = json.dumps(data, default=default)
             if message_type == MessageType.command:
                 j = b"C:" + j
             elif message_type == MessageType.data:
                 j = b"D:" + j
-
-        with Timer(timeit, "", "websocket send", 1):
+            elif message_type == MessageType.listen:
+                j = b"L:" + j
+            elif message_type == MessageType.backend:
+                j = b"B:" + j
+            elif message_type == MessageType.backend_response:
+                j = b"R:" + j
+            elif message_type == MessageType.config:
+                j = b"S:" + j
+
+        with Timer(timeit, "", f"websocket send {len(j)/1024/1024:.3f} MB", 1):
             ws = connect(f"{CMD_URL}:{port}")
             ws.send(j)
 
@@ -68,10 +102,22 @@ def send_data(data, port=None, timeit=False):
     return _send(data, MessageType.data, port, timeit)
 
 
+def send_config(config, port=None, timeit=False):
+    return _send(config, MessageType.config, port, timeit)
+
+
 def send_command(data, port=None, timeit=False):
     return _send(data, MessageType.command, port, timeit)
 
 
+def send_backend(data, port=None, timeit=False):
+    return _send(data, MessageType.backend, port, timeit)
+
+
+def send_response(data, port=None, timeit=False):
+    return _send(data, MessageType.backend_response, port, timeit)
+
+
 #
 # Receive data from the viewer
 #
@@ -84,7 +130,7 @@ def send_command(data, port=None, timeit=False):
 def listener(callback):
     def _listen():
         LAST_CONFIG = {}
-        with connect(f"{CMD_URL}:{CMD_PORT}") as websocket:
+        with connect(f"{CMD_URL}:{CMD_PORT}", max_size=2**28) as websocket:
             websocket.send(b"L:register")
             while True:
                 try:
@@ -93,6 +139,9 @@ def listener(callback):
                         continue
 
                     message = json.loads(message)
+                    if "model" in message.keys():
+                        callback(message["model"], MessageType.data)
+
                     if message.get("command") == "status":
                         changes = message["text"]
                         new_changes = {}

{ocp_vscode-1.2.2 → ocp_vscode-2.0.2}/ocp_vscode/config.py

@@ -16,7 +16,7 @@
 
 from enum import Enum
 
-from .comms import send_command, send_data, get_port
+from .comms import send_command, send_config, get_port
 
 __all__ = [
     "workspace_config",
@@ -65,6 +65,7 @@ CONFIG_WORKSPACE_KEYS = CONFIG_UI_KEYS + [
     "collapse",
     "dark",
     "glass",
+    "measure_tools",
     "orbit_control",
     "ticks",
     "tools",
@@ -87,6 +88,8 @@ CONFIG_WORKSPACE_KEYS = CONFIG_UI_KEYS + [
     "default_vertexcolor",
     "default_opacity",
     "deviation",
+    "measure_tools",
+    "modifier_keys",
 ]
 
 CONFIG_CONTROL_KEYS = [
@@ -175,7 +178,7 @@ def set_viewer_config(
         "type": "ui",
         "config": config,
     }
-    send_data(data)
+    send_config(data)
 
 
 def get_default(key):
@@ -189,6 +192,7 @@ def get_defaults():
 def set_defaults(
     glass=None,
     tools=None,
+    measure_tools=None,
     tree_width=None,
     axes=None,
     axes0=None,
@@ -230,6 +234,7 @@ def set_defaults(
     - UI
         glass:             Use glass mode where tree is an overlay over the cad object (default=False)
         tools:             Show tools (default=True)
+        measure_tools:     Show measure tools (default=False)
         tree_width:        Width of the object tree (default=240)
 
     - Viewer
@@ -368,6 +373,7 @@ def combined_config(port=None, use_status=True):
         wspace_config["ortho"] = False
         wspace_config["transparent"] = False
         wspace_config["black_edges"] = False
+        wspace_config["measure_tools"] = False
 
     wspace_config.update(DEFAULTS)
     if use_status:

ocp_vscode-2.0.2/ocp_vscode/interactive.py

@@ -0,0 +1,9 @@
+# In this module I want to make a function that will be responsible 
+#for holding references to the original shapes and the converted ones 
+#as well as listening to commands from the viewer and sending back data 
+#depending on what the command
+
+from threading import Thread
+
+def start_interactive_session(python_objs, tcv_objs):
+    

ocp_vscode-2.0.2/ocp_vscode/persistence.py

@@ -0,0 +1,123 @@
+from OCP.BinTools import BinTools
+from OCP.TopoDS import (
+    TopoDS_Shape,
+    TopoDS_Compound,
+    TopoDS_CompSolid,
+    TopoDS_Solid,
+    TopoDS_Shell,
+    TopoDS_Face,
+    TopoDS_Wire,
+    TopoDS_Edge,
+    TopoDS_Vertex,
+)
+from OCP.TopLoc import TopLoc_Location
+from OCP.gp import gp_Trsf, gp_Quaternion, gp_Vec
+import io
+import copyreg
+from build123d.topology import downcast
+import struct
+
+
+def serialize_shape(shape: TopoDS_Shape):
+    """
+    Serialize a OCP shape, this method can be used to provide a custom serialization algo for pickle
+    """
+    if shape is None:
+        return None
+
+    bio = io.BytesIO()
+    BinTools.Write_s(shape, bio)
+    buffer = bio.getvalue()
+    return buffer
+
+
+def deserialize_shape(buffer: bytes):
+    """
+    This does the opposite as serialize, it construct a TopoDS_Shape from bytes.
+    """
+    if buffer is None:
+        return None
+
+    shape = TopoDS_Shape()
+    bio = io.BytesIO(buffer)
+    BinTools.Read_s(shape, bio)
+    return downcast(shape)
+
+
+def serialize_location(location: TopLoc_Location):
+    """
+    Serialize a OCP location, this method can be used to provide a custom serialization algo for pickle
+    """
+    if location is None:
+        return None
+    transfo = location.Transformation()
+    translation = transfo.TranslationPart()
+    rotation = transfo.GetRotation()
+    # convert floats in bytes
+    translation_bytes = bytearray()
+    for i in range(1, 4):
+        translation_bytes.extend(struct.pack("f", translation.Coord(i)))
+    rotation_bytes = bytearray()
+    rotation_bytes.extend(struct.pack("f", rotation.X()))
+    rotation_bytes.extend(struct.pack("f", rotation.Y()))
+    rotation_bytes.extend(struct.pack("f", rotation.Z()))
+    rotation_bytes.extend(struct.pack("f", rotation.W()))
+
+    buffer = bytearray()
+    buffer.extend(translation_bytes)
+    buffer.extend(rotation_bytes)
+    return buffer
+
+
+def deserialize_location(buffer: bytes):
+    """
+    This does the opposite as serialize, it construct a TopLoc_Location from bytes.
+    """
+    if buffer is None:
+        return None
+
+    # Makes 4 bytes chunks (floats are 4 bytes long)
+    chunks = iter(struct.iter_unpack("f", buffer))
+    translation = gp_Vec(
+        next(chunks)[0],
+        next(chunks)[0],
+        next(chunks)[0],
+    )
+
+    # Read the rotation bytes
+    rotation = gp_Quaternion(
+        next(chunks)[0],
+        next(chunks)[0],
+        next(chunks)[0],
+        next(chunks)[0],
+    )
+
+    # Create the TopLoc_Location object
+    transfo = gp_Trsf()
+    transfo.SetTransformation(rotation, translation)
+
+    return TopLoc_Location(transfo)
+
+
+def reduce_shape(shape: TopoDS_Shape):
+    """Special function used by pickle to serialize or deserialize OCP Shapes objects"""
+    return (deserialize_shape, (serialize_shape(shape),))
+
+
+def reduce_location(location: TopLoc_Location):
+    """Special function used by pickle to serialize or deserialize OCP Location objects"""
+    return (deserialize_location, (serialize_location(location),))
+
+
+def modify_copyreg():
+    """Modify the copyreg so that pickle knows what to look for when it tries to pickle an OCP Shape"""
+    copyreg.pickle(TopoDS_Shape, reduce_shape)
+    copyreg.pickle(TopoDS_Compound, reduce_shape)
+    copyreg.pickle(TopoDS_CompSolid, reduce_shape)
+    copyreg.pickle(TopoDS_Solid, reduce_shape)
+    copyreg.pickle(TopoDS_Shell, reduce_shape)
+    copyreg.pickle(TopoDS_Face, reduce_shape)
+    copyreg.pickle(TopoDS_Wire, reduce_shape)
+    copyreg.pickle(TopoDS_Edge, reduce_shape)
+    copyreg.pickle(TopoDS_Vertex, reduce_shape)
+    copyreg.pickle(TopLoc_Location, reduce_location)

{ocp_vscode-1.2.2 → ocp_vscode-2.0.2}/ocp_vscode/show.py

@@ -14,7 +14,7 @@
 # limitations under the License.
 #
 import re
-import sys
+
 from ocp_tessellate import PartGroup
 from ocp_tessellate.convert import (
     tessellate_group,
@@ -23,6 +23,7 @@ from ocp_tessellate.convert import (
     to_assembly,
     mp_get_results,
     is_topods_shape,
+    is_cadquery,
     is_vector,
 )
 from ocp_tessellate.utils import numpy_to_buffer_json, Timer, Color
@@ -34,7 +35,6 @@ from ocp_tessellate.ocp_utils import (
     is_cadquery_assembly,
     is_cadquery_sketch,
     is_build123d,
-    is_build123d_assembly,
     is_toploc_location,
 )
 
@@ -46,7 +46,7 @@ from ocp_tessellate.cad_objects import (
     OCP_Part,
     OCP_Vertices,
 )
-from ocp_tessellate.convert import to_assembly, conv
+from ocp_tessellate.convert import to_assembly
 import ocp_tessellate.convert as oc
 
 from .config import (
@@ -55,38 +55,35 @@ from .config import (
     workspace_config,
     combined_config,
     get_default,
-    status,
-    set_viewer_config,
     Camera,
     Collapse,
     check_deprecated,
 )
-from .comms import send_data, MessageType
+from .comms import send_backend, send_data
 from .colors import *
 
+from .persistence import modify_copyreg
+
 __all__ = ["show", "show_object", "reset_show", "show_all", "show_clear"]
 
 OBJECTS = {"objs": [], "names": [], "colors": [], "alphas": []}
 
-FIRST_CALL = True
 LAST_CALL = "other"
 
+modify_copyreg()
+
 
 def _tessellate(
     *cad_objs, names=None, colors=None, alphas=None, progress=None, **kwargs
 ):
-    global FIRST_CALL
-
     if workspace_config().get("_splash"):
         conf = combined_config(use_status=False)
+        reset_camera = Camera.RESET
     else:
         conf = combined_config(use_status=True)
-        if FIRST_CALL:
-            conf["reset_camera"] = Camera.RESET.value
-            FIRST_CALL = False
-        else:
-            reset_camera = conf.get("reset_camera", Camera.RESET)
-            conf["reset_camera"] = reset_camera.value
+        reset_camera = conf.get("reset_camera", Camera.RESET)
+
+    conf["reset_camera"] = reset_camera.value
 
     collapse = conf.get("collapse", Collapse.LEAVES)
     conf["collapse"] = collapse.value
@@ -171,6 +168,8 @@ def _tessellate(
             print(f"Setting {k} can only be set in VSCode config")
 
         elif v is not None:
+            if k == "reset_camera" and params.get("_splash") == True:
+                continue
             params[k] = v
 
     parallel = preset("parallel", params.get("parallel"))
@@ -189,7 +188,7 @@ def _tessellate(
             init_pool()
             keymap.reset()
 
-        instances, shapes, states = tessellate_group(
+        instances, shapes, states, mapping = tessellate_group(
             part_group, params, progress, params.get("timeit")
         )
 
@@ -208,16 +207,24 @@ def _tessellate(
 
     # add global bounding box
     shapes["bb"] = bb
-    return instances, shapes, states, params, part_group.count_shapes()
 
+    return instances, shapes, states, params, part_group.count_shapes(), mapping
 
-def _convert(*cad_objs, names=None, colors=None, alphas=None, progress=None, **kwargs):
+
+def _convert(
+    *cad_objs,
+    names=None,
+    colors=None,
+    alphas=None,
+    progress=None,
+    **kwargs,
+):
     timeit = preset("timeit", kwargs.get("timeit"))
 
     if progress is None:
         progress = Progress([c for c in "-+c"])
 
-    instances, shapes, states, config, count_shapes = _tessellate(
+    instances, shapes, states, config, count_shapes, mapping = _tessellate(
         *cad_objs,
         names=names,
         colors=colors,
@@ -225,6 +232,7 @@ def _convert(*cad_objs, names=None, colors=None, alphas=None, progress=None, **k
         progress=progress,
         **kwargs,
     )
+
     if config.get("dark") is not None:
         config["theme"] = "dark"
     elif config.get("orbit_control") is not None:
@@ -237,16 +245,14 @@ def _convert(*cad_objs, names=None, colors=None, alphas=None, progress=None, **k
         config["explode"] = kwargs["explode"]
 
     with Timer(timeit, "", "create data obj", 1):
-        data = {
+        return {
             "data": numpy_to_buffer_json(
                 dict(instances=instances, shapes=shapes, states=states)
             ),
             "type": "data",
             "config": config,
             "count": count_shapes,
-        }
-
-    return data
+        }, mapping
 
 
 class Progress:
@@ -265,7 +271,7 @@ def align_attrs(attr_list, length, default, tag, explode=True):
     if attr_list is None:
         return [None] * length if explode else None
     elif len(attr_list) < length:
-        print(f"Too view {tag}, using defaults to fill")
+        print(f"Too few {tag}, using defaults to fill")
         return list(attr_list) + [default] * (length - len(attr_list))
     elif len(attr_list) > length:
         print(f"Too many {tag}, trimming to length {length}")
@@ -283,6 +289,7 @@ def show(
     progress="-+c",
     glass=None,
     tools=None,
+    measure_tools=None,
     tree_width=None,
     axes=None,
     axes0=None,
@@ -343,6 +350,7 @@ def show(
     Valid keywords to configure the viewer (**kwargs):
     - UI
         glass:                   Use glass mode where tree is an overlay over the cad object (default=False)
+        measure_tools:           Show measure tools (default=False)
         tools:                   Show tools (default=True)
         tree_width:              Width of the object tree (default=240)
 
@@ -398,7 +406,7 @@ def show(
         render_joints:           Render build123d joints (default=False)
         parallel:                Tessellate objects in parallel (default=False)
         show_parent:             Render parent of faces, edges or vertices as wireframe
-        helper_scale:              Scale of rendered helpers (locations, axis, mates for MAssemblies) (default=1)
+        helper_scale:            Scale of rendered helpers (locations, axis, mates for MAssemblies) (default=1)
 
     - Debug
         debug:                   Show debug statements to the VS Code browser console (default=False)
@@ -406,10 +414,6 @@ def show(
     """
     global LAST_CALL
 
-    # if sys.gettrace() is not None and not _force_in_debug:
-    #     print("\nshow and show_object are ignored in debugging sessions\n")
-    #     return
-
     kwargs = {
         k: v
         for k, v in locals().items()
@@ -430,7 +434,17 @@ def show(
 
     timeit = preset("timeit", timeit)
 
-    names = align_attrs(names, len(cad_objs), None, "names", explode=False)
+    if measure_tools is None:
+        measure_tools = get_default("measure_tools")
+        if measure_tools is None:
+            conf = workspace_config()
+            measure_tools = conf["measure_tools"]
+    kwargs["measure_tools"] = measure_tools
+
+    if measure_tools and kwargs.get("collapse") is None:
+        kwargs["collapse"] = Collapse.ROOT
+
+    names = align_attrs(names, len(cad_objs), None, "names", explode=measure_tools)
 
     # Handle colormaps
 
@@ -464,7 +478,7 @@ def show(
     progress = Progress([] if progress is None else [c for c in progress])
 
     with Timer(timeit, "", "overall"):
-        data = _convert(
+        t, mapping = _convert(
             *cad_objs,
             names=names,
             colors=colors,
@@ -473,13 +487,16 @@ def show(
             **kwargs,
         )
 
-    if not _force_in_debug:
-        LAST_CALL = "show"
-    else:
-        LAST_CALL = "other"
+        if not _force_in_debug:
+            LAST_CALL = "show"
+        else:
+            LAST_CALL = "other"
 
     with Timer(timeit, "", "send"):
-        return send_data(data, port=port, timeit=timeit)
+        send_data(t, port=port, timeit=timeit)
+
+    if measure_tools:
+        send_backend({"model": mapping}, port=port, timeit=timeit)
 
 
 def reset_show():
@@ -498,6 +515,7 @@ def show_object(
     progress="-+c",
     glass=None,
     tools=None,
+    measure_tools=None,
     tree_width=None,
     axes=None,
     axes0=None,
@@ -560,6 +578,7 @@ def show_object(
     Valid keywords to configure the viewer (**kwargs):
     - UI
         glass:                   Use glass mode where tree is an overlay over the cad object (default=False)
+        measure_tools:           Show measure tools (default=False)
         tools:                   Show tools (default=True)
         tree_width:              Width of the object tree (default=240)
 
@@ -674,10 +693,13 @@ def show_clear():
     send_data(data)
 
 
-def show_all(variables=None, exclude=None, **kwargs):
+def show_all(variables=None, exclude=None, force=False, **kwargs):
     import inspect
 
-    global FIRST_CALL, LAST_CALL
+    global LAST_CALL
+
+    if force:
+        LAST_CALL = "other"
 
     if LAST_CALL == "show":
         LAST_CALL = "other"
@@ -708,8 +730,8 @@ def show_all(variables=None, exclude=None, **kwargs):
             if hasattr(obj, "locations") and hasattr(obj, "local_locations"):
                 obj = obj.locations
 
-            if hasattr(obj, "to_location"):
-                obj = obj.to_location()
+            if hasattr(obj, "local_coord_system"):
+                obj = obj.location
 
             if (
                 (
@@ -729,6 +751,11 @@ def show_all(variables=None, exclude=None, **kwargs):
                     and len(obj) > 0
                     and hasattr(obj[0], "wrapped")
                 )
+                or (
+                    hasattr(obj, "wrapped")
+                    and hasattr(obj, "position")
+                    and hasattr(obj, "direction")
+                )
             ):
                 objects.append(obj)
                 names.append(name)
@@ -746,9 +773,6 @@ def show_all(variables=None, exclude=None, **kwargs):
                 objects.append(pg)
                 names.append(name)
 
-    if FIRST_CALL:
-        kwargs["reset_camera"] = Camera.RESET
-
     if len(objects) > 0:
         show(
             *objects,
@@ -757,6 +781,5 @@ def show_all(variables=None, exclude=None, **kwargs):
             _force_in_debug=True,
             **kwargs,
         )
-        FIRST_CALL = False
     else:
         show_clear()

{ocp_vscode-1.2.2 → ocp_vscode-2.0.2}/ocp_vscode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ocp-vscode
-Version: 1.2.2
+Version: 2.0.2
 Summary: OCP CAD Viewer for VSCode
 Home-page: https://github.com/bernhard-42/vscode-ocp-cad-viewer
 Author: Bernhard Walter
@@ -18,4 +18,4 @@ Classifier: Programming Language :: Python :: 3.11
 Requires-Python: >=3.9
 License-File: LICENSE
 
-An extension to show OCP cad CAD objects (CadQuery, build123d) in VS Code via pythreejs
+An extension to show OCP cad CAD objects (CadQuery, build123d) in VS Code via threejs

{ocp_vscode-1.2.2 → ocp_vscode-2.0.2}/ocp_vscode.egg-info/SOURCES.txt

@@ -4,14 +4,19 @@ setup.cfg
 setup.py
 ocp_vscode/__init__.py
 ocp_vscode/animation.py
+ocp_vscode/backend.py
 ocp_vscode/colors.py
 ocp_vscode/comms.py
 ocp_vscode/config.py
 ocp_vscode/finder.py
+ocp_vscode/interactive.py
+ocp_vscode/persistence.py
 ocp_vscode/show.py
 ocp_vscode.egg-info/PKG-INFO
 ocp_vscode.egg-info/SOURCES.txt
 ocp_vscode.egg-info/dependency_links.txt
 ocp_vscode.egg-info/not-zip-safe
 ocp_vscode.egg-info/requires.txt
-ocp_vscode.egg-info/top_level.txt
+ocp_vscode.egg-info/top_level.txt
+test/test_for_backend.py
+test/testextension.py

{ocp_vscode-1.2.2 → ocp_vscode-2.0.2}/ocp_vscode.egg-info/requires.txt

@@ -1,4 +1,4 @@
-ocp-tessellate<1.2.2,>=1.1.2
+ocp-tessellate<2.1.0,>=2.0.2
 requests
 ipykernel
 orjson

{ocp_vscode-1.2.2 → ocp_vscode-2.0.2}/setup.cfg

@@ -1,5 +1,5 @@
 [bumpversion]
-current_version = 1.2.2
+current_version = 2.0.2
 commit = False
 tag = False
 parse = (?P<major>\d+)\.(?P<minor>\d+)\.(?P<patch>\d+)(?P<release>\D*)(?P<build>\d*)

{ocp_vscode-1.2.2 → ocp_vscode-2.0.2}/setup.py

@@ -2,13 +2,13 @@ from setuptools import setup, find_packages
 
 setup_args = {
     "name": "ocp_vscode",
-    "version": "1.2.2",
+    "version": "2.0.2",
     "description": "OCP CAD Viewer for VSCode",
-    "long_description": "An extension to show OCP cad CAD objects (CadQuery, build123d) in VS Code via pythreejs",
+    "long_description": "An extension to show OCP cad CAD objects (CadQuery, build123d) in VS Code via threejs",
     "include_package_data": True,
     "python_requires": ">=3.9",
     "install_requires": [
-        "ocp-tessellate>=1.1.2,<1.2.2",
+        "ocp-tessellate>=2.0.2,<2.1.0",
         "requests",
         "ipykernel",
         "orjson",

ocp_vscode-2.0.2/test/test_for_backend.py

@@ -0,0 +1,19 @@
+from build123d import *
+from ocp_vscode import *
+
+# set_port(3939)
+# set_defaults(reset_camera=Camera.KEEP, ortho=True)
+
+with BuildPart() as p:
+    Box(10, 10, 10)
+    with Locations((5, 0, 0)):
+        Box(10, 10, 5)
+c = Circle(10)
+cc = extrude(c, 10)
+for e in cc.faces()[0].edges():
+    print(e.geom_type())
+v = Vertex(0, 0, 0)
+# print(c.geom_type())
+pass
+# line = line.edges()[0]
+# show(p, f1, f2)

ocp_vscode-2.0.2/test/testextension.py

@@ -0,0 +1,58 @@
+from build123d import *
+from ocp_vscode import *
+
+set_port(3939)
+set_defaults(reset_camera=Camera.KEEP, ortho=True)
+densa = 7800 / 1e6  # carbon steel density g/mm^3
+densb = 2700 / 1e6  # aluminum alloy
+densc = 1020 / 1e6  # ABS
+LB = 453.592  # g/lb
+ms = Mode.SUBTRACT
+LMH, LMV = LengthMode.HORIZONTAL, LengthMode.VERTICAL
+# %%
+
+with BuildPart() as p:
+    with BuildSketch(Plane.XZ) as s:
+        with BuildLine(Plane.XZ) as l:
+            m1 = Line((3.5 / 2, 0), (5.625 / 2, 0))
+            m2 = Line(m1 @ 1, m1 @ 1 + (0, 3))
+            m3 = Line(m2 @ 1, m2 @ 1 + (-(5.625 - 3.75) / 2, 0))
+            m4 = Line(m3 @ 1, m3 @ 1 + (0, -0.375))
+            m5 = Line(m4 @ 1, m4 @ 1 + (-0.75 / 2, 0))
+            m6 = Line(m5 @ 1, m5 @ 1 + (0, -3 + 1.75 + 0.375))
+            m7 = Line(m6 @ 1, m6 @ 1 + (0.5 / 2, 0))
+            m8 = Line(m7 @ 1, m1 @ 0)
+        make_face()
+    revolve(axis=Axis.Z, revolution_arc=90)
+
+    with BuildSketch(Plane.XZ.rotated((0, 0, -45))) as s2:
+        Rectangle(1, 1.5, align=(Align.CENTER, Align.MIN))
+        with Locations((0, 1)):
+            Rectangle(2, 0.25, align=(Align.CENTER, Align.MIN))
+    extrude(amount=-6, mode=ms)
+
+    with Locations(Plane.XY.offset(3)):
+        with PolarLocations(4.625 / 2, 1, 45):
+            CounterBoreHole(0.375 / 2, 0.625 / 2, 0.25)
+    mirror(about=Plane.XZ)
+    mirror(about=Plane.YZ)
+
+
+r = RegularPolygon(100, 5)
+pp = extrude(r, 1000)
+pp -= Hole(2, 50)
+
+
+classes = (BuildPart, BuildSketch, BuildLine)  # for OCP-vscode
+set_colormap(ColorMap.seeded(colormap="rgb", alpha=1, seed_value="vscod"))
+show2(pp, name="item")
+
+# b = Box(1, 2, 3) - Plane.YZ * Cylinder(0.5, 1)
+# b = fillet(b.edges().filter_by(Axis.X), 0.3)
+# b = chamfer(b.edges().filter_by(Axis.Y), 0.1)
+# c = Pos(3, 0, 0) * Box(1, 1, 1)
+# s = Pos(0, 2, 1) * Circle(0.5)
+
+# show2(b, c, s)
+print()
+print(f"part mass = {p.part.scale(IN).volume*densb/LB}")