receivers for http/tcp/web socket communication

.pre-commit-config.yaml

@@ -34,6 +34,7 @@ repos:
       types-requests==2.31.0,
       numpy==2.0.1,
       pytest==8.3.1,
+      websockets>=10.4,
       types-setuptools>=71.1.0.20240818
       ]
     args: [--config=pyproject.toml]

src/gh/components/DF_http_listener/code.py

@@ -0,0 +1,136 @@
+#! python3
+
+from ghpythonlib.componentbase import executingcomponent as component
+import os
+import tempfile
+import requests
+import threading
+import Rhino
+import Rhino.Geometry as rg
+import scriptcontext as sc
+from diffCheck import df_gh_canvas_utils
+
+
+class DFHTTPListener(component):
+
+    def __init__(self):
+        try:
+            ghenv.Component.ExpireSolution(True)  # noqa: F821
+            ghenv.Component.Attributes.PerformLayout()  # noqa: F821
+        except NameError:
+            pass
+
+        df_gh_canvas_utils.add_button(ghenv.Component, "Load", 0, x_offset=60)  # noqa: F821
+        df_gh_canvas_utils.add_panel(ghenv.Component, "Ply_url", "https://github.com/diffCheckOrg/diffCheck/raw/refs/heads/main/tests/test_data/cube_mesh.ply", 1, 60, 20)  # noqa: F821
+
+    def RunScript(self,
+            i_load: bool,
+            i_ply_url: str):
+
+        prefix = 'http'
+
+        # initialize sticky variables
+        sc.sticky.setdefault(f'{prefix}_ply_url', None)  # last url processed
+        sc.sticky.setdefault(f'{prefix}_imported_geom', None)  # last geo imported from ply
+        sc.sticky.setdefault(f'{prefix}_status_message', "Waiting..")  # status message on component
+        sc.sticky.setdefault(f'{prefix}_prev_load', False)  # previous state of toggle
+        sc.sticky.setdefault(f'{prefix}_thread_running', False)  # is a background thread running?
+
+        def _import_job(url: str) -> None:
+
+            """
+            Downloads and imports a .ply file from a given URL in a background thread.
+            Background job:
+            - Downloads the .ply file from the URL
+            - Imports it into the active Rhino document
+            - Extracts the new geometry (point cloud or mesh)
+            - Cleans up the temporary file and document objects
+            - Updates sticky state and status message
+            - Signals to GH that it should re-solve
+
+            :param url: A string representing a direct URL to a .ply file (e.g. from GitHub or local server).
+                        The file must end with ".ply".
+            :returns: None
+            """
+
+            tmp = None
+            try:
+                if not url.lower().endswith('.ply'):
+                    raise ValueError("URL must end in .ply")
+
+                resp = requests.get(url, timeout=30)
+                resp.raise_for_status()
+                # save om temporary file
+                fn = os.path.basename(url)
+                tmp = os.path.join(tempfile.gettempdir(), fn)
+                with open(tmp, 'wb') as f:
+                    f.write(resp.content)
+
+                doc = Rhino.RhinoDoc.ActiveDoc
+                # recordd existing object IDs to detect new ones
+                before_ids = {o.Id for o in doc.Objects}
+
+                # import PLY using Rhino's API
+                opts = Rhino.FileIO.FilePlyReadOptions()
+                ok = Rhino.FileIO.FilePly.Read(tmp, doc, opts)
+                if not ok:
+                    raise RuntimeError("Rhino.FilePly.Read failed")
+
+                after_ids = {o.Id for o in doc.Objects}
+                new_ids = after_ids - before_ids
+                # get new pcd or mesh from document
+                geom = None
+                for guid in new_ids:
+                    g = doc.Objects.FindId(guid).Geometry
+                    if isinstance(g, rg.PointCloud):
+                        geom = g.Duplicate()
+                        break
+                    elif isinstance(g, rg.Mesh):
+                        geom = g.DuplicateMesh()
+                        break
+                # remove imported objects
+                for guid in new_ids:
+                    doc.Objects.Delete(guid, True)
+                doc.Views.Redraw()
+
+                # store new geometry
+                sc.sticky[f'{prefix}_imported_geom'] = geom
+                count = geom.Count if isinstance(geom, rg.PointCloud) else geom.Vertices.Count
+                if isinstance(geom, rg.PointCloud):
+                    sc.sticky[f'{prefix}_status_message'] = f"Loaded pcd with {count} pts"
+                else:
+                    sc.sticky[f'{prefix}_status_message'] = f"Loaded mesh wih {count} vertices"
+                ghenv.Component.Message = sc.sticky.get(f'{prefix}_status_message')  # noqa: F821
+
+            except Exception as e:
+                sc.sticky[f'{prefix}_imported_geom'] = None
+                sc.sticky[f'{prefix}_status_message'] = f"Error: {e}"
+            finally:
+                try:
+                    os.remove(tmp)
+                except Exception:
+                    pass
+                # mark thread as finished
+                sc.sticky[f'{prefix}_thread_running'] = False
+                ghenv.Component.ExpireSolution(True)  # noqa: F821
+
+        # check if the URL input has changed
+        if sc.sticky[f'{prefix}_ply_url'] != i_ply_url:
+            sc.sticky[f'{prefix}_ply_url'] = i_ply_url
+            sc.sticky[f'{prefix}_status_message'] = "URL changed. Press Load"
+            sc.sticky[f'{prefix}_thread_running'] = False
+            sc.sticky[f'{prefix}_prev_load'] = False
+
+        # start importing if Load toggle is pressed and import thread is not already running
+        if i_load and not sc.sticky[f'{prefix}_prev_load'] and not sc.sticky[f'{prefix}_thread_running']:
+            sc.sticky[f'{prefix}_status_message'] = "Loading..."
+            sc.sticky[f'{prefix}_thread_running'] = True
+            threading.Thread(target=_import_job, args=(i_ply_url,), daemon=True).start()
+
+        sc.sticky[f'{prefix}_prev_load'] = i_load
+        ghenv.Component.Message = sc.sticky.get(f'{prefix}_status_message', "")  # noqa: F821
+
+        # output
+        o_geometry = sc.sticky.get(f'{prefix}_imported_geom')
+
+        return [o_geometry]

src/gh/components/DF_http_listener/metadata.json

@@ -0,0 +1,52 @@
+{
+    "name": "DFHTTPListener",
+    "nickname": "HTTPIn",
+    "category": "diffCheck",
+    "subcategory": "IO",
+    "description": "This component reads a ply file from the internet.",
+    "exposure": 4,
+    "instanceGuid": "ca4b5c94-6c85-4bc5-87f0-132cc34c4536",
+    "ghpython": {
+        "hideOutput": true,
+        "hideInput": true,
+        "isAdvancedMode": true,
+        "marshalOutGuids": true,
+        "iconDisplay": 2,
+        "inputParameters": [
+            {
+                "name": "i_load",
+                "nickname": "i_load",
+                "description": "Button to import ply from url.",
+                "optional": true,
+                "allowTreeAccess": true,
+                "showTypeHints": true,
+                "scriptParamAccess": "item",
+                "wireDisplay": "default",
+                "sourceCount": 0,
+                "typeHintID": "bool"
+            },
+            {
+                "name": "i_ply_url",
+                "nickname": "i_ply_url",
+                "description": "The url where to get the pointcloud",
+                "optional": true,
+                "allowTreeAccess": true,
+                "showTypeHints": true,
+                "scriptParamAccess": "item",
+                "wireDisplay": "default",
+                "sourceCount": 0,
+                "typeHintID": "str"
+            }
+        ],
+        "outputParameters": [
+            {
+                "name": "o_geometry",
+                "nickname": "o_geo",
+                "description": "The mesh or pcd that was imported.",
+                "optional": false,
+                "sourceCount": 0,
+                "graft": false
+            }
+        ]
+    }
+}

src/gh/components/DF_tcp_listener/code.py

@@ -0,0 +1,160 @@
+#! python3
+
+from ghpythonlib.componentbase import executingcomponent as component
+import socket
+import threading
+import json
+import time
+import scriptcontext as sc
+import Rhino.Geometry as rg
+import System.Drawing as sd
+from diffCheck import df_gh_canvas_utils
+from Grasshopper.Kernel import GH_RuntimeMessageLevel as RML
+
+class DFTCPListener(component):
+    def __init__(self):
+        try:
+            ghenv.Component.ExpireSolution(True)  # noqa: F821
+            ghenv.Component.Attributes.PerformLayout()  # noqa: F821
+        except NameError:
+            pass
+
+        for idx, label in enumerate(("Start", "Stop", "Load")):
+            df_gh_canvas_utils.add_button(
+                ghenv.Component, label, idx, x_offset=60)  # noqa: F821
+        df_gh_canvas_utils.add_panel(ghenv.Component, "Host", "127.0.0.1", 3, 60, 20)  # noqa: F821
+        df_gh_canvas_utils.add_panel(ghenv.Component, "Port", "5000", 4, 60, 20)  # noqa: F821
+
+    def RunScript(self,
+            i_start: bool,
+            i_stop: bool,
+            i_load: bool,
+            i_host: str,
+            i_port: int):
+
+        prefix = 'tcp'
+
+        # Sticky initialization
+        sc.sticky.setdefault(f'{prefix}_server_sock', None)
+        sc.sticky.setdefault(f'{prefix}_server_started', False)
+        sc.sticky.setdefault(f'{prefix}_cloud_buffer_raw', [])
+        sc.sticky.setdefault(f'{prefix}_latest_cloud', None)
+        sc.sticky.setdefault(f'{prefix}_status_message', 'Waiting..')
+        sc.sticky.setdefault(f'{prefix}_prev_start', False)
+        sc.sticky.setdefault(f'{prefix}_prev_stop', False)
+        sc.sticky.setdefault(f'{prefix}_prev_load', False)
+
+        # Client handler
+        def handle_client(conn: socket.socket) -> None:
+            """
+            Reads the incoming bytes from a single TCP client socket and stores valid data in a shared buffer.
+
+            :param conn: A socket object returned by `accept()` representing a live client connection.
+                         The client is expected to send newline-delimited JSON-encoded data, where each
+                         message is a list of 6D values: [x, y, z, r, g, b].
+
+            :returns: None
+            """
+            buf = b''
+            with conn:
+                while sc.sticky.get(f'{prefix}_server_started', False):
+                    try:
+                        chunk = conn.recv(4096)
+                        if not chunk:
+                            break
+                        buf += chunk
+                        while b'\n' in buf:
+                            line, buf = buf.split(b'\n', 1)
+                            try:
+                                raw = json.loads(line.decode())
+                            except Exception:
+                                continue
+                            if isinstance(raw, list) and all(isinstance(pt, list) and len(pt) == 6 for pt in raw):
+                                sc.sticky[f'{prefix}_cloud_buffer_raw'] = raw
+                    except Exception:
+                        break
+                    time.sleep(0.05)  # sleep briefly to prevent CPU spin
+
+        # thread to accept incoming connections
+        def server_loop(sock: socket.socket) -> None:
+            """
+            Accepts a single client connection and starts a background thread to handle it.
+
+            :param sock: A bound and listening TCP socket created by start_server().
+                         This socket will accept one incoming connection, then delegate it to handle_client().
+
+            :returns: None. This runs as a background thread and blocks on accept().
+            """
+            try:
+                conn, _ = sock.accept()
+                handle_client(conn)
+            except Exception:
+                pass
+
+        # Start TCP server
+        def start_server() -> None:
+            """
+            creates and binds a TCP socket on the given host/port, marks the server as started and then starts the accept_loop in a background thread
+
+            :returns: None.
+            """
+            sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+            sock.bind((i_host, i_port))
+            sock.listen(1)
+            sc.sticky[f'{prefix}_server_sock'] = sock
+            sc.sticky[f'{prefix}_server_started'] = True
+            sc.sticky[f'{prefix}_status_message'] = f'Listening on {i_host}:{i_port}'
+            # Only accept one connection to keep it long-lived
+            threading.Thread(target=server_loop, args=(sock,), daemon=True).start()
+
+        def stop_server() -> None:
+            """
+            Stops the running TCP server by closing the listening socket and resetting internal state.
+
+            :returns: None.
+            """
+            sock = sc.sticky.get(f'{prefix}_server_sock')
+            if sock:
+                try:
+                    sock.close()
+                except Exception:
+                    pass
+            sc.sticky[f'{prefix}_server_sock'] = None
+            sc.sticky[f'{prefix}_server_started'] = False
+            sc.sticky[f'{prefix}_cloud_buffer_raw'] = []
+            sc.sticky[f'{prefix}_status_message'] = 'Stopped'
+
+        # Start or stop server based on inputs
+        if i_start and not sc.sticky[f'{prefix}_prev_start']:
+            start_server()
+        if i_stop and not sc.sticky[f'{prefix}_prev_stop']:
+            stop_server()
+
+        # Load buffered points into Rhino PointCloud
+        if i_load and not sc.sticky[f'{prefix}_prev_load']:
+            if not sc.sticky.get(f'{prefix}_server_started', False):
+                self.AddRuntimeMessage(RML.Warning,
+                                       "Please start server here before trying to send data from remote device.")
+                sc.sticky[f'{prefix}_status_message'] = "Server not started"
+            else:
+                raw = sc.sticky.get(f'{prefix}_cloud_buffer_raw', [])
+                if raw:
+                    pc = rg.PointCloud()
+                    for x, y, z, r, g, b in raw:
+                        pc.Add(rg.Point3d(x, y, z), sd.Color.FromArgb(int(r), int(g), int(b)))
+                    sc.sticky[f'{prefix}_latest_cloud'] = pc
+                    sc.sticky[f'{prefix}_status_message'] = f'Loaded pcd with {pc.Count} pts'
+                else:
+                    sc.sticky[f'{prefix}_status_message'] = 'No data buffered'
+
+        # Update previous states
+        sc.sticky[f'{prefix}_prev_start'] = i_start
+        sc.sticky[f'{prefix}_prev_stop'] = i_stop
+        sc.sticky[f'{prefix}_prev_load'] = i_load
+
+        # Update UI and output
+        ghenv.Component.Message = sc.sticky[f'{prefix}_status_message']  # noqa: F821
+
+        o_cloud = sc.sticky[f'{prefix}_latest_cloud']
+        return [o_cloud]