| """A tiny, browser-friendly subset of the FreeCAD Python API. |
| |
| The shim does not perform real boundary-representation modelling. It records |
| the operations that a macro asks for and emits a small JSON scene graph which |
| the Three.js front-end can build and display. It is intentionally forgiving |
| so that simple Part-based macros run without a FreeCAD installation. |
| """ |
|
|
| import copy |
| import json |
| import math |
| import sys |
| import traceback |
| import types |
|
|
| PALETTE = [ |
| (0.94, 0.68, 0.32), |
| (0.40, 0.64, 0.56), |
| (0.94, 0.49, 0.37), |
| (0.40, 0.50, 0.66), |
| (0.83, 0.78, 0.66), |
| (0.60, 0.47, 0.70), |
| ] |
|
|
|
|
| |
| |
| |
|
|
| def _num(value, default=0.0): |
| try: |
| return float(value) |
| except Exception: |
| return default |
|
|
|
|
| class Vector: |
| __slots__ = ("x", "y", "z") |
|
|
| def __init__(self, x=0.0, y=0.0, z=0.0): |
| if isinstance(x, Vector): |
| self.x, self.y, self.z = x.x, x.y, x.z |
| elif isinstance(x, (tuple, list)): |
| values = list(x) + [0.0, 0.0, 0.0] |
| self.x, self.y, self.z = _num(values[0]), _num(values[1]), _num(values[2]) |
| else: |
| self.x, self.y, self.z = _num(x), _num(y), _num(z) |
|
|
| def __iter__(self): |
| yield self.x |
| yield self.y |
| yield self.z |
|
|
| def __getitem__(self, index): |
| return (self.x, self.y, self.z)[index] |
|
|
| def __len__(self): |
| return 3 |
|
|
| def __add__(self, other): |
| other = Vector(other) |
| return Vector(self.x + other.x, self.y + other.y, self.z + other.z) |
|
|
| def __sub__(self, other): |
| other = Vector(other) |
| return Vector(self.x - other.x, self.y - other.y, self.z - other.z) |
|
|
| def __mul__(self, other): |
| if isinstance(other, (Vector, tuple, list)): |
| return self.dot(Vector(other)) |
| return Vector(self.x * other, self.y * other, self.z * other) |
|
|
| __rmul__ = __mul__ |
|
|
| def __truediv__(self, other): |
| return Vector(self.x / other, self.y / other, self.z / other) |
|
|
| def __neg__(self): |
| return Vector(-self.x, -self.y, -self.z) |
|
|
| def __repr__(self): |
| return "Vector (%g, %g, %g)" % (self.x, self.y, self.z) |
|
|
| def clone(self): |
| return Vector(self) |
|
|
| copy = clone |
|
|
| def Length(self): |
| return math.sqrt(self.x * self.x + self.y * self.y + self.z * self.z) |
|
|
| def normalize(self): |
| length = self.Length() |
| if length > 1e-12: |
| self.x /= length |
| self.y /= length |
| self.z /= length |
| return self |
|
|
| normalized = normalize |
|
|
| def dot(self, other): |
| other = Vector(other) |
| return self.x * other.x + self.y * other.y + self.z * other.z |
|
|
| def cross(self, other): |
| other = Vector(other) |
| return Vector( |
| self.y * other.z - self.z * other.y, |
| self.z * other.x - self.x * other.z, |
| self.x * other.y - self.y * other.x, |
| ) |
|
|
| def to_list(self): |
| return [self.x, self.y, self.z] |
|
|
|
|
| def _qmul(a, b): |
| x1, y1, z1, w1 = a |
| x2, y2, z2, w2 = b |
| return ( |
| w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2, |
| w1 * y2 - x1 * z2 + y1 * w2 + z1 * x2, |
| w1 * z2 + x1 * y2 - y1 * x2 + z1 * w2, |
| w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2, |
| ) |
|
|
|
|
| def _qaxis(axis, angle_deg): |
| axis = Vector(axis) |
| length = axis.Length() |
| if length < 1e-12: |
| return (0.0, 0.0, 0.0, 1.0) |
| axis = axis / length |
| half = math.radians(_num(angle_deg)) * 0.5 |
| sine = math.sin(half) |
| return (axis.x * sine, axis.y * sine, axis.z * sine, math.cos(half)) |
|
|
|
|
| def _qnorm(q): |
| length = math.sqrt(sum(v * v for v in q)) |
| if length < 1e-12: |
| return (0.0, 0.0, 0.0, 1.0) |
| return tuple(v / length for v in q) |
|
|
|
|
| def _qconj(q): |
| return (-q[0], -q[1], -q[2], q[3]) |
|
|
|
|
| def _qrotate(q, v): |
| v = Vector(v) |
| r = _qmul(_qmul(q, (v.x, v.y, v.z, 0.0)), _qconj(q)) |
| return Vector(r[0], r[1], r[2]) |
|
|
|
|
| def _qmatrix(q): |
| x, y, z, w = _qnorm(q) |
| xx, yy, zz = x * x, y * y, z * z |
| xy, xz, yz = x * y, x * z, y * z |
| wx, wy, wz = w * x, w * y, w * z |
| return [ |
| [1 - 2 * (yy + zz), 2 * (xy - wz), 2 * (xz + wy)], |
| [2 * (xy + wz), 1 - 2 * (xx + zz), 2 * (yz - wx)], |
| [2 * (xz - wy), 2 * (yz + wx), 1 - 2 * (xx + yy)], |
| ] |
|
|
|
|
| def _matmul(a, b): |
| return [[sum(a[r][k] * b[k][c] for k in range(4)) for c in range(4)] for r in range(4)] |
|
|
|
|
| def _mat_identity(): |
| return [ |
| [1.0, 0.0, 0.0, 0.0], |
| [0.0, 1.0, 0.0, 0.0], |
| [0.0, 0.0, 1.0, 0.0], |
| [0.0, 0.0, 0.0, 1.0], |
| ] |
|
|
|
|
| def _mat_translate(v): |
| m = _mat_identity() |
| m[0][3], m[1][3], m[2][3] = v.x, v.y, v.z |
| return m |
|
|
|
|
| def _mat_rotate(q): |
| r = _qmatrix(q) |
| return [ |
| [r[0][0], r[0][1], r[0][2], 0.0], |
| [r[1][0], r[1][1], r[1][2], 0.0], |
| [r[2][0], r[2][1], r[2][2], 0.0], |
| [0.0, 0.0, 0.0, 1.0], |
| ] |
|
|
|
|
| def _mat_to_column_major(m): |
| return [m[r][c] for c in range(4) for r in range(4)] |
|
|
|
|
| def _mat_is_identity(m): |
| for r in range(4): |
| for c in range(4): |
| expected = 1.0 if r == c else 0.0 |
| if abs(m[r][c] - expected) > 1e-9: |
| return False |
| return True |
|
|
|
|
| class Rotation: |
| def __init__(self, *args): |
| if not args: |
| self.q = (0.0, 0.0, 0.0, 1.0) |
| elif len(args) == 1 and isinstance(args[0], Rotation): |
| self.q = tuple(args[0].q) |
| elif len(args) == 1 and isinstance(args[0], (tuple, list)) and len(args[0]) == 4: |
| self.q = _qnorm(tuple(_num(v) for v in args[0])) |
| elif len(args) == 2: |
| self.q = _qaxis(Vector(args[0]), args[1]) |
| elif len(args) == 3: |
| yaw = _qaxis((0.0, 0.0, 1.0), args[0]) |
| pitch = _qaxis((0.0, 1.0, 0.0), args[1]) |
| roll = _qaxis((1.0, 0.0, 0.0), args[2]) |
| self.q = _qnorm(_qmul(_qmul(yaw, pitch), roll)) |
| elif len(args) == 4: |
| self.q = _qnorm(tuple(_num(v) for v in args)) |
| else: |
| self.q = (0.0, 0.0, 0.0, 1.0) |
|
|
| def __repr__(self): |
| return "Rotation (%g, %g, %g, %g)" % self.q |
|
|
| def multiply(self, other): |
| return Rotation(_qmul(self.q, Rotation(other).q)) |
|
|
| def __mul__(self, other): |
| if isinstance(other, Placement): |
| return Placement(other.Base, self).multiply(other.Rotation) |
| return self.multiply(other) |
|
|
| def toMatrix(self): |
| return _qmatrix(self.q) |
|
|
| @property |
| def Q(self): |
| return self.q |
|
|
| @property |
| def Angle(self): |
| w = max(-1.0, min(1.0, self.q[3])) |
| return math.degrees(2.0 * math.acos(w)) |
|
|
| @property |
| def Axis(self): |
| x, y, z, w = self.q |
| s = math.sqrt(max(0.0, 1.0 - w * w)) |
| if s < 1e-9: |
| return Vector(0.0, 0.0, 1.0) |
| return Vector(x / s, y / s, z / s) |
|
|
| def copy(self): |
| return Rotation(self) |
|
|
|
|
| class Placement: |
| def __init__(self, *args): |
| self.Base = Vector() |
| self.Rotation = Rotation() |
| if not args: |
| return |
| if len(args) == 1 and isinstance(args[0], Placement): |
| self.Base = Vector(args[0].Base) |
| self.Rotation = Rotation(args[0].Rotation) |
| elif len(args) == 1 and isinstance(args[0], (Vector, tuple, list)): |
| self.Base = Vector(args[0]) |
| elif len(args) >= 2: |
| self.Base = Vector(args[0]) |
| self.Rotation = Rotation(args[1]) |
|
|
| def __repr__(self): |
| return "Placement [Pos=%s, Rot=%s]" % (self.Base, self.Rotation) |
|
|
| def copy(self): |
| return Placement(self) |
|
|
| def multiply(self, other): |
| other = Placement(other) |
| q = _qmul(self.Rotation.q, other.Rotation.q) |
| base = self.Base + _qrotate(self.Rotation.q, other.Base) |
| return Placement(base, Rotation(q)) |
|
|
| def __mul__(self, other): |
| if isinstance(other, Vector): |
| return self.Base + _qrotate(self.Rotation.q, other) |
| if isinstance(other, Placement): |
| return self.multiply(other) |
| if isinstance(other, Shape): |
| shape = other.copy() |
| shape.Placement = self * shape.Placement |
| return shape |
| raise TypeError("unsupported Placement multiplication") |
|
|
| def __rmul__(self, other): |
| if isinstance(other, Vector): |
| return self.Base + _qrotate(self.Rotation.q, other) |
| return NotImplemented |
|
|
| def toMatrix(self): |
| return _mat_to_column_major(_matmul(_mat_translate(self.Base), _mat_rotate(self.Rotation.q))) |
|
|
|
|
| class Matrix: |
| def __init__(self, *args): |
| self._m = _mat_identity() |
| if len(args) == 16: |
| values = [_num(v) for v in args] |
| self._m = [[values[c * 4 + r] for c in range(4)] for r in range(4)] |
| elif len(args) == 1 and isinstance(args[0], Matrix): |
| self._m = copy.deepcopy(args[0]._m) |
|
|
| def move(self, vector): |
| self._m = _matmul(_mat_translate(Vector(vector)), self._m) |
|
|
| def multiply(self, other): |
| self._m = _matmul(self._m, other._m) |
|
|
| def A11(self): |
| return self._m[0][0] |
|
|
| def to_list(self): |
| return _mat_to_column_major(self._m) |
|
|
|
|
| |
| |
| |
|
|
| class Shape: |
| def __init__(self, node=None, profile=None, placed=False): |
| self._node = node |
| self._profile = profile |
| self._placement = Placement() |
|
|
| def __repr__(self): |
| return "<Shape>" |
|
|
| @property |
| def Placement(self): |
| return self._placement |
|
|
| @Placement.setter |
| def Placement(self, value): |
| self._placement = Placement(value) |
|
|
| @property |
| def ShapeType(self): |
| return "Solid" |
|
|
| def copy(self): |
| shape = Shape(copy.deepcopy(self._node), copy.deepcopy(self._profile)) |
| shape._placement = Placement(self._placement) |
| return shape |
|
|
| def render_node(self): |
| node = copy.deepcopy(self._node) |
| matrix = self._placement.toMatrix() |
| if not _mat_is_identity(_matmul(_mat_translate(self._placement.Base), _mat_rotate(self._placement.Rotation.q))): |
| node = {"op": "transform", "m": matrix, "child": node} |
| return node |
|
|
| def translate(self, vector, *args): |
| self._placement = Placement(Vector(vector)) * self._placement |
| return self |
|
|
| def rotate(self, center, axis, angle, *args): |
| center = Vector(center) |
| rot = Placement(Vector(0, 0, 0), Rotation(axis, angle)) |
| self._placement = ( |
| Placement(center) * rot * Placement(-center) * self._placement |
| ) |
| return self |
|
|
| def scale(self, *args): |
| return self |
|
|
| def cut(self, tool): |
| return _boolean("cut", self, tool) |
|
|
| def fuse(self, tool): |
| return _boolean("fuse", self, tool) |
|
|
| def common(self, tool): |
| return _boolean("common", self, tool) |
|
|
| def multiFuse(self, tools): |
| return _multi_boolean("fuse", [self] + list(tools)) |
|
|
| def multiCommon(self, tools): |
| return _multi_boolean("common", [self] + list(tools)) |
|
|
| def extrude(self, vector): |
| if self._profile is None: |
| raise ValueError("extrude() needs a Face or closed wire") |
| node = {"op": "extrude", "profile": self._profile, "vector": Vector(vector).to_list()} |
| matrix = self._placement.toMatrix() |
| if not _mat_is_identity( |
| _matmul(_mat_translate(self._placement.Base), _mat_rotate(self._placement.Rotation.q)) |
| ): |
| node = {"op": "transform", "m": matrix, "child": node} |
| return Shape(node) |
|
|
| def removeSplitter(self): |
| return self |
|
|
| def isClosed(self): |
| return self._profile is not None |
|
|
|
|
| def _boolean(kind, a, b): |
| if not isinstance(a, Shape) or not isinstance(b, Shape): |
| raise TypeError("boolean operations need Shape arguments") |
| node = {"op": "boolean", "kind": kind, "a": a.render_node(), "b": b.render_node()} |
| return Shape(node) |
|
|
|
|
| def _multi_boolean(kind, shapes): |
| shapes = [s for s in shapes if isinstance(s, Shape)] |
| if not shapes: |
| raise ValueError("no shapes supplied") |
| if len(shapes) == 1: |
| return shapes[0].copy() |
| node = {"op": "group", "children": [s.render_node() for s in shapes]} |
| return Shape(node) |
|
|
|
|
| def _points2d(points): |
| result = [] |
| for point in points: |
| p = Vector(point) |
| result.append([p.x, p.y]) |
| return result |
|
|
|
|
| def _make_face(profile, placement=None): |
| face = Shape({"op": "face", "profile": profile}, profile=profile) |
| if placement is not None: |
| face._placement = Placement(placement) |
| return face |
|
|
|
|
| |
| |
| |
|
|
| def _make_box(length, width, height, pnt=None, dir=None): |
| return Shape( |
| { |
| "op": "box", |
| "l": _num(length), |
| "w": _num(width), |
| "h": _num(height), |
| "pnt": Vector(pnt).to_list() if pnt is not None else [0, 0, 0], |
| "dir": Vector(dir).to_list() if dir is not None else [0, 0, 1], |
| } |
| ) |
|
|
|
|
| def _make_cylinder(radius, height, pnt=None, dir=None, angle=360): |
| return Shape( |
| { |
| "op": "cylinder", |
| "r": _num(radius), |
| "h": _num(height), |
| "pnt": Vector(pnt).to_list() if pnt is not None else [0, 0, 0], |
| "dir": Vector(dir).to_list() if dir is not None else [0, 0, 1], |
| "angle": _num(angle, 360), |
| } |
| ) |
|
|
|
|
| def _make_sphere(radius, pnt=None, *args): |
| return Shape( |
| { |
| "op": "sphere", |
| "r": _num(radius), |
| "pnt": Vector(pnt).to_list() if pnt is not None else [0, 0, 0], |
| } |
| ) |
|
|
|
|
| def _make_cone(radius1, radius2, height, pnt=None, dir=None, angle=360): |
| return Shape( |
| { |
| "op": "cone", |
| "r1": _num(radius1), |
| "r2": _num(radius2), |
| "h": _num(height), |
| "pnt": Vector(pnt).to_list() if pnt is not None else [0, 0, 0], |
| "dir": Vector(dir).to_list() if dir is not None else [0, 0, 1], |
| "angle": _num(angle, 360), |
| } |
| ) |
|
|
|
|
| def _make_torus(radius1, radius2, pnt=None, dir=None, *args): |
| return Shape( |
| { |
| "op": "torus", |
| "r1": _num(radius1), |
| "r2": _num(radius2), |
| "pnt": Vector(pnt).to_list() if pnt is not None else [0, 0, 0], |
| "dir": Vector(dir).to_list() if dir is not None else [0, 0, 1], |
| } |
| ) |
|
|
|
|
| def _make_polygon(points, closed=False): |
| profile = _points2d(points) |
| return Shape({"op": "wire", "profile": profile, "closed": bool(closed)}, profile=profile) |
|
|
|
|
| def _make_line(point1, point2): |
| return _make_polygon([point1, point2], False) |
|
|
|
|
| def _make_face_from(value): |
| if isinstance(value, Shape): |
| if value._profile is None: |
| raise ValueError("Part.Face() needs a closed wire") |
| return _make_face(copy.deepcopy(value._profile), value._placement) |
| profile = _points2d(value) |
| if len(profile) > 2 and profile[0] != profile[-1]: |
| profile.append(profile[0]) |
| return _make_face(profile) |
|
|
|
|
| def _make_compound(shapes): |
| shapes = [s for s in shapes if isinstance(s, Shape)] |
| return _multi_boolean("fuse", shapes) |
|
|
|
|
| def _show(shape, name=None): |
| document = _active_document() |
| if document is None: |
| document = newDocument("Unnamed") |
| return document._show(shape, name) |
|
|
|
|
| |
| |
| |
|
|
| class ViewObject: |
| def __init__(self, obj): |
| self.obj = obj |
| self.ShapeColor = None |
| self.LineColor = None |
| self.Visibility = True |
| self.Transparency = 0 |
| self.DisplayMode = "Flat Lines" |
|
|
| def update(self): |
| pass |
|
|
|
|
| class DocObject: |
| def __init__(self, document, type_id, name): |
| object.__setattr__(self, "Document", document) |
| object.__setattr__(self, "Name", name) |
| object.__setattr__(self, "Label", name) |
| object.__setattr__(self, "TypeId", type_id) |
| object.__setattr__(self, "_shape", None) |
| object.__setattr__(self, "_feature_shape", None) |
| object.__setattr__(self, "_dirty", True) |
| object.__setattr__(self, "ViewObject", ViewObject(self)) |
| object.__setattr__(self, "_props", self._defaults(type_id)) |
| if "Placement" not in self._props: |
| self._props["Placement"] = Placement() |
|
|
| @staticmethod |
| def _defaults(type_id): |
| if type_id == "Part::Box": |
| return {"Length": 10.0, "Width": 10.0, "Height": 10.0, "Placement": Placement()} |
| if type_id == "Part::Cylinder": |
| return {"Radius": 2.0, "Height": 10.0, "Angle": 360.0, "Placement": Placement()} |
| if type_id == "Part::Sphere": |
| return {"Radius": 5.0, "Placement": Placement()} |
| if type_id == "Part::Cone": |
| return { |
| "Radius1": 2.0, |
| "Radius2": 4.0, |
| "Height": 10.0, |
| "Angle": 360.0, |
| "Placement": Placement(), |
| } |
| if type_id == "Part::Torus": |
| return {"Radius1": 10.0, "Radius2": 2.0, "Placement": Placement()} |
| if type_id in ("Part::Cut", "Part::Fuse"): |
| return {"Base": None, "Tool": None, "Placement": Placement()} |
| if type_id in ("Part::MultiFuse", "Part::MultiCommon"): |
| return {"Shapes": [], "Placement": Placement()} |
| return {"Placement": Placement()} |
|
|
| def __getattr__(self, name): |
| props = object.__getattribute__(self, "_props") |
| if name in props: |
| return props[name] |
| raise AttributeError("'%s' object has no attribute '%s'" % (self.TypeId, name)) |
|
|
| def __setattr__(self, name, value): |
| if name in ("Document", "Name", "Label", "TypeId", "ViewObject"): |
| object.__setattr__(self, name, value) |
| elif name == "Shape": |
| object.__setattr__(self, "_feature_shape", value) |
| object.__setattr__(self, "_shape", value) |
| object.__setattr__(self, "_dirty", False) |
| elif name.startswith("_"): |
| object.__setattr__(self, name, value) |
| else: |
| self._props[name] = value |
| object.__setattr__(self, "_dirty", True) |
|
|
| @property |
| def Shape(self): |
| if self._dirty or self._shape is None: |
| self._shape = self._compute() |
| object.__setattr__(self, "_dirty", False) |
| return self._shape |
|
|
| @Shape.setter |
| def Shape(self, value): |
| object.__setattr__(self, "_feature_shape", value) |
| object.__setattr__(self, "_shape", value) |
| object.__setattr__(self, "_dirty", False) |
|
|
| def _compute(self): |
| type_id = self.TypeId |
| placement = self._props.get("Placement", Placement()) |
| if type_id == "Part::Feature": |
| return self._feature_shape |
| if type_id == "Part::Box": |
| shape = _make_box(self.Length, self.Width, self.Height) |
| elif type_id == "Part::Cylinder": |
| shape = _make_cylinder(self.Radius, self.Height, angle=self.Angle) |
| elif type_id == "Part::Sphere": |
| shape = _make_sphere(self.Radius) |
| elif type_id == "Part::Cone": |
| shape = _make_cone(self.Radius1, self.Radius2, self.Height, angle=self.Angle) |
| elif type_id == "Part::Torus": |
| shape = _make_torus(self.Radius1, self.Radius2) |
| elif type_id == "Part::Cut": |
| if self.Base is None or self.Tool is None: |
| raise ValueError("%s needs Base and Tool" % self.Name) |
| shape = self.Base.Shape.copy().cut(self.Tool.Shape) |
| elif type_id == "Part::Fuse": |
| if self.Base is None or self.Tool is None: |
| raise ValueError("%s needs Base and Tool" % self.Name) |
| shape = self.Base.Shape.copy().fuse(self.Tool.Shape) |
| elif type_id == "Part::MultiFuse": |
| shape = _multi_boolean("fuse", [s.Shape for s in self.Shapes]) |
| elif type_id == "Part::MultiCommon": |
| shape = _multi_boolean("common", [s.Shape for s in self.Shapes]) |
| else: |
| return self._feature_shape |
| if type_id != "Part::Feature": |
| shape.Placement = placement |
| return shape |
|
|
|
|
| class Document: |
| def __init__(self, name="Unnamed"): |
| self.Name = name |
| self.Label = name |
| self._objects = [] |
| self._counter = 0 |
| self._errors = [] |
|
|
| @property |
| def Objects(self): |
| return list(self._objects) |
|
|
| def addObject(self, type_id, name=None): |
| return self._add(type_id, name) |
|
|
| def _add(self, type_id, name=None): |
| if name is None: |
| name = type_id.split("::")[-1] + "%03d" % self._counter |
| base_name = name |
| while self.getObject(name) is not None: |
| self._counter += 1 |
| name = base_name + "%03d" % self._counter |
| obj = DocObject(self, type_id, name) |
| self._objects.append(obj) |
| self._counter += 1 |
| return obj |
|
|
| def _show(self, shape, name=None): |
| if not isinstance(shape, Shape): |
| raise TypeError("Part.show() needs a Shape") |
| obj = self._add("Part::Feature", name or "Shape") |
| obj.Shape = shape.copy() |
| return obj |
|
|
| def recompute(self): |
| self._errors = [] |
| for obj in list(self._objects): |
| try: |
| _ = obj.Shape |
| except Exception as error: |
| self._errors.append("%s: %s" % (obj.Name, error)) |
| return self |
|
|
| def getObject(self, name): |
| for obj in self._objects: |
| if obj.Name == name: |
| return obj |
| return None |
|
|
| def removeObject(self, name): |
| obj = self.getObject(name) |
| if obj is not None: |
| self._objects.remove(obj) |
|
|
| def __repr__(self): |
| return "<Document %s>" % self.Name |
|
|
|
|
| |
| |
| |
|
|
| _freecad = None |
| _part = None |
| _documents = {} |
| _active = None |
| _log = [] |
|
|
|
|
| def _log_message(kind): |
| def inner(*args, **kwargs): |
| text = " ".join(str(a) for a in args) |
| _log.append("%s: %s" % (kind, text)) |
|
|
| return inner |
|
|
|
|
| def newDocument(name="Unnamed", *args, **kwargs): |
| global _active |
| document = Document(name) |
| if name in _documents: |
| index = 1 |
| while "%s%03d" % (name, index) in _documents: |
| index += 1 |
| document.Name = "%s%03d" % (name, index) |
| document.Label = document.Name |
| _documents[document.Name] = document |
| _active = document |
| if _freecad is not None: |
| _freecad.ActiveDocument = document |
| return document |
|
|
|
|
| def activeDocument(): |
| return _active |
|
|
|
|
| def _active_document(): |
| return _active |
|
|
|
|
| def closeDocument(name): |
| global _active |
| document = _documents.pop(name, None) |
| if _active is document: |
| _active = None |
| if _freecad is not None: |
| _freecad.ActiveDocument = None |
| return document |
|
|
|
|
| def listDocuments(): |
| return dict(_documents) |
|
|
|
|
| def _get_color(obj, index): |
| color = getattr(obj.ViewObject, "ShapeColor", None) |
| opacity = 1.0 - (max(0.0, min(100.0, _num(getattr(obj.ViewObject, "Transparency", 0)))) / 100.0) |
| if color is None: |
| rgb = PALETTE[index % len(PALETTE)] |
| elif isinstance(color, str): |
| value = color.strip() |
| if value.startswith("#") and len(value) >= 7: |
| rgb = ( |
| int(value[1:3], 16) / 255.0, |
| int(value[3:5], 16) / 255.0, |
| int(value[5:7], 16) / 255.0, |
| ) |
| else: |
| rgb = PALETTE[index % len(PALETTE)] |
| else: |
| values = list(color) |
| values += [0.0, 0.0, 0.0] |
| rgb = (_num(values[0], 0.8), _num(values[1], 0.8), _num(values[2], 0.8)) |
| return [max(0.0, min(1.0, float(c))) for c in rgb], opacity |
|
|
|
|
| def build_scene(): |
| document = _active |
| if document is None: |
| return {"objects": [], "errors": [], "log": list(_log)} |
| document.recompute() |
| objects = [] |
| for obj in document.Objects: |
| if getattr(obj.ViewObject, "Visibility", True) is False: |
| continue |
| try: |
| shape = obj.Shape |
| except Exception: |
| continue |
| if shape is None: |
| continue |
| color, opacity = _get_color(obj, len(objects)) |
| objects.append( |
| { |
| "name": obj.Name, |
| "color": color, |
| "opacity": opacity, |
| "node": shape.render_node(), |
| } |
| ) |
| return {"objects": objects, "errors": list(document._errors), "log": list(_log)} |
|
|
|
|
| class Runtime: |
| def reset(self): |
| global _active, _log |
| _documents.clear() |
| _active = None |
| _log = [] |
| if _freecad is not None: |
| _freecad.ActiveDocument = None |
|
|
| def run(self, code): |
| self.reset() |
| try: |
| namespace = {"__name__": "__main__", "__file__": "<wfreecad>"} |
| exec(compile(code, "<wfreecad>", "exec"), namespace, namespace) |
| scene = build_scene() |
| return {"ok": True, "scene": scene} |
| except Exception: |
| return {"ok": False, "error": traceback.format_exc(limit=8), "log": list(_log)} |
|
|
|
|
| _runtime = Runtime() |
|
|
|
|
| def install(): |
| global _freecad, _part |
| if _freecad is not None: |
| return |
|
|
| _freecad = types.ModuleType("FreeCAD") |
| _freecad.Vector = Vector |
| _freecad.Rotation = Rotation |
| _freecad.Placement = Placement |
| _freecad.Matrix = Matrix |
| _freecad.newDocument = newDocument |
| _freecad.activeDocument = activeDocument |
| _freecad.closeDocument = closeDocument |
| _freecad.listDocuments = listDocuments |
| _freecad.ActiveDocument = None |
| _freecad.Console = types.SimpleNamespace( |
| PrintMessage=_log_message("Message"), |
| PrintWarning=_log_message("Warning"), |
| PrintError=_log_message("Error"), |
| ) |
| sys.modules["FreeCAD"] = _freecad |
|
|
| _part = types.ModuleType("Part") |
| _part.makeBox = _make_box |
| _part.makeCylinder = _make_cylinder |
| _part.makeSphere = _make_sphere |
| _part.makeCone = _make_cone |
| _part.makeTorus = _make_torus |
| _part.makePolygon = _make_polygon |
| _part.makeLine = _make_line |
| _part.makeCompound = _make_compound |
| _part.Face = _make_face_from |
| _part.Wire = lambda *args, **kwargs: _make_polygon(args[0] if args else [], True) |
| _part.show = _show |
| _part.Shape = Shape |
| sys.modules["Part"] = _part |
|
|
| try: |
| sys.modules["FreeCADGui"] = types.ModuleType("FreeCADGui") |
| except Exception: |
| pass |
|
|
|
|
| install() |
|
|
| __wfcad_runtime = _runtime |
|
|
