|
|
import math
|
|
|
import re
|
|
|
from pathlib import Path
|
|
|
|
|
|
import FreeCAD as App
|
|
|
|
|
|
import TerminalObjects
|
|
|
|
|
|
try:
|
|
|
import ImportGui
|
|
|
except Exception:
|
|
|
ImportGui = None
|
|
|
|
|
|
|
|
|
class BatchAssemblyError(RuntimeError):
|
|
|
pass
|
|
|
|
|
|
|
|
|
TERMINAL_STRIP_NAME_PROPERTIES = (
|
|
|
"QetTerminalStripName",
|
|
|
"QetTerminalBlockName",
|
|
|
"QetTerminalGroupName",
|
|
|
"QetStripName",
|
|
|
"QetParentTerminalBlockName",
|
|
|
)
|
|
|
|
|
|
TERMINAL_STRIP_ORDER_PROPERTIES = (
|
|
|
"QetTerminalStripIndex",
|
|
|
"QetTerminalIndex",
|
|
|
"QetTerminalSequence",
|
|
|
"QetTerminalOrder",
|
|
|
"QetTerminalNo",
|
|
|
"QetTerminalDisplay",
|
|
|
)
|
|
|
|
|
|
DEVICE_PREFIX_PROPERTIES = (
|
|
|
"QetDeviceTag",
|
|
|
"QetDeviceName",
|
|
|
"QetDisplayTag",
|
|
|
"QetSymbolLabel",
|
|
|
"QetInstanceId",
|
|
|
"QetElementUuid",
|
|
|
)
|
|
|
|
|
|
|
|
|
def _project_uuid(doc):
|
|
|
try:
|
|
|
root = TerminalObjects.ensure_root_group(doc)
|
|
|
return (getattr(root, "QetProjectUuid", "") or "").strip()
|
|
|
except Exception:
|
|
|
return ""
|
|
|
|
|
|
|
|
|
def _safe_label(text, fallback):
|
|
|
value = str(text or "").strip()
|
|
|
return value or fallback
|
|
|
|
|
|
|
|
|
def _text_values(obj, include_children=False):
|
|
|
values = []
|
|
|
for attr_name in ("Label", "Name"):
|
|
|
value = (getattr(obj, attr_name, "") or "").strip()
|
|
|
if value:
|
|
|
values.append(value)
|
|
|
for prop_name in DEVICE_PREFIX_PROPERTIES + TERMINAL_STRIP_NAME_PROPERTIES:
|
|
|
value = (getattr(obj, prop_name, "") or "").strip()
|
|
|
if value:
|
|
|
values.append(value)
|
|
|
if include_children:
|
|
|
for child in list(getattr(obj, "Group", []) or []):
|
|
|
for attr_name in ("Label", "Name"):
|
|
|
value = (getattr(child, attr_name, "") or "").strip()
|
|
|
if value:
|
|
|
values.append(value)
|
|
|
return values
|
|
|
|
|
|
|
|
|
def _label_name_values(obj):
|
|
|
values = []
|
|
|
for attr_name in ("Label", "Name"):
|
|
|
value = (getattr(obj, attr_name, "") or "").strip()
|
|
|
if value:
|
|
|
values.append(value)
|
|
|
return values
|
|
|
|
|
|
|
|
|
def _natural_sort_key(value):
|
|
|
text = str(value or "")
|
|
|
key = []
|
|
|
for part in re.split(r"(\d+)", text):
|
|
|
if part.isdigit():
|
|
|
key.append((0, int(part)))
|
|
|
else:
|
|
|
key.append((1, part.lower()))
|
|
|
return key
|
|
|
|
|
|
|
|
|
def _parse_strip_name_and_order(obj):
|
|
|
for prop_name in TERMINAL_STRIP_NAME_PROPERTIES:
|
|
|
strip_name = (getattr(obj, prop_name, "") or "").strip()
|
|
|
if not strip_name:
|
|
|
continue
|
|
|
order = _explicit_order(obj)
|
|
|
if order is None:
|
|
|
order = _order_from_texts(_text_values(obj))
|
|
|
return strip_name, order
|
|
|
|
|
|
for text in _label_name_values(obj):
|
|
|
# Examples from QET trees: UD:1, UD-2, ID_006.
|
|
|
match = re.match(r"^\s*([A-Za-z][A-Za-z0-9]{0,8})\s*[:：_\-]\s*(\d+)\b", text)
|
|
|
if match:
|
|
|
return match.group(1), int(match.group(2))
|
|
|
return "", None
|
|
|
|
|
|
|
|
|
def _explicit_order(obj):
|
|
|
for prop_name in TERMINAL_STRIP_ORDER_PROPERTIES:
|
|
|
value = (getattr(obj, prop_name, "") or "").strip()
|
|
|
if not value:
|
|
|
continue
|
|
|
match = re.search(r"\d+", value)
|
|
|
if match:
|
|
|
return int(match.group(0))
|
|
|
return None
|
|
|
|
|
|
|
|
|
def _order_from_texts(texts):
|
|
|
for text in texts:
|
|
|
match = re.search(r"(\d+)(?!.*\d)", str(text or ""))
|
|
|
if match:
|
|
|
return int(match.group(1))
|
|
|
return None
|
|
|
|
|
|
|
|
|
def _is_group_like(obj):
|
|
|
try:
|
|
|
return bool(obj and obj.isDerivedFrom("App::DocumentObjectGroup"))
|
|
|
except Exception:
|
|
|
return bool(getattr(obj, "Group", None) is not None)
|
|
|
|
|
|
|
|
|
def _qet_identity(obj):
|
|
|
instance_id = (getattr(obj, "QetInstanceId", "") or "").strip()
|
|
|
element_uuid = (getattr(obj, "QetElementUuid", "") or "").strip()
|
|
|
return instance_id, element_uuid
|
|
|
|
|
|
|
|
|
def _is_qet_device_object(obj):
|
|
|
if obj is None:
|
|
|
return False
|
|
|
if TerminalObjects.is_terminal_object(obj):
|
|
|
return False
|
|
|
group_kind = (getattr(obj, "QetGroupKind", "") or "").strip()
|
|
|
if group_kind in {TerminalObjects.TERMINAL_GROUP_KIND, TerminalObjects.WIRE_GROUP_KIND}:
|
|
|
return False
|
|
|
name = getattr(obj, "Name", "") or ""
|
|
|
if name.startswith(TerminalObjects.TERMINAL_GROUP_PREFIX) or name.startswith(TerminalObjects.WIRE_GROUP_PREFIX):
|
|
|
return False
|
|
|
instance_id, element_uuid = _qet_identity(obj)
|
|
|
if name.startswith(TerminalObjects.DEVICE_GROUP_PREFIX):
|
|
|
return True
|
|
|
if group_kind == "Device":
|
|
|
return True
|
|
|
return bool(instance_id or element_uuid)
|
|
|
|
|
|
|
|
|
def _contains_terminal_slice_geometry(obj):
|
|
|
text = " ".join(_text_values(obj, include_children=True)).lower()
|
|
|
return any(
|
|
|
token in text
|
|
|
for token in (
|
|
|
"terminalslice",
|
|
|
"terminal_slice",
|
|
|
"terminal slice",
|
|
|
"get_terminal_slice",
|
|
|
"端子片",
|
|
|
"端子排",
|
|
|
)
|
|
|
)
|
|
|
|
|
|
|
|
|
def _contains_qet_terminal_group(obj):
|
|
|
for child in list(getattr(obj, "Group", []) or []):
|
|
|
if (getattr(child, "QetGroupKind", "") or "").strip() == TerminalObjects.TERMINAL_GROUP_KIND:
|
|
|
return True
|
|
|
if getattr(child, "Name", "").startswith(TerminalObjects.TERMINAL_GROUP_PREFIX):
|
|
|
return True
|
|
|
return False
|
|
|
|
|
|
|
|
|
def _is_terminal_strip_device(obj):
|
|
|
if not _is_qet_device_object(obj):
|
|
|
return False
|
|
|
strip_name, _order = _parse_strip_name_and_order(obj)
|
|
|
if not strip_name:
|
|
|
return False
|
|
|
if _contains_terminal_slice_geometry(obj):
|
|
|
return True
|
|
|
if _contains_qet_terminal_group(obj):
|
|
|
return True
|
|
|
return False
|
|
|
|
|
|
|
|
|
def _matches_prefix(obj, prefix):
|
|
|
prefix = (prefix or "").strip().lower()
|
|
|
if not prefix:
|
|
|
return True
|
|
|
for text in _text_values(obj):
|
|
|
if text.lower().startswith(prefix):
|
|
|
return True
|
|
|
return False
|
|
|
|
|
|
|
|
|
def _is_batch_generated(obj):
|
|
|
return bool((getattr(obj, "QetBatchAssemblyKind", "") or "").strip())
|
|
|
|
|
|
|
|
|
def _existing_terminal_strip_devices(doc, strip_name=""):
|
|
|
wanted = (strip_name or "").strip().lower()
|
|
|
devices = []
|
|
|
for obj in list(getattr(doc, "Objects", []) or []):
|
|
|
if not _is_terminal_strip_device(obj):
|
|
|
continue
|
|
|
current_strip, order = _parse_strip_name_and_order(obj)
|
|
|
if wanted and current_strip.lower() != wanted:
|
|
|
continue
|
|
|
devices.append((current_strip, order, obj))
|
|
|
devices.sort(
|
|
|
key=lambda item: (
|
|
|
item[0].lower(),
|
|
|
item[1] if item[1] is not None else 10**9,
|
|
|
_natural_sort_key(getattr(item[2], "Label", "") or getattr(item[2], "Name", "")),
|
|
|
)
|
|
|
)
|
|
|
return [obj for _strip, _order, obj in devices]
|
|
|
|
|
|
|
|
|
def available_terminal_strip_names(doc):
|
|
|
names = []
|
|
|
seen = set()
|
|
|
for obj in list(getattr(doc, "Objects", []) or []):
|
|
|
if not _is_terminal_strip_device(obj):
|
|
|
continue
|
|
|
strip_name, _order = _parse_strip_name_and_order(obj)
|
|
|
key = strip_name.lower()
|
|
|
if strip_name and key not in seen:
|
|
|
seen.add(key)
|
|
|
names.append(strip_name)
|
|
|
names.sort(key=_natural_sort_key)
|
|
|
return names
|
|
|
|
|
|
|
|
|
def _existing_devices_by_prefix(doc, prefix=""):
|
|
|
devices = []
|
|
|
for obj in list(getattr(doc, "Objects", []) or []):
|
|
|
if not _is_qet_device_object(obj):
|
|
|
continue
|
|
|
if _is_terminal_strip_device(obj):
|
|
|
continue
|
|
|
if _is_batch_generated(obj):
|
|
|
continue
|
|
|
if not _matches_prefix(obj, prefix):
|
|
|
continue
|
|
|
devices.append(obj)
|
|
|
devices.sort(key=lambda obj: _natural_sort_key(getattr(obj, "Label", "") or getattr(obj, "Name", "")))
|
|
|
return devices
|
|
|
|
|
|
|
|
|
def _axis_vector(rail):
|
|
|
axis = (getattr(rail, "QetCarrierAxis", "") or "x").strip().lower()
|
|
|
if axis == "y":
|
|
|
vector = App.Vector(0, 1, 0)
|
|
|
elif axis == "z":
|
|
|
vector = App.Vector(0, 0, 1)
|
|
|
else:
|
|
|
vector = App.Vector(1, 0, 0)
|
|
|
|
|
|
try:
|
|
|
placement = getattr(rail, "Placement", None)
|
|
|
rotation = getattr(placement, "Rotation", None)
|
|
|
if rotation is not None and hasattr(rotation, "multVec"):
|
|
|
vector = rotation.multVec(vector)
|
|
|
except Exception:
|
|
|
pass
|
|
|
|
|
|
length = math.sqrt(vector.x * vector.x + vector.y * vector.y + vector.z * vector.z)
|
|
|
if length <= 1e-9:
|
|
|
return App.Vector(1, 0, 0)
|
|
|
return App.Vector(vector.x / length, vector.y / length, vector.z / length)
|
|
|
|
|
|
|
|
|
def _base_point(rail):
|
|
|
placement = getattr(rail, "Placement", None)
|
|
|
base = getattr(placement, "Base", None)
|
|
|
if base is None:
|
|
|
return App.Vector(0, 0, 0)
|
|
|
return App.Vector(base.x, base.y, base.z)
|
|
|
|
|
|
|
|
|
def _point_at(base, axis, offset):
|
|
|
return App.Vector(
|
|
|
base.x + axis.x * float(offset or 0.0),
|
|
|
base.y + axis.y * float(offset or 0.0),
|
|
|
base.z + axis.z * float(offset or 0.0),
|
|
|
)
|
|
|
|
|
|
|
|
|
def _placement_at(rail, point):
|
|
|
rotation = None
|
|
|
try:
|
|
|
rotation = getattr(getattr(rail, "Placement", None), "Rotation", None)
|
|
|
except Exception:
|
|
|
rotation = None
|
|
|
return App.Placement(point, rotation or App.Rotation())
|
|
|
|
|
|
|
|
|
def _vector_copy(vector):
|
|
|
return App.Vector(
|
|
|
float(getattr(vector, "x", 0.0) or 0.0),
|
|
|
float(getattr(vector, "y", 0.0) or 0.0),
|
|
|
float(getattr(vector, "z", 0.0) or 0.0),
|
|
|
)
|
|
|
|
|
|
|
|
|
def _vector_add(left, right):
|
|
|
return App.Vector(
|
|
|
float(getattr(left, "x", 0.0) or 0.0) + float(getattr(right, "x", 0.0) or 0.0),
|
|
|
float(getattr(left, "y", 0.0) or 0.0) + float(getattr(right, "y", 0.0) or 0.0),
|
|
|
float(getattr(left, "z", 0.0) or 0.0) + float(getattr(right, "z", 0.0) or 0.0),
|
|
|
)
|
|
|
|
|
|
|
|
|
def _vector_sub(left, right):
|
|
|
return App.Vector(
|
|
|
float(getattr(left, "x", 0.0) or 0.0) - float(getattr(right, "x", 0.0) or 0.0),
|
|
|
float(getattr(left, "y", 0.0) or 0.0) - float(getattr(right, "y", 0.0) or 0.0),
|
|
|
float(getattr(left, "z", 0.0) or 0.0) - float(getattr(right, "z", 0.0) or 0.0),
|
|
|
)
|
|
|
|
|
|
|
|
|
def _placement_base(obj):
|
|
|
placement = getattr(obj, "Placement", None)
|
|
|
base = getattr(placement, "Base", None)
|
|
|
if base is None:
|
|
|
return None
|
|
|
return _vector_copy(base)
|
|
|
|
|
|
|
|
|
def _placement_controls_children(obj):
|
|
|
try:
|
|
|
return bool(obj is not None and obj.isDerivedFrom("App::Part"))
|
|
|
except Exception:
|
|
|
return False
|
|
|
|
|
|
|
|
|
def _iter_transform_children(obj):
|
|
|
for child in list(getattr(obj, "Group", []) or []):
|
|
|
yield child
|
|
|
if not _placement_controls_children(child):
|
|
|
for nested in _iter_transform_children(child):
|
|
|
yield nested
|
|
|
|
|
|
|
|
|
def _object_anchor_point(obj):
|
|
|
if obj is None:
|
|
|
return App.Vector(0, 0, 0)
|
|
|
children = list(getattr(obj, "Group", []) or [])
|
|
|
if _placement_controls_children(obj) or not children:
|
|
|
return _placement_base(obj) or App.Vector(0, 0, 0)
|
|
|
|
|
|
points = []
|
|
|
for child in _iter_transform_children(obj):
|
|
|
base = _placement_base(child)
|
|
|
if base is not None:
|
|
|
points.append(base)
|
|
|
if not points:
|
|
|
return _placement_base(obj) or App.Vector(0, 0, 0)
|
|
|
|
|
|
return App.Vector(
|
|
|
sum(point.x for point in points) / len(points),
|
|
|
sum(point.y for point in points) / len(points),
|
|
|
sum(point.z for point in points) / len(points),
|
|
|
)
|
|
|
|
|
|
|
|
|
def _translate_placement(obj, delta):
|
|
|
placement = getattr(obj, "Placement", None)
|
|
|
base = getattr(placement, "Base", None)
|
|
|
if placement is None or base is None:
|
|
|
return False
|
|
|
new_base = _vector_add(base, delta)
|
|
|
try:
|
|
|
placement.Base = new_base
|
|
|
obj.Placement = placement
|
|
|
return True
|
|
|
except Exception:
|
|
|
try:
|
|
|
obj.Placement = App.Placement(new_base, getattr(placement, "Rotation", App.Rotation()))
|
|
|
return True
|
|
|
except Exception:
|
|
|
return False
|
|
|
|
|
|
|
|
|
def _translate_group_children(obj, delta):
|
|
|
moved = 0
|
|
|
for child in list(getattr(obj, "Group", []) or []):
|
|
|
if _translate_placement(child, delta):
|
|
|
moved += 1
|
|
|
if not _placement_controls_children(child):
|
|
|
moved += _translate_group_children(child, delta)
|
|
|
return moved
|
|
|
|
|
|
|
|
|
def _ensure_rail(rail):
|
|
|
if rail is None:
|
|
|
raise BatchAssemblyError("请先选择一根导轨。")
|
|
|
kind = (getattr(rail, "QetCarrierKind", "") or "").strip()
|
|
|
if kind and kind != "rail":
|
|
|
raise BatchAssemblyError("所选对象不是导轨。")
|
|
|
return rail
|
|
|
|
|
|
|
|
|
def _ensure_batch_root(doc, project_uuid=""):
|
|
|
group = doc.getObject("QETBatchAssembly")
|
|
|
if group is None:
|
|
|
group = doc.addObject("App::DocumentObjectGroup", "QETBatchAssembly")
|
|
|
group.Label = "QET Batch Assembly"
|
|
|
if project_uuid:
|
|
|
TerminalObjects.ensure_string_property(
|
|
|
group,
|
|
|
"QetProjectUuid",
|
|
|
"QET Batch Assembly",
|
|
|
"Project UUID",
|
|
|
project_uuid,
|
|
|
)
|
|
|
return group
|
|
|
|
|
|
|
|
|
def _unique_object_name(doc, base_name):
|
|
|
name = TerminalObjects.safe_token(base_name) or "QETObject"
|
|
|
if doc.getObject(name) is None:
|
|
|
return name
|
|
|
|
|
|
suffix = 1
|
|
|
while doc.getObject("{0}_{1}".format(name, suffix)) is not None:
|
|
|
suffix += 1
|
|
|
return "{0}_{1}".format(name, suffix)
|
|
|
|
|
|
|
|
|
def _existing_object_names(doc):
|
|
|
return {getattr(obj, "Name", "") for obj in list(getattr(doc, "Objects", []) or [])}
|
|
|
|
|
|
|
|
|
def _new_objects_since(doc, before_names):
|
|
|
return [
|
|
|
obj
|
|
|
for obj in list(getattr(doc, "Objects", []) or [])
|
|
|
if getattr(obj, "Name", "") not in before_names
|
|
|
]
|
|
|
|
|
|
|
|
|
def _top_level_objects(objects):
|
|
|
object_set = set(objects or [])
|
|
|
result = []
|
|
|
for obj in objects or []:
|
|
|
parents = set(getattr(obj, "InList", []) or [])
|
|
|
if parents.intersection(object_set):
|
|
|
continue
|
|
|
result.append(obj)
|
|
|
return result
|
|
|
|
|
|
|
|
|
def _supported_model_path(path):
|
|
|
suffix = Path(path or "").suffix.lower()
|
|
|
return suffix in {".fcstd", ".step", ".stp"}
|
|
|
|
|
|
|
|
|
def _set_source_model_path(obj, model_path):
|
|
|
TerminalObjects.ensure_string_property(
|
|
|
obj,
|
|
|
"QetBatchSourceModelPath",
|
|
|
"QET Batch Assembly",
|
|
|
"Batch assembly imported model path",
|
|
|
model_path,
|
|
|
)
|
|
|
|
|
|
|
|
|
def _import_fcstd_objects(doc, path):
|
|
|
if not hasattr(App, "openDocument") or not hasattr(doc, "copyObject"):
|
|
|
return []
|
|
|
source_doc = None
|
|
|
try:
|
|
|
source_doc = App.openDocument(path, hidden=True, temporary=True)
|
|
|
copied = []
|
|
|
for source_obj in _top_level_objects(list(getattr(source_doc, "Objects", []) or [])):
|
|
|
copied.append(doc.copyObject(source_obj, True))
|
|
|
return copied
|
|
|
finally:
|
|
|
if source_doc is not None and hasattr(App, "closeDocument"):
|
|
|
try:
|
|
|
App.closeDocument(source_doc.Name)
|
|
|
except Exception:
|
|
|
pass
|
|
|
|
|
|
|
|
|
def _import_step_objects(doc, path):
|
|
|
if ImportGui is None:
|
|
|
return []
|
|
|
before = _existing_object_names(doc)
|
|
|
try:
|
|
|
ImportGui.insert(name=path, docName=doc.Name, merge=False, useLinkGroup=True)
|
|
|
except TypeError:
|
|
|
ImportGui.insert(path, doc.Name)
|
|
|
return _top_level_objects(_new_objects_since(doc, before))
|
|
|
|
|
|
|
|
|
def _import_model_objects(doc, model_path):
|
|
|
path = str(model_path or "").strip()
|
|
|
if not path:
|
|
|
return []
|
|
|
if not _supported_model_path(path):
|
|
|
raise BatchAssemblyError("请选择 STEP/STP/FCStd 模型文件。")
|
|
|
if not Path(path).is_file():
|
|
|
raise BatchAssemblyError("模型文件不存在：{0}".format(path))
|
|
|
suffix = Path(path).suffix.lower()
|
|
|
if suffix == ".fcstd":
|
|
|
return _import_fcstd_objects(doc, path)
|
|
|
return _import_step_objects(doc, path)
|
|
|
|
|
|
|
|
|
def _set_batch_properties(obj, kind, batch_name, host):
|
|
|
TerminalObjects.ensure_string_property(
|
|
|
obj,
|
|
|
"QetBatchAssemblyKind",
|
|
|
"QET Batch Assembly",
|
|
|
"Batch assembly kind",
|
|
|
kind,
|
|
|
)
|
|
|
TerminalObjects.ensure_string_property(
|
|
|
obj,
|
|
|
"QetBatchAssemblyName",
|
|
|
"QET Batch Assembly",
|
|
|
"Batch assembly name",
|
|
|
batch_name,
|
|
|
)
|
|
|
TerminalObjects.ensure_string_property(
|
|
|
obj,
|
|
|
"QetMountKind",
|
|
|
"QET Mount",
|
|
|
"Mount kind",
|
|
|
"rail",
|
|
|
)
|
|
|
TerminalObjects.ensure_string_property(
|
|
|
obj,
|
|
|
"QetMountHostName",
|
|
|
"QET Mount",
|
|
|
"Mount host object name",
|
|
|
getattr(host, "Name", "") or "",
|
|
|
)
|
|
|
TerminalObjects.ensure_string_property(
|
|
|
obj,
|
|
|
"QetMountHostKind",
|
|
|
"QET Mount",
|
|
|
"Mount host kind",
|
|
|
(getattr(host, "QetCarrierKind", "") or "").strip(),
|
|
|
)
|
|
|
|
|
|
|
|
|
def _set_layout_properties(obj, kind, batch_name, host, order_index, offset_mm):
|
|
|
_set_batch_properties(obj, kind, batch_name, host)
|
|
|
TerminalObjects.ensure_string_property(
|
|
|
obj,
|
|
|
"QetBatchAssemblyMode",
|
|
|
"QET Batch Assembly",
|
|
|
"Batch assembly mode",
|
|
|
"layout_existing",
|
|
|
)
|
|
|
TerminalObjects.ensure_string_property(
|
|
|
obj,
|
|
|
"QetBatchAssemblyOrder",
|
|
|
"QET Batch Assembly",
|
|
|
"Batch assembly order",
|
|
|
str(int(order_index)),
|
|
|
)
|
|
|
TerminalObjects.ensure_string_property(
|
|
|
obj,
|
|
|
"QetBatchAssemblyOffsetMm",
|
|
|
"QET Batch Assembly",
|
|
|
"Batch assembly offset in millimeters",
|
|
|
"{0:.6f}".format(float(offset_mm or 0.0)),
|
|
|
)
|
|
|
|
|
|
|
|
|
def _set_object_placement(obj, placement):
|
|
|
if obj is not None and getattr(obj, "Group", None) and not _placement_controls_children(obj):
|
|
|
current = _object_anchor_point(obj)
|
|
|
target = getattr(placement, "Base", App.Vector(0, 0, 0))
|
|
|
delta = _vector_sub(target, current)
|
|
|
moved_children = _translate_group_children(obj, delta)
|
|
|
try:
|
|
|
obj.Placement = placement
|
|
|
except Exception:
|
|
|
pass
|
|
|
if moved_children:
|
|
|
return True
|
|
|
|
|
|
try:
|
|
|
obj.Placement = placement
|
|
|
return True
|
|
|
except Exception:
|
|
|
try:
|
|
|
existing = getattr(obj, "Placement", None)
|
|
|
if existing is not None:
|
|
|
existing.Base = placement.Base
|
|
|
existing.Rotation = placement.Rotation
|
|
|
obj.Placement = existing
|
|
|
return True
|
|
|
except Exception:
|
|
|
pass
|
|
|
return False
|
|
|
|
|
|
|
|
|
def _set_qet_device_properties(obj, project_uuid, element_uuid, instance_id):
|
|
|
TerminalObjects.ensure_string_property(
|
|
|
obj,
|
|
|
"QetGroupKind",
|
|
|
"QET Exchange",
|
|
|
"FreeCADExchange group kind",
|
|
|
"Device",
|
|
|
)
|
|
|
TerminalObjects.ensure_string_property(
|
|
|
obj,
|
|
|
"QetProjectUuid",
|
|
|
"QET Exchange",
|
|
|
"Project UUID from QET exchange",
|
|
|
project_uuid,
|
|
|
)
|
|
|
TerminalObjects.ensure_string_property(
|
|
|
obj,
|
|
|
"QetElementUuid",
|
|
|
"QET Exchange",
|
|
|
"Parent element UUID from QET exchange",
|
|
|
element_uuid,
|
|
|
)
|
|
|
TerminalObjects.ensure_string_property(
|
|
|
obj,
|
|
|
"QetInstanceId",
|
|
|
"QET Exchange",
|
|
|
"Parent instance id from QET exchange",
|
|
|
instance_id,
|
|
|
)
|
|
|
|
|
|
|
|
|
def _create_device_group(
|
|
|
doc,
|
|
|
parent,
|
|
|
label,
|
|
|
placement,
|
|
|
kind,
|
|
|
batch_name,
|
|
|
host,
|
|
|
project_uuid,
|
|
|
element_uuid,
|
|
|
instance_id,
|
|
|
):
|
|
|
group = doc.addObject(
|
|
|
"App::DocumentObjectGroup",
|
|
|
_unique_object_name(doc, "QETDevice_{0}".format(label)),
|
|
|
)
|
|
|
group.Label = label
|
|
|
try:
|
|
|
group.Placement = placement
|
|
|
except Exception:
|
|
|
pass
|
|
|
parent.addObject(group)
|
|
|
_set_batch_properties(group, kind, batch_name, host)
|
|
|
_set_qet_device_properties(group, project_uuid, element_uuid, instance_id)
|
|
|
return group
|
|
|
|
|
|
|
|
|
def _create_visual_placeholder(doc, device_group, label, placement, kind):
|
|
|
try:
|
|
|
body = doc.addObject("Part::Feature", "QETBatchBody_{0}".format(TerminalObjects.safe_token(label)))
|
|
|
body.Label = "{0} 模型".format(label)
|
|
|
body.Placement = placement
|
|
|
try:
|
|
|
import Part
|
|
|
|
|
|
if kind == "breaker":
|
|
|
body.Shape = Part.makeBox(18.0, 72.0, 80.0)
|
|
|
else:
|
|
|
body.Shape = Part.makeBox(5.2, 40.0, 45.0)
|
|
|
except Exception:
|
|
|
pass
|
|
|
try:
|
|
|
if kind == "breaker":
|
|
|
body.ViewObject.ShapeColor = (0.78, 0.78, 0.72)
|
|
|
else:
|
|
|
body.ViewObject.ShapeColor = (0.35, 0.75, 0.35)
|
|
|
except Exception:
|
|
|
pass
|
|
|
device_group.addObject(body)
|
|
|
_set_batch_properties(body, kind, getattr(device_group, "Label", "") or label, device_group)
|
|
|
return body
|
|
|
except Exception:
|
|
|
return None
|
|
|
|
|
|
|
|
|
def _create_visual_model(doc, device_group, label, placement, kind, model_path=""):
|
|
|
imported = _import_model_objects(doc, model_path)
|
|
|
if imported:
|
|
|
for index, obj in enumerate(imported):
|
|
|
try:
|
|
|
obj.Placement = placement
|
|
|
except Exception:
|
|
|
pass
|
|
|
if index == 0:
|
|
|
obj.Label = "{0} 模型".format(label)
|
|
|
device_group.addObject(obj)
|
|
|
_set_batch_properties(obj, kind, getattr(device_group, "Label", "") or label, device_group)
|
|
|
_set_source_model_path(obj, model_path)
|
|
|
return imported[0]
|
|
|
return _create_visual_placeholder(doc, device_group, label, placement, kind)
|
|
|
|
|
|
|
|
|
def _create_terminal(
|
|
|
doc,
|
|
|
device_group,
|
|
|
project_uuid,
|
|
|
element_uuid,
|
|
|
instance_id,
|
|
|
terminal_no,
|
|
|
offset_index=0,
|
|
|
label_prefix="",
|
|
|
):
|
|
|
owner_label = _safe_label(label_prefix, getattr(device_group, "Label", "") or instance_id)
|
|
|
label = "{0}:{1}".format(owner_label, terminal_no)
|
|
|
base = getattr(getattr(device_group, "Placement", None), "Base", App.Vector())
|
|
|
terminal_point = App.Vector(base.x, base.y + float(offset_index) * 2.0, base.z)
|
|
|
terminal = TerminalObjects.create_lcs_object(
|
|
|
doc,
|
|
|
"QETTerminal_{0}_{1}".format(TerminalObjects.safe_token(instance_id), TerminalObjects.safe_token(terminal_no)),
|
|
|
placement=App.Placement(terminal_point, App.Rotation()),
|
|
|
label=label,
|
|
|
)
|
|
|
terminal_group = TerminalObjects.ensure_terminal_group(
|
|
|
doc,
|
|
|
device_group,
|
|
|
project_uuid=project_uuid,
|
|
|
instance_id=instance_id,
|
|
|
)
|
|
|
terminal_group.addObject(terminal)
|
|
|
TerminalObjects.set_terminal_semantics(
|
|
|
terminal,
|
|
|
project_uuid,
|
|
|
element_uuid,
|
|
|
"local:{0}:{1}".format(instance_id, terminal_no),
|
|
|
instance_id,
|
|
|
label=label,
|
|
|
slot_name=str(terminal_no),
|
|
|
)
|
|
|
TerminalObjects.hide_engineering_terminal(terminal)
|
|
|
return terminal
|
|
|
|
|
|
|
|
|
def _terminal_objects_for_devices(devices):
|
|
|
terminals = []
|
|
|
for device in devices or []:
|
|
|
try:
|
|
|
terminals.extend(TerminalObjects.collect_terminal_objects(device))
|
|
|
except Exception:
|
|
|
pass
|
|
|
return terminals
|
|
|
|
|
|
|
|
|
def _batch_report(kind, group, devices, terminals, source="fallback_created"):
|
|
|
return {
|
|
|
"kind": kind,
|
|
|
"group": group,
|
|
|
"devices": devices,
|
|
|
"terminals": terminals,
|
|
|
"created_devices": len(devices),
|
|
|
"created_terminals": len(terminals),
|
|
|
"updated_devices": 0,
|
|
|
"updated_terminals": 0,
|
|
|
"source": source,
|
|
|
}
|
|
|
|
|
|
|
|
|
def _layout_existing_objects(
|
|
|
doc,
|
|
|
rail,
|
|
|
objects,
|
|
|
kind,
|
|
|
batch_name,
|
|
|
pitch_mm,
|
|
|
start_offset_mm,
|
|
|
):
|
|
|
rail = _ensure_rail(rail)
|
|
|
objects = [obj for obj in objects or [] if obj is not None]
|
|
|
if not objects:
|
|
|
return _batch_report(kind, rail, [], [], source="qet_existing")
|
|
|
|
|
|
base = _base_point(rail)
|
|
|
axis = _axis_vector(rail)
|
|
|
updated = []
|
|
|
for index, obj in enumerate(objects):
|
|
|
offset = float(start_offset_mm or 0.0) + index * float(pitch_mm or 0.0)
|
|
|
placement = _placement_at(rail, _point_at(base, axis, offset))
|
|
|
if _set_object_placement(obj, placement):
|
|
|
_set_layout_properties(obj, kind, batch_name, rail, index + 1, offset)
|
|
|
updated.append(obj)
|
|
|
|
|
|
try:
|
|
|
doc.recompute()
|
|
|
except Exception:
|
|
|
pass
|
|
|
|
|
|
terminals = _terminal_objects_for_devices(updated)
|
|
|
return {
|
|
|
"kind": kind,
|
|
|
"group": rail,
|
|
|
"devices": updated,
|
|
|
"terminals": terminals,
|
|
|
"created_devices": 0,
|
|
|
"created_terminals": 0,
|
|
|
"updated_devices": len(updated),
|
|
|
"updated_terminals": len(terminals),
|
|
|
"source": "qet_existing",
|
|
|
}
|
|
|
|
|
|
|
|
|
def layout_existing_terminal_block(
|
|
|
doc,
|
|
|
rail,
|
|
|
block_name="",
|
|
|
pitch_mm=5.2,
|
|
|
start_offset_mm=0.0,
|
|
|
):
|
|
|
if doc is None:
|
|
|
raise BatchAssemblyError("请先打开 FreeCAD 工程。")
|
|
|
rail = _ensure_rail(rail)
|
|
|
devices = _existing_terminal_strip_devices(doc, block_name)
|
|
|
if not devices:
|
|
|
return _batch_report("terminal_block", rail, [], [], source="qet_existing")
|
|
|
batch_name = _safe_label(block_name, _parse_strip_name_and_order(devices[0])[0] or "QET端子排")
|
|
|
return _layout_existing_objects(
|
|
|
doc,
|
|
|
rail,
|
|
|
devices,
|
|
|
"terminal_block",
|
|
|
batch_name,
|
|
|
pitch_mm,
|
|
|
start_offset_mm,
|
|
|
)
|
|
|
|
|
|
|
|
|
def layout_existing_devices(
|
|
|
doc,
|
|
|
rail,
|
|
|
prefix="QF",
|
|
|
pitch_mm=18.0,
|
|
|
start_offset_mm=0.0,
|
|
|
kind="device_batch",
|
|
|
):
|
|
|
if doc is None:
|
|
|
raise BatchAssemblyError("请先打开 FreeCAD 工程。")
|
|
|
rail = _ensure_rail(rail)
|
|
|
devices = _existing_devices_by_prefix(doc, prefix)
|
|
|
if not devices:
|
|
|
return _batch_report(kind, rail, [], [], source="qet_existing")
|
|
|
batch_name = _safe_label(prefix, "QET设备")
|
|
|
return _layout_existing_objects(
|
|
|
doc,
|
|
|
rail,
|
|
|
devices,
|
|
|
kind,
|
|
|
batch_name,
|
|
|
pitch_mm,
|
|
|
start_offset_mm,
|
|
|
)
|
|
|
|
|
|
|
|
|
def create_terminal_block(
|
|
|
doc,
|
|
|
rail,
|
|
|
block_name="XT1",
|
|
|
count=10,
|
|
|
pitch_mm=5.2,
|
|
|
start_offset_mm=0.0,
|
|
|
model_path="",
|
|
|
):
|
|
|
if doc is None:
|
|
|
raise BatchAssemblyError("请先打开 FreeCAD 工程。")
|
|
|
rail = _ensure_rail(rail)
|
|
|
count = int(count or 0)
|
|
|
if count <= 0:
|
|
|
raise BatchAssemblyError("端子数量必须大于 0。")
|
|
|
|
|
|
project_uuid = _project_uuid(doc)
|
|
|
batch_name = _safe_label(block_name, "XT1")
|
|
|
root = _ensure_batch_root(doc, project_uuid)
|
|
|
group = doc.addObject("App::DocumentObjectGroup", TerminalObjects.safe_token(batch_name))
|
|
|
group.Label = batch_name
|
|
|
root.addObject(group)
|
|
|
_set_batch_properties(group, "terminal_block", batch_name, rail)
|
|
|
|
|
|
base = _base_point(rail)
|
|
|
axis = _axis_vector(rail)
|
|
|
devices = []
|
|
|
terminals = []
|
|
|
for index in range(count):
|
|
|
terminal_no = str(index + 1)
|
|
|
point = _point_at(base, axis, float(start_offset_mm or 0.0) + index * float(pitch_mm or 0.0))
|
|
|
device_label = "{0}_{1:03d}".format(batch_name, index + 1)
|
|
|
device = _create_device_group(
|
|
|
doc,
|
|
|
group,
|
|
|
device_label,
|
|
|
_placement_at(rail, point),
|
|
|
"terminal_slice",
|
|
|
batch_name,
|
|
|
rail,
|
|
|
project_uuid,
|
|
|
device_label,
|
|
|
device_label,
|
|
|
)
|
|
|
_create_visual_model(doc, device, device_label, _placement_at(rail, point), "terminal_slice", model_path)
|
|
|
instance_id = device_label
|
|
|
element_uuid = batch_name
|
|
|
terminal = _create_terminal(
|
|
|
doc,
|
|
|
device,
|
|
|
project_uuid,
|
|
|
element_uuid,
|
|
|
instance_id,
|
|
|
terminal_no,
|
|
|
label_prefix=batch_name,
|
|
|
)
|
|
|
devices.append(device)
|
|
|
terminals.append(terminal)
|
|
|
|
|
|
try:
|
|
|
doc.recompute()
|
|
|
except Exception:
|
|
|
pass
|
|
|
return _batch_report("terminal_block", group, devices, terminals)
|
|
|
|
|
|
|
|
|
def create_breakers(
|
|
|
doc,
|
|
|
rail,
|
|
|
base_name="QF",
|
|
|
count=3,
|
|
|
pitch_mm=18.0,
|
|
|
start_offset_mm=0.0,
|
|
|
terminal_numbers=("1", "2", "3", "4", "5", "6"),
|
|
|
model_path="",
|
|
|
):
|
|
|
if doc is None:
|
|
|
raise BatchAssemblyError("请先打开 FreeCAD 工程。")
|
|
|
rail = _ensure_rail(rail)
|
|
|
count = int(count or 0)
|
|
|
if count <= 0:
|
|
|
raise BatchAssemblyError("断路器数量必须大于 0。")
|
|
|
terminal_numbers = [str(item).strip() for item in terminal_numbers or () if str(item).strip()]
|
|
|
if not terminal_numbers:
|
|
|
raise BatchAssemblyError("至少需要一个端子号。")
|
|
|
|
|
|
project_uuid = _project_uuid(doc)
|
|
|
batch_name = _safe_label(base_name, "QF")
|
|
|
root = _ensure_batch_root(doc, project_uuid)
|
|
|
group = doc.addObject("App::DocumentObjectGroup", "QETBatch_{0}".format(TerminalObjects.safe_token(batch_name)))
|
|
|
group.Label = "{0} 批量断路器".format(batch_name)
|
|
|
root.addObject(group)
|
|
|
_set_batch_properties(group, "breaker_batch", batch_name, rail)
|
|
|
|
|
|
base = _base_point(rail)
|
|
|
axis = _axis_vector(rail)
|
|
|
devices = []
|
|
|
terminals = []
|
|
|
for index in range(count):
|
|
|
device_label = "{0}{1}".format(batch_name, index + 1)
|
|
|
point = _point_at(base, axis, float(start_offset_mm or 0.0) + index * float(pitch_mm or 0.0))
|
|
|
device = _create_device_group(
|
|
|
doc,
|
|
|
group,
|
|
|
device_label,
|
|
|
_placement_at(rail, point),
|
|
|
"breaker",
|
|
|
batch_name,
|
|
|
rail,
|
|
|
project_uuid,
|
|
|
device_label,
|
|
|
device_label,
|
|
|
)
|
|
|
_create_visual_model(doc, device, device_label, _placement_at(rail, point), "breaker", model_path)
|
|
|
instance_id = device_label
|
|
|
element_uuid = device_label
|
|
|
for terminal_index, terminal_no in enumerate(terminal_numbers):
|
|
|
terminals.append(
|
|
|
_create_terminal(
|
|
|
doc,
|
|
|
device,
|
|
|
project_uuid,
|
|
|
element_uuid,
|
|
|
instance_id,
|
|
|
terminal_no,
|
|
|
offset_index=terminal_index,
|
|
|
)
|
|
|
)
|
|
|
devices.append(device)
|
|
|
|
|
|
try:
|
|
|
doc.recompute()
|
|
|
except Exception:
|
|
|
pass
|
|
|
return _batch_report("breaker_batch", group, devices, terminals)
|