adxc 0.1.0__py3-none-any.whl

adxc/__init__.py

@@ -0,0 +1,103 @@
+import tempfile
+import zipfile
+from pathlib import Path
+
+import copy
+
+from .fields import SensorField
+from .library import Robot, Track, Gantry, Positioner, Process, WireArcMode, SensorShape, Sensor
+from .cell import Cell, _build_adxc, _uri_to_path
+from .nozzle import Nozzle
+
+
+def _validate_meshes(cell):
+	objects = list(cell.robot.heads if cell.robot is not None else ())
+	objects.extend(cell.unknown_pending_heads)
+	objects.extend(cell.cell_elements)
+	for obj in objects:
+		filepath = getattr(obj, "filepath", "")
+		if filepath:
+			source = _uri_to_path(filepath)
+			if not source.is_file():
+				raise FileNotFoundError(f"Mesh file not found: {source}")
+
+
+def save(value, output_dir="."):
+	"""Save one cell or nozzle using a default path in the current directory."""
+	output_dir = Path(output_dir)
+	if isinstance(value, Cell):
+		_validate_meshes(value)
+		file_stem = value.name.replace(" ", "_")
+		output_dir = output_dir / value.name
+		output_dir.mkdir(parents=True, exist_ok=True)
+		path = output_dir / f"{file_stem}.adxc"
+		path.write_bytes(_build_adxc(value))
+		return path
+	if isinstance(value, Nozzle):
+		path = output_dir if output_dir.suffix == ".adxn" else output_dir / value.filename
+		return value.write(path)
+	raise TypeError("value must be a Cell or Nozzle")
+
+
+def savezip(value, output_dir="."):
+	"""Save a cell or one or more nozzles as an archive."""
+	output_dir = Path(output_dir)
+
+	if isinstance(value, Cell):
+
+		_validate_meshes(value)
+		cell = copy.deepcopy(value)
+		resources = {}
+		for obj in ([*cell.robot.heads] if cell.robot is not None else []) + cell.unknown_pending_heads + cell.cell_elements:
+			if obj.filepath:
+				source = _uri_to_path(obj.filepath)
+				resources[source.name] = source
+				obj.filepath = f"./resource/{source.name}"
+		stem = value.name
+		output_dir.mkdir(parents=True, exist_ok=True)
+		zip_path = output_dir / f"{stem}.adxczip"
+
+		with tempfile.TemporaryDirectory() as tmp:
+			folder = Path(tmp) / stem
+			resource_folder = folder / "resource"
+			resource_folder.mkdir(parents=True, exist_ok=True)
+			file_stem = stem.replace(" ", "_")
+			(folder / f"{file_stem}.adxc").write_bytes(_build_adxc(cell))
+			for name, source in resources.items():
+				(resource_folder / name).write_bytes(source.read_bytes())
+			with zipfile.ZipFile(zip_path, "w", zipfile.ZIP_DEFLATED) as archive:
+				for file in folder.rglob("*"):
+					if file.is_file():
+						archive.write(file, file.relative_to(folder))
+		return zip_path
+	
+	if isinstance(value, Nozzle):
+		nozzles = [value]
+
+	elif isinstance(value, (list, tuple)) and all(isinstance(item, Nozzle) for item in value):
+		nozzles = list(value)
+
+	else:
+		raise TypeError("value must be a Cell, Nozzle, or list of Nozzle objects")
+	
+	if not nozzles:
+		raise ValueError("at least one nozzle is required")
+
+	path = output_dir if output_dir.suffix == ".zip" else output_dir / "nozzles.zip"
+	path.parent.mkdir(parents=True, exist_ok=True)
+	with tempfile.TemporaryDirectory() as temporary_directory:
+		temporary_directory = Path(temporary_directory)
+		files = []
+		for nozzle in nozzles:
+			temporary_path = temporary_directory / nozzle.filename
+			nozzle.write(temporary_path)
+			files.append(temporary_path)
+		with zipfile.ZipFile(path, "w", zipfile.ZIP_DEFLATED) as archive:
+			for temporary_path in files:
+				archive.write(temporary_path, temporary_path.name)
+	return path
+
+__all__ = [
+	"Cell", "Process", "SensorShape", "Sensor", "SensorField", "WireArcMode", "Robot", "Track",
+	"Gantry", "Positioner", "save", "savezip",
+]

adxc/cell.py

@@ -0,0 +1,558 @@
+from __future__ import annotations
+import struct, copy, time
+from pathlib import Path
+from dataclasses import dataclass, fields
+from urllib.parse import urlparse, unquote
+from .protobuf import write_protobuf
+from .library import *
+from .fields import *
+
+# fixed HeadMessage slots; a sensor shape's leading params fill these positionally.
+_SENSOR_SLOTS = ("sensor_near", "sensor_far", "sensor_size", "sensor_height")
+
+
+@dataclass
+class Head(HeadFields):
+
+    def add_toolframe(
+        self, 
+        name="", 
+        translation=None, 
+        rotation=None,
+        process=None, 
+        mode=None, 
+        sensor=None,
+        near=None,
+        far=None,
+        length=None,
+        radius=None,
+        width=None,
+        height=None,
+        sensor_translation=None,
+        sensor_rotation=None,
+    ):
+      
+        if isinstance(name, SensorField):
+            sensor, name = name, ""
+        if isinstance(sensor, SensorField):
+            sensor = {field.name: getattr(sensor, field.name)
+                      for field in fields(sensor) if getattr(sensor, field.name) is not None}
+
+            
+        if sensor is not None and not isinstance(sensor, dict):
+            sensor = {"shape": sensor}
+            sensor.update({name: value for name, value in {
+            "near": near, "far": far, "length": length,
+            "radius": radius, "width": width,
+            "height": height,
+            }.items() if value is not None})
+            if sensor_translation is not None:
+                sensor["translation"] = sensor_translation
+            if sensor_rotation is not None:
+                sensor["rotation"] = sensor_rotation
+        elif sensor is not None and any(value is not None for value in (
+            near, far, length, radius, width, height,
+            sensor_translation, sensor_rotation)):
+            raise TypeError("sensor dimensions must be passed as keyword arguments, not with a sensor dict")
+        process_kwargs = {}
+        if process:
+            process = Process.resolve(process)
+            process_kwargs["process"] = GUID(process.equipment_id)
+            process_mode = process.mode
+            if mode is not None:
+                process_mode = mode if isinstance(mode, int) else WireArcMode[str(mode).upper()].value
+            process_kwargs["mode"] = process_mode
+        if sensor:
+            shape = SensorShape.resolve(sensor.get("shape"))
+            allowed = shape.params
+            for pname, pval in sensor.items():
+                if pname in ("shape", "translation", "rotation"):
+                    continue
+                if pname not in allowed:
+                    raise ValueError(f"{shape.label} accepts {list(allowed)}; got unexpected {pname!r}")
+                process_kwargs[_SENSOR_SLOTS[allowed.index(pname)]] = float(pval)
+            sensor["shape"] = shape.label
+            process_kwargs["sensor_on"] = shape.code
+            if sensor.get("translation") is not None:
+                process_kwargs["sensor_translation"] = _as_vec(sensor["translation"])
+            if sensor.get("rotation") is not None:
+                process_kwargs["sensor_rotation"] = _as_vec(sensor["rotation"])
+
+        self._frames.append({
+            "name": name, 
+            "translation": translation, 
+            "rotation": rotation,
+            "process": process, 
+            "mode": mode, 
+            "sensor": sensor,
+            "process_kwargs": process_kwargs
+        })
+        return self
+
+
+def _as_vec(v):
+    if v is None or isinstance(v, EmptyMessage):
+        return EmptyMessage()
+    if isinstance(v, Vec3):
+        return EmptyMessage() if not any((v.x, v.y, v.z)) else v
+    return EmptyMessage() if not any(v) else Vec3(*v)
+
+
+def _normalize_transform(value):
+    return EmptyMessage() if value is None or not any(value) else Vec3(*value)
+
+
+def _normalize_translation_rotation(value):
+    for field_name in ("translation", "rotation"):
+        field_value = getattr(value, field_name)
+        if isinstance(field_value, (list, tuple)):
+            setattr(value, field_name, _normalize_transform(field_value))
+    return value
+
+
+def _make_holders():
+    return [ToolFrame(ToolFrameData(field_3=None, name="fake_holder")),
+            ToolFrame(ToolFrameData(field_3=None, name="fake_holder"))]
+
+
+def _sensor_settings(sensor):
+    if not sensor:
+        return None
+    shape = SensorShape.resolve(sensor.get("shape"))
+    parameters = SensorParameters(
+        shape=shape.code,
+        near_or_length=(sensor.get("far") if shape.label in ("linear", "conic", "rectangle")
+                        else sensor.get("length")),
+        far_or_size=(sensor.get("width") or sensor.get("radius")),
+        height=sensor.get("height"),
+    )
+    return SensorSettings(
+        shape=shape.code,
+        translation=_as_vec(sensor.get("translation")),
+        rotation=_as_vec(sensor.get("rotation")),
+        parameters=parameters,
+        offset=_as_vec(sensor.get("translation")),
+    )
+
+
+_EMPTY_FRAME = {"name": "", "translation": None, "rotation": None,
+                "process": None, "mode": None, "sensor": None}
+
+
+def finalize_head(head: Head):
+    """Return (HeadMessage, [Tool, ...]). One head layout; the toolframe count
+    sets multi_process (0 for <=1, 1 for 2+). Process is PER-TOOLFRAME: a single
+    toolframe folds it into the head; 2+ put each on its own toolframe."""
+    holders = _make_holders()
+
+    if len(head._frames) <= 1:                                   # ---- single-process ----
+        f = head._frames[0] if head._frames else dict(
+            _EMPTY_FRAME, translation=head.translation, rotation=head.rotation)
+        proc = f.get("process_kwargs", {})
+        tcp_t, tcp_r = _as_vec(f["translation"]), _as_vec(f["rotation"])
+        holders[0].data.translation = copy.deepcopy(tcp_t)       # both holders mirror the TCP
+        holders[1].data.translation = copy.deepcopy(tcp_t)
+        msg = HeadMessage(
+            id=head.id, filepath=head.filepath,
+            translation=tcp_t, rotation=tcp_r,
+            model=head.model, brand=head.brand,
+            toolframes=holders, file_name=head.file_name, multi_process=0, **proc,
+        )
+        tools = [Tool(used=-1, name=f["name"] or head.tool_id or "tool1",
+                      head=head.id, toolframe=null_guid())]
+        return msg, tools
+
+    user, tools = [], []                                         # ---- multi-process ----
+    # Per-toolframe process GUID goes at 1.5.25[i].1.12. The richer .2 settings
+    # block (.2.10 shape/params per process) is the next step - see TODO below.
+    for index, f in enumerate(head._frames):
+        frame_id = GUID()
+        proc_guid = f.get("process_kwargs", {}).get("process", null_guid())
+        user.append(ToolFrame(ToolFrameData(
+            translation=_as_vec(f["translation"]), rotation=_as_vec(f["rotation"]),
+            name=f["name"] or f"Name {index + 1}", id=frame_id,
+            nozzle_holder_ref=proc_guid,          # field 12 = per-toolframe process GUID
+            created=int(time.time() * 1000),
+        ), settings=_sensor_settings(f["sensor"])))
+        tools.append(Tool(used=-1, name=f["name"] or f"tool{index + 1}",
+                          head=head.id, toolframe=frame_id))
+        
+    msg = HeadMessage(
+        id=head.id,
+        filepath=head.filepath,
+        model=head.model, 
+        brand=head.brand,
+        toolframes=holders + user, 
+        file_name=head.file_name, 
+        multi_process=1,
+    )
+    return msg, tools
+
+
+@dataclass
+class Cell(CellField):
+
+    def add_workframe(self, 
+        workoffset_index=1, 
+        id=None, 
+        name="",
+        translation=None, 
+        rotation=None, 
+        min_x=None, 
+        min_y=None,
+        max_x=None, 
+        max_y=None, 
+        grid_spacing=None,
+        hidden=False
+    ):
+
+        self.work_frames[0].hidden = True
+
+        workframe = WorkFrame(
+            name=name, translation=translation, rotation=rotation,
+            min_x=min_x, min_y=min_y, max_x=max_x, max_y=max_y,
+            grid_spacing=grid_spacing, hidden=hidden,
+        )
+        if id is not None:
+            workframe.id = id
+
+        if len(self.work_frames) == 1:
+            workframe.active = 1
+
+        if isinstance(workframe.translation, (list, tuple)):
+            workframe.translation = (EmptyMessage()
+                if not any(workframe.translation)
+                else Vec3(*workframe.translation)
+            )
+
+        if isinstance(workframe.rotation, (list, tuple)):
+            rx, ry, rz = workframe.rotation
+            # AdaOne's workframe rotation message stores Y in slot 1 and X in slot 2.
+            workframe.rotation = (EmptyMessage()
+                if not any(workframe.rotation)
+                else Vec3(ry, rx, rz)
+            )
+
+        self.work_frames.append(workframe)
+
+        self.kinematics.workoffsets = self.kinematics.workoffsets or WorkOffsets()
+        self.kinematics.workoffsets.offsets[workoffset_index].workframe = workframe.id
+
+
+    def add_robot(self, definition):
+
+        self.work_frames[0].hidden = True
+
+        robot_chain = GUID()
+        target = RobotPosition(
+            guid=GUID(),
+            joint_angles=struct.pack("<6f", 0.0, 0.0, -90.0, 0.0, 15.0, 0.0),
+            external_axes=struct.pack("<6f", *([float("inf")] * 6)),
+            flag=1,
+            name="Default home position",
+        )
+
+        robot_base = GUID()
+        self.robot = Robot(
+            kinematic_chain=robot_chain,
+            robot_model=GUID(definition["model"]),
+            current_position=target.joint_angles,
+            targets=[target],
+            robot_base=robot_base,
+            default_target=target.guid,
+            axis_max=struct.pack("<6f", *definition["axis_max"]),
+            axis_min=struct.pack("<6f", *definition["axis_min"]),
+        )
+        self.kinematics.robot_base = robot_chain
+        self.kinematics.workoffsets = WorkOffsets(robot_chain=robot_chain)
+        self.kinematics.workoffsets.offsets[0].workframe = robot_base
+        self.kinematics.print_chain = [Chain(robot=GUID(guid)) for guid in definition["chains"]]
+        for axis in self.kinematics.external_axes:
+            axis.parent_chain = self.robot.kinematic_chain
+
+        # pending heads added before the robot now belong to it; the tool wiring
+        # happens in _finalize_heads (count-driven), not here.
+        self.robot.heads.extend(self.unknown_pending_heads)
+        self.unknown_pending_heads.clear()
+        if self.robot.heads:
+            self.robot.active_head = self.robot.heads[-1]
+
+        self.kinematics.version = 0
+        self.kinematics.app_name = "AdaOne"
+        return self
+
+    def add_track(self, 
+            definition,
+            kinematic_chain=None, 
+            equipment_id=None,
+            translation=None, 
+            rotation=None, 
+            axis_mode=1,
+            track_properties=None, 
+            equipment_kind=None, 
+            stroke=None
+        ):
+        self.work_frames[0].hidden = True
+
+        track = Equipment(
+            kinematic_chain=kinematic_chain, 
+            equipment_id=equipment_id,
+            translation=translation, 
+            rotation=rotation,
+            axis_mode=axis_mode, 
+            track_properties=track_properties,
+            equipment_kind=equipment_kind, 
+            stroke=stroke,
+        )
+        _normalize_translation_rotation(track)
+
+        track.kinematic_chain = track.kinematic_chain or GUID()
+        track.equipment_id = track.equipment_id or GUID(definition["equipment_id"])
+        track.track_properties = track.track_properties or TrackProperties()
+        track.track_properties.size = definition["size"]
+        track.track_properties.rotation = definition.get("rotation") or None
+        track.track_properties.riser = definition.get("riser") or None
+        track.field_5 = track.field_5 or struct.pack("<f", 0.0)
+        track.stroke = 0.0 if track.stroke is None else track.stroke
+        track.stroke_range = track.stroke_range or struct.pack("<2f", 0.0, definition["length"])
+        self.equipment.append(track)
+        self.kinematics.external_axes.append(
+            ExternalAxis(
+                track_chain=track.kinematic_chain,
+                axis_type=definition["axis_type"],
+                parent_chain=(self.robot.kinematic_chain
+                              if self.robot is not None else null_guid()),
+            )
+        )
+        return self
+    
+    def add_gantry(self, 
+        definition,
+        kinematic_chain=None, 
+        equipment_id=None,
+        translation=None, 
+        rotation=None, 
+        axis_mode=3,
+        track_properties=None, 
+        equipment_kind=None, 
+        stroke=None
+    ):
+
+        self.work_frames[0].hidden = True
+
+        gantry = Equipment(
+            kinematic_chain=kinematic_chain, equipment_id=equipment_id,
+            translation=translation, rotation=rotation,
+            axis_mode=axis_mode, track_properties=track_properties,
+            equipment_kind=equipment_kind, stroke=stroke,
+        )
+        _normalize_translation_rotation(gantry)
+            
+        gantry.kinematic_chain = gantry.kinematic_chain or GUID()
+        gantry.equipment_id = gantry.equipment_id or GUID(definition["equipment_id"])
+        gantry.axis_mode = 3
+        gantry.field_5 = gantry.field_5 or struct.pack("<3f", 0.0, 0.0, 0.0)
+        gantry.track_properties = None
+        self.equipment.append(gantry)
+        parent_chain = self.robot.kinematic_chain if self.robot else null_guid()
+
+        self.kinematics.external_axes.append(
+            ExternalAxis(
+                axis_type=3,
+                track_chain=gantry.kinematic_chain,
+                parent_chain=parent_chain
+            )
+        )
+        for axis_index in range(1, definition["axes"] + 1):
+            self.kinematics.external_axes.append(
+                ExternalAxis(
+                    axis_type=3, 
+                    axis_index=axis_index,
+                    track_chain=gantry.kinematic_chain,
+                    parent_chain=parent_chain
+                )
+            )
+        return self
+
+    def add_positioner(self, 
+        definition, 
+        kinematic_chain=None, 
+        equipment_id=None,
+        translation=None, 
+        rotation=None, 
+        axis_mode=0,
+        track_properties=None, 
+        equipment_kind=None, 
+        stroke=None
+    ):
+
+        self.work_frames[0].hidden = True
+
+
+        positioner = Equipment(
+            kinematic_chain=kinematic_chain, equipment_id=equipment_id,
+            translation=translation, rotation=rotation,
+            axis_mode=axis_mode, track_properties=track_properties,
+            equipment_kind=equipment_kind, stroke=stroke,
+        )
+
+        for field_name in ("translation", "rotation"):
+            value = getattr(positioner, field_name)
+            if isinstance(value, (list, tuple)):
+                setattr(positioner, field_name, EmptyMessage() if not any(value) else Vec3(
+                    x=value[0], y=value[1], z=value[2]
+                ))
+
+        positioner.kinematic_chain = positioner.kinematic_chain or GUID()
+        positioner.equipment_id = positioner.equipment_id or GUID(definition["equipment_id"])
+        positioner.axis_mode = 0
+        positioner.track_properties = None
+        positioner.field_5 = positioner.field_5 or struct.pack("<2f", *definition["home_position"])
+        positioner.equipment_kind = 2
+        self.equipment.append(positioner)
+        axes = definition["axes"]
+        axis_indices = [None] if axes == 1 else list(range(1, axes + 1))
+
+        for axis_index in axis_indices:
+            self.kinematics.external_axes.append(
+                ExternalAxis(axis_index=axis_index,
+                              track_chain=positioner.kinematic_chain,
+                              axis_enabled=1, axis_type=0,
+                              parent_chain=null_guid())
+            )
+        return self
+
+    def add_head(self, 
+        tool_id=None, 
+        id=None, 
+        filepath="", 
+        translation=None,
+        rotation=None, 
+        model="", 
+        brand="", 
+        nozzle_holder_ref=None,
+        file_name="", 
+        frame=None, 
+        name=None
+        ):
+
+        self.work_frames[0].hidden = True
+
+        if frame is not None and not isinstance(frame, Frame):
+            raise TypeError("frame must be a Frame instance")
+
+        if frame is not None:
+            translation = translation if translation is not None else frame.translation
+            rotation = rotation if rotation is not None else frame.rotation
+
+        head = Head(
+            id=id, filepath=filepath, translation=translation, rotation=rotation,
+            model=model, brand=brand, nozzle_holder_ref=nozzle_holder_ref,
+            file_name=file_name,
+        )
+        
+        head.tool_id = tool_id or name
+
+        normalized = str(head.filepath).replace("\\", "/")
+        head.id = head.id or GUID()
+        head.filepath = _file_uri(head.filepath)
+        head.file_name = head.file_name or normalized.rsplit("/", 1)[-1]
+        head.model = head.model or f"Process head {len(self.robot.heads) if self.robot else 0}"
+        head.nozzle_holder_ref = head.nozzle_holder_ref or null_guid()
+
+        if self.robot is None:
+            self.unknown_pending_heads.append(head)
+        else:
+            self.robot.heads.append(head)
+            self.robot.active_head = self.robot.heads[-1]
+
+        return head
+
+    def add_element(self, 
+        name="",
+        filepath="", 
+        translation=None,
+        rotation=None, 
+        workframe=None,
+        payload=None, 
+        parent=None, 
+        appearance=None, 
+        id=None,
+    ):
+
+        self.work_frames[0].hidden = True
+
+        element = CellElement(
+            id=id, filepath=filepath, translation=translation, rotation=rotation,
+            payload=payload, parent=parent, workframe=workframe,
+            appearance=appearance, name=name,
+        )
+
+        if isinstance(element.workframe, WorkFrame):
+            element.workframe = element.workframe.id
+
+        if element.parent is None and self.robot is not None:
+            element.parent = self.robot.robot_base
+            
+        for field_name in ("translation", "rotation"):
+            value = getattr(element, field_name)
+            if isinstance(value, (list, tuple)):
+                setattr(element, field_name, EmptyMessage() if not any(value) else Vec3(
+                    x=value[0], y=value[1], z=value[2]
+                ))
+
+        normalized = str(element.filepath).replace("\\", "/")
+        uri = _file_uri(element.filepath)
+        element.id = element.id or GUID()
+        element.filepath = uri
+        element.name = element.name or Path(normalized).stem
+        self.cell_elements.append(element)
+        return self
+
+def _file_uri(filepath):
+    normalized = str(filepath).replace("\\", "/")
+    if normalized.startswith("file://"):
+        return normalized
+    if len(normalized) >= 2 and normalized[1] == ":":
+        return "file:///" + normalized
+    return Path(normalized).resolve().as_uri()
+
+
+def _uri_to_path(uri: str) -> Path:
+    raw = unquote(urlparse(uri).path)
+    if raw and raw[0] == "/" and len(raw) > 2 and raw[2] == ":":
+        raw = raw[1:]
+    return Path(raw)
+
+
+def _finalize_heads(cell: Cell) -> None:
+    """Convert every accumulator Head into its concrete single/multi message and
+    wire the resulting tools into kinematics. The toolframe count decides the
+    layout (0-1 -> single, 2+ -> multi)."""
+    concrete: dict[int, object] = {}
+
+    def convert(head):
+        if id(head) in concrete:
+            return concrete[id(head)]
+        message, tools = finalize_head(head)
+        concrete[id(head)] = message
+        if tools:
+            robot_chain = cell.robot.kinematic_chain if cell.robot is not None else None
+            cell.kinematics.tools = cell.kinematics.tools or Tools(robot_chain=robot_chain)
+            cell.kinematics.tools.tools.extend(tools)
+        return message
+
+    if cell.robot is not None:
+        cell.robot.heads = [convert(head) if isinstance(head, Head) else head
+                            for head in cell.robot.heads]
+        if isinstance(cell.robot.active_head, Head):
+            cell.robot.active_head = concrete.get(id(cell.robot.active_head),
+                                                  convert(cell.robot.active_head))
+
+    cell.unknown_pending_heads = [convert(head) if isinstance(head, Head) else head
+                                  for head in cell.unknown_pending_heads]
+
+
+def _build_adxc(cell: Cell) -> bytes:
+    _finalize_heads(cell)
+    return write_protobuf(cell)