820 lines
33 KiB
Python
820 lines
33 KiB
Python
from __future__ import annotations
|
||
|
||
from collections.abc import Iterable, Mapping
|
||
|
||
|
||
def property_specs_from_scdm_cache(
|
||
cache: Mapping[str, object],
|
||
*,
|
||
selected_face_ids: Iterable[int] = (),
|
||
selected_edge_ids: Iterable[int] = (),
|
||
selected_solid_ids: Iterable[int] = (),
|
||
execution_ready: bool | Iterable[str] = False,
|
||
) -> list[dict[str, object]]:
|
||
face_ids = {int(item) for item in selected_face_ids}
|
||
edge_ids = {int(item) for item in selected_edge_ids}
|
||
solid_ids = {int(item) for item in selected_solid_ids}
|
||
if not face_ids and not edge_ids and not solid_ids:
|
||
return []
|
||
objects = cache.get("objects")
|
||
if not isinstance(objects, list):
|
||
return []
|
||
|
||
specs: list[dict[str, object]] = []
|
||
for item in objects:
|
||
if not isinstance(item, Mapping) or not _object_matches(
|
||
item,
|
||
face_ids=face_ids,
|
||
edge_ids=edge_ids,
|
||
solid_ids=solid_ids,
|
||
):
|
||
continue
|
||
capabilities = item.get("capabilities")
|
||
if not isinstance(capabilities, list):
|
||
continue
|
||
for capability in capabilities:
|
||
if isinstance(capability, Mapping):
|
||
if str(capability.get("key") or "") in {"pattern.segment_spacing", "pattern.instance_position"}:
|
||
continue
|
||
spec = _capability_spec(item, capability, execution_ready=execution_ready)
|
||
if spec is not None:
|
||
specs.append(spec)
|
||
specs.extend(
|
||
_pattern_instance_position_specs(
|
||
item,
|
||
selected_face_ids=face_ids,
|
||
selected_solid_ids=solid_ids,
|
||
execution_ready=execution_ready,
|
||
)
|
||
)
|
||
specs.extend(_pattern_segment_spacing_specs(item, execution_ready=execution_ready))
|
||
return specs
|
||
|
||
|
||
def _object_matches(
|
||
raw_object: Mapping[str, object],
|
||
*,
|
||
face_ids: set[int],
|
||
edge_ids: set[int],
|
||
solid_ids: set[int],
|
||
) -> bool:
|
||
signature = raw_object.get("geometrySignature")
|
||
if not isinstance(signature, Mapping):
|
||
return False
|
||
object_faces = set(_int_values(signature.get("faceIds")))
|
||
object_faces.update(_int_values(signature.get("supportFaceIds")))
|
||
object_edges = set(_int_values(signature.get("edgeIds")))
|
||
if (face_ids and object_faces & face_ids) or (edge_ids and object_edges & edge_ids):
|
||
return True
|
||
if not solid_ids:
|
||
return False
|
||
object_type = str(raw_object.get("objectType") or "").strip().lower()
|
||
if object_type not in {"pattern", "linear_pattern"}:
|
||
return False
|
||
return bool(_pattern_local_solid_ids(signature) & solid_ids)
|
||
|
||
|
||
def _capability_spec(
|
||
raw_object: Mapping[str, object],
|
||
capability: Mapping[str, object],
|
||
*,
|
||
execution_ready: bool | Iterable[str],
|
||
) -> dict[str, object] | None:
|
||
key = str(capability.get("key") or "").strip()
|
||
label = str(capability.get("displayName") or key).strip()
|
||
if not key or not label:
|
||
return None
|
||
value_kind = str(capability.get("valueKind") or "number")
|
||
current = capability.get("currentValue")
|
||
value_type = _value_type(value_kind, key)
|
||
signature = raw_object.get("geometrySignature") if isinstance(raw_object.get("geometrySignature"), Mapping) else {}
|
||
unit_scale = _unit_scale(signature if isinstance(signature, Mapping) else {})
|
||
current_display = _display_value(current, key=key, value_type=value_type, unit_scale=unit_scale)
|
||
command_value = value_type == "command"
|
||
current_text = "可执行" if command_value else _format_value(current_display, value_type=value_type)
|
||
target_text = "执行" if command_value else _format_value(current_display, value_type=value_type)
|
||
capability_block = str(capability.get("blockReason") or "").strip()
|
||
object_block = str(raw_object.get("blockReason") or "").strip()
|
||
block_reason = capability_block or object_block
|
||
if not command_value and not _current_value_available(current_display, value_type=value_type):
|
||
block_reason = block_reason or f"SCDM 已识别“{label}”，但没有返回可用于编辑的当前值。"
|
||
backend_operation = str(capability.get("backendOperation") or "")
|
||
post_check = str(capability.get("postCheck") or "")
|
||
max_value = _display_max_value(key=key, signature=signature if isinstance(signature, Mapping) else {}, unit_scale=unit_scale)
|
||
range_hint = "来源：SCDM 结构化识别结果。执行前仍需生成 edit job，并在结果 STEP 上做 OCCT 校验和目标值回测。"
|
||
if key == "pattern.spacing" and max_value is not None:
|
||
range_hint = f"该阵列受承载面范围限制，保持阵列中心不变时最大间距约 {max_value:g}；超过后会跑出承载面。"
|
||
can_execute = bool(_capability_execution_ready(key, execution_ready) and capability.get("editable", True) and not block_reason)
|
||
if can_execute:
|
||
disabled_tip = ""
|
||
enabled_tip = (
|
||
f"SCDM 已识别“{label}”可由 {backend_operation or '后端命令'} 修改；"
|
||
f"执行后会用 {post_check or '结果回测'} 校验。"
|
||
)
|
||
elif block_reason:
|
||
enabled_tip = ""
|
||
disabled_tip = f"SCDM 已识别该对象，但当前能力被阻止：{block_reason}"
|
||
else:
|
||
enabled_tip = ""
|
||
disabled_tip = "SCDM 已识别该参数，但 S5 修改执行器还没有接入；当前只作为后端识别结果缓存，不开放执行。"
|
||
return {
|
||
"key": f"scdm:{key}",
|
||
"label": label,
|
||
"current_raw": current_display if current_display is not None else "",
|
||
"scdm_current_raw": current if current is not None else "",
|
||
"scdm_unit_scale": unit_scale,
|
||
"current_text": current_text,
|
||
"target_text": target_text,
|
||
"editable": True,
|
||
"enabled": can_execute,
|
||
"status_text": "可修改" if can_execute else "暂未接入",
|
||
"scope_text": str(capability.get("defaultIntent") or "SCDM"),
|
||
"action": "apply_scdm_property_edit",
|
||
"value_type": value_type,
|
||
"enabled_tip": enabled_tip,
|
||
"disabled_tip": disabled_tip,
|
||
"range_hint": range_hint,
|
||
"min_value": 0.0 if value_type == "positive" else None,
|
||
"min_exclusive": True if value_type == "positive" else False,
|
||
"max_value": max_value,
|
||
"scdm_object_id": raw_object.get("objectId"),
|
||
"scdm_source_backend_id": raw_object.get("sourceBackendId"),
|
||
"scdm_capability_key": key,
|
||
"scdm_backend_operation": backend_operation,
|
||
"scdm_post_check": post_check,
|
||
"scdm_geometry_signature": signature if isinstance(signature, Mapping) else {},
|
||
}
|
||
|
||
|
||
def _unit_scale(signature: Mapping[str, object]) -> float:
|
||
try:
|
||
value = float(str(signature.get("localUnitScale")).strip())
|
||
except (TypeError, ValueError):
|
||
return 1.0
|
||
return value if value > 0 else 1.0
|
||
|
||
|
||
def _display_value(value: object, *, key: str, value_type: str, unit_scale: float) -> object:
|
||
if unit_scale <= 0 or abs(unit_scale - 1.0) <= 1.0e-12 or not _uses_length_units(key, value_type):
|
||
return value
|
||
if value_type == "vector3":
|
||
values = _float_values(value)
|
||
if len(values) == 3:
|
||
return [item / unit_scale for item in values]
|
||
return value
|
||
try:
|
||
return float(str(value).strip()) / unit_scale
|
||
except (TypeError, ValueError):
|
||
return value
|
||
|
||
|
||
def _uses_length_units(key: str, value_type: str) -> bool:
|
||
if value_type == "vector3":
|
||
return True
|
||
suffixes = (
|
||
".diameter",
|
||
".radius",
|
||
".offset",
|
||
".width",
|
||
".depth",
|
||
".height",
|
||
".distance",
|
||
".thickness",
|
||
".spacing",
|
||
".segment_spacing",
|
||
".position",
|
||
)
|
||
return key.endswith(suffixes)
|
||
|
||
|
||
def _display_max_value(*, key: str, signature: Mapping[str, object], unit_scale: float) -> float | None:
|
||
if key != "pattern.spacing":
|
||
return None
|
||
fit = signature.get("supportPatternFit")
|
||
if not isinstance(fit, Mapping):
|
||
return None
|
||
value = fit.get("maxSpacingLocal")
|
||
try:
|
||
result = float(str(value).strip())
|
||
except (TypeError, ValueError):
|
||
backend_value = fit.get("maxSpacing")
|
||
try:
|
||
return float(str(backend_value).strip()) / unit_scale if unit_scale > 0 else None
|
||
except (TypeError, ValueError):
|
||
return None
|
||
return result if result > 0 else None
|
||
|
||
|
||
def _pattern_segment_spacing_specs(
|
||
raw_object: Mapping[str, object],
|
||
*,
|
||
execution_ready: bool | Iterable[str],
|
||
) -> list[dict[str, object]]:
|
||
if str(raw_object.get("objectType") or "").strip().lower() != "linear_pattern":
|
||
return []
|
||
signature = raw_object.get("geometrySignature")
|
||
if not isinstance(signature, Mapping):
|
||
return []
|
||
axis = _unit_vector(_float_values(signature.get("axis")))
|
||
if len(axis) != 3:
|
||
return []
|
||
instances = _sorted_pattern_instances(signature, axis)
|
||
if len(instances) < 2:
|
||
return []
|
||
unit_scale = _unit_scale(signature)
|
||
can_execute = bool(_capability_execution_ready("pattern.segment_spacing", execution_ready) and not str(raw_object.get("blockReason") or "").strip())
|
||
specs: list[dict[str, object]] = []
|
||
for segment_index in range(len(instances) - 1):
|
||
# UI 上展示的是相邻实例之间的“段间距”，不是整列统一 spacing。
|
||
# 每一段都带自己的移动语义和安全范围，避免“第 1-2 间距”改成整列平移。
|
||
left = instances[segment_index]
|
||
right = instances[segment_index + 1]
|
||
left_label = _segment_instance_label(left, segment_index + 1)
|
||
right_label = _segment_instance_label(right, segment_index + 2)
|
||
segment_label = f"{left_label}-{right_label}间距"
|
||
current = max(0.0, float(right["projection"]) - float(left["projection"]))
|
||
if current <= 0:
|
||
continue
|
||
current_display = current / unit_scale if unit_scale > 0 else current
|
||
scope_modes = _segment_scope_modes(
|
||
signature,
|
||
instances,
|
||
segment_index,
|
||
current,
|
||
current_display,
|
||
unit_scale,
|
||
left_label=left_label,
|
||
right_label=right_label,
|
||
segment_label=segment_label,
|
||
can_execute=can_execute,
|
||
)
|
||
default_mode = scope_modes.get("fix_left_move_right", {}) if isinstance(scope_modes, Mapping) else {}
|
||
max_display = default_mode.get("max_value")
|
||
range_hint = str(default_mode.get("range_hint") or "")
|
||
enabled_tip = str(default_mode.get("enabled_tip") or range_hint)
|
||
segment_signature = default_mode.get("scdm_geometry_signature")
|
||
if not isinstance(segment_signature, Mapping):
|
||
segment_signature = _segment_signature(
|
||
signature,
|
||
segment_index,
|
||
current,
|
||
unit_scale,
|
||
left_label=left_label,
|
||
right_label=right_label,
|
||
moving_side="after",
|
||
motion_semantics="fix_left_move_right_group",
|
||
)
|
||
specs.append(
|
||
{
|
||
"key": f"scdm:pattern.segment_spacing:{segment_index}",
|
||
"label": segment_label,
|
||
"current_raw": current_display,
|
||
"scdm_current_raw": current,
|
||
"scdm_unit_scale": unit_scale,
|
||
"current_text": _format_value(current_display, value_type="positive"),
|
||
"target_text": _format_value(current_display, value_type="positive"),
|
||
"editable": True,
|
||
"enabled": can_execute,
|
||
"status_text": "可修改" if can_execute else "暂未接入",
|
||
"scope_text": "固定前项，移动后侧",
|
||
"scope_modes": scope_modes,
|
||
"scope_default": "fix_left_move_right",
|
||
"action": "apply_scdm_property_edit",
|
||
"value_type": "positive",
|
||
"enabled_tip": enabled_tip,
|
||
"disabled_tip": "" if can_execute else "SCDM 已识别该局部间距，但当前修改执行器尚未开放。",
|
||
"range_hint": range_hint,
|
||
"min_value": 0.0,
|
||
"min_exclusive": True,
|
||
"max_value": max_display,
|
||
"scdm_object_id": raw_object.get("objectId"),
|
||
"scdm_source_backend_id": raw_object.get("sourceBackendId"),
|
||
"scdm_capability_key": "pattern.segment_spacing",
|
||
"scdm_backend_operation": "change_pattern_segment_spacing",
|
||
"scdm_post_check": "target_pattern_segment_spacing",
|
||
"scdm_geometry_signature": segment_signature,
|
||
}
|
||
)
|
||
return specs
|
||
|
||
|
||
def _pattern_instance_position_specs(
|
||
raw_object: Mapping[str, object],
|
||
*,
|
||
selected_face_ids: set[int],
|
||
selected_solid_ids: set[int],
|
||
execution_ready: bool | Iterable[str],
|
||
) -> list[dict[str, object]]:
|
||
if str(raw_object.get("objectType") or "").strip().lower() not in {"pattern", "linear_pattern"}:
|
||
return []
|
||
signature = raw_object.get("geometrySignature")
|
||
if not isinstance(signature, Mapping):
|
||
return []
|
||
unit_scale = _unit_scale(signature)
|
||
can_execute = bool(_capability_execution_ready("pattern.instance_position", execution_ready) and not str(raw_object.get("blockReason") or "").strip())
|
||
specs: list[dict[str, object]] = []
|
||
instances = _pattern_instances_in_original_order(signature)
|
||
for ordinal, instance in enumerate(instances, start=1):
|
||
if selected_face_ids and not (set(_int_values(instance.get("faceIds"))) & selected_face_ids):
|
||
continue
|
||
if selected_solid_ids and not (_instance_local_solid_ids(instance) & selected_solid_ids):
|
||
continue
|
||
center = _float_values(instance.get("center") or instance.get("instanceCenter"))
|
||
if len(center) != 3:
|
||
continue
|
||
label = _segment_instance_label({"source": instance}, ordinal)
|
||
current_display = [value / unit_scale for value in center] if unit_scale > 0 else list(center)
|
||
instance_signature = _pattern_instance_signature(signature, instance, unit_scale=unit_scale, label=label)
|
||
locatable = _pattern_instance_has_locator(instance_signature)
|
||
enabled = bool(can_execute and locatable)
|
||
disabled_tip = ""
|
||
if not can_execute:
|
||
disabled_tip = "SCDM 已识别该阵列实例，但当前修改执行器尚未开放。"
|
||
elif not locatable:
|
||
disabled_tip = "SCDM 已识别该阵列实例，但缓存里没有可定位的 Face / Body / Component，不能稳定移动。"
|
||
range_hint = f"移动阵列实例：只平移 {label}，不自动保持整体阵列等距；需要保持间距时请使用“阵列间距”或“局部间距”。"
|
||
specs.append(
|
||
{
|
||
"key": f"scdm:pattern.instance_position:{ordinal - 1}",
|
||
"label": f"{label}位置",
|
||
"current_raw": current_display,
|
||
"scdm_current_raw": center,
|
||
"scdm_unit_scale": unit_scale,
|
||
"current_text": _format_value(current_display, value_type="vector3"),
|
||
"target_text": _format_value(current_display, value_type="vector3"),
|
||
"editable": True,
|
||
"enabled": enabled,
|
||
"status_text": "可修改" if enabled else "暂未接入",
|
||
"scope_text": "只移动该实例",
|
||
"action": "apply_scdm_property_edit",
|
||
"value_type": "vector3",
|
||
"enabled_tip": range_hint if enabled else "",
|
||
"disabled_tip": disabled_tip,
|
||
"range_hint": range_hint,
|
||
"min_value": None,
|
||
"min_exclusive": False,
|
||
"max_value": None,
|
||
"scdm_object_id": raw_object.get("objectId"),
|
||
"scdm_source_backend_id": raw_object.get("sourceBackendId"),
|
||
"scdm_capability_key": "pattern.instance_position",
|
||
"scdm_backend_operation": "move_pattern_instance",
|
||
"scdm_post_check": "target_pattern_instance_center",
|
||
"scdm_geometry_signature": instance_signature,
|
||
}
|
||
)
|
||
return specs
|
||
|
||
|
||
def _pattern_instances_in_original_order(signature: Mapping[str, object]) -> list[Mapping[str, object]]:
|
||
value = signature.get("patternInstances")
|
||
if not isinstance(value, (list, tuple)):
|
||
return []
|
||
return [item for item in value if isinstance(item, Mapping)]
|
||
|
||
|
||
def _pattern_instance_signature(
|
||
signature: Mapping[str, object],
|
||
instance: Mapping[str, object],
|
||
*,
|
||
unit_scale: float,
|
||
label: str,
|
||
) -> dict[str, object]:
|
||
result = dict(instance)
|
||
result["objectType"] = "pattern_instance"
|
||
result["displayLabel"] = label
|
||
result["patternObjectType"] = signature.get("objectType")
|
||
result["patternKind"] = signature.get("patternKind")
|
||
result["instanceKind"] = instance.get("instanceKind") or signature.get("instanceKind")
|
||
result["axis"] = signature.get("axis")
|
||
result["localUnitScale"] = unit_scale
|
||
center = _float_values(instance.get("center") or instance.get("instanceCenter"))
|
||
if len(center) == 3:
|
||
result["center"] = center
|
||
result["instanceCenter"] = center
|
||
return result
|
||
|
||
|
||
def _pattern_instance_has_locator(signature: Mapping[str, object]) -> bool:
|
||
if signature.get("componentLocators") or signature.get("bodyLocators") or signature.get("scdmFaceLocators"):
|
||
return True
|
||
if _int_values(signature.get("faceOrdinals")) or _int_values(signature.get("globalFaceOrdinals")):
|
||
return True
|
||
if _int_or_none(signature.get("faceOrdinal")) is not None or _int_or_none(signature.get("globalFaceOrdinal")) is not None:
|
||
return True
|
||
instance_kind = str(signature.get("instanceKind") or "").strip().lower()
|
||
return instance_kind in {"body", "part", "component"} and _int_or_none(signature.get("bodyIndex")) is not None
|
||
|
||
|
||
def _pattern_local_solid_ids(signature: Mapping[str, object]) -> set[int]:
|
||
ids = set(_int_values(signature.get("localSolidIds")))
|
||
local_solid = _int_or_none(signature.get("localSolidId"))
|
||
if local_solid is not None:
|
||
ids.add(local_solid)
|
||
ids.update(_int_values(signature.get("bodyIndices")))
|
||
body_index = _int_or_none(signature.get("bodyIndex"))
|
||
if body_index is not None:
|
||
ids.add(body_index)
|
||
for instance in _pattern_instances_in_original_order(signature):
|
||
ids.update(_instance_local_solid_ids(instance))
|
||
return ids
|
||
|
||
|
||
def _instance_local_solid_ids(instance: Mapping[str, object]) -> set[int]:
|
||
ids = set(_int_values(instance.get("localSolidIds")))
|
||
local_solid = _int_or_none(instance.get("localSolidId"))
|
||
if local_solid is not None:
|
||
ids.add(local_solid)
|
||
body_index = _int_or_none(instance.get("bodyIndex"))
|
||
if body_index is not None:
|
||
ids.add(body_index)
|
||
return ids
|
||
|
||
|
||
def _sorted_pattern_instances(signature: Mapping[str, object], axis: list[float]) -> list[dict[str, object]]:
|
||
value = signature.get("patternInstances")
|
||
if not isinstance(value, (list, tuple)):
|
||
return []
|
||
result: list[dict[str, object]] = []
|
||
for index, item in enumerate(value):
|
||
if not isinstance(item, Mapping):
|
||
continue
|
||
center = _float_values(item.get("center") or item.get("instanceCenter"))
|
||
if len(center) != 3:
|
||
continue
|
||
result.append(
|
||
{
|
||
"index": index,
|
||
"source": item,
|
||
"center": center,
|
||
"projection": _point_projection(center, axis),
|
||
}
|
||
)
|
||
# 用阵列轴投影排序，比原始 cache 顺序更接近用户看到的左到右/前到后顺序。
|
||
result.sort(key=lambda item: float(item["projection"]))
|
||
return result
|
||
|
||
|
||
def _segment_max_spacing_display(
|
||
signature: Mapping[str, object],
|
||
instances: list[dict[str, object]],
|
||
segment_index: int,
|
||
current_display: float,
|
||
unit_scale: float,
|
||
*,
|
||
moving_side: str = "after",
|
||
) -> float | None:
|
||
fit = signature.get("supportPatternFit")
|
||
if not isinstance(fit, Mapping):
|
||
return None
|
||
projection_min = _float_or_none(fit.get("supportProjectionMinLocal"))
|
||
projection_max = _float_or_none(fit.get("supportProjectionMaxLocal"))
|
||
member_span = _float_or_none(fit.get("memberSpanLocal"))
|
||
if projection_min is None or projection_max is None or member_span is None or member_span <= 0:
|
||
return None
|
||
first_projection = float(instances[0]["projection"])
|
||
last_projection = float(instances[-1]["projection"])
|
||
first_projection_display = first_projection / unit_scale if unit_scale > 0 else first_projection
|
||
last_projection_display = last_projection / unit_scale if unit_scale > 0 else last_projection
|
||
backward_capacity = first_projection_display - projection_min - (member_span * 0.5)
|
||
forward_capacity = projection_max - (member_span * 0.5) - last_projection_display
|
||
if moving_side in {"before", "left", "single_left", "only_left"}:
|
||
extra = backward_capacity
|
||
elif moving_side in {"split", "both", "center"}:
|
||
extra = 2.0 * min(backward_capacity, forward_capacity)
|
||
else:
|
||
extra = forward_capacity
|
||
return max(current_display, current_display + max(0.0, extra))
|
||
|
||
|
||
def _segment_scope_modes(
|
||
signature: Mapping[str, object],
|
||
instances: list[dict[str, object]],
|
||
segment_index: int,
|
||
current_backend: float,
|
||
current_display: float,
|
||
unit_scale: float,
|
||
*,
|
||
left_label: str,
|
||
right_label: str,
|
||
segment_label: str,
|
||
can_execute: bool,
|
||
) -> dict[str, dict[str, object]]:
|
||
modes: dict[str, dict[str, object]] = {}
|
||
# 同一个“间距”参数有多种建模意图：固定哪一侧、是否保持中心。
|
||
# 这些模式会直接进入 scdm_edit_job，不能只作为 UI 文案存在。
|
||
for key, label, moving_side, semantics, description in (
|
||
(
|
||
"fix_left_move_right",
|
||
"固定前项，移动后侧",
|
||
"after",
|
||
"fix_left_move_right_group",
|
||
f"固定 {left_label}，平移 {right_label} 及其右侧所有阵列成员，右侧已有间距保持不变。",
|
||
),
|
||
(
|
||
"fix_right_move_left",
|
||
"固定后项，移动前侧",
|
||
"before",
|
||
"fix_right_move_left_group",
|
||
f"固定 {right_label}，平移 {left_label} 及其左侧所有阵列成员，左侧已有间距保持不变。",
|
||
),
|
||
(
|
||
"split_keep_center",
|
||
"两侧均分，中心不变",
|
||
"split",
|
||
"split_groups_keep_segment_center",
|
||
f"{left_label} 及左侧向前移动一半，{right_label} 及右侧向后移动一半，保持这段间距中心不变。",
|
||
),
|
||
):
|
||
max_display = _segment_max_spacing_display(
|
||
signature,
|
||
instances,
|
||
segment_index,
|
||
current_display,
|
||
unit_scale,
|
||
moving_side=moving_side,
|
||
)
|
||
mode_signature = _segment_signature(
|
||
signature,
|
||
segment_index,
|
||
current_backend,
|
||
unit_scale,
|
||
left_label=left_label,
|
||
right_label=right_label,
|
||
moving_side=moving_side,
|
||
motion_semantics=semantics,
|
||
max_display=max_display,
|
||
)
|
||
range_hint = f"{label}：{description} 对象段：{segment_label}，沿阵列方向由 {left_label} 到 {right_label}。"
|
||
if max_display is not None and max_display > 0:
|
||
range_hint += f" 当前支撑面约允许该策略最大间距 {max_display:g}。"
|
||
modes[key] = {
|
||
"label": label,
|
||
"enabled": can_execute,
|
||
"enabled_tip": range_hint,
|
||
"disabled_tip": "" if can_execute else "SCDM 已识别该局部间距，但当前修改执行器尚未开放。",
|
||
"range_hint": range_hint,
|
||
"max_value": max_display,
|
||
"scdm_geometry_signature": mode_signature,
|
||
}
|
||
for key, label, moving_side, semantics, moved_label, neighbor_warning in (
|
||
(
|
||
"move_single_left",
|
||
"只移动前项",
|
||
"single_left",
|
||
"move_only_left_instance",
|
||
left_label,
|
||
"会改变它与左侧相邻成员的距离",
|
||
),
|
||
(
|
||
"move_single_right",
|
||
"只移动后项",
|
||
"single_right",
|
||
"move_only_right_instance",
|
||
right_label,
|
||
"会改变它与右侧相邻成员的距离",
|
||
),
|
||
):
|
||
max_display = _segment_max_spacing_display(
|
||
signature,
|
||
instances,
|
||
segment_index,
|
||
current_display,
|
||
unit_scale,
|
||
moving_side=moving_side,
|
||
)
|
||
mode_signature = _segment_signature(
|
||
signature,
|
||
segment_index,
|
||
current_backend,
|
||
unit_scale,
|
||
left_label=left_label,
|
||
right_label=right_label,
|
||
moving_side=moving_side,
|
||
motion_semantics=semantics,
|
||
max_display=max_display,
|
||
)
|
||
range_hint = (
|
||
f"{label}：只平移 {moved_label}，把 {left_label}-{right_label} 这段调到目标间距；"
|
||
f"{neighbor_warning}，不用于保持整列等距。对象段：{segment_label}。"
|
||
)
|
||
if max_display is not None and max_display > 0:
|
||
range_hint += f" 当前支撑面约允许该策略最大间距 {max_display:g}。"
|
||
modes[key] = {
|
||
"label": label,
|
||
"enabled": can_execute,
|
||
"enabled_tip": range_hint if can_execute else "",
|
||
"disabled_tip": "" if can_execute else "SCDM 已识别该局部间距，但当前修改执行器尚未开放。",
|
||
"range_hint": range_hint,
|
||
"max_value": max_display,
|
||
"scdm_geometry_signature": mode_signature,
|
||
}
|
||
return modes
|
||
|
||
|
||
def _segment_signature(
|
||
signature: Mapping[str, object],
|
||
segment_index: int,
|
||
current_backend: float,
|
||
unit_scale: float,
|
||
*,
|
||
left_label: str,
|
||
right_label: str,
|
||
moving_side: str,
|
||
motion_semantics: str,
|
||
max_display: object = None,
|
||
) -> dict[str, object]:
|
||
result = dict(signature)
|
||
segment_fit = dict(result.get("supportPatternFit") if isinstance(result.get("supportPatternFit"), Mapping) else {})
|
||
max_number = _float_or_none(max_display)
|
||
if max_number is not None and max_number > 0:
|
||
segment_fit["maxSegmentSpacingLocal"] = max_number
|
||
segment_fit["maxSegmentSpacing"] = max_number * unit_scale if unit_scale > 0 else max_number
|
||
result["supportPatternFit"] = segment_fit
|
||
result["segmentIndex"] = segment_index
|
||
result["segmentLabel"] = f"{left_label}-{right_label}"
|
||
result["segmentLeftLabel"] = left_label
|
||
result["segmentRightLabel"] = right_label
|
||
result["segmentSpacing"] = current_backend
|
||
result["movingSide"] = moving_side
|
||
result["motionSemantics"] = motion_semantics
|
||
axis = _unit_vector(_float_values(signature.get("axis")))
|
||
instances = _sorted_pattern_instances(signature, axis) if len(axis) == 3 else []
|
||
if segment_index < len(instances) - 1:
|
||
result["segmentLeft"] = _segment_instance_reference(instances[segment_index], label=left_label)
|
||
result["segmentRight"] = _segment_instance_reference(instances[segment_index + 1], label=right_label)
|
||
result["localUnitScale"] = unit_scale
|
||
return result
|
||
|
||
|
||
def _segment_instance_reference(item: Mapping[str, object], *, label: str = "") -> dict[str, object]:
|
||
source = item.get("source")
|
||
if not isinstance(source, Mapping):
|
||
return {}
|
||
return {
|
||
"displayLabel": label,
|
||
"sourceObjectId": source.get("sourceObjectId"),
|
||
"faceIds": _int_values(source.get("faceIds")),
|
||
"bodyIndex": _int_or_none(source.get("bodyIndex")),
|
||
"componentLocators": source.get("componentLocators") or source.get("bodyLocators") or [],
|
||
}
|
||
|
||
|
||
def _segment_instance_label(item: Mapping[str, object], ordinal: int) -> str:
|
||
source = item.get("source")
|
||
if not isinstance(source, Mapping):
|
||
return f"阵列成员{ordinal}"
|
||
instance_kind = str(source.get("instanceKind") or "").strip().lower()
|
||
if instance_kind in {"body", "part", "component"}:
|
||
local_solid_ids = sorted(set(_int_values(source.get("localSolidIds") or [source.get("localSolidId")])))
|
||
if local_solid_ids:
|
||
return f"Solid{local_solid_ids[0]}{'组' if len(local_solid_ids) > 1 else ''}"
|
||
local_part_ids = sorted(set(_int_values(source.get("localPartIds") or [source.get("localPartId")])))
|
||
if local_part_ids:
|
||
return f"Part{local_part_ids[0]}{'组' if len(local_part_ids) > 1 else ''}"
|
||
component_label = _component_locator_label(source.get("componentLocators") or source.get("bodyLocators"), include_index=False)
|
||
if component_label:
|
||
return component_label
|
||
body_index = _int_or_none(source.get("bodyIndex"))
|
||
if body_index is not None:
|
||
return f"Solid{body_index}"
|
||
face_ids = sorted(set(_int_values(source.get("faceIds"))))
|
||
if face_ids:
|
||
return f"Face{face_ids[0]}{'组' if len(face_ids) > 1 else ''}"
|
||
component_label = _component_locator_label(source.get("componentLocators") or source.get("bodyLocators"))
|
||
if component_label:
|
||
return component_label
|
||
body_index = _int_or_none(source.get("bodyIndex"))
|
||
if body_index is not None:
|
||
return f"Solid{body_index}"
|
||
source_id = str(source.get("sourceObjectId") or "").strip()
|
||
if source_id:
|
||
return source_id
|
||
return f"阵列成员{ordinal}"
|
||
|
||
|
||
def _component_locator_label(value: object, *, include_index: bool = True) -> str:
|
||
if not isinstance(value, (list, tuple)):
|
||
return ""
|
||
for locator in value:
|
||
if not isinstance(locator, Mapping):
|
||
continue
|
||
for key in ("componentName", "name", "displayName"):
|
||
text = str(locator.get(key) or "").strip()
|
||
if text:
|
||
return text
|
||
if not include_index:
|
||
return ""
|
||
for locator in value:
|
||
if not isinstance(locator, Mapping):
|
||
continue
|
||
component_index = _int_or_none(locator.get("componentIndex"))
|
||
if component_index is not None:
|
||
return f"组件{component_index + 1}"
|
||
return ""
|
||
|
||
|
||
def _unit_vector(values: list[float]) -> list[float]:
|
||
if len(values) != 3:
|
||
return []
|
||
length = sum(item * item for item in values) ** 0.5
|
||
if length <= 1.0e-12:
|
||
return []
|
||
return [item / length for item in values]
|
||
|
||
|
||
def _point_projection(point: list[float], axis: list[float]) -> float:
|
||
return sum(float(point[index]) * float(axis[index]) for index in range(3))
|
||
|
||
|
||
def _float_or_none(value: object) -> float | None:
|
||
try:
|
||
return float(str(value).strip())
|
||
except (TypeError, ValueError):
|
||
return None
|
||
|
||
|
||
def _value_type(value_kind: str, key: str) -> str:
|
||
if value_kind == "vector3":
|
||
return "vector3"
|
||
if value_kind == "command":
|
||
return "command"
|
||
positive_suffixes = (".diameter", ".radius", ".width", ".depth", ".height", ".distance", ".thickness", ".spacing", ".segment_spacing")
|
||
if key.endswith(positive_suffixes):
|
||
return "positive"
|
||
return "number"
|
||
|
||
|
||
def _capability_execution_ready(key: str, execution_ready: bool | Iterable[str]) -> bool:
|
||
if isinstance(execution_ready, bool):
|
||
return execution_ready
|
||
try:
|
||
return key in {str(item) for item in execution_ready}
|
||
except TypeError:
|
||
return False
|
||
|
||
|
||
def _format_value(value: object, *, value_type: str) -> str:
|
||
if value is None:
|
||
return ""
|
||
if value_type == "vector3":
|
||
values = _float_values(value)
|
||
return f"({values[0]:g}, {values[1]:g}, {values[2]:g})" if len(values) == 3 else ""
|
||
if isinstance(value, float):
|
||
return f"{value:g}"
|
||
return str(value)
|
||
|
||
|
||
def _current_value_available(value: object, *, value_type: str) -> bool:
|
||
if value is None or value == "":
|
||
return False
|
||
if value_type == "vector3":
|
||
return len(_float_values(value)) == 3
|
||
if value_type in {"number", "positive"}:
|
||
try:
|
||
return float(str(value).strip()) > 0 if value_type == "positive" else True
|
||
except (TypeError, ValueError):
|
||
return False
|
||
return True
|
||
|
||
|
||
def _float_values(value: object) -> list[float]:
|
||
if isinstance(value, (str, bytes)) or value is None:
|
||
return []
|
||
try:
|
||
values = list(value) # type: ignore[arg-type]
|
||
except TypeError:
|
||
return []
|
||
result: list[float] = []
|
||
for item in values[:3]:
|
||
try:
|
||
result.append(float(item))
|
||
except (TypeError, ValueError):
|
||
return []
|
||
return result
|
||
|
||
|
||
def _int_values(value: object) -> list[int]:
|
||
if isinstance(value, (str, bytes)) or value is None:
|
||
return []
|
||
try:
|
||
values = list(value) # type: ignore[arg-type]
|
||
except TypeError:
|
||
return []
|
||
result: list[int] = []
|
||
for item in values:
|
||
try:
|
||
result.append(int(item))
|
||
except (TypeError, ValueError):
|
||
continue
|
||
return result
|
||
|
||
|
||
def _int_or_none(value: object) -> int | None:
|
||
try:
|
||
return int(value)
|
||
except (TypeError, ValueError):
|
||
return None
|
||
|
||
|
||
__all__ = ["property_specs_from_scdm_cache"]
|