from __future__ import annotations import math from collections.abc import Iterable, Mapping from pathlib import Path from .scdm_capabilities import capability_definition, planned_capability_keys, productized_capability_keys from .scdm_schema import SCDM_CACHE_SCHEMA_VERSION, payload_backend_version, payload_model_fingerprint, read_json, utc_now, write_json def map_scdm_raw_features(raw_payload: Mapping[str, object]) -> dict[str, object]: objects = [] diagnostics: dict[str, object] = { "discovered_not_productized": [], "planned_not_productized": [], "blocked": [], } raw_diagnostics = _mapping(raw_payload.get("diagnostics")) available_commands = raw_diagnostics.get("availableCommands") available_command_names = _available_command_names(available_commands) if isinstance(available_commands, list): diagnostics["backend_commands"] = [dict(item) for item in available_commands if isinstance(item, Mapping)] face_adjacency = raw_diagnostics.get("faceAdjacency") if isinstance(face_adjacency, list): diagnostics["face_adjacency"] = [dict(item) for item in face_adjacency if isinstance(item, Mapping)] edge_geometry_summary = raw_diagnostics.get("edgeGeometrySummary") if isinstance(edge_geometry_summary, Mapping): diagnostics["edge_geometry_summary"] = dict(edge_geometry_summary) feature_inventory = raw_diagnostics.get("featureInventory") if isinstance(feature_inventory, Mapping): diagnostics["feature_inventory"] = { str(key): dict(value) for key, value in feature_inventory.items() if isinstance(value, Mapping) } raw_summary = raw_payload.get("summary") if isinstance(raw_summary, Mapping): diagnostics["raw_summary"] = dict(raw_summary) raw_objects = raw_payload.get("objects") if not isinstance(raw_objects, list): raw_objects = [] cylindrical_group_objects = _cylindrical_face_group_objects(raw_objects) derived_objects = _derived_feature_objects([*raw_objects, *cylindrical_group_objects]) if derived_objects: diagnostics["derived_feature_candidates"] = [ { "objectId": _object_id(item), "objectType": str(item.get("objectType") or ""), "geometrySignature": geometry_signature(item), "rawLimitations": list(item.get("rawLimitations") or []), } for item in derived_objects if isinstance(item, Mapping) ] diagnostics["geometry_candidate_hints"] = _geometry_candidate_hints( [*raw_objects, *cylindrical_group_objects, *derived_objects], raw_diagnostics, ) for raw_object in [*raw_objects, *derived_objects]: if not isinstance(raw_object, Mapping): continue capability_keys = productized_capability_keys(raw_object) planned_keys = planned_capability_keys(raw_object) capabilities = [_capability_payload(key, raw_object, available_command_names=available_command_names) for key in capability_keys] capabilities = [item for item in capabilities if item is not None] normalized_object = { "objectId": _object_id(raw_object), "objectType": str(raw_object.get("objectType") or ""), "sourceBackendId": str(raw_object.get("backendId") or ""), "geometrySignature": geometry_signature(raw_object), "capabilities": capabilities, "blockReason": str(raw_object.get("blockReason") or ""), } if capabilities: objects.append(normalized_object) else: diagnostics["discovered_not_productized"].append( { "objectId": normalized_object["objectId"], "objectType": normalized_object["objectType"], "sourceBackendId": normalized_object["sourceBackendId"], "reason": "no_productized_capability", } ) for key in planned_keys: definition = capability_definition(key) diagnostics["planned_not_productized"].append( { "objectId": normalized_object["objectId"], "objectType": normalized_object["objectType"], "sourceBackendId": normalized_object["sourceBackendId"], "capabilityKey": key, "displayName": definition.display_name if definition else key, "roadmapStage": definition.roadmap_stage if definition else "", "reason": definition.block_reason if definition else "Planned capability is not productized.", } ) if normalized_object["blockReason"]: diagnostics["blocked"].append( { "objectId": normalized_object["objectId"], "objectType": normalized_object["objectType"], "reason": normalized_object["blockReason"], } ) for raw_object in cylindrical_group_objects: capability_keys = productized_capability_keys(raw_object) capabilities = [_capability_payload(key, raw_object, available_command_names=available_command_names) for key in capability_keys] capabilities = [item for item in capabilities if item is not None] normalized_object = { "objectId": _object_id(raw_object), "objectType": str(raw_object.get("objectType") or ""), "sourceBackendId": str(raw_object.get("backendId") or ""), "geometrySignature": geometry_signature(raw_object), "capabilities": capabilities, "blockReason": str(raw_object.get("blockReason") or ""), } if capabilities: objects.append(normalized_object) else: diagnostics["discovered_not_productized"].append( { "objectId": normalized_object["objectId"], "objectType": normalized_object["objectType"], "sourceBackendId": normalized_object["sourceBackendId"], "reason": "no_productized_capability", } ) return { "schemaVersion": SCDM_CACHE_SCHEMA_VERSION, "source": "SCDM", "createdAt": utc_now(), "modelFingerprint": payload_model_fingerprint(raw_payload), "backendVersion": payload_backend_version(raw_payload), "objects": objects, "diagnostics": diagnostics, } def _geometry_candidate_hints( raw_objects: list[object], raw_diagnostics: Mapping[str, object], ) -> list[dict[str, object]]: inventory = _mapping(raw_diagnostics.get("featureInventory")) object_counts = _normalized_count_dict(inventory.get("objectTypeCounts")) surface_counts = _normalized_count_dict(inventory.get("surfaceTypeCounts")) curve_counts = _normalized_count_dict(inventory.get("curveTypeCounts")) operation_counts = _normalized_count_dict(inventory.get("operationCounts")) scanned = _scan_raw_feature_counts(raw_objects) object_counts = _merge_count_dicts(object_counts, scanned["objectTypeCounts"]) surface_counts = _merge_count_dicts(surface_counts, scanned["surfaceTypeCounts"]) curve_counts = _merge_count_dicts(curve_counts, scanned["curveTypeCounts"]) operation_counts = _merge_count_dicts(operation_counts, scanned["operationCounts"]) edge_summary = _mapping(raw_diagnostics.get("edgeGeometrySummary")) edge_kind_counts = _normalized_count_dict(edge_summary.get("edgeKindCounts")) circular_edges = _count_value(edge_summary.get("circularEdgeCount")) or edge_kind_counts.get("circular", 0) linear_edges = edge_kind_counts.get("linear", 0) radius_buckets = edge_summary.get("circularRadiusBuckets") radius_bucket_count = len(radius_buckets) if isinstance(radius_buckets, list) else 0 cylinder_faces = surface_counts.get("cylinder", 0) planar_faces = surface_counts.get("plane", 0) round_objects = object_counts.get("round", 0) + object_counts.get("fillet", 0) slot_objects = object_counts.get("slot", 0) + object_counts.get("obround_slot", 0) + object_counts.get("rectangular_slot", 0) boss_objects = object_counts.get("boss", 0) + object_counts.get("cylindrical_boss", 0) + object_counts.get("rectangular_boss", 0) chamfer_objects = object_counts.get("chamfer", 0) pattern_objects = object_counts.get("pattern", 0) + object_counts.get("linear_pattern", 0) shell_objects = object_counts.get("shell", 0) + object_counts.get("thin_wall", 0) hints: list[dict[str, object]] = [] if slot_objects: _add_hint_group( hints, ("slot.width", "slot.depth", "slot.position"), slot_objects, "medium", "SCDM raw 已给出槽类对象；进入 S7 第二批真实命令和样例回测。", "scdm-object-type", ) elif cylinder_faces and circular_edges and linear_edges: _add_hint_group( hints, ("slot.width", "slot.depth", "slot.position"), min(cylinder_faces, circular_edges), "low", "当前模型含圆柱面、圆边和直边，具备槽/长圆孔分类材料；还需要确认具体槽组和编辑命令。", "scdm-geometry-summary", ) if boss_objects: _add_hint_group( hints, ("boss.height", "boss.diameter", "boss.position"), boss_objects, "medium", "SCDM raw 已给出凸台类对象；进入 S7 第三批真实命令和样例回测。", "scdm-object-type", ) elif cylinder_faces and planar_faces: _add_hint_group( hints, ("boss.height", "boss.diameter", "boss.position"), cylinder_faces, "low", "当前模型含圆柱面和平面，具备凸台/外圆分类材料；还需要区分孔、外圆、槽和圆角。", "scdm-geometry-summary", ) round_candidate_count = ( round_objects or operation_counts.get("change_round_radius", 0) or operation_counts.get("delete_round_or_chamfer", 0) ) if round_candidate_count: _add_hint_group( hints, ("round.radius", "feature.delete_round_or_chamfer"), round_candidate_count, "medium", "SCDM raw 已给出圆角/倒圆候选命令；执行器和专门质量校验仍待回测。", "scdm-command-candidate", ) elif circular_edges and radius_bucket_count: _add_hint_group( hints, ("round.radius",), circular_edges, "low", "当前模型含圆边和半径分组，具备圆角链分类材料；还需要确认支撑面和真实 Round 命令。", "scdm-edge-summary", ) if chamfer_objects: _add_hint_group( hints, ("chamfer.distance", "feature.delete_round_or_chamfer"), chamfer_objects, "medium", "SCDM raw 已给出倒角对象；进入 S7 第四批真实命令和样例回测。", "scdm-object-type", ) elif planar_faces and linear_edges and circular_edges: _add_hint_group( hints, ("chamfer.distance",), min(planar_faces, linear_edges), "low", "当前模型含大量平面和直边，具备倒角分类材料；还需要确认倒角斜面和相邻支撑面。", "scdm-geometry-summary", ) if pattern_objects: _add_hint_group( hints, ("pattern.spacing", "pattern.instance_position"), pattern_objects, "medium", "SCDM raw 已给出阵列对象；进入 S7 第五批真实命令和样例回测。", "scdm-object-type", ) elif radius_bucket_count and circular_edges >= 4: _add_hint_group( hints, ("pattern.spacing", "pattern.instance_position"), radius_bucket_count, "low", "当前模型含重复圆边半径分组，具备孔/圆角阵列识别材料；还需要确认实例分组和间距方向。", "scdm-edge-summary", ) if shell_objects: _add_hint_group( hints, ("shell.thickness",), shell_objects, "medium", "SCDM raw 已给出壳体/薄壁对象；进入 S7 第五批真实命令和样例回测。", "scdm-object-type", ) elif planar_faces >= 2: _add_hint_group( hints, ("shell.thickness",), planar_faces, "low", "当前模型含多组平面，具备薄壁/相对面厚度分类材料；还需要确认成对壁面和偏移方向。", "scdm-geometry-summary", ) return hints def _add_hint_group( hints: list[dict[str, object]], keys: tuple[str, ...], count: int, confidence: str, reason: str, source: str, ) -> None: evidence_count = max(0, int(count)) if evidence_count <= 0: return for key in keys: definition = capability_definition(key) if definition is None or definition.productized: continue hints.append( { "capabilityKey": key, "displayName": definition.display_name, "roadmapStage": definition.roadmap_stage, "evidenceCount": evidence_count, "confidence": confidence, "source": source, "reason": reason, } ) def _scan_raw_feature_counts(raw_objects: list[object]) -> dict[str, dict[str, int]]: result = { "objectTypeCounts": {}, "surfaceTypeCounts": {}, "curveTypeCounts": {}, "operationCounts": {}, } for raw_object in raw_objects: if not isinstance(raw_object, Mapping): continue _increment_count(result["objectTypeCounts"], raw_object.get("objectType")) geometry = _mapping(raw_object.get("geometry")) if geometry.get("surfaceType") is not None: _increment_count(result["surfaceTypeCounts"], geometry.get("surfaceType")) if geometry.get("curveType") is not None: _increment_count(result["curveTypeCounts"], geometry.get("curveType")) for command in raw_object.get("backendCommandCandidates", []) or []: if isinstance(command, Mapping) and command.get("enabled") is not False: _increment_count(result["operationCounts"], command.get("operation")) return result def _normalized_count_dict(value: object) -> dict[str, int]: if not isinstance(value, Mapping): return {} result: dict[str, int] = {} for key, count in value.items(): normalized = _count_key(key) number = _count_value(count) if normalized and number > 0: result[normalized] = result.get(normalized, 0) + number return result def _merge_count_dicts(primary: Mapping[str, int], fallback: Mapping[str, int]) -> dict[str, int]: result = {str(key): int(value) for key, value in primary.items() if int(value) > 0} for key, value in fallback.items(): text = str(key) number = int(value) if number > result.get(text, 0): result[text] = number return result def _increment_count(counts: dict[str, int], key: object) -> None: normalized = _count_key(key) if normalized: counts[normalized] = counts.get(normalized, 0) + 1 def _count_key(value: object) -> str: return str(value or "").strip().lower() def _count_value(value: object) -> int: try: return int(value) except (TypeError, ValueError): return 0 def map_scdm_raw_features_file(raw_path: str | Path, cache_path: str | Path | None = None) -> dict[str, object]: cache = map_scdm_raw_features(read_json(raw_path)) if cache_path is not None: write_json(cache_path, cache) return cache def _cylindrical_face_group_objects(raw_objects: list[object]) -> list[dict[str, object]]: groups: dict[tuple[object, ...], list[Mapping[str, object]]] = {} for raw_object in raw_objects: if not isinstance(raw_object, Mapping): continue geometry = _mapping(raw_object.get("geometry")) if _surface_key(geometry.get("surfaceType") or geometry.get("surface")) != "cylinder": continue center = _rounded_vector(geometry.get("center") or geometry.get("axisCenter")) axis = _canonical_axis(_rounded_vector(geometry.get("axis") or geometry.get("normal"))) radius = _rounded_number(geometry.get("radius")) if len(center) != 3 or len(axis) != 3 or radius is None or radius <= 0: continue topology = _mapping(raw_object.get("topologyHint")) body_index = _int_or_none(_first_present(topology.get("bodyIndex"), geometry.get("bodyIndex"))) key = (body_index, tuple(center), tuple(axis), radius) groups.setdefault(key, []).append(raw_object) result: list[dict[str, object]] = [] for (_body_index, center, axis, radius), members in groups.items(): if len(members) < 2: continue locators = [_locator_from_raw_object(member) for member in members] locators = [item for item in locators if item] topology = { "bodyIndex": _body_index, "faceOrdinal": _first_int(item.get("faceOrdinal") for item in locators), "faceOrdinals": [item["faceOrdinal"] for item in locators if item.get("faceOrdinal") is not None], "globalFaceOrdinal": _first_int(item.get("globalFaceOrdinal") for item in locators), "globalFaceOrdinals": [item["globalFaceOrdinal"] for item in locators if item.get("globalFaceOrdinal") is not None], "faceIds": _merge_ints(_mapping(member.get("topologyHint")).get("faceIds") for member in members), "scdmFaceLocators": locators, } source_ids = [str(member.get("backendId") or "") for member in members if str(member.get("backendId") or "")] result.append( { "backendId": "cylindrical_group:" + "|".join(source_ids), "objectType": "cylindrical_face_group", "geometry": { "surfaceType": "cylinder", "center": list(center), "axis": list(axis), "radius": radius, "diameter": radius * 2.0, "sourceBackendIds": source_ids, }, "topologyHint": topology, "backendCommandCandidates": [ {"operation": "change_hole_diameter", "enabled": True, "parameterFields": {"diameter": radius * 2.0}}, {"operation": "move_hole_axis", "enabled": True, "parameterFields": {"center": list(center)}}, {"operation": "fill_feature", "enabled": True, "parameterFields": {}}, ], "rawLimitations": [], } ) return result def _derived_feature_objects(source_objects: list[object]) -> list[dict[str, object]]: return _derived_linear_pattern_objects(source_objects) def _derived_linear_pattern_objects(source_objects: list[object]) -> list[dict[str, object]]: groups: dict[tuple[object, ...], list[dict[str, object]]] = {} for raw_object in source_objects: if not isinstance(raw_object, Mapping): continue object_type = str(raw_object.get("objectType") or "").strip().lower() if object_type not in {"hole", "cylindrical_hole", "cylindrical_face_group"}: continue geometry = _mapping(raw_object.get("geometry")) center = _rounded_vector(geometry.get("center") or geometry.get("axisCenter")) axis = _canonical_axis(_rounded_vector(geometry.get("axis") or geometry.get("normal"))) radius = _rounded_number(geometry.get("radius")) if radius is None: diameter = _rounded_number(geometry.get("diameter")) radius = diameter * 0.5 if diameter is not None else None if len(center) != 3 or len(axis) != 3 or radius is None or radius <= 0: continue topology = _mapping(raw_object.get("topologyHint")) key = ( _int_or_none(_first_present(topology.get("bodyIndex"), geometry.get("bodyIndex"))), tuple(axis), round(float(radius), 6), ) groups.setdefault(key, []).append( { "objectId": _object_id(raw_object), "center": center, "axis": axis, "radius": float(radius), "faceIds": _int_list(topology.get("faceIds") or geometry.get("faceIds")), "globalFaceOrdinals": _int_list( topology.get("globalFaceOrdinals") or topology.get("faceOrdinals") or [topology.get("globalFaceOrdinal"), topology.get("faceOrdinal")] ), } ) result: list[dict[str, object]] = [] seen: set[tuple[object, ...]] = set() for (body_index, _axis, radius), instances in groups.items(): if len(instances) < 3: continue candidates = _linear_pattern_candidates(instances) for candidate in candidates: member_ids = tuple(str(item.get("objectId") or "") for item in candidate["members"]) pattern_axis = tuple(round(float(value), 6) for value in candidate["direction"]) spacing = round(float(candidate["spacing"]), 6) key = (body_index, radius, pattern_axis, spacing, member_ids) if key in seen: continue seen.add(key) face_ids: list[int] = [] global_face_ordinals: list[int] = [] centers = [] for member in candidate["members"]: centers.append(list(member["center"])) face_ids.extend(_int_list(member.get("faceIds"))) global_face_ordinals.extend(_int_list(member.get("globalFaceOrdinals"))) center = [ round(sum(float(item[index]) for item in centers) / len(centers), 6) for index in range(3) ] result.append( { "backendId": "derived:linear_pattern:" + "|".join(member_ids), "objectType": "linear_pattern", "geometry": { "center": center, "axis": list(pattern_axis), "spacing": spacing, "pitch": spacing, "instanceCount": len(candidate["members"]), "instanceCenters": centers, "radius": radius, "diameter": radius * 2.0, "sourceObjectIds": list(member_ids), }, "topologyHint": { "bodyIndex": body_index, "faceIds": sorted(set(face_ids)), "globalFaceOrdinals": sorted(set(global_face_ordinals)), }, "backendCommandCandidates": [], "rawLimitations": [ "Derived from repeated cylindrical feature centers; SCDM edit command is not productized yet.", ], } ) if len(result) >= 24: return result return result def _linear_pattern_candidates(instances: list[dict[str, object]]) -> list[dict[str, object]]: if len(instances) < 3: return [] points = [list(item["center"]) for item in instances] diagonal = _point_cloud_diagonal(points) tolerance = max(diagonal * 1.0e-4, max(float(item.get("radius") or 0.0) for item in instances) * 0.02, 1.0e-5) candidates: list[dict[str, object]] = [] for left_index in range(len(instances)): for right_index in range(left_index + 1, len(instances)): p0 = points[left_index] p1 = points[right_index] direction = _unit_vector([p1[index] - p0[index] for index in range(3)]) if len(direction) != 3: continue collinear: list[tuple[float, dict[str, object]]] = [] for instance in instances: point = list(instance["center"]) delta = [point[index] - p0[index] for index in range(3)] projection = sum(delta[index] * direction[index] for index in range(3)) nearest = [p0[index] + projection * direction[index] for index in range(3)] distance = math.sqrt(sum((point[index] - nearest[index]) ** 2 for index in range(3))) if distance <= tolerance: collinear.append((projection, instance)) if len(collinear) < 3: continue collinear.sort(key=lambda item: item[0]) spacings = [ collinear[index + 1][0] - collinear[index][0] for index in range(len(collinear) - 1) if collinear[index + 1][0] - collinear[index][0] > tolerance ] if len(spacings) < 2: continue spacing = sum(spacings) / len(spacings) if spacing <= tolerance: continue spacing_tolerance = max(abs(spacing) * 0.03, tolerance * 3.0) if any(abs(value - spacing) > spacing_tolerance for value in spacings): continue members = [item[1] for item in collinear] canonical_direction = _canonical_axis([round(value, 6) for value in direction]) if not canonical_direction: continue member_ids = tuple(str(item.get("objectId") or "") for item in members) if any(set(member_ids) == set(str(member.get("objectId") or "") for member in existing["members"]) for existing in candidates): continue candidates.append({"members": members, "direction": canonical_direction, "spacing": spacing}) if len(candidates) >= 12: return candidates candidates.sort(key=lambda item: (-len(item["members"]), float(item["spacing"]))) return candidates def _point_cloud_diagonal(points: list[list[float]]) -> float: if not points: return 0.0 mins = [min(float(point[index]) for point in points) for index in range(3)] maxs = [max(float(point[index]) for point in points) for index in range(3)] return math.sqrt(sum((maxs[index] - mins[index]) ** 2 for index in range(3))) def _unit_vector(values: list[float]) -> list[float]: length = math.sqrt(sum(float(item) * float(item) for item in values)) if length <= 1.0e-12: return [] return [float(item) / length for item in values] def geometry_signature(raw_object: Mapping[str, object]) -> dict[str, object]: geometry = _mapping(raw_object.get("geometry")) topology = _mapping(raw_object.get("topologyHint")) return { "objectType": str(raw_object.get("objectType") or ""), "faceIds": _int_list(topology.get("faceIds") or geometry.get("faceIds")), "edgeIds": _int_list(topology.get("edgeIds") or geometry.get("edgeIds")), "bodyIndex": _int_or_none(_first_present(topology.get("bodyIndex"), geometry.get("bodyIndex"))), "faceOrdinal": _int_or_none(_first_present(topology.get("faceOrdinal"), geometry.get("faceOrdinal"))), "faceOrdinals": _int_list(topology.get("faceOrdinals") or geometry.get("faceOrdinals")), "edgeOrdinal": _int_or_none(_first_present(topology.get("edgeOrdinal"), geometry.get("edgeOrdinal"))), "globalFaceOrdinal": _int_or_none(_first_present(topology.get("globalFaceOrdinal"), geometry.get("globalFaceOrdinal"))), "globalFaceOrdinals": _int_list(topology.get("globalFaceOrdinals") or geometry.get("globalFaceOrdinals")), "globalEdgeOrdinal": _int_or_none(_first_present(topology.get("globalEdgeOrdinal"), geometry.get("globalEdgeOrdinal"))), "adjacentFaceOrdinals": _int_list(topology.get("adjacentFaceOrdinals") or geometry.get("adjacentFaceOrdinals")), "adjacentFaceCount": _int_or_none(_first_present(topology.get("adjacentFaceCount"), geometry.get("adjacentFaceCount"))), "surfaceType": str(geometry.get("surfaceType") or geometry.get("surface") or ""), "curveType": str(geometry.get("curveType") or ""), "center": _rounded_vector(geometry.get("center") or geometry.get("axisCenter")), "axis": _rounded_vector(geometry.get("axis") or geometry.get("normal")), "startPoint": _rounded_vector(geometry.get("startPoint")), "endPoint": _rounded_vector(geometry.get("endPoint")), "midPoint": _rounded_vector(geometry.get("midPoint")), "length": _rounded_number(geometry.get("length")), "radius": _rounded_number(geometry.get("radius")), "diameter": _rounded_number(geometry.get("diameter")), "spacing": _rounded_number(geometry.get("spacing")), "pitch": _rounded_number(geometry.get("pitch")), "instanceCount": _int_or_none(geometry.get("instanceCount")), "instanceCenters": _rounded_vector_list(geometry.get("instanceCenters")), "sourceObjectIds": _string_list(geometry.get("sourceObjectIds")), "planeOffset": _rounded_number(geometry.get("planeOffset")), "scdmFaceLocators": _face_locators(topology.get("scdmFaceLocators")), } def attach_local_face_ids_to_scdm_cache( cache: Mapping[str, object], local_face_signatures: Iterable[Mapping[str, object]], *, min_score: float = 5.0, unique_margin: float = 0.75, ) -> dict[str, object]: local_signatures = [dict(item) for item in local_face_signatures if isinstance(item, Mapping)] result = dict(cache) diagnostics = dict(result.get("diagnostics") if isinstance(result.get("diagnostics"), Mapping) else {}) mapping_rows: list[dict[str, object]] = [] objects = [] for raw_object in result.get("objects", []) if isinstance(result.get("objects"), list) else []: if not isinstance(raw_object, Mapping): continue item = dict(raw_object) signature = dict(item.get("geometrySignature") if isinstance(item.get("geometrySignature"), Mapping) else {}) if not _int_list(signature.get("faceIds")): if str(signature.get("objectType") or "") in {"cylindrical_face_group", "cylindrical_hole"}: match = _match_local_face_group_signatures(signature, local_signatures, min_score=min_score, unique_margin=unique_margin) else: match = _match_local_face_signature(signature, local_signatures, min_score=min_score, unique_margin=unique_margin) status = str(match.get("status") or "") if status in {"unique", "group"}: face_ids = _int_list(match.get("faceIds")) face_id = _int_or_none(match.get("faceId")) if not face_ids and face_id is not None: face_ids = [face_id] if face_ids: signature["faceIds"] = face_ids signature["localMatchScore"] = match.get("score") signature["localUnitScale"] = match.get("unitScale") mapping_rows.append( { "objectId": item.get("objectId"), "status": status, "faceId": match.get("faceId"), "faceIds": match.get("faceIds"), "score": match.get("score"), "message": match.get("message"), } ) item["geometrySignature"] = signature objects.append(item) diagnostics["local_face_mapping"] = mapping_rows result["objects"] = objects result["diagnostics"] = diagnostics return result def _match_local_face_signature( scdm_signature: Mapping[str, object], local_signatures: list[dict[str, object]], *, min_score: float, unique_margin: float, ) -> dict[str, object]: scored = [] for local in local_signatures: score, scale = _local_signature_score(scdm_signature, local) if score <= 0: continue scored.append({"faceId": local.get("faceId"), "score": score, "unitScale": scale}) scored.sort(key=lambda item: float(item.get("score") or 0.0), reverse=True) if not scored or float(scored[0].get("score") or 0.0) < min_score: return {"status": "none", "message": "No local Face signature matched SCDM object.", "candidates": scored[:5]} if len(scored) > 1: top = float(scored[0].get("score") or 0.0) second = float(scored[1].get("score") or 0.0) if top - second < unique_margin: return {"status": "multiple", "message": "Multiple local Faces match the same SCDM object.", "candidates": scored[:5]} return {"status": "unique", "message": "Matched one local Face.", **scored[0]} def _match_local_face_group_signatures( scdm_signature: Mapping[str, object], local_signatures: list[dict[str, object]], *, min_score: float, unique_margin: float, ) -> dict[str, object]: scored = [] for local in local_signatures: score, scale = _local_signature_score(scdm_signature, local) if score < min_score: continue scored.append({"faceId": local.get("faceId"), "score": score, "unitScale": scale}) scored.sort(key=lambda item: float(item.get("score") or 0.0), reverse=True) if not scored: return {"status": "none", "message": "No local cylindrical Face matched SCDM group.", "candidates": []} top = float(scored[0].get("score") or 0.0) selected = [item for item in scored if top - float(item.get("score") or 0.0) <= unique_margin] face_ids = sorted(set(_int_or_none(item.get("faceId")) for item in selected if _int_or_none(item.get("faceId")) is not None)) if not face_ids: return {"status": "none", "message": "Local cylindrical group matched no usable Face IDs.", "candidates": scored[:5]} return { "status": "group", "message": "Matched a local cylindrical Face group.", "faceIds": face_ids, "score": top, "unitScale": selected[0].get("unitScale"), "candidates": scored[:8], } def _local_signature_score(scdm_signature: Mapping[str, object], local: Mapping[str, object]) -> tuple[float, float]: scdm_surface = _surface_key(scdm_signature.get("surfaceType")) local_surface = _surface_key(local.get("surfaceType")) if scdm_surface and local_surface and scdm_surface != local_surface: return 0.0, 1.0 scales = _unit_scale_candidates(scdm_signature, local) best_score = 0.0 best_scale = 1.0 for scale in scales: score = 2.0 if scdm_surface and scdm_surface == local_surface else 0.0 score += _axis_match_score(_rounded_vector(scdm_signature.get("axis")), _rounded_vector(local.get("axis"))) if scdm_surface == "plane": score += _scaled_number_match_score( _rounded_number(local.get("planeOffset")), _rounded_number(scdm_signature.get("planeOffset")), scale, ) elif scdm_surface == "cylinder": score += _scaled_number_match_score( _rounded_number(local.get("radius")), _rounded_number(scdm_signature.get("radius")), scale, ) score += _axis_point_distance_score( _rounded_vector(local.get("center")), _rounded_vector(local.get("axis")), _rounded_vector(scdm_signature.get("center")), scale, ) else: score += _scaled_vector_match_score( _rounded_vector(local.get("center")), _rounded_vector(scdm_signature.get("center")), scale, ) if score > best_score: best_score = score best_scale = scale return best_score, best_scale def _unit_scale_candidates(scdm_signature: Mapping[str, object], local: Mapping[str, object]) -> tuple[float, ...]: values = [1.0, 0.001, 1000.0] local_radius = _rounded_number(local.get("radius")) scdm_radius = _rounded_number(scdm_signature.get("radius")) if local_radius and scdm_radius: values.append(float(scdm_radius) / float(local_radius)) local_offset = _rounded_number(local.get("planeOffset")) scdm_offset = _rounded_number(scdm_signature.get("planeOffset")) if local_offset not in {None, 0.0} and scdm_offset is not None: values.append(float(scdm_offset) / float(local_offset)) result = [] for value in values: if value > 0 and all(abs(value - existing) > max(value, existing) * 1e-9 for existing in result): result.append(value) return tuple(result) def _capability_payload( key: str, raw_object: Mapping[str, object], *, available_command_names: set[str] | None = None, ) -> dict[str, object] | None: definition = capability_definition(key) if definition is None: return None block_reason = _missing_backend_command_reason(key, available_command_names) return { "key": definition.key, "displayName": definition.display_name, "valueKind": definition.value_kind, "currentValue": _current_value(definition.current_fields, raw_object), "defaultIntent": definition.default_intent, "backendOperation": definition.backend_operation, "postCheck": definition.post_check, "editable": True, "blockReason": block_reason, } def _current_value(fields: tuple[str, ...], raw_object: Mapping[str, object]) -> object: geometry = _mapping(raw_object.get("geometry")) for field in fields: if field == "0": return 0.0 if field == "1": return 1 if field == "geometry.radius*2": radius = _number(geometry.get("radius")) if radius is not None: return radius * 2.0 continue if field.startswith("geometry."): key = field.split(".", 1)[1] if key in geometry and geometry.get(key) is not None: return geometry.get(key) return None def _available_command_names(value: object) -> set[str] | None: if not isinstance(value, list): return None result: set[str] = set() for item in value: if not isinstance(item, Mapping): continue if item.get("available") is not True: continue name = str(item.get("name") or "").strip() if name: result.add(name) return result def _missing_backend_command_reason(key: str, available_command_names: set[str] | None) -> str: if available_command_names is None: return "" definition = capability_definition(key) groups = definition.required_backend_command_groups if definition is not None else () if not groups: return "" if any(all(command in available_command_names for command in group) for group in groups): return "" readable = " / ".join(" + ".join(group) for group in groups) return f"SCDM 当前脚本环境缺少 {readable} 命令，暂不能执行该参数。" def _object_id(raw_object: Mapping[str, object]) -> str: existing = str(raw_object.get("objectId") or "").strip() if existing: return existing object_type = str(raw_object.get("objectType") or "object").strip() or "object" backend_id = str(raw_object.get("backendId") or "").strip() if backend_id: return f"{object_type}:{backend_id}" signature = geometry_signature(raw_object) face_ids = signature.get("faceIds") if isinstance(face_ids, list) and face_ids: return f"{object_type}:face:{'-'.join(str(item) for item in face_ids)}" return object_type def _locator_from_raw_object(raw_object: Mapping[str, object]) -> dict[str, object]: geometry = _mapping(raw_object.get("geometry")) topology = _mapping(raw_object.get("topologyHint")) return { "backendId": str(raw_object.get("backendId") or ""), "bodyIndex": _int_or_none(_first_present(topology.get("bodyIndex"), geometry.get("bodyIndex"))), "faceOrdinal": _int_or_none(_first_present(topology.get("faceOrdinal"), geometry.get("faceOrdinal"))), "globalFaceOrdinal": _int_or_none(_first_present(topology.get("globalFaceOrdinal"), geometry.get("globalFaceOrdinal"))), } def _face_locators(value: object) -> list[dict[str, object]]: if not isinstance(value, (list, tuple)): return [] result: list[dict[str, object]] = [] for item in value: if not isinstance(item, Mapping): continue locator = { "backendId": str(item.get("backendId") or ""), "bodyIndex": _int_or_none(item.get("bodyIndex")), "faceOrdinal": _int_or_none(item.get("faceOrdinal")), "globalFaceOrdinal": _int_or_none(item.get("globalFaceOrdinal")), } if any(locator.get(key) is not None for key in ("bodyIndex", "faceOrdinal", "globalFaceOrdinal")): result.append(locator) return result def _first_int(values: Iterable[object]) -> int | None: for value in values: number = _int_or_none(value) if number is not None: return number return None def _merge_ints(values: Iterable[object]) -> list[int]: result: list[int] = [] for value in values: result.extend(_int_list(value)) return sorted(set(result)) def _mapping(value: object) -> Mapping[str, object]: return value if isinstance(value, Mapping) else {} def _int_list(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 sorted(set(result)) def _int_or_none(value: object) -> int | None: try: return int(value) except (TypeError, ValueError): return None def _first_present(*values: object) -> object: for value in values: if value is not None and value != "": return value return None def _surface_key(value: object) -> str: text = str(value or "").strip().lower() if "plane" in text: return "plane" if "cylinder" in text: return "cylinder" return text def _canonical_axis(axis: list[float]) -> list[float]: if len(axis) != 3: return [] length = math.sqrt(sum(item * item for item in axis)) if length <= 1e-12: return [] normalized = [item / length for item in axis] for value in normalized: if abs(value) > 1e-12: if value < 0: normalized = [-item for item in normalized] break return [round(item, 6) for item in normalized] def _axis_match_score(left: list[float], right: list[float]) -> float: if len(left) != 3 or len(right) != 3: return 0.0 left_len = math.sqrt(sum(item * item for item in left)) right_len = math.sqrt(sum(item * item for item in right)) if left_len <= 1e-12 or right_len <= 1e-12: return 0.0 dot = abs(sum(left[index] * right[index] for index in range(3)) / (left_len * right_len)) if dot >= 0.999: return 3.0 if dot >= 0.99: return 2.0 return 0.0 def _scaled_number_match_score(local_value: float | None, scdm_value: float | None, scale: float) -> float: if local_value is None or scdm_value is None: return 0.0 error = abs(float(local_value) * scale - float(scdm_value)) reference = max(abs(float(scdm_value)), abs(float(local_value) * scale), 1.0e-9) relative = error / reference if relative <= 1.0e-5: return 4.0 if relative <= 1.0e-3: return 3.0 if relative <= 1.0e-2: return 1.0 return 0.0 def _scaled_vector_match_score(local_value: list[float], scdm_value: list[float], scale: float) -> float: if len(local_value) != 3 or len(scdm_value) != 3: return 0.0 distance = math.sqrt(sum((local_value[index] * scale - scdm_value[index]) ** 2 for index in range(3))) reference = max(max(abs(item) for item in scdm_value), 1.0e-9) relative = distance / reference if relative <= 1.0e-5: return 4.0 if relative <= 1.0e-3: return 3.0 if relative <= 1.0e-2: return 1.0 return 0.0 def _axis_point_distance_score( local_point: list[float], local_axis: list[float], scdm_point: list[float], scale: float, ) -> float: if len(local_point) != 3 or len(local_axis) != 3 or len(scdm_point) != 3: return 0.0 point = [local_point[index] * scale for index in range(3)] axis_len = math.sqrt(sum(item * item for item in local_axis)) if axis_len <= 1e-12: return 0.0 axis = [item / axis_len for item in local_axis] delta = [scdm_point[index] - point[index] for index in range(3)] projection = sum(delta[index] * axis[index] for index in range(3)) nearest = [point[index] + projection * axis[index] for index in range(3)] distance = math.sqrt(sum((nearest[index] - scdm_point[index]) ** 2 for index in range(3))) reference = max(max(abs(item) for item in scdm_point), 1.0e-9) relative = distance / reference if relative <= 1.0e-5: return 3.0 if relative <= 1.0e-3: return 2.0 if relative <= 1.0e-2: return 0.75 return 0.0 def _rounded_vector(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]: number = _number(item) if number is None: return [] result.append(round(number, 6)) return result if len(result) == 3 else [] def _rounded_vector_list(value: object) -> list[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[list[float]] = [] for item in values: rounded = _rounded_vector(item) if len(rounded) == 3: result.append(rounded) return result def _string_list(value: object) -> list[str]: if isinstance(value, (str, bytes)) or value is None: return [] try: values = list(value) # type: ignore[arg-type] except TypeError: return [] result: list[str] = [] for item in values: text = str(item or "").strip() if text: result.append(text) return result def _rounded_number(value: object) -> float | None: number = _number(value) return None if number is None else round(number, 6) def _number(value: object) -> float | None: try: return float(value) except (TypeError, ValueError): return None __all__ = [ "attach_local_face_ids_to_scdm_cache", "geometry_signature", "map_scdm_raw_features", "map_scdm_raw_features_file", ]