4543 lines
185 KiB
C#
4543 lines
185 KiB
C#
using System.Globalization;
|
||
using System.Diagnostics;
|
||
using System.Reflection;
|
||
using System.Runtime.InteropServices;
|
||
using System.Text.Json;
|
||
using System.Text.RegularExpressions;
|
||
using Microsoft.Win32;
|
||
|
||
try
|
||
{
|
||
var options = CliOptions.Parse(args);
|
||
if (string.IsNullOrWhiteSpace(options.DrawingPath) || !File.Exists(options.DrawingPath))
|
||
throw new FileNotFoundException($"DWG 文件不存在：{options.DrawingPath}");
|
||
|
||
Directory.CreateDirectory(options.OutputDir);
|
||
var result = string.IsNullOrWhiteSpace(options.ReuseExtractionDir)
|
||
? StaRunner.Run(() => AutoCadExtractor.Extract(options))
|
||
: AutoCadExtractor.ReanalyzeExistingExtraction(options);
|
||
Console.WriteLine(JsonSerializer.Serialize(result, JsonDefaults.Options));
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
Environment.ExitCode = 1;
|
||
Console.Error.WriteLine(ex.ToString());
|
||
Console.WriteLine(JsonSerializer.Serialize(new Dictionary<string, object?>
|
||
{
|
||
["ok"] = false,
|
||
["error_type"] = ex.GetType().FullName,
|
||
["message"] = ex.Message
|
||
}, JsonDefaults.Options));
|
||
}
|
||
|
||
sealed class AutoCadExtractor
|
||
{
|
||
const double AngleToleranceDeg = 1.0;
|
||
const double CollinearDistanceTolerance = 0.05;
|
||
const double GapTolerance = 0.05;
|
||
const double MainViewConnectTolerance = 0.5;
|
||
const double ViewRegionProbeTolerance = 0.5;
|
||
const double ViewRegionSpatialExpansionTolerance = 12.0;
|
||
|
||
public static ExtractionResult Extract(CliOptions options)
|
||
{
|
||
LogProgress("connect_autocad_start");
|
||
var app = ConnectOrCreate(options.ProgId, options.Visible, options.AllowStartAutoCad, out var started);
|
||
LogProgress("connect_autocad_ok");
|
||
object? doc = null;
|
||
try
|
||
{
|
||
LogProgress("wait_autocad_start");
|
||
WaitForQuiescent(app, TimeSpan.FromSeconds(30));
|
||
LogProgress("open_document_start");
|
||
doc = OpenDocument(app, options.DrawingPath);
|
||
LogProgress("open_document_ok");
|
||
WaitForQuiescent(app, TimeSpan.FromSeconds(30));
|
||
|
||
LogProgress("read_spline_endpoints_start");
|
||
var splineEndpoints = ReadSplineEndpointsViaAutoLisp(app, doc, options.OutputDir);
|
||
LogProgress("read_spline_endpoints_ok");
|
||
LogProgress("read_block_explosions_start");
|
||
var blockExplosions = ReadBlockExplosionsViaAutoLisp(app, doc, options.OutputDir);
|
||
LogProgress("read_block_explosions_ok");
|
||
LogProgress("read_dimension_definition_points_start");
|
||
var dimensionDefinitionPoints = ReadDimensionDefinitionPointsViaAutoLisp(app, doc, options.OutputDir);
|
||
LogProgress("read_dimension_definition_points_ok");
|
||
var extraction = new DocumentExtraction();
|
||
LogProgress("extract_modelspace_start");
|
||
ExtractSpace(doc, "ModelSpace", extraction, options.MaxEntities, splineEndpoints, blockExplosions, dimensionDefinitionPoints);
|
||
LogProgress("extract_modelspace_ok");
|
||
LogProgress("extract_paperspace_start");
|
||
ExtractSpace(doc, "PaperSpace", extraction, options.MaxEntities, splineEndpoints, blockExplosions, dimensionDefinitionPoints);
|
||
LogProgress("extract_paperspace_ok");
|
||
LogProgress("select_main_view_start");
|
||
SelectMainView(extraction, options.MainViewSeedMode, options.MainViewReferenceSelectionPath);
|
||
LogProgress("select_main_view_ok");
|
||
LogProgress("analyze_view_regions_start");
|
||
AnalyzeViewRegions(extraction, options);
|
||
LogProgress("analyze_view_regions_ok");
|
||
LogProgress("normalize_geometry_start");
|
||
NormalizeGeometry(extraction);
|
||
LogProgress("normalize_geometry_ok");
|
||
if (!string.IsNullOrWhiteSpace(options.SaveMainViewOnlyDwgPath))
|
||
{
|
||
var keptHandles = extraction.MainViewGeometry
|
||
.Select(item => ReadDictString(item, "handle"))
|
||
.Where(handle => !string.IsNullOrWhiteSpace(handle))
|
||
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
||
var savePath = Path.GetFullPath(options.SaveMainViewOnlyDwgPath);
|
||
var deleteResult = SaveMainViewOnlyDwg(doc, savePath, keptHandles);
|
||
extraction.MainViewSelection["main_view_only_dwg_path"] = savePath;
|
||
extraction.MainViewSelection["main_view_only_deleted_entity_count"] = deleteResult.DeletedCount;
|
||
extraction.MainViewSelection["main_view_only_kept_handle_count"] = keptHandles.Count;
|
||
}
|
||
|
||
LogProgress("write_files_start");
|
||
var manifest = WriteFiles(options.OutputDir, options.DrawingPath, options.ProgId, started, extraction);
|
||
LogProgress("write_files_ok");
|
||
if (options.CloseAfterExtract)
|
||
{
|
||
LogProgress("close_document_start");
|
||
TryInvoke(doc, "Close", [false]);
|
||
LogProgress("close_document_ok");
|
||
}
|
||
|
||
return new ExtractionResult
|
||
{
|
||
Ok = true,
|
||
Source = "AutoCAD COM external extractor",
|
||
ProgId = options.ProgId,
|
||
Started = started,
|
||
DrawingPath = options.DrawingPath,
|
||
ExportDir = options.OutputDir,
|
||
ManifestPath = Path.Combine(options.OutputDir, "manifest.json"),
|
||
EntityCount = extraction.EntitiesCommon.Count,
|
||
TypeCounts = extraction.TypeCounts,
|
||
CategoryFiles = manifest.CategoryFiles,
|
||
Message = $"已通过 AutoCAD COM 提取 DWG：{Path.GetFileName(options.DrawingPath)}"
|
||
};
|
||
}
|
||
finally
|
||
{
|
||
if (doc != null)
|
||
ReleaseCom(doc);
|
||
ReleaseCom(app);
|
||
}
|
||
}
|
||
|
||
public static ExtractionResult ReanalyzeExistingExtraction(CliOptions options)
|
||
{
|
||
LogProgress("reuse_extraction_load_start");
|
||
var extraction = LoadExistingExtraction(options.ReuseExtractionDir);
|
||
LogProgress("reuse_extraction_load_ok");
|
||
|
||
LogProgress("select_main_view_start");
|
||
SelectMainView(extraction, options.MainViewSeedMode, options.MainViewReferenceSelectionPath);
|
||
LogProgress("select_main_view_ok");
|
||
|
||
LogProgress("analyze_view_regions_start");
|
||
AnalyzeViewRegions(extraction, options);
|
||
LogProgress("analyze_view_regions_ok");
|
||
|
||
LogProgress("normalize_geometry_start");
|
||
NormalizeGeometry(extraction);
|
||
LogProgress("normalize_geometry_ok");
|
||
|
||
LogProgress("write_files_start");
|
||
var manifest = WriteFiles(options.OutputDir, options.DrawingPath, options.ProgId, false, extraction);
|
||
LogProgress("write_files_ok");
|
||
|
||
return new ExtractionResult
|
||
{
|
||
Ok = true,
|
||
Source = "Existing AutoCAD extraction reanalysis",
|
||
ProgId = options.ProgId,
|
||
Started = false,
|
||
DrawingPath = options.DrawingPath,
|
||
ExportDir = options.OutputDir,
|
||
ManifestPath = Path.Combine(options.OutputDir, "manifest.json"),
|
||
EntityCount = extraction.EntitiesCommon.Count,
|
||
TypeCounts = extraction.TypeCounts,
|
||
CategoryFiles = manifest.CategoryFiles,
|
||
Message = $"Reanalyzed existing extraction: {Path.GetFileName(options.ReuseExtractionDir)}"
|
||
};
|
||
}
|
||
|
||
static void LogProgress(string stage) =>
|
||
Console.Error.WriteLine($"[{DateTime.Now:HH:mm:ss}] AutoCadDwgExtractor {stage}");
|
||
|
||
static void ExtractSpace(
|
||
object doc,
|
||
string spaceName,
|
||
DocumentExtraction extraction,
|
||
int maxEntities,
|
||
Dictionary<string, SplineEndpoint> splineEndpoints,
|
||
Dictionary<string, List<Dictionary<string, object?>>> blockExplosions,
|
||
Dictionary<string, DimensionDefinitionPoints> dimensionDefinitionPoints)
|
||
{
|
||
var space = GetProperty(doc, spaceName);
|
||
if (space == null)
|
||
return;
|
||
|
||
try
|
||
{
|
||
var count = ToInt(GetProperty(space, "Count")) ?? 0;
|
||
if (spaceName.Equals("ModelSpace", StringComparison.OrdinalIgnoreCase))
|
||
extraction.ModelSpaceCount = count;
|
||
else
|
||
extraction.PaperSpaceCount = count;
|
||
|
||
for (var i = 0; i < count && extraction.EntitiesCommon.Count < maxEntities; i++)
|
||
{
|
||
var entity = GetCollectionItem(space, i);
|
||
if (entity == null)
|
||
continue;
|
||
try
|
||
{
|
||
ExtractEntity(entity, spaceName, i, extraction, splineEndpoints, blockExplosions, dimensionDefinitionPoints);
|
||
}
|
||
finally
|
||
{
|
||
ReleaseCom(entity);
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
ReleaseCom(space);
|
||
}
|
||
}
|
||
|
||
static void ExtractEntity(
|
||
object entity,
|
||
string spaceName,
|
||
int index,
|
||
DocumentExtraction extraction,
|
||
Dictionary<string, SplineEndpoint> splineEndpoints,
|
||
Dictionary<string, List<Dictionary<string, object?>>> blockExplosions,
|
||
Dictionary<string, DimensionDefinitionPoints> dimensionDefinitionPoints)
|
||
{
|
||
var objectName = ReadString(entity, "ObjectName");
|
||
if (string.IsNullOrWhiteSpace(objectName))
|
||
objectName = entity.GetType().Name;
|
||
|
||
extraction.TypeCounts[objectName] = extraction.TypeCounts.TryGetValue(objectName, out var count) ? count + 1 : 1;
|
||
|
||
var common = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase)
|
||
{
|
||
["space"] = spaceName,
|
||
["index"] = index,
|
||
["object_name"] = objectName,
|
||
["handle"] = ReadString(entity, "Handle"),
|
||
["layer"] = ReadString(entity, "Layer"),
|
||
["linetype"] = ReadString(entity, "Linetype"),
|
||
["color"] = ToInt(GetProperty(entity, "Color")),
|
||
["lineweight"] = ToInt(GetProperty(entity, "Lineweight"))
|
||
};
|
||
extraction.EntitiesCommon.Add(common);
|
||
|
||
var details = ExtractDetails(entity, objectName);
|
||
var handle = ReadDictString(common, "handle");
|
||
if (objectName.Contains("Spline", StringComparison.OrdinalIgnoreCase) &&
|
||
!string.IsNullOrWhiteSpace(handle) &&
|
||
splineEndpoints.TryGetValue(handle, out var splineEndpoint))
|
||
{
|
||
details["start"] = splineEndpoint.Start;
|
||
details["end"] = splineEndpoint.End;
|
||
details["spline_endpoint_source"] = splineEndpoint.Source;
|
||
}
|
||
if (objectName.Contains("BlockReference", StringComparison.OrdinalIgnoreCase) &&
|
||
!string.IsNullOrWhiteSpace(handle) &&
|
||
blockExplosions.TryGetValue(handle, out var exploded))
|
||
{
|
||
details["exploded_entities"] = exploded;
|
||
details["exploded_entity_count"] = exploded.Count;
|
||
}
|
||
if (objectName.Contains("Dimension", StringComparison.OrdinalIgnoreCase) &&
|
||
!string.IsNullOrWhiteSpace(handle) &&
|
||
dimensionDefinitionPoints.TryGetValue(handle, out var definitionPoints))
|
||
{
|
||
ApplyDimensionDefinitionPoints(details, definitionPoints);
|
||
}
|
||
var merged = Merge(common, details);
|
||
if (objectName.Contains("Dimension", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
extraction.Dimensions.Add(merged);
|
||
var tol = ExtractDimensionalTolerance(common, details);
|
||
if (tol != null)
|
||
extraction.DimensionalTolerances.Add(tol);
|
||
}
|
||
else if (IsGeometry(objectName))
|
||
{
|
||
extraction.Geometry.Add(merged);
|
||
}
|
||
else if (IsAnnotation(objectName))
|
||
{
|
||
extraction.Annotations.Add(merged);
|
||
}
|
||
else
|
||
{
|
||
extraction.UnknownEntities.Add(merged);
|
||
}
|
||
|
||
var text = details.TryGetValue("text", out var t) ? Convert.ToString(t, CultureInfo.InvariantCulture) ?? "" : "";
|
||
var blockName = details.TryGetValue("effective_name", out var b) ? Convert.ToString(b, CultureInfo.InvariantCulture) ?? "" : "";
|
||
if (LooksLikeRoughness(text, blockName))
|
||
extraction.Roughness.Add(merged);
|
||
if (LooksLikeGeometricTolerance(text, blockName))
|
||
extraction.GeometricTolerances.Add(merged);
|
||
if (LooksLikeDatum(text, blockName))
|
||
extraction.Datums.Add(merged);
|
||
}
|
||
|
||
static Dictionary<string, object?> ExtractDetails(object entity, string objectName)
|
||
{
|
||
var details = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);
|
||
var bbox = ReadEntityBoundingBox(entity);
|
||
if (bbox != null)
|
||
details["bbox"] = bbox;
|
||
|
||
if (IsPolyline(objectName))
|
||
{
|
||
var coordinates = DoubleList(GetProperty(entity, "Coordinates"));
|
||
details["coordinates"] = coordinates;
|
||
details["closed"] = ToBool(GetProperty(entity, "Closed"));
|
||
details["elevation"] = ToDouble(GetProperty(entity, "Elevation"));
|
||
details["bulges"] = ReadPolylineBulges(entity, coordinates.Count);
|
||
}
|
||
else if (objectName.Contains("Circle", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
AddPoint(details, "center", GetProperty(entity, "Center"));
|
||
var radius = ToDouble(GetProperty(entity, "Radius"));
|
||
details["radius"] = radius;
|
||
details["diameter"] = radius == null ? null : radius * 2;
|
||
}
|
||
else if (objectName.Contains("Arc", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
AddPoint(details, "center", GetProperty(entity, "Center"));
|
||
details["radius"] = ToDouble(GetProperty(entity, "Radius"));
|
||
details["start_angle"] = ToDouble(GetProperty(entity, "StartAngle"));
|
||
details["end_angle"] = ToDouble(GetProperty(entity, "EndAngle"));
|
||
}
|
||
else if (objectName.Contains("Spline", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
AddPoint(details, "start", GetProperty(entity, "StartPoint"));
|
||
AddPoint(details, "end", GetProperty(entity, "EndPoint"));
|
||
var fitPoints = DoubleList(GetProperty(entity, "FitPoints"));
|
||
var controlPoints = DoubleList(GetProperty(entity, "ControlPoints"));
|
||
if (fitPoints.Count > 0)
|
||
details["fit_points"] = fitPoints;
|
||
if (controlPoints.Count > 0)
|
||
details["control_points"] = controlPoints;
|
||
EnsureSplineEndpoint(details, "start", fitPoints, controlPoints, takeFirst: true);
|
||
EnsureSplineEndpoint(details, "end", fitPoints, controlPoints, takeFirst: false);
|
||
details["degree"] = ToInt(GetProperty(entity, "Degree"));
|
||
details["closed"] = ToBool(GetProperty(entity, "Closed"));
|
||
}
|
||
else if (objectName.Contains("Line", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
AddPoint(details, "start", GetProperty(entity, "StartPoint"));
|
||
AddPoint(details, "end", GetProperty(entity, "EndPoint"));
|
||
}
|
||
else if (objectName.Contains("Text", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var raw = ReadString(entity, "TextString");
|
||
details["text"] = CleanAcadText(raw);
|
||
details["raw_text"] = raw;
|
||
details["height"] = ToDouble(GetProperty(entity, "Height"));
|
||
details["rotation"] = ToDouble(GetProperty(entity, "Rotation"));
|
||
AddPoint(details, "insertion_point", GetProperty(entity, "InsertionPoint"));
|
||
}
|
||
else if (objectName.Contains("Dimension", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var raw = ReadString(entity, "TextOverride");
|
||
details["measurement"] = ToDouble(GetProperty(entity, "Measurement"));
|
||
details["text_override"] = raw;
|
||
details["text"] = CleanAcadText(raw);
|
||
var missingPointFields = new List<string>();
|
||
AddPointFromProperties(details, "text_position", entity, missingPointFields, "TextPosition");
|
||
AddPointFromProperties(details, "xline1_point", entity, missingPointFields, "XLine1Point", "ExtLine1Point", "ExtensionLine1Point");
|
||
AddPointFromProperties(details, "xline2_point", entity, missingPointFields, "XLine2Point", "ExtLine2Point", "ExtensionLine2Point");
|
||
AddPointFromProperties(details, "dim_line_point", entity, missingPointFields, "DimLinePoint", "DimLineLocation");
|
||
AddPointFromProperties(details, "center", entity, missingPointFields, "Center");
|
||
AddPointFromProperties(details, "chord_point", entity, missingPointFields, "ChordPoint");
|
||
AddPointFromProperties(details, "far_chord_point", entity, missingPointFields, "FarChordPoint");
|
||
if (missingPointFields.Count > 0)
|
||
details["dimension_point_missing_fields"] = missingPointFields;
|
||
}
|
||
else if (objectName.Contains("BlockReference", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
details["name"] = ReadString(entity, "Name");
|
||
details["effective_name"] = ReadString(entity, "EffectiveName");
|
||
details["rotation"] = ToDouble(GetProperty(entity, "Rotation"));
|
||
AddPoint(details, "insertion_point", GetProperty(entity, "InsertionPoint"));
|
||
var attributes = ReadBlockAttributes(entity);
|
||
if (attributes.Count > 0)
|
||
{
|
||
details["attributes"] = attributes;
|
||
details["text"] = string.Join(" ", attributes.Select(a => a.TryGetValue("value", out var value) ? value : null));
|
||
}
|
||
}
|
||
else if (objectName.Contains("Hatch", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
details["pattern_name"] = ReadString(entity, "PatternName");
|
||
details["pattern_scale"] = ToDouble(GetProperty(entity, "PatternScale"));
|
||
}
|
||
|
||
return details;
|
||
}
|
||
|
||
static Dictionary<string, object?>? ReadEntityBoundingBox(object entity)
|
||
{
|
||
try
|
||
{
|
||
object? minPoint = null;
|
||
object? maxPoint = null;
|
||
object?[] args = [minPoint, maxPoint];
|
||
var modifiers = new ParameterModifier(2);
|
||
modifiers[0] = true;
|
||
modifiers[1] = true;
|
||
entity.GetType().InvokeMember(
|
||
"GetBoundingBox",
|
||
BindingFlags.InvokeMethod,
|
||
null,
|
||
entity,
|
||
args,
|
||
[modifiers],
|
||
CultureInfo.InvariantCulture,
|
||
null);
|
||
|
||
var min = DoubleList(args[0]);
|
||
var max = DoubleList(args[1]);
|
||
if (min.Count < 2 || max.Count < 2)
|
||
return null;
|
||
|
||
return new Dictionary<string, object?>
|
||
{
|
||
["min_x"] = Math.Min(min[0], max[0]),
|
||
["min_y"] = Math.Min(min[1], max[1]),
|
||
["max_x"] = Math.Max(min[0], max[0]),
|
||
["max_y"] = Math.Max(min[1], max[1])
|
||
};
|
||
}
|
||
catch
|
||
{
|
||
return null;
|
||
}
|
||
}
|
||
|
||
static List<Dictionary<string, object?>> ReadBlockAttributes(object entity)
|
||
{
|
||
var result = new List<Dictionary<string, object?>>();
|
||
if (ToBool(GetProperty(entity, "HasAttributes")) != true)
|
||
return result;
|
||
|
||
var raw = TryInvoke(entity, "GetAttributes", []);
|
||
if (raw is not Array array)
|
||
return result;
|
||
|
||
foreach (var item in array)
|
||
{
|
||
if (item == null)
|
||
continue;
|
||
result.Add(new Dictionary<string, object?>
|
||
{
|
||
["tag"] = ReadString(item, "TagString"),
|
||
["value"] = CleanAcadText(ReadString(item, "TextString")),
|
||
["raw_value"] = ReadString(item, "TextString")
|
||
});
|
||
ReleaseCom(item);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
static Dictionary<string, object?>? ExtractDimensionalTolerance(Dictionary<string, object?> common, Dictionary<string, object?> details)
|
||
{
|
||
var raw = details.TryGetValue("text_override", out var rawValue) ? Convert.ToString(rawValue, CultureInfo.InvariantCulture) ?? "" : "";
|
||
var text = details.TryGetValue("text", out var textValue) ? Convert.ToString(textValue, CultureInfo.InvariantCulture) ?? "" : "";
|
||
if (!DimensionalToleranceParser.LooksLikeTolerance(raw, text))
|
||
return null;
|
||
|
||
var measurement = details.TryGetValue("measurement", out var measurementValue)
|
||
? ToDouble(measurementValue)
|
||
: null;
|
||
var objectName = common.TryGetValue("object_name", out var objectNameValue)
|
||
? Convert.ToString(objectNameValue, CultureInfo.InvariantCulture) ?? ""
|
||
: "";
|
||
var parsed = DimensionalToleranceParser.Parse(text, raw, measurement, objectName);
|
||
var result = Merge(Merge(common, details), parsed);
|
||
result["measurement"] = measurementValue;
|
||
result["numeric_values"] = ExtractNumbers(text);
|
||
return result;
|
||
}
|
||
|
||
static void NormalizeGeometry(DocumentExtraction extraction)
|
||
{
|
||
var full = NormalizePrimitiveSet(extraction.Geometry, "full_drawing");
|
||
extraction.NormalizedGeometry = full.Normalized;
|
||
extraction.MergedLines = full.MergedLines;
|
||
extraction.GeometryOverlaps = full.Overlaps;
|
||
extraction.NormalizationSummary = full.Summary;
|
||
|
||
var main = NormalizePrimitiveSet(extraction.MainViewGeometry, "main_view");
|
||
extraction.MainViewNormalizedGeometry = main.Normalized;
|
||
extraction.MainViewMergedLines = main.MergedLines;
|
||
extraction.MainViewOverlaps = main.Overlaps;
|
||
extraction.MainViewSignature = BuildViewSignature(
|
||
extraction.MainViewNormalizedGeometry,
|
||
extraction.MainViewMergedLines,
|
||
"main_view");
|
||
|
||
foreach (var item in main.Summary)
|
||
extraction.MainViewSelection["normalization_" + item.Key] = item.Value;
|
||
}
|
||
|
||
static NormalizedGeometrySet NormalizePrimitiveSet(List<Dictionary<string, object?>> geometry, string scope)
|
||
{
|
||
var primitives = new List<Dictionary<string, object?>>();
|
||
foreach (var entity in geometry)
|
||
AddNormalizedPrimitives(entity, primitives);
|
||
|
||
var lines = primitives
|
||
.Where(item => string.Equals(ReadDictString(item, "kind"), "line", StringComparison.OrdinalIgnoreCase))
|
||
.Select(LinePrimitive.FromDictionary)
|
||
.Where(item => item != null && item.Length > 1e-9)
|
||
.Cast<LinePrimitive>()
|
||
.ToList();
|
||
|
||
var mergedLines = MergeStrongLines(lines);
|
||
var overlaps = FindStyleDifferentOverlaps(lines);
|
||
var summary = new Dictionary<string, object?>
|
||
{
|
||
["scope"] = scope,
|
||
["raw_geometry_count"] = geometry.Count,
|
||
["normalized_primitive_count"] = primitives.Count,
|
||
["normalized_line_count"] = lines.Count,
|
||
["merged_line_count"] = mergedLines.Count,
|
||
["overlap_group_count"] = overlaps.Count,
|
||
["angle_tolerance_deg"] = AngleToleranceDeg,
|
||
["collinear_distance_tolerance"] = CollinearDistanceTolerance,
|
||
["gap_tolerance"] = GapTolerance,
|
||
["merge_policy"] = "strong_only_same_style_collinear_interval_union"
|
||
};
|
||
|
||
return new NormalizedGeometrySet(primitives, mergedLines, overlaps, summary);
|
||
}
|
||
|
||
static void AddNormalizedPrimitives(Dictionary<string, object?> entity, List<Dictionary<string, object?>> output)
|
||
{
|
||
var objectName = ReadDictString(entity, "object_name");
|
||
if (IsPolyline(objectName))
|
||
{
|
||
AddPolylinePrimitives(entity, output);
|
||
return;
|
||
}
|
||
|
||
if (objectName.Contains("Circle", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var center = ReadPoint(entity, "center");
|
||
var radius = ReadDictDouble(entity, "radius");
|
||
if (center.Count >= 2 && radius != null)
|
||
output.Add(BasePrimitive(entity, "circle", new Dictionary<string, object?>
|
||
{
|
||
["center"] = center,
|
||
["radius"] = radius,
|
||
["diameter"] = radius * 2
|
||
}));
|
||
return;
|
||
}
|
||
|
||
if (objectName.Contains("Arc", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var center = ReadPoint(entity, "center");
|
||
var radius = ReadDictDouble(entity, "radius");
|
||
var startAngle = ReadDictDouble(entity, "start_angle");
|
||
var endAngle = ReadDictDouble(entity, "end_angle");
|
||
if (center.Count >= 2 && radius != null)
|
||
{
|
||
var extra = new Dictionary<string, object?>
|
||
{
|
||
["center"] = center,
|
||
["radius"] = radius,
|
||
["start_angle"] = startAngle,
|
||
["end_angle"] = endAngle
|
||
};
|
||
if (startAngle != null)
|
||
extra["start"] = PointOnCircle(center, radius.Value, startAngle.Value);
|
||
if (endAngle != null)
|
||
extra["end"] = PointOnCircle(center, radius.Value, endAngle.Value);
|
||
output.Add(BasePrimitive(entity, "arc", extra));
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (objectName.Contains("Spline", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
output.Add(BasePrimitive(entity, "spline", new Dictionary<string, object?>
|
||
{
|
||
["start"] = ReadPoint(entity, "start"),
|
||
["end"] = ReadPoint(entity, "end"),
|
||
["degree"] = ReadDictInt(entity, "degree"),
|
||
["closed"] = ReadDictBool(entity, "closed")
|
||
}));
|
||
return;
|
||
}
|
||
|
||
if (objectName.Contains("Line", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
AddLinePrimitive(entity, output, ReadPoint(entity, "start"), ReadPoint(entity, "end"), null, "line");
|
||
return;
|
||
}
|
||
|
||
if (objectName.Contains("Hatch", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
output.Add(BasePrimitive(entity, "hatch", new Dictionary<string, object?>
|
||
{
|
||
["pattern_name"] = ReadDictString(entity, "pattern_name"),
|
||
["pattern_scale"] = ReadDictDouble(entity, "pattern_scale")
|
||
}));
|
||
}
|
||
}
|
||
|
||
static void AddPolylinePrimitives(Dictionary<string, object?> entity, List<Dictionary<string, object?>> output)
|
||
{
|
||
var coordinates = ReadDoubleList(entity, "coordinates");
|
||
if (coordinates.Count < 4)
|
||
return;
|
||
|
||
var stride = coordinates.Count % 3 == 0 ? 3 : 2;
|
||
var points = new List<List<double>>();
|
||
for (var i = 0; i + stride - 1 < coordinates.Count; i += stride)
|
||
points.Add(new List<double> { coordinates[i], coordinates[i + 1] });
|
||
|
||
if (points.Count < 2)
|
||
return;
|
||
|
||
var bulges = ReadDoubleList(entity, "bulges");
|
||
var closed = ReadDictBool(entity, "closed") == true;
|
||
var segmentCount = closed ? points.Count : points.Count - 1;
|
||
for (var i = 0; i < segmentCount; i++)
|
||
{
|
||
var start = points[i];
|
||
var end = points[(i + 1) % points.Count];
|
||
var bulge = i < bulges.Count ? bulges[i] : 0.0;
|
||
if (Math.Abs(bulge) <= 1e-12)
|
||
{
|
||
AddLinePrimitive(entity, output, start, end, i + 1, "polyline_segment");
|
||
}
|
||
else
|
||
{
|
||
output.Add(BasePrimitive(entity, "arc", new Dictionary<string, object?>
|
||
{
|
||
["start"] = start,
|
||
["end"] = end,
|
||
["bulge"] = bulge,
|
||
["segment_index"] = i + 1,
|
||
["source_kind"] = "polyline_bulge_segment"
|
||
}));
|
||
}
|
||
}
|
||
}
|
||
|
||
static void AddLinePrimitive(
|
||
Dictionary<string, object?> entity,
|
||
List<Dictionary<string, object?>> output,
|
||
List<double> start,
|
||
List<double> end,
|
||
int? segmentIndex,
|
||
string sourceKind)
|
||
{
|
||
if (start.Count < 2 || end.Count < 2)
|
||
return;
|
||
|
||
var dx = end[0] - start[0];
|
||
var dy = end[1] - start[1];
|
||
var length = Math.Sqrt(dx * dx + dy * dy);
|
||
if (length <= 1e-9)
|
||
return;
|
||
|
||
var angle = NormalizeAngleDeg(Math.Atan2(dy, dx) * 180.0 / Math.PI);
|
||
var extra = new Dictionary<string, object?>
|
||
{
|
||
["start"] = start,
|
||
["end"] = end,
|
||
["length"] = length,
|
||
["angle_deg"] = angle,
|
||
["source_kind"] = sourceKind
|
||
};
|
||
if (segmentIndex != null)
|
||
extra["segment_index"] = segmentIndex;
|
||
|
||
output.Add(BasePrimitive(entity, "line", extra));
|
||
}
|
||
|
||
static List<Dictionary<string, object?>> MergeStrongLines(List<LinePrimitive> lines)
|
||
{
|
||
var result = new List<Dictionary<string, object?>>();
|
||
foreach (var styleGroup in lines.GroupBy(line => line.StyleKey, StringComparer.OrdinalIgnoreCase))
|
||
{
|
||
foreach (var angleGroup in styleGroup.GroupBy(line => AngleBucket(line.AngleDeg)))
|
||
{
|
||
foreach (var cluster in BuildCollinearClusters(angleGroup.ToList()))
|
||
{
|
||
foreach (var merged in MergeClusterIntervals(cluster))
|
||
result.Add(merged);
|
||
}
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
static List<Dictionary<string, object?>> FindStyleDifferentOverlaps(List<LinePrimitive> lines)
|
||
{
|
||
var result = new List<Dictionary<string, object?>>();
|
||
var groupIndex = 0;
|
||
foreach (var angleGroup in lines.GroupBy(line => AngleBucket(line.AngleDeg)))
|
||
{
|
||
foreach (var cluster in BuildCollinearClusters(angleGroup.ToList()))
|
||
{
|
||
var intervals = cluster
|
||
.Select(line => new LineInterval(line, Math.Min(line.T0, line.T1), Math.Max(line.T0, line.T1)))
|
||
.OrderBy(item => item.Start)
|
||
.ToList();
|
||
|
||
var active = new List<LineInterval>();
|
||
foreach (var current in intervals)
|
||
{
|
||
active.RemoveAll(item => item.End < current.Start + CollinearDistanceTolerance);
|
||
foreach (var prior in active)
|
||
{
|
||
if (string.Equals(prior.Line.StyleKey, current.Line.StyleKey, StringComparison.OrdinalIgnoreCase))
|
||
continue;
|
||
|
||
var overlapStart = Math.Max(prior.Start, current.Start);
|
||
var overlapEnd = Math.Min(prior.End, current.End);
|
||
var overlapLength = overlapEnd - overlapStart;
|
||
if (overlapLength <= GapTolerance)
|
||
continue;
|
||
|
||
groupIndex++;
|
||
result.Add(new Dictionary<string, object?>
|
||
{
|
||
["overlap_group_id"] = $"overlap-{groupIndex:000000}",
|
||
["handles"] = new[] { prior.Line.Handle, current.Line.Handle }.Where(x => !string.IsNullOrWhiteSpace(x)).Distinct().ToList(),
|
||
["indices"] = new[] { prior.Line.Index, current.Line.Index },
|
||
["overlap_length"] = overlapLength,
|
||
["reason"] = "same_geometry_different_style",
|
||
["style_a"] = prior.Line.Style,
|
||
["style_b"] = current.Line.Style
|
||
});
|
||
}
|
||
active.Add(current);
|
||
}
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
static List<List<LinePrimitive>> BuildCollinearClusters(List<LinePrimitive> lines)
|
||
{
|
||
var clusters = new List<List<LinePrimitive>>();
|
||
foreach (var line in lines.OrderBy(item => item.Offset))
|
||
{
|
||
List<LinePrimitive>? target = null;
|
||
foreach (var cluster in clusters)
|
||
{
|
||
if (IsCollinear(cluster[0], line))
|
||
{
|
||
target = cluster;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (target == null)
|
||
{
|
||
target = new List<LinePrimitive>();
|
||
clusters.Add(target);
|
||
}
|
||
target.Add(line);
|
||
}
|
||
|
||
return clusters;
|
||
}
|
||
|
||
static List<Dictionary<string, object?>> MergeClusterIntervals(List<LinePrimitive> cluster)
|
||
{
|
||
var result = new List<Dictionary<string, object?>>();
|
||
if (cluster.Count == 0)
|
||
return result;
|
||
|
||
var basis = cluster[0];
|
||
var intervals = cluster
|
||
.Select(line => new LineInterval(line, Math.Min(line.T0, line.T1), Math.Max(line.T0, line.T1)))
|
||
.OrderBy(item => item.Start)
|
||
.ToList();
|
||
|
||
var currentStart = intervals[0].Start;
|
||
var currentEnd = intervals[0].End;
|
||
var currentLines = new List<LinePrimitive> { intervals[0].Line };
|
||
|
||
void Flush()
|
||
{
|
||
var start = basis.PointAt(currentStart);
|
||
var end = basis.PointAt(currentEnd);
|
||
var rawLengthSum = currentLines.Sum(line => line.Length);
|
||
var coveredLength = Math.Max(0.0, currentEnd - currentStart);
|
||
result.Add(new Dictionary<string, object?>
|
||
{
|
||
["kind"] = "line",
|
||
["start"] = start,
|
||
["end"] = end,
|
||
["length"] = coveredLength,
|
||
["angle_deg"] = basis.AngleDeg,
|
||
["layer"] = basis.Layer,
|
||
["linetype"] = basis.Linetype,
|
||
["color"] = basis.Color,
|
||
["lineweight"] = basis.Lineweight,
|
||
["style_key"] = basis.StyleKey,
|
||
["source_handles"] = currentLines.SelectMany(line => line.SourceHandles).Where(x => !string.IsNullOrWhiteSpace(x)).Distinct().ToList(),
|
||
["source_indices"] = currentLines.Select(line => line.Index).Distinct().ToList(),
|
||
["merge_count"] = currentLines.Count,
|
||
["merge_type"] = "collinear_interval_union",
|
||
["covered_length"] = coveredLength,
|
||
["raw_length_sum"] = rawLengthSum,
|
||
["overlap_length"] = Math.Max(0.0, rawLengthSum - coveredLength)
|
||
});
|
||
}
|
||
|
||
foreach (var interval in intervals.Skip(1))
|
||
{
|
||
if (interval.Start <= currentEnd + GapTolerance)
|
||
{
|
||
currentEnd = Math.Max(currentEnd, interval.End);
|
||
currentLines.Add(interval.Line);
|
||
continue;
|
||
}
|
||
|
||
Flush();
|
||
currentStart = interval.Start;
|
||
currentEnd = interval.End;
|
||
currentLines = new List<LinePrimitive> { interval.Line };
|
||
}
|
||
|
||
Flush();
|
||
return result;
|
||
}
|
||
|
||
static Dictionary<string, object?> BasePrimitive(Dictionary<string, object?> entity, string kind, Dictionary<string, object?> extra)
|
||
{
|
||
var handle = ReadDictString(entity, "handle");
|
||
var result = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase)
|
||
{
|
||
["kind"] = kind,
|
||
["space"] = ReadDictString(entity, "space"),
|
||
["index"] = ReadDictInt(entity, "index"),
|
||
["object_name"] = ReadDictString(entity, "object_name"),
|
||
["handle"] = handle,
|
||
["source_handles"] = string.IsNullOrWhiteSpace(handle) ? new List<string>() : new List<string> { handle },
|
||
["layer"] = ReadDictString(entity, "layer"),
|
||
["linetype"] = ReadDictString(entity, "linetype"),
|
||
["color"] = ReadDictInt(entity, "color"),
|
||
["lineweight"] = ReadDictInt(entity, "lineweight")
|
||
};
|
||
foreach (var item in extra)
|
||
result[item.Key] = item.Value;
|
||
result["style_key"] = StyleKey(result);
|
||
return result;
|
||
}
|
||
|
||
static bool IsCollinear(LinePrimitive a, LinePrimitive b)
|
||
{
|
||
if (Math.Abs(AngleDeltaDeg(a.AngleDeg, b.AngleDeg)) > AngleToleranceDeg)
|
||
return false;
|
||
return Math.Abs(a.SignedDistanceToLine(b.StartX, b.StartY)) <= CollinearDistanceTolerance &&
|
||
Math.Abs(a.SignedDistanceToLine(b.EndX, b.EndY)) <= CollinearDistanceTolerance;
|
||
}
|
||
|
||
static int AngleBucket(double angleDeg) => (int)Math.Round(NormalizeAngleDeg(angleDeg) / AngleToleranceDeg);
|
||
|
||
static double NormalizeAngleDeg(double angle)
|
||
{
|
||
angle %= 180.0;
|
||
if (angle < 0)
|
||
angle += 180.0;
|
||
return angle;
|
||
}
|
||
|
||
static double AngleDeltaDeg(double a, double b)
|
||
{
|
||
var delta = Math.Abs(NormalizeAngleDeg(a) - NormalizeAngleDeg(b));
|
||
return Math.Min(delta, 180.0 - delta);
|
||
}
|
||
|
||
static string StyleKey(Dictionary<string, object?> item)
|
||
{
|
||
return string.Join("|",
|
||
ReadDictString(item, "space"),
|
||
ReadDictString(item, "layer"),
|
||
ReadDictString(item, "linetype"),
|
||
ReadDictInt(item, "color")?.ToString(CultureInfo.InvariantCulture) ?? "",
|
||
ReadDictInt(item, "lineweight")?.ToString(CultureInfo.InvariantCulture) ?? "");
|
||
}
|
||
|
||
static List<double> PointOnCircle(List<double> center, double radius, double angleRad)
|
||
{
|
||
return new List<double>
|
||
{
|
||
center[0] + radius * Math.Cos(angleRad),
|
||
center[1] + radius * Math.Sin(angleRad)
|
||
};
|
||
}
|
||
|
||
static string ReadDictString(Dictionary<string, object?> item, string key)
|
||
{
|
||
return item.TryGetValue(key, out var value) ? Convert.ToString(value, CultureInfo.InvariantCulture) ?? "" : "";
|
||
}
|
||
|
||
static int? ReadDictInt(Dictionary<string, object?> item, string key)
|
||
{
|
||
return item.TryGetValue(key, out var value) ? ToInt(value) : null;
|
||
}
|
||
|
||
static double? ReadDictDouble(Dictionary<string, object?> item, string key)
|
||
{
|
||
return item.TryGetValue(key, out var value) ? ToDouble(value) : null;
|
||
}
|
||
|
||
static bool? ReadDictBool(Dictionary<string, object?> item, string key)
|
||
{
|
||
return item.TryGetValue(key, out var value) ? ToBool(value) : null;
|
||
}
|
||
|
||
static List<double> ReadPoint(Dictionary<string, object?> item, string key) => ReadDoubleList(item, key);
|
||
|
||
static List<double> ReadDoubleList(Dictionary<string, object?> item, string key)
|
||
{
|
||
return item.TryGetValue(key, out var value) ? DoubleList(value) : new List<double>();
|
||
}
|
||
|
||
static void SelectMainView(DocumentExtraction extraction, string seedMode, string mainViewReferenceSelectionPath)
|
||
{
|
||
if (string.Equals(seedMode, "solidworks-candidate", StringComparison.OrdinalIgnoreCase))
|
||
SelectSolidWorksCandidateMainView(extraction);
|
||
else if (string.Equals(seedMode, "solidworks-multiview", StringComparison.OrdinalIgnoreCase))
|
||
SelectSolidWorksMultiviewMainView(extraction, mainViewReferenceSelectionPath);
|
||
else if (string.Equals(seedMode, "solidworks-multiview-inner-frame", StringComparison.OrdinalIgnoreCase))
|
||
SelectSolidWorksMultiviewInnerFrameMainView(extraction);
|
||
else
|
||
SelectUpperLeftMainView(extraction);
|
||
}
|
||
|
||
static void SelectUpperLeftMainView(DocumentExtraction extraction)
|
||
{
|
||
var rawNodes = BuildRawGeometryNodes(extraction.Geometry)
|
||
.Where(node => !string.Equals(node.Kind, "hatch", StringComparison.OrdinalIgnoreCase))
|
||
.ToList();
|
||
var drawingBox = BoundingBox.Union(rawNodes.Select(node => node.Box));
|
||
var nodes = rawNodes
|
||
.Where(node => !IsFrameOrBorderNode(node, drawingBox))
|
||
.ToList();
|
||
var lineSeedCandidates = nodes
|
||
.Where(node => string.Equals(node.Kind, "line", StringComparison.OrdinalIgnoreCase))
|
||
.ToList();
|
||
var seedCandidates = lineSeedCandidates.Where(IsPreferredMainViewSeed).ToList();
|
||
if (seedCandidates.Count == 0)
|
||
seedCandidates = lineSeedCandidates;
|
||
|
||
if (seedCandidates.Count == 0)
|
||
{
|
||
extraction.MainViewSelection = new Dictionary<string, object?>
|
||
{
|
||
["ok"] = false,
|
||
["reason"] = "no_raw_line_seed_available",
|
||
["selection_rule"] = "min_x_then_max_y_seed_line_connected_expansion"
|
||
};
|
||
return;
|
||
}
|
||
|
||
var seed = seedCandidates
|
||
.OrderBy(node => node.Box.MinX)
|
||
.ThenByDescending(node => node.Box.MaxY)
|
||
.First();
|
||
|
||
var selected = ExpandConnectedNodes(seed, nodes);
|
||
var selectedBox = BoundingBoxForViewBbox(selected, out _, out _);
|
||
|
||
// Include isolated holes/arcs/circles inside the seed-connected outline; they belong to
|
||
// the same view but may not touch the contour geometrically.
|
||
foreach (var node in nodes)
|
||
{
|
||
if (selected.Contains(node))
|
||
continue;
|
||
if (selectedBox.Expand(MainViewConnectTolerance).Contains(node.Box.CenterX, node.Box.CenterY))
|
||
selected.Add(node);
|
||
}
|
||
|
||
selectedBox = BoundingBoxForViewBbox(
|
||
selected,
|
||
out var bboxExcludedCenterlineNodeCount,
|
||
out var bboxExcludedSectionCutSymbolNodeCount);
|
||
var selectedHandles = selected
|
||
.SelectMany(node => node.SourceHandles)
|
||
.Where(handle => !string.IsNullOrWhiteSpace(handle))
|
||
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
||
|
||
extraction.MainViewGeometry = extraction.Geometry
|
||
.Where(item => selectedHandles.Contains(ReadDictString(item, "handle")))
|
||
.ToList();
|
||
|
||
extraction.MainViewSelection = new Dictionary<string, object?>
|
||
{
|
||
["ok"] = true,
|
||
["selection_rule"] = "min_x_then_max_y_seed_line_connected_expansion",
|
||
["processing_order"] = "raw_geometry_seed_expand_then_main_view_normalization_merge_overlap",
|
||
["seed"] = new Dictionary<string, object?>
|
||
{
|
||
["bbox"] = seed.Box.ToDictionary(),
|
||
["source_handles"] = seed.SourceHandles,
|
||
["object_name"] = ReadDictString(seed.Data, "object_name"),
|
||
["layer"] = ReadDictString(seed.Data, "layer"),
|
||
["linetype"] = ReadDictString(seed.Data, "linetype"),
|
||
["seed_filter"] = "preferred_visible_contour_line_excluding_frame"
|
||
},
|
||
["bbox"] = selectedBox.ToDictionary(),
|
||
["bbox_policy"] = "exclude_centerline_and_section_cut_symbol_nodes_keep_geometry",
|
||
["bbox_excluded_centerline_node_count"] = bboxExcludedCenterlineNodeCount,
|
||
["bbox_excluded_section_cut_symbol_node_count"] = bboxExcludedSectionCutSymbolNodeCount,
|
||
["bbox_excluded_auxiliary_node_count"] = bboxExcludedCenterlineNodeCount + bboxExcludedSectionCutSymbolNodeCount,
|
||
["drawing_bbox"] = drawingBox.ToDictionary(),
|
||
["connect_tolerance"] = MainViewConnectTolerance,
|
||
["selected_node_count"] = selected.Count,
|
||
["selected_source_handle_count"] = selectedHandles.Count,
|
||
["main_view_geometry_count"] = extraction.MainViewGeometry.Count,
|
||
["excluded"] = "annotations_dimensions_text_hatch_frame_border"
|
||
};
|
||
}
|
||
|
||
static void SelectSolidWorksCandidateMainView(DocumentExtraction extraction)
|
||
{
|
||
var rawNodes = BuildRawGeometryNodes(extraction.Geometry)
|
||
.Where(node => !string.Equals(node.Kind, "hatch", StringComparison.OrdinalIgnoreCase))
|
||
.ToList();
|
||
var drawingBox = BoundingBox.Union(rawNodes.Select(node => node.Box));
|
||
var frameSeeds = rawNodes
|
||
.Where(node => IsOuterDrawingEdgeNode(node, drawingBox))
|
||
.OrderByDescending(node => Math.Max(node.Box.Width, node.Box.Height))
|
||
.ToList();
|
||
var frameAndTitleNodes = new HashSet<PrimitiveNode>();
|
||
foreach (var seed in frameSeeds)
|
||
frameAndTitleNodes.UnionWith(ExpandConnectedNodes(seed, rawNodes));
|
||
|
||
var selected = rawNodes
|
||
.Where(node => !frameAndTitleNodes.Contains(node))
|
||
.ToHashSet();
|
||
|
||
if (selected.Count == 0)
|
||
{
|
||
extraction.MainViewSelection = new Dictionary<string, object?>
|
||
{
|
||
["ok"] = false,
|
||
["reason"] = "no_geometry_after_frame_title_filter",
|
||
["selection_rule"] = "solidworks_candidate_remove_frame_title_take_remaining_geometry"
|
||
};
|
||
return;
|
||
}
|
||
|
||
var selectedBox = BoundingBox.Union(selected.Select(node => node.Box));
|
||
var internalNodesBeforeAbsorb = rawNodes
|
||
.Where(node => !selected.Contains(node) &&
|
||
selectedBox.Expand(MainViewConnectTolerance).ContainsBox(node.Box))
|
||
.ToList();
|
||
foreach (var node in internalNodesBeforeAbsorb)
|
||
selected.Add(node);
|
||
|
||
selectedBox = BoundingBox.Union(selected.Select(node => node.Box));
|
||
var internalNodesAfterAbsorb = rawNodes
|
||
.Where(node => !selected.Contains(node) &&
|
||
selectedBox.Expand(MainViewConnectTolerance).ContainsBox(node.Box))
|
||
.ToList();
|
||
var selectedHandles = selected
|
||
.SelectMany(node => node.SourceHandles)
|
||
.Where(handle => !string.IsNullOrWhiteSpace(handle))
|
||
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
||
|
||
extraction.MainViewGeometry = extraction.Geometry
|
||
.Where(item => selectedHandles.Contains(ReadDictString(item, "handle")))
|
||
.ToList();
|
||
|
||
extraction.MainViewSelection = new Dictionary<string, object?>
|
||
{
|
||
["ok"] = true,
|
||
["selection_rule"] = "solidworks_candidate_remove_frame_title_take_remaining_geometry",
|
||
["processing_order"] = "raw_geometry_expand_outer_edge_connected_frame_title_then_take_remaining_geometry",
|
||
["bbox"] = selectedBox.ToDictionary(),
|
||
["drawing_bbox"] = drawingBox.ToDictionary(),
|
||
["frame_seed_count"] = frameSeeds.Count,
|
||
["frame_title_node_count"] = frameAndTitleNodes.Count,
|
||
["bbox_internal_absorbed_node_count"] = internalNodesBeforeAbsorb.Count,
|
||
["bbox_internal_missing_node_count"] = internalNodesAfterAbsorb.Count,
|
||
["bbox_internal_missing_handles"] = internalNodesAfterAbsorb
|
||
.SelectMany(node => node.SourceHandles)
|
||
.Where(handle => !string.IsNullOrWhiteSpace(handle))
|
||
.Distinct(StringComparer.OrdinalIgnoreCase)
|
||
.ToList(),
|
||
["selected_node_count"] = selected.Count,
|
||
["selected_source_handle_count"] = selectedHandles.Count,
|
||
["main_view_geometry_count"] = extraction.MainViewGeometry.Count,
|
||
["excluded"] = "annotations_dimensions_text_hatch_frame_border_solidworks_title_block"
|
||
};
|
||
}
|
||
|
||
static void SelectSolidWorksMultiviewMainView(DocumentExtraction extraction, string mainViewReferenceSelectionPath)
|
||
{
|
||
var rawNodes = BuildRawGeometryNodes(extraction.Geometry)
|
||
.Where(node => !string.Equals(node.Kind, "hatch", StringComparison.OrdinalIgnoreCase))
|
||
.ToList();
|
||
var drawingBox = BoundingBox.Union(rawNodes.Select(node => node.Box));
|
||
var frameSeeds = rawNodes
|
||
.Where(node => IsOuterDrawingEdgeNode(node, drawingBox))
|
||
.OrderByDescending(node => Math.Max(node.Box.Width, node.Box.Height))
|
||
.ToList();
|
||
var frameAndTitleNodes = new HashSet<PrimitiveNode>();
|
||
foreach (var seed in frameSeeds)
|
||
frameAndTitleNodes.UnionWith(ExpandConnectedNodes(seed, rawNodes));
|
||
|
||
var remaining = rawNodes
|
||
.Where(node => !frameAndTitleNodes.Contains(node))
|
||
.ToList();
|
||
if (remaining.Count == 0)
|
||
{
|
||
extraction.MainViewSelection = new Dictionary<string, object?>
|
||
{
|
||
["ok"] = false,
|
||
["reason"] = "no_geometry_after_frame_title_filter",
|
||
["selection_rule"] = "solidworks_multiview_remove_frame_title_then_pick_upper_left_component"
|
||
};
|
||
return;
|
||
}
|
||
|
||
if (TrySelectSolidWorksMultiviewMainViewByReferenceBox(
|
||
extraction,
|
||
remaining,
|
||
drawingBox,
|
||
frameSeeds.Count,
|
||
frameAndTitleNodes.Count,
|
||
mainViewReferenceSelectionPath))
|
||
{
|
||
return;
|
||
}
|
||
|
||
var components = new List<HashSet<PrimitiveNode>>();
|
||
var unassigned = new HashSet<PrimitiveNode>(remaining);
|
||
while (unassigned.Count > 0)
|
||
{
|
||
var seed = unassigned
|
||
.OrderBy(node => node.Box.MinX)
|
||
.ThenByDescending(node => node.Box.MaxY)
|
||
.First();
|
||
var component = ExpandConnectedNodes(seed, remaining);
|
||
components.Add(component);
|
||
unassigned.ExceptWith(component);
|
||
}
|
||
|
||
var selected = components
|
||
.Select(component => new
|
||
{
|
||
Nodes = component,
|
||
Box = BoundingBox.Union(component.Select(node => node.Box))
|
||
})
|
||
.OrderBy(item => item.Box.MinX)
|
||
.ThenByDescending(item => item.Box.MaxY)
|
||
.First();
|
||
|
||
var selectedNodes = selected.Nodes;
|
||
var selectedBox = selected.Box;
|
||
var internalNodes = remaining
|
||
.Where(node => !selectedNodes.Contains(node) &&
|
||
selectedBox.Expand(MainViewConnectTolerance).Contains(node.Box.CenterX, node.Box.CenterY))
|
||
.ToList();
|
||
foreach (var node in internalNodes)
|
||
selectedNodes.Add(node);
|
||
|
||
selectedBox = BoundingBox.Union(selectedNodes.Select(node => node.Box));
|
||
var selectedHandles = selectedNodes
|
||
.SelectMany(node => node.SourceHandles)
|
||
.Where(handle => !string.IsNullOrWhiteSpace(handle))
|
||
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
||
|
||
extraction.MainViewGeometry = extraction.Geometry
|
||
.Where(item => selectedHandles.Contains(ReadDictString(item, "handle")))
|
||
.ToList();
|
||
|
||
extraction.MainViewSelection = new Dictionary<string, object?>
|
||
{
|
||
["ok"] = true,
|
||
["selection_rule"] = "solidworks_multiview_remove_frame_title_then_pick_upper_left_component",
|
||
["processing_order"] = "remove_outer_edge_connected_frame_title_then_connected_components_pick_min_x_max_y",
|
||
["bbox"] = selectedBox.ToDictionary(),
|
||
["drawing_bbox"] = drawingBox.ToDictionary(),
|
||
["frame_seed_count"] = frameSeeds.Count,
|
||
["frame_title_node_count"] = frameAndTitleNodes.Count,
|
||
["component_count"] = components.Count,
|
||
["bbox_internal_absorbed_node_count"] = internalNodes.Count,
|
||
["selected_node_count"] = selectedNodes.Count,
|
||
["selected_source_handle_count"] = selectedHandles.Count,
|
||
["main_view_geometry_count"] = extraction.MainViewGeometry.Count,
|
||
["excluded"] = "annotations_dimensions_text_hatch_frame_border_solidworks_title_block_other_projected_views"
|
||
};
|
||
}
|
||
|
||
static bool TrySelectSolidWorksMultiviewMainViewByReferenceBox(
|
||
DocumentExtraction extraction,
|
||
List<PrimitiveNode> remaining,
|
||
BoundingBox drawingBox,
|
||
int frameSeedCount,
|
||
int frameTitleNodeCount,
|
||
string mainViewReferenceSelectionPath)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(mainViewReferenceSelectionPath))
|
||
return false;
|
||
if (!File.Exists(mainViewReferenceSelectionPath))
|
||
throw new FileNotFoundException($"main view reference selection 不存在: {mainViewReferenceSelectionPath}");
|
||
|
||
var referenceBox = ReadReferenceSelectionBox(mainViewReferenceSelectionPath);
|
||
if (referenceBox == null)
|
||
throw new InvalidOperationException($"main view reference selection 缺少 bbox: {mainViewReferenceSelectionPath}");
|
||
|
||
var expandedReferenceBox = referenceBox.Value.Expand(Math.Max(MainViewConnectTolerance, 1.0));
|
||
var selectedNodes = remaining
|
||
.Where(node => expandedReferenceBox.ContainsBox(node.Box) ||
|
||
expandedReferenceBox.Contains(node.Box.CenterX, node.Box.CenterY) ||
|
||
BoxesOverlap(expandedReferenceBox, node.Box, MainViewConnectTolerance))
|
||
.ToHashSet();
|
||
if (selectedNodes.Count == 0)
|
||
return false;
|
||
|
||
var selectedBox = BoundingBox.Union(selectedNodes.Select(node => node.Box));
|
||
var absorbedNodes = remaining
|
||
.Where(node => !selectedNodes.Contains(node) &&
|
||
selectedBox.Expand(MainViewConnectTolerance).ContainsBox(node.Box))
|
||
.ToList();
|
||
foreach (var node in absorbedNodes)
|
||
selectedNodes.Add(node);
|
||
|
||
selectedBox = BoundingBox.Union(selectedNodes.Select(node => node.Box));
|
||
var selectedHandles = selectedNodes
|
||
.SelectMany(node => node.SourceHandles)
|
||
.Where(handle => !string.IsNullOrWhiteSpace(handle))
|
||
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
||
|
||
extraction.MainViewGeometry = extraction.Geometry
|
||
.Where(item => selectedHandles.Contains(ReadDictString(item, "handle")))
|
||
.ToList();
|
||
|
||
extraction.MainViewSelection = new Dictionary<string, object?>
|
||
{
|
||
["ok"] = true,
|
||
["selection_rule"] = "solidworks_multiview_reference_main_bbox",
|
||
["processing_order"] = "remove_outer_edge_connected_frame_title_then_select_geometry_inside_previous_main_view_bbox",
|
||
["bbox"] = selectedBox.ToDictionary(),
|
||
["reference_bbox"] = referenceBox.Value.ToDictionary(),
|
||
["reference_selection_path"] = mainViewReferenceSelectionPath,
|
||
["drawing_bbox"] = drawingBox.ToDictionary(),
|
||
["frame_seed_count"] = frameSeedCount,
|
||
["frame_title_node_count"] = frameTitleNodeCount,
|
||
["bbox_internal_absorbed_node_count"] = absorbedNodes.Count,
|
||
["selected_node_count"] = selectedNodes.Count,
|
||
["selected_source_handle_count"] = selectedHandles.Count,
|
||
["main_view_geometry_count"] = extraction.MainViewGeometry.Count,
|
||
["excluded"] = "annotations_dimensions_text_hatch_frame_border_solidworks_title_block_other_projected_views"
|
||
};
|
||
return true;
|
||
}
|
||
|
||
static void SelectSolidWorksMultiviewInnerFrameMainView(DocumentExtraction extraction)
|
||
{
|
||
var rawNodes = BuildRawGeometryNodes(extraction.Geometry)
|
||
.Where(node => !string.Equals(node.Kind, "hatch", StringComparison.OrdinalIgnoreCase))
|
||
.ToList();
|
||
var drawingBox = BoundingBox.Union(rawNodes.Select(node => node.Box));
|
||
if (!TryFindInnerFrameAnchors(rawNodes, drawingBox, out var leftFrame, out var topFrame))
|
||
{
|
||
extraction.MainViewSelection = new Dictionary<string, object?>
|
||
{
|
||
["ok"] = false,
|
||
["reason"] = "inner_frame_left_or_top_line_not_found",
|
||
["selection_rule"] = "solidworks_multiview_inner_frame_seed_spatial_expansion",
|
||
["drawing_bbox"] = drawingBox.ToDictionary()
|
||
};
|
||
return;
|
||
}
|
||
|
||
var frameSeeds = rawNodes
|
||
.Where(node => IsOuterDrawingEdgeNode(node, drawingBox))
|
||
.OrderByDescending(node => Math.Max(node.Box.Width, node.Box.Height))
|
||
.ToList();
|
||
var frameAndTitleNodes = new HashSet<PrimitiveNode>();
|
||
foreach (var seed in frameSeeds)
|
||
frameAndTitleNodes.UnionWith(ExpandConnectedNodes(seed, rawNodes));
|
||
|
||
var remaining = rawNodes
|
||
.Where(node => !frameAndTitleNodes.Contains(node))
|
||
.ToList();
|
||
var innerTolerance = Math.Max(MainViewConnectTolerance, Math.Min(drawingBox.Width, drawingBox.Height) * 0.001);
|
||
var seedCandidates = remaining
|
||
.Where(node => string.Equals(node.Kind, "line", StringComparison.OrdinalIgnoreCase))
|
||
.Where(node => node.Box.MinX > leftFrame!.Box.MinX + innerTolerance)
|
||
.Where(node => node.Box.MaxY < topFrame!.Box.MaxY - innerTolerance)
|
||
.ToList();
|
||
var preferredSeedCandidates = seedCandidates.Where(IsPreferredMainViewSeed).ToList();
|
||
if (preferredSeedCandidates.Count > 0)
|
||
seedCandidates = preferredSeedCandidates;
|
||
|
||
if (seedCandidates.Count == 0)
|
||
{
|
||
extraction.MainViewSelection = new Dictionary<string, object?>
|
||
{
|
||
["ok"] = false,
|
||
["reason"] = "no_seed_line_inside_inner_frame",
|
||
["selection_rule"] = "solidworks_multiview_inner_frame_seed_spatial_expansion",
|
||
["drawing_bbox"] = drawingBox.ToDictionary(),
|
||
["inner_frame_left"] = NodeToDictionary(leftFrame!),
|
||
["inner_frame_top"] = NodeToDictionary(topFrame!),
|
||
["frame_seed_count"] = frameSeeds.Count,
|
||
["frame_title_node_count"] = frameAndTitleNodes.Count
|
||
};
|
||
return;
|
||
}
|
||
|
||
var seedLine = seedCandidates
|
||
.OrderBy(node => node.Box.MinX)
|
||
.ThenByDescending(node => node.Box.MaxY)
|
||
.ThenByDescending(node => Math.Max(node.Box.Width, node.Box.Height))
|
||
.First();
|
||
var selectedRegion = ExpandRegionFromSeed(
|
||
seedLine,
|
||
remaining,
|
||
new HashSet<string>(StringComparer.OrdinalIgnoreCase));
|
||
var selectedNodes = selectedRegion.Nodes;
|
||
var selectedBox = BoundingBoxForViewBbox(selectedNodes, out _, out _);
|
||
|
||
var changed = true;
|
||
var absorbedNodeCount = 0;
|
||
while (changed)
|
||
{
|
||
changed = false;
|
||
var expandedSelectedBox = selectedBox.Expand(MainViewConnectTolerance);
|
||
var internalNodes = remaining
|
||
.Where(node => !selectedNodes.Contains(node))
|
||
.Where(node => expandedSelectedBox.ContainsBox(node.Box) ||
|
||
expandedSelectedBox.Contains(node.Box.CenterX, node.Box.CenterY))
|
||
.ToList();
|
||
foreach (var node in internalNodes)
|
||
selectedNodes.Add(node);
|
||
if (internalNodes.Count == 0)
|
||
continue;
|
||
|
||
absorbedNodeCount += internalNodes.Count;
|
||
selectedBox = BoundingBoxForViewBbox(selectedNodes, out _, out _);
|
||
changed = true;
|
||
}
|
||
|
||
selectedBox = BoundingBoxForViewBbox(
|
||
selectedNodes,
|
||
out var bboxExcludedCenterlineNodeCount,
|
||
out var bboxExcludedSectionCutSymbolNodeCount);
|
||
|
||
var selectedHandles = selectedNodes
|
||
.SelectMany(node => node.SourceHandles)
|
||
.Where(handle => !string.IsNullOrWhiteSpace(handle))
|
||
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
||
|
||
extraction.MainViewGeometry = extraction.Geometry
|
||
.Where(item => selectedHandles.Contains(ReadDictString(item, "handle")))
|
||
.ToList();
|
||
|
||
extraction.MainViewSelection = new Dictionary<string, object?>
|
||
{
|
||
["ok"] = true,
|
||
["selection_rule"] = "solidworks_multiview_inner_frame_seed_spatial_expansion",
|
||
["processing_order"] = "find_inner_left_top_frame_lines_then_pick_min_inner_x_max_y_seed_and_expand_spatial_view_region",
|
||
["bbox"] = selectedBox.ToDictionary(),
|
||
["bbox_policy"] = "exclude_centerline_and_section_cut_symbol_nodes_keep_geometry",
|
||
["bbox_excluded_centerline_node_count"] = bboxExcludedCenterlineNodeCount,
|
||
["bbox_excluded_section_cut_symbol_node_count"] = bboxExcludedSectionCutSymbolNodeCount,
|
||
["bbox_excluded_auxiliary_node_count"] = bboxExcludedCenterlineNodeCount + bboxExcludedSectionCutSymbolNodeCount,
|
||
["drawing_bbox"] = drawingBox.ToDictionary(),
|
||
["inner_frame_left"] = NodeToDictionary(leftFrame!),
|
||
["inner_frame_top"] = NodeToDictionary(topFrame!),
|
||
["seed"] = NodeToDictionary(seedLine),
|
||
["seed_candidate_count"] = seedCandidates.Count,
|
||
["frame_seed_count"] = frameSeeds.Count,
|
||
["frame_title_node_count"] = frameAndTitleNodes.Count,
|
||
["bbox_internal_absorbed_node_count"] = absorbedNodeCount,
|
||
["selected_node_count"] = selectedNodes.Count,
|
||
["selected_source_handle_count"] = selectedHandles.Count,
|
||
["main_view_geometry_count"] = extraction.MainViewGeometry.Count,
|
||
["excluded"] = "annotations_dimensions_text_hatch_frame_border_solidworks_title_block_other_projected_views"
|
||
};
|
||
}
|
||
|
||
static bool TryFindInnerFrameAnchors(
|
||
List<PrimitiveNode> rawNodes,
|
||
BoundingBox drawingBox,
|
||
out PrimitiveNode? leftFrame,
|
||
out PrimitiveNode? topFrame)
|
||
{
|
||
var tolerance = Math.Max(MainViewConnectTolerance, Math.Min(drawingBox.Width, drawingBox.Height) * 0.001);
|
||
var verticalMinHeight = drawingBox.Height * 0.45;
|
||
var horizontalMinWidth = drawingBox.Width * 0.45;
|
||
|
||
leftFrame = rawNodes
|
||
.Where(node => IsVerticalLineNode(node, tolerance))
|
||
.Where(node => node.Box.Height >= verticalMinHeight)
|
||
.Where(node => node.Box.MinX > drawingBox.MinX + tolerance)
|
||
.Where(node => node.Box.CenterX < drawingBox.CenterX)
|
||
.OrderByDescending(node => node.Box.Height)
|
||
.ThenBy(node => node.Box.MinX)
|
||
.FirstOrDefault();
|
||
|
||
topFrame = rawNodes
|
||
.Where(node => IsHorizontalLineNode(node, tolerance))
|
||
.Where(node => node.Box.Width >= horizontalMinWidth)
|
||
.Where(node => node.Box.MaxY < drawingBox.MaxY - tolerance)
|
||
.Where(node => node.Box.CenterY > drawingBox.CenterY)
|
||
.OrderByDescending(node => node.Box.Width)
|
||
.ThenByDescending(node => node.Box.MaxY)
|
||
.FirstOrDefault();
|
||
|
||
return leftFrame != null && topFrame != null;
|
||
}
|
||
|
||
static BoundingBox? ReadReferenceSelectionBox(string path)
|
||
{
|
||
using var document = JsonDocument.Parse(File.ReadAllText(path));
|
||
if (!document.RootElement.TryGetProperty("bbox", out var bbox) ||
|
||
bbox.ValueKind != JsonValueKind.Object)
|
||
return null;
|
||
|
||
if (!TryGetJsonDouble(bbox, "min_x", out var minX) ||
|
||
!TryGetJsonDouble(bbox, "min_y", out var minY) ||
|
||
!TryGetJsonDouble(bbox, "max_x", out var maxX) ||
|
||
!TryGetJsonDouble(bbox, "max_y", out var maxY))
|
||
{
|
||
return null;
|
||
}
|
||
|
||
return new BoundingBox(minX, minY, maxX, maxY);
|
||
}
|
||
|
||
static bool TryGetJsonDouble(JsonElement element, string propertyName, out double value)
|
||
{
|
||
value = 0;
|
||
return element.TryGetProperty(propertyName, out var property) &&
|
||
property.ValueKind == JsonValueKind.Number &&
|
||
property.TryGetDouble(out value);
|
||
}
|
||
|
||
static void AnalyzeViewRegions(DocumentExtraction extraction, CliOptions options)
|
||
{
|
||
var rawNodes = BuildRawGeometryNodes(extraction.Geometry)
|
||
.Where(node => !string.Equals(node.Kind, "hatch", StringComparison.OrdinalIgnoreCase))
|
||
.ToList();
|
||
if (rawNodes.Count == 0)
|
||
{
|
||
extraction.ViewRegions = new Dictionary<string, object?>
|
||
{
|
||
["ok"] = false,
|
||
["reason"] = "no_raw_geometry_nodes"
|
||
};
|
||
return;
|
||
}
|
||
|
||
var drawingBox = BoundingBox.Union(rawNodes.Select(node => node.Box));
|
||
var nodes = rawNodes
|
||
.Where(node => !IsFrameOrBorderNode(node, drawingBox))
|
||
.ToList();
|
||
var mainBox = ReadEntityBox(extraction.MainViewSelection, "bbox");
|
||
if (mainBox == null)
|
||
{
|
||
extraction.ViewRegions = new Dictionary<string, object?>
|
||
{
|
||
["ok"] = false,
|
||
["reason"] = "main_view_bbox_missing",
|
||
["drawing_bbox"] = drawingBox.ToDictionary()
|
||
};
|
||
return;
|
||
}
|
||
|
||
var mainHandles = extraction.MainViewGeometry
|
||
.Select(item => ReadDictString(item, "handle"))
|
||
.Where(handle => !string.IsNullOrWhiteSpace(handle))
|
||
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
||
|
||
var sectionSymbols = FindSectionSymbols(extraction.Annotations)
|
||
.OrderByDescending(symbol => symbol.Box.CenterY)
|
||
.ThenBy(symbol => symbol.Box.CenterX)
|
||
.ToList();
|
||
var sectionViews = new List<Dictionary<string, object?>>();
|
||
var sectionHandles = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
||
|
||
foreach (var symbol in sectionSymbols)
|
||
{
|
||
var seed = FindSectionSeed(symbol, nodes, mainHandles, sectionHandles, options.SectionViewProbeDirection);
|
||
if (seed == null)
|
||
{
|
||
sectionViews.Add(new Dictionary<string, object?>
|
||
{
|
||
["ok"] = false,
|
||
["reason"] = $"no_geometry_seed_{options.SectionViewProbeDirection}_section_symbol",
|
||
["probe_direction"] = options.SectionViewProbeDirection,
|
||
["label"] = symbol.Label,
|
||
["symbol"] = symbol.ToDictionary()
|
||
});
|
||
continue;
|
||
}
|
||
|
||
var excluded = new HashSet<string>(mainHandles, StringComparer.OrdinalIgnoreCase);
|
||
excluded.UnionWith(sectionHandles);
|
||
var region = ExpandRegionFromSeed(seed, nodes, excluded);
|
||
if (sectionViews.Any(item =>
|
||
ReadEntityBox(item, "bbox") is { } existing &&
|
||
BoxesOverlap(existing, region.Box, MainViewConnectTolerance)))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
foreach (var handle in region.Handles)
|
||
sectionHandles.Add(handle);
|
||
sectionViews.Add(new Dictionary<string, object?>
|
||
{
|
||
["ok"] = true,
|
||
["kind"] = "section_view",
|
||
["label"] = symbol.Label,
|
||
["probe_direction"] = options.SectionViewProbeDirection,
|
||
["symbol"] = symbol.ToDictionary(),
|
||
["seed"] = NodeToDictionary(seed),
|
||
["bbox"] = region.Box.ToDictionary(),
|
||
["geometry_node_count"] = region.Nodes.Count,
|
||
["source_handle_count"] = region.Handles.Count,
|
||
["source_handles"] = region.Handles.OrderBy(handle => handle, StringComparer.OrdinalIgnoreCase).ToList()
|
||
});
|
||
}
|
||
|
||
var orthographicViews = new List<Dictionary<string, object?>>();
|
||
orthographicViews.Add(ProbeOrthographicView(
|
||
"down",
|
||
"bottom_view_candidate",
|
||
mainBox.Value,
|
||
nodes,
|
||
mainHandles,
|
||
sectionHandles));
|
||
orthographicViews.Add(ProbeOrthographicView(
|
||
"right",
|
||
"right_of_main_view_candidate",
|
||
mainBox.Value,
|
||
nodes,
|
||
mainHandles,
|
||
sectionHandles));
|
||
|
||
foreach (var sectionView in sectionViews)
|
||
AttachRegionSignature(sectionView, extraction.Geometry, ReadDictString(sectionView, "kind"));
|
||
foreach (var orthographicView in orthographicViews)
|
||
AttachRegionSignature(orthographicView, extraction.Geometry, ReadDictString(orthographicView, "kind"));
|
||
|
||
var bottomBox = orthographicViews
|
||
.Where(item => string.Equals(ReadDictString(item, "kind"), "bottom_view_candidate", StringComparison.OrdinalIgnoreCase))
|
||
.Where(item => item.TryGetValue("ok", out var ok) && ok is true)
|
||
.Select(item => ReadEntityBox(item, "bbox"))
|
||
.FirstOrDefault(item => item != null);
|
||
extraction.SectionCutSymbols = FindSectionCutSymbols(extraction.Annotations, mainBox.Value, bottomBox);
|
||
|
||
extraction.BottomViewSignature = orthographicViews
|
||
.Where(item => string.Equals(ReadDictString(item, "kind"), "bottom_view_candidate", StringComparison.OrdinalIgnoreCase))
|
||
.Where(item => item.TryGetValue("ok", out var ok) && ok is true)
|
||
.Select(item => item.TryGetValue("signature", out var signature) && signature is Dictionary<string, object?> dict ? dict : null)
|
||
.FirstOrDefault(item => item != null)
|
||
?? new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);
|
||
|
||
extraction.ViewRegions = new Dictionary<string, object?>
|
||
{
|
||
["ok"] = true,
|
||
["rule"] = $"section_symbols_expand_{options.SectionViewProbeDirection}_then_probe_orthographic_down_right_from_main_bbox_center",
|
||
["section_view_probe_direction"] = options.SectionViewProbeDirection,
|
||
["main_view_bbox"] = mainBox.Value.ToDictionary(),
|
||
["drawing_bbox"] = drawingBox.ToDictionary(),
|
||
["section_symbol_count"] = sectionSymbols.Count,
|
||
["section_view_count"] = sectionViews.Count(item => item.TryGetValue("ok", out var ok) && ok is true),
|
||
["section_views"] = sectionViews,
|
||
["section_cut_symbol_count"] = extraction.SectionCutSymbols.Count,
|
||
["section_cut_symbols"] = extraction.SectionCutSymbols,
|
||
["orthographic_probe_directions"] = new[] { "down", "right" },
|
||
["orthographic_views"] = orthographicViews,
|
||
["excluded_from_orthographic_probe"] = "main_view_handles_and_section_view_handles"
|
||
};
|
||
}
|
||
|
||
static List<Dictionary<string, object?>> FindSectionCutSymbols(
|
||
List<Dictionary<string, object?>> annotations,
|
||
BoundingBox mainBox,
|
||
BoundingBox? bottomBox)
|
||
{
|
||
var result = new List<Dictionary<string, object?>>();
|
||
foreach (var block in annotations)
|
||
{
|
||
if (!block.TryGetValue("exploded_entities", out var explodedValue) ||
|
||
explodedValue is not IEnumerable<object> explodedObjects)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
var children = explodedObjects
|
||
.OfType<Dictionary<string, object?>>()
|
||
.ToList();
|
||
if (children.Count == 0)
|
||
continue;
|
||
|
||
var labels = children
|
||
.Select(child => new
|
||
{
|
||
Text = ExtractSingleLetterLabel(ReadDictString(child, "text")),
|
||
Box = ReadEntityBox(child, "bbox"),
|
||
Child = child
|
||
})
|
||
.Where(item => item.Text != null && item.Box != null)
|
||
.ToList();
|
||
if (labels.Count != 2 || !string.Equals(labels[0].Text, labels[1].Text, StringComparison.OrdinalIgnoreCase))
|
||
continue;
|
||
|
||
var lines = children
|
||
.Where(child => string.Equals(ReadDictString(child, "object_name"), "AcDbLine", StringComparison.OrdinalIgnoreCase))
|
||
.ToList();
|
||
var hatches = children
|
||
.Where(child => string.Equals(ReadDictString(child, "object_name"), "AcDbHatch", StringComparison.OrdinalIgnoreCase))
|
||
.Select(child => new { Box = ReadEntityBox(child, "bbox"), Child = child })
|
||
.Where(item => item.Box != null)
|
||
.ToList();
|
||
if (lines.Count < 4 || hatches.Count < 2)
|
||
continue;
|
||
|
||
var blockBox = ReadEntityBox(block, "bbox") ?? BoundingBox.Union(children.Select(child => ReadEntityBox(child, "bbox")).Where(box => box != null).Select(box => box!.Value));
|
||
var markers = hatches
|
||
.OrderByDescending(item => item.Box!.Value.CenterY)
|
||
.Select(item => BuildSectionCutMarker(item.Box!.Value, lines, labels.Select(label => label.Box!.Value).ToList()))
|
||
.Where(item => item != null)
|
||
.Cast<Dictionary<string, object?>>()
|
||
.ToList();
|
||
if (markers.Count < 2)
|
||
continue;
|
||
|
||
var corners = markers
|
||
.Select(marker => ReadPoint(marker, "corner"))
|
||
.Where(point => point.Count >= 2)
|
||
.ToList();
|
||
if (corners.Count < 2)
|
||
continue;
|
||
|
||
var cornerPair = FindFarthestPointPair(corners);
|
||
var rawStart = cornerPair.Start;
|
||
var rawEnd = cornerPair.End;
|
||
var cutDirection = Math.Abs(rawStart[0] - rawEnd[0]) <= Math.Abs(rawStart[1] - rawEnd[1])
|
||
? "vertical"
|
||
: "horizontal";
|
||
var cornerStart = cutDirection == "vertical"
|
||
? new[] { rawStart, rawEnd }.OrderByDescending(point => point[1]).ThenBy(point => point[0]).First()
|
||
: new[] { rawStart, rawEnd }.OrderBy(point => point[0]).ThenByDescending(point => point[1]).First();
|
||
var cornerEnd = cutDirection == "vertical"
|
||
? new[] { rawStart, rawEnd }.OrderBy(point => point[1]).ThenBy(point => point[0]).First()
|
||
: new[] { rawStart, rawEnd }.OrderByDescending(point => point[0]).ThenByDescending(point => point[1]).First();
|
||
var cutCenter = new List<double>
|
||
{
|
||
(cornerStart[0] + cornerEnd[0]) / 2.0,
|
||
(cornerStart[1] + cornerEnd[1]) / 2.0
|
||
};
|
||
var cornerDistance = Distance(cornerStart, cornerEnd);
|
||
var halfLength = Math.Max(cornerDistance / 2.0, 1.0);
|
||
var cutLineStart = cutDirection == "vertical"
|
||
? new List<double> { cutCenter[0], cutCenter[1] + halfLength }
|
||
: new List<double> { cutCenter[0] - halfLength, cutCenter[1] };
|
||
var cutLineEnd = cutDirection == "vertical"
|
||
? new List<double> { cutCenter[0], cutCenter[1] - halfLength }
|
||
: new List<double> { cutCenter[0] + halfLength, cutCenter[1] };
|
||
var viewKind = ClassifySectionCutView(blockBox, mainBox, bottomBox);
|
||
|
||
result.Add(new Dictionary<string, object?>
|
||
{
|
||
["ok"] = true,
|
||
["kind"] = "section_cut_symbol_pair",
|
||
["label"] = labels[0].Text,
|
||
["source"] = "block_reference_exploded_entities",
|
||
["parent_handle"] = ReadDictString(block, "handle"),
|
||
["block_name"] = ReadDictString(block, "name"),
|
||
["effective_name"] = ReadDictString(block, "effective_name"),
|
||
["view_kind"] = viewKind,
|
||
["bbox"] = blockBox.ToDictionary(),
|
||
["text_count"] = labels.Count,
|
||
["line_count"] = lines.Count,
|
||
["arrow_hatch_count"] = hatches.Count,
|
||
["cut_line"] = new Dictionary<string, object?>
|
||
{
|
||
["start"] = cutLineStart,
|
||
["end"] = cutLineEnd,
|
||
["center"] = cutCenter,
|
||
["direction"] = cutDirection,
|
||
["source"] = "paired_section_symbol_corners_common_center",
|
||
["corner_start"] = cornerStart,
|
||
["corner_end"] = cornerEnd,
|
||
["corner_count"] = corners.Count
|
||
},
|
||
["markers"] = markers
|
||
});
|
||
}
|
||
|
||
return result
|
||
.OrderBy(item => ReadDictString(item, "label"), StringComparer.OrdinalIgnoreCase)
|
||
.ThenBy(item => ReadEntityBox(item, "bbox")?.CenterX ?? 0)
|
||
.ThenByDescending(item => ReadEntityBox(item, "bbox")?.CenterY ?? 0)
|
||
.ToList();
|
||
}
|
||
|
||
static Dictionary<string, object?>? BuildSectionCutMarker(
|
||
BoundingBox arrowBox,
|
||
List<Dictionary<string, object?>> lines,
|
||
List<BoundingBox> labelBoxes)
|
||
{
|
||
var candidates = new List<(Dictionary<string, object?> Marker, double Score)>();
|
||
var horizontal = BuildSectionCutMarkerForLeaderAxis(arrowBox, lines, labelBoxes, leaderIsHorizontal: true);
|
||
if (horizontal != null)
|
||
candidates.Add(horizontal.Value);
|
||
var vertical = BuildSectionCutMarkerForLeaderAxis(arrowBox, lines, labelBoxes, leaderIsHorizontal: false);
|
||
if (vertical != null)
|
||
candidates.Add(vertical.Value);
|
||
|
||
return candidates
|
||
.OrderBy(candidate => candidate.Score)
|
||
.Select(candidate => candidate.Marker)
|
||
.FirstOrDefault();
|
||
}
|
||
|
||
static (Dictionary<string, object?> Marker, double Score)? BuildSectionCutMarkerForLeaderAxis(
|
||
BoundingBox arrowBox,
|
||
List<Dictionary<string, object?>> lines,
|
||
List<BoundingBox> labelBoxes,
|
||
bool leaderIsHorizontal)
|
||
{
|
||
var arrowCenter = new List<double> { arrowBox.CenterX, arrowBox.CenterY };
|
||
var lineItems = lines
|
||
.Select(line => new { Line = line, Start = ReadPoint(line, "start"), End = ReadPoint(line, "end"), Box = ReadEntityBox(line, "bbox") })
|
||
.Where(item => item.Start.Count >= 2 && item.End.Count >= 2 && item.Box != null)
|
||
.ToList();
|
||
var leaders = lineItems
|
||
.Where(item => leaderIsHorizontal
|
||
? Math.Abs(item.Start[1] - item.End[1]) <= 1e-6
|
||
: Math.Abs(item.Start[0] - item.End[0]) <= 1e-6)
|
||
.OrderBy(item => leaderIsHorizontal
|
||
? Math.Abs(item.Box!.Value.CenterY - arrowBox.CenterY)
|
||
: Math.Abs(item.Box!.Value.CenterX - arrowBox.CenterX))
|
||
.ThenBy(item => item.Box!.Value.DistanceTo(arrowBox))
|
||
.FirstOrDefault();
|
||
if (leaders == null)
|
||
return null;
|
||
|
||
var endpoints = new[] { leaders.Start, leaders.End };
|
||
var sectionSymbolLines = lineItems
|
||
.Where(item => leaderIsHorizontal
|
||
? Math.Abs(item.Start[0] - item.End[0]) <= 1e-6
|
||
: Math.Abs(item.Start[1] - item.End[1]) <= 1e-6)
|
||
.ToList();
|
||
var cornerCandidate = endpoints
|
||
.Select(point => new
|
||
{
|
||
Point = point,
|
||
SectionSymbolLine = sectionSymbolLines
|
||
.OrderBy(line => new[] { line.Start, line.End }.Min(vp => Distance(point, vp)))
|
||
.FirstOrDefault(),
|
||
DistanceToSectionSymbol = sectionSymbolLines
|
||
.SelectMany(line => new[] { line.Start, line.End })
|
||
.Select(vp => Distance(point, vp))
|
||
.DefaultIfEmpty(double.MaxValue)
|
||
.Min()
|
||
})
|
||
.OrderBy(item => item.DistanceToSectionSymbol)
|
||
.First();
|
||
var corner = cornerCandidate.Point;
|
||
var sectionSymbolLine = cornerCandidate.SectionSymbolLine;
|
||
if (sectionSymbolLine == null)
|
||
return null;
|
||
|
||
var dx = arrowCenter[0] - corner[0];
|
||
var dy = arrowCenter[1] - corner[1];
|
||
var length = Math.Sqrt(dx * dx + dy * dy);
|
||
var labelBox = labelBoxes
|
||
.OrderBy(box => box.DistanceTo(arrowBox))
|
||
.FirstOrDefault();
|
||
|
||
var marker = new Dictionary<string, object?>
|
||
{
|
||
["corner"] = corner,
|
||
["arrow_tip"] = arrowCenter,
|
||
["arrow_direction"] = length > 1e-9
|
||
? new[] { dx / length, dy / length }
|
||
: new[] { 0.0, 0.0 },
|
||
[leaderIsHorizontal ? "horizontal_line" : "vertical_line"] = new Dictionary<string, object?>
|
||
{
|
||
["start"] = leaders.Start,
|
||
["end"] = leaders.End
|
||
},
|
||
["section_symbol_line"] = new Dictionary<string, object?>
|
||
{
|
||
["start"] = sectionSymbolLine.Start,
|
||
["end"] = sectionSymbolLine.End
|
||
},
|
||
["label_bbox"] = labelBox.ToDictionary()
|
||
};
|
||
var score = (leaderIsHorizontal
|
||
? Math.Abs(leaders.Box!.Value.CenterY - arrowBox.CenterY)
|
||
: Math.Abs(leaders.Box!.Value.CenterX - arrowBox.CenterX)) +
|
||
leaders.Box!.Value.DistanceTo(arrowBox) +
|
||
cornerCandidate.DistanceToSectionSymbol;
|
||
return (marker, score);
|
||
}
|
||
|
||
static (List<double> Start, List<double> End) FindFarthestPointPair(List<List<double>> points)
|
||
{
|
||
var bestStart = points[0];
|
||
var bestEnd = points[1];
|
||
var bestDistance = Distance(bestStart, bestEnd);
|
||
for (var i = 0; i < points.Count; i++)
|
||
{
|
||
for (var j = i + 1; j < points.Count; j++)
|
||
{
|
||
var distance = Distance(points[i], points[j]);
|
||
if (distance > bestDistance)
|
||
{
|
||
bestStart = points[i];
|
||
bestEnd = points[j];
|
||
bestDistance = distance;
|
||
}
|
||
}
|
||
}
|
||
|
||
return (bestStart, bestEnd);
|
||
}
|
||
|
||
static (List<double> Start, List<double> End)? ReadLine(Dictionary<string, object?> dict, string key)
|
||
{
|
||
if (!dict.TryGetValue(key, out var value) || value is not Dictionary<string, object?> line)
|
||
return null;
|
||
var start = ReadPoint(line, "start");
|
||
var end = ReadPoint(line, "end");
|
||
return start.Count >= 2 && end.Count >= 2 ? (start, end) : null;
|
||
}
|
||
|
||
static string? ExtractSingleLetterLabel(string text)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(text))
|
||
return null;
|
||
var cleaned = Regex.Replace(text, @"\\[^;]*;", "");
|
||
cleaned = Regex.Replace(cleaned, @"[{}\\]", "").Trim();
|
||
var match = Regex.Match(cleaned, @"^[A-Z]$", RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
|
||
return match.Success ? match.Value.ToUpperInvariant() : null;
|
||
}
|
||
|
||
static string ClassifySectionCutView(BoundingBox symbolBox, BoundingBox mainBox, BoundingBox? bottomBox)
|
||
{
|
||
var mainOverlap = OverlapArea(symbolBox, mainBox);
|
||
var bottomOverlap = bottomBox == null ? 0.0 : OverlapArea(symbolBox, bottomBox.Value);
|
||
if (mainOverlap <= 0 && bottomOverlap <= 0)
|
||
return "unknown";
|
||
return mainOverlap >= bottomOverlap ? "main_view" : "bottom_view_candidate";
|
||
}
|
||
|
||
static double OverlapArea(BoundingBox a, BoundingBox b)
|
||
{
|
||
var width = Math.Max(0.0, Math.Min(a.MaxX, b.MaxX) - Math.Max(a.MinX, b.MinX));
|
||
var height = Math.Max(0.0, Math.Min(a.MaxY, b.MaxY) - Math.Max(a.MinY, b.MinY));
|
||
return width * height;
|
||
}
|
||
|
||
static void AttachRegionSignature(
|
||
Dictionary<string, object?> region,
|
||
List<Dictionary<string, object?>> geometry,
|
||
string scope)
|
||
{
|
||
if (!region.TryGetValue("ok", out var ok) || ok is not true)
|
||
return;
|
||
|
||
var handles = ReadStringList(region, "source_handles")
|
||
.ToHashSet(StringComparer.OrdinalIgnoreCase);
|
||
if (handles.Count == 0)
|
||
return;
|
||
|
||
var regionGeometry = geometry
|
||
.Where(item => handles.Contains(ReadDictString(item, "handle")))
|
||
.ToList();
|
||
var normalized = NormalizePrimitiveSet(regionGeometry, scope);
|
||
var signature = BuildViewSignature(normalized.Normalized, normalized.MergedLines, scope);
|
||
signature["normalization_summary"] = normalized.Summary;
|
||
signature["source_handle_count"] = handles.Count;
|
||
signature["raw_geometry_count"] = regionGeometry.Count;
|
||
region["signature"] = signature;
|
||
}
|
||
|
||
static List<SectionSymbol> FindSectionSymbols(List<Dictionary<string, object?>> annotations)
|
||
{
|
||
var result = new List<SectionSymbol>();
|
||
foreach (var annotation in annotations)
|
||
{
|
||
var text = ReadDictString(annotation, "text");
|
||
if (string.IsNullOrWhiteSpace(text))
|
||
continue;
|
||
var match = Regex.Match(
|
||
text,
|
||
@"(?<![A-Z0-9])([A-Z0-9]{1,4})\s*-\s*\1(?![A-Z0-9])(?:\s*/?\s*\d+(?:\.\d+)?\s*:\s*\d+(?:\.\d+)?)?",
|
||
RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
|
||
if (!match.Success)
|
||
continue;
|
||
|
||
var box = ReadAnnotationBox(annotation);
|
||
if (box == null)
|
||
continue;
|
||
|
||
var labelToken = match.Groups[1].Value.ToUpperInvariant();
|
||
result.Add(new SectionSymbol(labelToken + "-" + labelToken, match.Value, text, box.Value, annotation));
|
||
}
|
||
return result;
|
||
}
|
||
|
||
static BoundingBox? ReadAnnotationBox(Dictionary<string, object?> annotation)
|
||
{
|
||
if (ReadEntityBox(annotation, "bbox") is { } box)
|
||
return box;
|
||
|
||
var point = ReadPoint(annotation, "insertion_point");
|
||
if (point.Count < 2)
|
||
point = ReadPoint(annotation, "text_position");
|
||
if (point.Count < 2)
|
||
return null;
|
||
|
||
var height = ReadDictDouble(annotation, "height") ?? 1.0;
|
||
return new BoundingBox(point[0] - height, point[1] - height, point[0] + height, point[1] + height);
|
||
}
|
||
|
||
static PrimitiveNode? FindSectionSeed(
|
||
SectionSymbol symbol,
|
||
List<PrimitiveNode> nodes,
|
||
HashSet<string> mainHandles,
|
||
HashSet<string> existingSectionHandles,
|
||
string probeDirection)
|
||
{
|
||
var searchHalfWidth = Math.Max(20.0, symbol.Box.Width * 8.0);
|
||
var candidates = nodes
|
||
.Where(node => !NodeHasAnyHandle(node, mainHandles))
|
||
.Where(node => !NodeHasAnyHandle(node, existingSectionHandles))
|
||
.Where(node => Math.Abs(node.Box.CenterX - symbol.Box.CenterX) <= searchHalfWidth ||
|
||
RangesOverlap(node.Box.MinX, node.Box.MaxX, symbol.Box.MinX - searchHalfWidth, symbol.Box.MaxX + searchHalfWidth));
|
||
|
||
if (string.Equals(probeDirection, "up", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
return candidates
|
||
.Where(node => node.Box.MinY >= symbol.Box.MaxY + ViewRegionProbeTolerance)
|
||
.OrderBy(node => node.Box.MinY - symbol.Box.MaxY)
|
||
.ThenBy(node => Math.Abs(node.Box.CenterX - symbol.Box.CenterX))
|
||
.FirstOrDefault();
|
||
}
|
||
|
||
return candidates
|
||
.Where(node => node.Box.MaxY <= symbol.Box.MinY - ViewRegionProbeTolerance)
|
||
.OrderBy(node => symbol.Box.MinY - node.Box.MaxY)
|
||
.ThenBy(node => Math.Abs(node.Box.CenterX - symbol.Box.CenterX))
|
||
.FirstOrDefault();
|
||
}
|
||
|
||
static Dictionary<string, object?> ProbeOrthographicView(
|
||
string direction,
|
||
string kind,
|
||
BoundingBox mainBox,
|
||
List<PrimitiveNode> nodes,
|
||
HashSet<string> mainHandles,
|
||
HashSet<string> sectionHandles)
|
||
{
|
||
var seed = FindRayHitFromMainView(direction, mainBox, nodes, mainHandles);
|
||
if (seed == null)
|
||
{
|
||
return new Dictionary<string, object?>
|
||
{
|
||
["ok"] = false,
|
||
["kind"] = kind,
|
||
["direction"] = direction,
|
||
["reason"] = "no_ray_hit"
|
||
};
|
||
}
|
||
|
||
if (NodeHasAnyHandle(seed, sectionHandles))
|
||
{
|
||
return new Dictionary<string, object?>
|
||
{
|
||
["ok"] = false,
|
||
["kind"] = kind,
|
||
["direction"] = direction,
|
||
["reason"] = "first_ray_hit_belongs_to_section_view",
|
||
["seed"] = NodeToDictionary(seed)
|
||
};
|
||
}
|
||
|
||
var excluded = new HashSet<string>(mainHandles, StringComparer.OrdinalIgnoreCase);
|
||
excluded.UnionWith(sectionHandles);
|
||
var region = ExpandRegionFromSeed(seed, nodes, excluded);
|
||
return new Dictionary<string, object?>
|
||
{
|
||
["ok"] = true,
|
||
["kind"] = kind,
|
||
["direction"] = direction,
|
||
["seed"] = NodeToDictionary(seed),
|
||
["bbox"] = region.Box.ToDictionary(),
|
||
["geometry_node_count"] = region.Nodes.Count,
|
||
["source_handle_count"] = region.Handles.Count,
|
||
["source_handles"] = region.Handles.OrderBy(handle => handle, StringComparer.OrdinalIgnoreCase).ToList()
|
||
};
|
||
}
|
||
|
||
static PrimitiveNode? FindRayHitFromMainView(
|
||
string direction,
|
||
BoundingBox mainBox,
|
||
List<PrimitiveNode> nodes,
|
||
HashSet<string> mainHandles)
|
||
{
|
||
if (string.Equals(direction, "down", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var x = mainBox.CenterX;
|
||
var candidates = nodes
|
||
.Where(node => !NodeHasAnyHandle(node, mainHandles))
|
||
.Where(node => node.Box.MaxY <= mainBox.MinY - ViewRegionProbeTolerance)
|
||
.Where(node => x >= node.Box.MinX - ViewRegionProbeTolerance && x <= node.Box.MaxX + ViewRegionProbeTolerance)
|
||
.OrderBy(node => mainBox.MinY - node.Box.MaxY)
|
||
.ToList();
|
||
return candidates.FirstOrDefault();
|
||
}
|
||
|
||
if (string.Equals(direction, "right", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var y = mainBox.CenterY;
|
||
var candidates = nodes
|
||
.Where(node => !NodeHasAnyHandle(node, mainHandles))
|
||
.Where(node => node.Box.MinX >= mainBox.MaxX + ViewRegionProbeTolerance)
|
||
.Where(node => y >= node.Box.MinY - ViewRegionProbeTolerance && y <= node.Box.MaxY + ViewRegionProbeTolerance)
|
||
.OrderBy(node => node.Box.MinX - mainBox.MaxX)
|
||
.ToList();
|
||
return candidates.FirstOrDefault();
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
static ViewRegion ExpandRegionFromSeed(PrimitiveNode seed, List<PrimitiveNode> nodes, HashSet<string> excludedHandles)
|
||
{
|
||
var available = nodes
|
||
.Where(node => ReferenceEquals(node, seed) || !NodeHasAnyHandle(node, excludedHandles))
|
||
.ToList();
|
||
var selected = ExpandConnectedNodes(seed, available);
|
||
var selectedBox = BoundingBox.Union(selected.Select(node => node.Box));
|
||
|
||
var changed = true;
|
||
while (changed)
|
||
{
|
||
changed = false;
|
||
foreach (var node in available)
|
||
{
|
||
if (selected.Contains(node))
|
||
continue;
|
||
var expandedBox = selectedBox.Expand(ViewRegionSpatialExpansionTolerance);
|
||
if (!expandedBox.ContainsBox(node.Box) &&
|
||
!BoxesOverlap(selectedBox, node.Box, ViewRegionSpatialExpansionTolerance) &&
|
||
!selected.Any(item => AreConnected(item, node)))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
selected.Add(node);
|
||
selectedBox = BoundingBox.Union(selected.Select(item => item.Box));
|
||
changed = true;
|
||
}
|
||
}
|
||
|
||
var handles = selected
|
||
.SelectMany(node => node.SourceHandles)
|
||
.Where(handle => !string.IsNullOrWhiteSpace(handle))
|
||
.Distinct(StringComparer.OrdinalIgnoreCase)
|
||
.ToList();
|
||
return new ViewRegion(selected, selectedBox, handles);
|
||
}
|
||
|
||
static bool NodeHasAnyHandle(PrimitiveNode node, HashSet<string> handles)
|
||
{
|
||
return node.SourceHandles.Any(handle => handles.Contains(handle));
|
||
}
|
||
|
||
static Dictionary<string, object?> NodeToDictionary(PrimitiveNode node)
|
||
{
|
||
return new Dictionary<string, object?>
|
||
{
|
||
["kind"] = node.Kind,
|
||
["bbox"] = node.Box.ToDictionary(),
|
||
["source_handles"] = node.SourceHandles,
|
||
["object_name"] = ReadDictString(node.Data, "object_name"),
|
||
["layer"] = ReadDictString(node.Data, "layer"),
|
||
["linetype"] = ReadDictString(node.Data, "linetype")
|
||
};
|
||
}
|
||
|
||
static bool RangesOverlap(double aMin, double aMax, double bMin, double bMax)
|
||
{
|
||
return aMin <= bMax && aMax >= bMin;
|
||
}
|
||
|
||
static bool BoxesOverlap(BoundingBox a, BoundingBox b, double tolerance)
|
||
{
|
||
return RangesOverlap(a.MinX - tolerance, a.MaxX + tolerance, b.MinX, b.MaxX) &&
|
||
RangesOverlap(a.MinY - tolerance, a.MaxY + tolerance, b.MinY, b.MaxY);
|
||
}
|
||
|
||
static BoundingBox? ReadEntityBox(Dictionary<string, object?> item, string key)
|
||
{
|
||
if (!item.TryGetValue(key, out var value) || value == null)
|
||
return null;
|
||
if (value is not Dictionary<string, object?> dict)
|
||
return null;
|
||
|
||
var minX = ReadDictDouble(dict, "min_x");
|
||
var minY = ReadDictDouble(dict, "min_y");
|
||
var maxX = ReadDictDouble(dict, "max_x");
|
||
var maxY = ReadDictDouble(dict, "max_y");
|
||
if (minX == null || minY == null || maxX == null || maxY == null)
|
||
return null;
|
||
return new BoundingBox(minX.Value, minY.Value, maxX.Value, maxY.Value);
|
||
}
|
||
|
||
static bool IsOuterDrawingEdgeNode(PrimitiveNode node, BoundingBox drawingBox)
|
||
{
|
||
var tolerance = Math.Max(MainViewConnectTolerance, Math.Min(drawingBox.Width, drawingBox.Height) * 0.002);
|
||
return Math.Abs(node.Box.MinX - drawingBox.MinX) <= tolerance ||
|
||
Math.Abs(node.Box.MaxX - drawingBox.MaxX) <= tolerance ||
|
||
Math.Abs(node.Box.MinY - drawingBox.MinY) <= tolerance ||
|
||
Math.Abs(node.Box.MaxY - drawingBox.MaxY) <= tolerance;
|
||
}
|
||
|
||
static bool IsPreferredMainViewSeed(PrimitiveNode node)
|
||
{
|
||
var layer = ReadDictString(node.Data, "layer");
|
||
var linetype = ReadDictString(node.Data, "linetype");
|
||
var lineweight = ReadDictInt(node.Data, "lineweight");
|
||
if (layer.Contains("粗实线", StringComparison.OrdinalIgnoreCase))
|
||
return true;
|
||
return string.Equals(linetype, "Continuous", StringComparison.OrdinalIgnoreCase) &&
|
||
lineweight != null &&
|
||
lineweight > 0;
|
||
}
|
||
|
||
static BoundingBox BoundingBoxForViewBbox(
|
||
IEnumerable<PrimitiveNode> nodes,
|
||
out int excludedCenterlineNodeCount,
|
||
out int excludedSectionCutSymbolNodeCount)
|
||
{
|
||
var nodeList = nodes.ToList();
|
||
var sectionCutSymbolNodes = FindSectionCutSymbolNodes(nodeList);
|
||
var bboxNodes = nodeList
|
||
.Where(node => !IsCenterlineNode(node) && !sectionCutSymbolNodes.Contains(node))
|
||
.ToList();
|
||
excludedCenterlineNodeCount = nodeList.Count(IsCenterlineNode);
|
||
excludedSectionCutSymbolNodeCount = sectionCutSymbolNodes.Count;
|
||
|
||
if (bboxNodes.Count == 0)
|
||
{
|
||
excludedCenterlineNodeCount = 0;
|
||
excludedSectionCutSymbolNodeCount = 0;
|
||
bboxNodes = nodeList;
|
||
}
|
||
|
||
return BoundingBox.Union(bboxNodes.Select(node => node.Box));
|
||
}
|
||
|
||
static HashSet<PrimitiveNode> FindSectionCutSymbolNodes(List<PrimitiveNode> nodes)
|
||
{
|
||
var result = new HashSet<PrimitiveNode>();
|
||
var lineNodes = nodes
|
||
.Where(node => string.Equals(node.Kind, "line", StringComparison.OrdinalIgnoreCase))
|
||
.ToList();
|
||
var phantomLines = lineNodes
|
||
.Where(node => string.Equals(ReadDictString(node.Data, "linetype"), "PHANTOM", StringComparison.OrdinalIgnoreCase))
|
||
.Where(node => Math.Max(node.Box.Width, node.Box.Height) >= 20.0)
|
||
.ToList();
|
||
|
||
foreach (var phantom in phantomLines)
|
||
{
|
||
var isVertical = phantom.Box.Width <= MainViewConnectTolerance && phantom.Box.Height > MainViewConnectTolerance;
|
||
var isHorizontal = phantom.Box.Height <= MainViewConnectTolerance && phantom.Box.Width > MainViewConnectTolerance;
|
||
if (!isVertical && !isHorizontal)
|
||
continue;
|
||
|
||
var symbolLeaders = lineNodes
|
||
.Where(node => !ReferenceEquals(node, phantom))
|
||
.Where(node => IsSectionCutLeaderForPhantom(node, phantom, isVertical))
|
||
.ToList();
|
||
if (symbolLeaders.Count < 2)
|
||
continue;
|
||
|
||
result.Add(phantom);
|
||
foreach (var leader in symbolLeaders)
|
||
result.Add(leader);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
static bool IsSectionCutLeaderForPhantom(PrimitiveNode node, PrimitiveNode phantom, bool phantomIsVertical)
|
||
{
|
||
var tolerance = Math.Max(3.0, MainViewConnectTolerance);
|
||
var length = Math.Max(node.Box.Width, node.Box.Height);
|
||
if (length < 2.0 || length > 25.0)
|
||
return false;
|
||
|
||
if (phantomIsVertical)
|
||
{
|
||
if (!IsHorizontalLineNode(node, MainViewConnectTolerance))
|
||
return false;
|
||
var nearPhantomX = Math.Abs(node.Box.MinX - phantom.Box.MinX) <= tolerance ||
|
||
Math.Abs(node.Box.MaxX - phantom.Box.MinX) <= tolerance ||
|
||
(node.Box.MinX <= phantom.Box.MinX && node.Box.MaxX >= phantom.Box.MinX);
|
||
var nearPhantomEndY = Math.Abs(node.Box.CenterY - phantom.Box.MinY) <= tolerance ||
|
||
Math.Abs(node.Box.CenterY - phantom.Box.MaxY) <= tolerance;
|
||
return nearPhantomX && nearPhantomEndY;
|
||
}
|
||
|
||
if (!IsVerticalLineNode(node, MainViewConnectTolerance))
|
||
return false;
|
||
var nearPhantomY = Math.Abs(node.Box.MinY - phantom.Box.MinY) <= tolerance ||
|
||
Math.Abs(node.Box.MaxY - phantom.Box.MinY) <= tolerance ||
|
||
(node.Box.MinY <= phantom.Box.MinY && node.Box.MaxY >= phantom.Box.MinY);
|
||
var nearPhantomEndX = Math.Abs(node.Box.CenterX - phantom.Box.MinX) <= tolerance ||
|
||
Math.Abs(node.Box.CenterX - phantom.Box.MaxX) <= tolerance;
|
||
return nearPhantomY && nearPhantomEndX;
|
||
}
|
||
|
||
static bool IsCenterlineNode(PrimitiveNode node)
|
||
{
|
||
return ContainsCenterlineMarker(ReadDictString(node.Data, "layer")) ||
|
||
ContainsCenterlineMarker(ReadDictString(node.Data, "linetype")) ||
|
||
ContainsCenterlineMarker(ReadDictString(node.Data, "style_key"));
|
||
}
|
||
|
||
static bool ContainsCenterlineMarker(string value)
|
||
{
|
||
return value.Contains("中心", StringComparison.OrdinalIgnoreCase) ||
|
||
value.Contains("CENTER", StringComparison.OrdinalIgnoreCase) ||
|
||
value.Contains("CENTRE", StringComparison.OrdinalIgnoreCase);
|
||
}
|
||
|
||
static bool IsVerticalLineNode(PrimitiveNode node, double tolerance) =>
|
||
string.Equals(node.Kind, "line", StringComparison.OrdinalIgnoreCase) &&
|
||
node.Box.Width <= tolerance &&
|
||
node.Box.Height > tolerance;
|
||
|
||
static bool IsHorizontalLineNode(PrimitiveNode node, double tolerance) =>
|
||
string.Equals(node.Kind, "line", StringComparison.OrdinalIgnoreCase) &&
|
||
node.Box.Height <= tolerance &&
|
||
node.Box.Width > tolerance;
|
||
|
||
static bool IsFrameOrBorderNode(PrimitiveNode node, BoundingBox drawingBox)
|
||
{
|
||
var layer = ReadDictString(node.Data, "layer");
|
||
var linetype = ReadDictString(node.Data, "linetype");
|
||
|
||
var width = drawingBox.Width;
|
||
var height = drawingBox.Height;
|
||
var nodeWidth = node.Box.Width;
|
||
var nodeHeight = node.Box.Height;
|
||
var edgeTolerance = Math.Max(MainViewConnectTolerance, Math.Min(width, height) * 0.08);
|
||
var nearOuterEdge =
|
||
Math.Abs(node.Box.MinX - drawingBox.MinX) <= MainViewConnectTolerance ||
|
||
Math.Abs(node.Box.MaxX - drawingBox.MaxX) <= MainViewConnectTolerance ||
|
||
Math.Abs(node.Box.MinY - drawingBox.MinY) <= MainViewConnectTolerance ||
|
||
Math.Abs(node.Box.MaxY - drawingBox.MaxY) <= MainViewConnectTolerance;
|
||
var nearFrameMargin =
|
||
Math.Abs(node.Box.MinX - drawingBox.MinX) <= edgeTolerance ||
|
||
Math.Abs(node.Box.MaxX - drawingBox.MaxX) <= edgeTolerance ||
|
||
Math.Abs(node.Box.MinY - drawingBox.MinY) <= edgeTolerance ||
|
||
Math.Abs(node.Box.MaxY - drawingBox.MaxY) <= edgeTolerance;
|
||
|
||
var longHorizontal = nodeHeight <= MainViewConnectTolerance && nodeWidth >= width * 0.5;
|
||
var longVertical = nodeWidth <= MainViewConnectTolerance && nodeHeight >= height * 0.5;
|
||
var frameLayerStyle =
|
||
string.Equals(layer, "0", StringComparison.OrdinalIgnoreCase) ||
|
||
string.Equals(linetype, "ByLayer", StringComparison.OrdinalIgnoreCase);
|
||
return (nearOuterEdge || nearFrameMargin) && (longHorizontal || longVertical) && frameLayerStyle;
|
||
}
|
||
|
||
static List<PrimitiveNode> BuildRawGeometryNodes(List<Dictionary<string, object?>> geometry)
|
||
{
|
||
var result = new List<PrimitiveNode>();
|
||
foreach (var entity in geometry)
|
||
{
|
||
var node = PrimitiveNode.FromRawGeometry(entity);
|
||
if (node != null)
|
||
result.Add(node);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
static HashSet<PrimitiveNode> ExpandConnectedNodes(PrimitiveNode seed, List<PrimitiveNode> lineNodes)
|
||
{
|
||
var selected = new HashSet<PrimitiveNode> { seed };
|
||
var queue = new Queue<PrimitiveNode>();
|
||
queue.Enqueue(seed);
|
||
|
||
while (queue.Count > 0)
|
||
{
|
||
var current = queue.Dequeue();
|
||
foreach (var candidate in lineNodes)
|
||
{
|
||
if (selected.Contains(candidate))
|
||
continue;
|
||
if (!AreConnected(current, candidate))
|
||
continue;
|
||
|
||
selected.Add(candidate);
|
||
queue.Enqueue(candidate);
|
||
}
|
||
}
|
||
|
||
return selected;
|
||
}
|
||
|
||
static bool AreConnected(PrimitiveNode a, PrimitiveNode b)
|
||
{
|
||
if (string.Equals(a.Kind, "line", StringComparison.OrdinalIgnoreCase) &&
|
||
string.Equals(b.Kind, "line", StringComparison.OrdinalIgnoreCase) &&
|
||
a.AnchorPoints.Count >= 2 &&
|
||
b.AnchorPoints.Count >= 2)
|
||
{
|
||
return SegmentDistance(a.AnchorPoints[0], a.AnchorPoints[1], b.AnchorPoints[0], b.AnchorPoints[1]) <= MainViewConnectTolerance;
|
||
}
|
||
|
||
foreach (var pa in a.AnchorPoints)
|
||
{
|
||
foreach (var pb in b.AnchorPoints)
|
||
{
|
||
if (Distance(pa, pb) <= MainViewConnectTolerance)
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
static double SegmentDistance(List<double> a0, List<double> a1, List<double> b0, List<double> b1)
|
||
{
|
||
if (SegmentsIntersect(a0, a1, b0, b1))
|
||
return 0.0;
|
||
|
||
return new[]
|
||
{
|
||
PointSegmentDistance(a0, b0, b1),
|
||
PointSegmentDistance(a1, b0, b1),
|
||
PointSegmentDistance(b0, a0, a1),
|
||
PointSegmentDistance(b1, a0, a1)
|
||
}.Min();
|
||
}
|
||
|
||
static bool SegmentsIntersect(List<double> a0, List<double> a1, List<double> b0, List<double> b1)
|
||
{
|
||
if (a0.Count < 2 || a1.Count < 2 || b0.Count < 2 || b1.Count < 2)
|
||
return false;
|
||
|
||
var d1 = Cross(a0, a1, b0);
|
||
var d2 = Cross(a0, a1, b1);
|
||
var d3 = Cross(b0, b1, a0);
|
||
var d4 = Cross(b0, b1, a1);
|
||
|
||
if (((d1 > 0 && d2 < 0) || (d1 < 0 && d2 > 0)) &&
|
||
((d3 > 0 && d4 < 0) || (d3 < 0 && d4 > 0)))
|
||
return true;
|
||
|
||
return Math.Abs(d1) <= MainViewConnectTolerance && PointOnSegment(b0, a0, a1) ||
|
||
Math.Abs(d2) <= MainViewConnectTolerance && PointOnSegment(b1, a0, a1) ||
|
||
Math.Abs(d3) <= MainViewConnectTolerance && PointOnSegment(a0, b0, b1) ||
|
||
Math.Abs(d4) <= MainViewConnectTolerance && PointOnSegment(a1, b0, b1);
|
||
}
|
||
|
||
static double Cross(List<double> a, List<double> b, List<double> p)
|
||
{
|
||
return (b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0]);
|
||
}
|
||
|
||
static bool PointOnSegment(List<double> p, List<double> a, List<double> b)
|
||
{
|
||
return p[0] >= Math.Min(a[0], b[0]) - MainViewConnectTolerance &&
|
||
p[0] <= Math.Max(a[0], b[0]) + MainViewConnectTolerance &&
|
||
p[1] >= Math.Min(a[1], b[1]) - MainViewConnectTolerance &&
|
||
p[1] <= Math.Max(a[1], b[1]) + MainViewConnectTolerance;
|
||
}
|
||
|
||
static double PointSegmentDistance(List<double> p, List<double> a, List<double> b)
|
||
{
|
||
if (p.Count < 2 || a.Count < 2 || b.Count < 2)
|
||
return double.MaxValue;
|
||
|
||
var dx = b[0] - a[0];
|
||
var dy = b[1] - a[1];
|
||
var len2 = dx * dx + dy * dy;
|
||
if (len2 <= 1e-12)
|
||
return Distance(p, a);
|
||
|
||
var t = ((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len2;
|
||
t = Math.Max(0.0, Math.Min(1.0, t));
|
||
var proj = new List<double> { a[0] + t * dx, a[1] + t * dy };
|
||
return Distance(p, proj);
|
||
}
|
||
|
||
static double Distance(List<double> a, List<double> b)
|
||
{
|
||
if (a.Count < 2 || b.Count < 2)
|
||
return double.MaxValue;
|
||
var dx = a[0] - b[0];
|
||
var dy = a[1] - b[1];
|
||
return Math.Sqrt(dx * dx + dy * dy);
|
||
}
|
||
|
||
static List<string> ReadStringList(Dictionary<string, object?> item, string key)
|
||
{
|
||
if (!item.TryGetValue(key, out var value) || value == null)
|
||
return new List<string>();
|
||
if (value is IEnumerable<string> strings)
|
||
return strings.Where(text => !string.IsNullOrWhiteSpace(text)).ToList();
|
||
if (value is IEnumerable<object> objects)
|
||
return objects.Select(obj => Convert.ToString(obj, CultureInfo.InvariantCulture) ?? "").Where(text => !string.IsNullOrWhiteSpace(text)).ToList();
|
||
return new List<string>();
|
||
}
|
||
|
||
static Dictionary<string, object?> BuildViewSignature(
|
||
List<Dictionary<string, object?>> normalizedGeometry,
|
||
List<Dictionary<string, object?>> mergedLines,
|
||
string scope)
|
||
{
|
||
var nonLine = normalizedGeometry
|
||
.Where(item => !string.Equals(ReadDictString(item, "kind"), "line", StringComparison.OrdinalIgnoreCase))
|
||
.ToList();
|
||
var normalizedLines = normalizedGeometry
|
||
.Where(item => string.Equals(ReadDictString(item, "kind"), "line", StringComparison.OrdinalIgnoreCase))
|
||
.ToList();
|
||
|
||
var lines = mergedLines;
|
||
var circles = nonLine.Where(item => string.Equals(ReadDictString(item, "kind"), "circle", StringComparison.OrdinalIgnoreCase)).ToList();
|
||
var arcs = nonLine.Where(item => string.Equals(ReadDictString(item, "kind"), "arc", StringComparison.OrdinalIgnoreCase)).ToList();
|
||
var splines = nonLine.Where(item => string.Equals(ReadDictString(item, "kind"), "spline", StringComparison.OrdinalIgnoreCase)).ToList();
|
||
|
||
var lineLengths = lines.Select(item => ReadDictDouble(item, "length")).Where(value => value != null).Select(value => value!.Value).ToList();
|
||
var circleRadii = circles.Select(item => ReadDictDouble(item, "radius")).Where(value => value != null).Select(value => value!.Value).ToList();
|
||
var arcRadii = arcs.Select(item => ReadDictDouble(item, "radius")).Where(value => value != null).Select(value => value!.Value).ToList();
|
||
var arcSweepAngles = arcs.Select(ArcSweepDeg).Where(value => value != null).Select(value => value!.Value).ToList();
|
||
var arcLengths = arcs
|
||
.Select(item =>
|
||
{
|
||
var radius = ReadDictDouble(item, "radius");
|
||
var sweep = ArcSweepDeg(item);
|
||
return radius != null && sweep != null ? radius.Value * sweep.Value * Math.PI / 180.0 : (double?)null;
|
||
})
|
||
.Where(value => value != null)
|
||
.Select(value => value!.Value)
|
||
.ToList();
|
||
|
||
return new Dictionary<string, object?>
|
||
{
|
||
["scope"] = scope,
|
||
["coordinate_policy"] = "relative_origin_from_leftmost_vertical_line_top_point",
|
||
["primitive_counts"] = new Dictionary<string, object?>
|
||
{
|
||
["line"] = lines.Count,
|
||
["circle"] = circles.Count,
|
||
["arc"] = arcs.Count,
|
||
["spline"] = splines.Count,
|
||
["total"] = lines.Count + circles.Count + arcs.Count + splines.Count
|
||
},
|
||
["line_direction_counts"] = BuildLineDirectionCounts(lines),
|
||
["relative_line_coordinates"] = BuildRelativeLineCoordinates(normalizedLines),
|
||
["line_length_histogram"] = Histogram(lineLengths, 1.0),
|
||
["line_length_stats"] = Stats(lineLengths),
|
||
["circle_radius_histogram"] = Histogram(circleRadii, 0.5),
|
||
["circle_radius_stats"] = Stats(circleRadii),
|
||
["arc_radius_histogram"] = Histogram(arcRadii, 0.5),
|
||
["arc_radius_stats"] = Stats(arcRadii),
|
||
["arc_sweep_angle_histogram"] = Histogram(arcSweepAngles, 5.0),
|
||
["arc_length_histogram"] = Histogram(arcLengths, 1.0),
|
||
["matching_primary_fields"] = new[]
|
||
{
|
||
"kind",
|
||
"length",
|
||
"radius",
|
||
"diameter",
|
||
"arc_length",
|
||
"sweep_angle",
|
||
"direction_class",
|
||
"angle_deg",
|
||
"relative_start",
|
||
"relative_end",
|
||
"relative_midpoint"
|
||
},
|
||
["matching_excluded_primary_fields"] = new[]
|
||
{
|
||
"start",
|
||
"end",
|
||
"center",
|
||
"absolute_start",
|
||
"absolute_end"
|
||
}
|
||
};
|
||
}
|
||
|
||
static Dictionary<string, object?> BuildRelativeLineCoordinates(List<Dictionary<string, object?>> lines)
|
||
{
|
||
var parsedLines = lines
|
||
.Select(LinePrimitive.FromDictionary)
|
||
.Where(item => item != null)
|
||
.Cast<LinePrimitive>()
|
||
.ToList();
|
||
var verticalLines = parsedLines
|
||
.Where(line => string.Equals(DirectionClass(line.AngleDeg), "vertical", StringComparison.OrdinalIgnoreCase))
|
||
.ToList();
|
||
|
||
if (verticalLines.Count == 0)
|
||
{
|
||
return new Dictionary<string, object?>
|
||
{
|
||
["ok"] = false,
|
||
["reason"] = "no_vertical_line_available",
|
||
["origin_rule"] = "leftmost_vertical_line_top_point"
|
||
};
|
||
}
|
||
|
||
var originLine = verticalLines
|
||
.OrderBy(line => Math.Min(line.StartX, line.EndX))
|
||
.ThenByDescending(line => Math.Max(line.StartY, line.EndY))
|
||
.ThenByDescending(line => line.Length)
|
||
.First();
|
||
|
||
var originX = originLine.StartY >= originLine.EndY ? originLine.StartX : originLine.EndX;
|
||
var originY = Math.Max(originLine.StartY, originLine.EndY);
|
||
var relativeLines = parsedLines
|
||
.Select((line, index) => BuildRelativeLineRecord(line, index + 1, originX, originY))
|
||
.OrderBy(item => Convert.ToDouble(item["relative_mid_x"], CultureInfo.InvariantCulture))
|
||
.ThenByDescending(item => Convert.ToDouble(item["relative_mid_y"], CultureInfo.InvariantCulture))
|
||
.ThenBy(item => Convert.ToDouble(item["length"], CultureInfo.InvariantCulture))
|
||
.ToList();
|
||
|
||
return new Dictionary<string, object?>
|
||
{
|
||
["ok"] = true,
|
||
["origin_rule"] = "leftmost_vertical_line_top_point",
|
||
["origin"] = new Dictionary<string, object?>
|
||
{
|
||
["x"] = originX,
|
||
["y"] = originY,
|
||
["source_handles"] = originLine.SourceHandles,
|
||
["line"] = new Dictionary<string, object?>
|
||
{
|
||
["start"] = new[] { originLine.StartX, originLine.StartY },
|
||
["end"] = new[] { originLine.EndX, originLine.EndY },
|
||
["length"] = originLine.Length,
|
||
["angle_deg"] = originLine.AngleDeg
|
||
}
|
||
},
|
||
["line_count"] = relativeLines.Count,
|
||
["bucket_size"] = 1.0,
|
||
["relative_midpoints"] = relativeLines.Select(item => new Dictionary<string, object?>
|
||
{
|
||
["index"] = item["index"],
|
||
["source_handles"] = item["source_handles"],
|
||
["x"] = item["relative_mid_x"],
|
||
["y"] = item["relative_mid_y"],
|
||
["x_bucket"] = item["relative_mid_x_bucket"],
|
||
["y_bucket"] = item["relative_mid_y_bucket"],
|
||
["midpoint_key"] = item["midpoint_key"]
|
||
}).ToList(),
|
||
["relative_midpoint_histogram"] = Histogram(relativeLines
|
||
.Select(item => Convert.ToString(item["midpoint_key"], CultureInfo.InvariantCulture) ?? "")
|
||
.Where(key => !string.IsNullOrWhiteSpace(key))
|
||
.ToList()),
|
||
["lines"] = relativeLines,
|
||
["feature_histogram"] = Histogram(relativeLines
|
||
.Select(item => Convert.ToString(item["feature_key"], CultureInfo.InvariantCulture) ?? "")
|
||
.Where(key => !string.IsNullOrWhiteSpace(key))
|
||
.ToList())
|
||
};
|
||
}
|
||
|
||
static Dictionary<string, object?> BuildRelativeLineRecord(LinePrimitive line, int index, double originX, double originY)
|
||
{
|
||
var rsx = line.StartX - originX;
|
||
var rsy = line.StartY - originY;
|
||
var rex = line.EndX - originX;
|
||
var rey = line.EndY - originY;
|
||
var midX = (rsx + rex) / 2.0;
|
||
var midY = (rsy + rey) / 2.0;
|
||
var direction = DirectionClass(line.AngleDeg);
|
||
var lengthBucket = Bucket(line.Length, 1.0);
|
||
var midXBucket = Bucket(midX, 1.0);
|
||
var midYBucket = Bucket(midY, 1.0);
|
||
var midpointKey = $"X{midXBucket:0.###}|Y{midYBucket:0.###}";
|
||
|
||
return new Dictionary<string, object?>
|
||
{
|
||
["index"] = index,
|
||
["source_handles"] = line.SourceHandles,
|
||
["direction_class"] = direction,
|
||
["angle_deg"] = line.AngleDeg,
|
||
["length"] = line.Length,
|
||
["length_bucket"] = lengthBucket,
|
||
["relative_start"] = new[] { rsx, rsy },
|
||
["relative_end"] = new[] { rex, rey },
|
||
["relative_midpoint"] = new[] { midX, midY },
|
||
["relative_mid_x"] = midX,
|
||
["relative_mid_y"] = midY,
|
||
["relative_mid_x_bucket"] = midXBucket,
|
||
["relative_mid_y_bucket"] = midYBucket,
|
||
["midpoint_key"] = midpointKey,
|
||
["feature_key"] = $"{direction}|L{lengthBucket:0.###}|X{midXBucket:0.###}|Y{midYBucket:0.###}"
|
||
};
|
||
}
|
||
|
||
static double Bucket(double value, double bucketSize)
|
||
{
|
||
return bucketSize <= 0 ? value : Math.Round(value / bucketSize) * bucketSize;
|
||
}
|
||
|
||
static Dictionary<string, int> Histogram(List<string> values)
|
||
{
|
||
var result = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
|
||
foreach (var value in values)
|
||
result[value] = result.TryGetValue(value, out var count) ? count + 1 : 1;
|
||
return result.OrderBy(item => item.Key, StringComparer.OrdinalIgnoreCase)
|
||
.ToDictionary(item => item.Key, item => item.Value, StringComparer.OrdinalIgnoreCase);
|
||
}
|
||
|
||
static Dictionary<string, int> BuildLineDirectionCounts(List<Dictionary<string, object?>> lines)
|
||
{
|
||
var result = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase)
|
||
{
|
||
["horizontal"] = 0,
|
||
["vertical"] = 0,
|
||
["diagonal"] = 0,
|
||
["unknown"] = 0
|
||
};
|
||
|
||
foreach (var line in lines)
|
||
{
|
||
var angle = ReadDictDouble(line, "angle_deg");
|
||
var key = angle == null ? "unknown" : DirectionClass(angle.Value);
|
||
result[key] = result.TryGetValue(key, out var count) ? count + 1 : 1;
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
static string DirectionClass(double angleDeg)
|
||
{
|
||
var normalized = NormalizeAngleDeg(angleDeg);
|
||
if (AngleDistance(normalized, 0) <= 5.0 || AngleDistance(normalized, 180) <= 5.0)
|
||
return "horizontal";
|
||
if (AngleDistance(normalized, 90) <= 5.0)
|
||
return "vertical";
|
||
return "diagonal";
|
||
}
|
||
|
||
static double AngleDistance(double a, double b)
|
||
{
|
||
var delta = Math.Abs(a - b) % 180.0;
|
||
return Math.Min(delta, 180.0 - delta);
|
||
}
|
||
|
||
static Dictionary<string, int> Histogram(List<double> values, double bucketSize)
|
||
{
|
||
var result = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
|
||
if (bucketSize <= 0)
|
||
return result;
|
||
|
||
foreach (var value in values.Where(value => !double.IsNaN(value) && !double.IsInfinity(value)))
|
||
{
|
||
var bucket = Math.Round(value / bucketSize) * bucketSize;
|
||
var key = bucket.ToString("0.###", CultureInfo.InvariantCulture);
|
||
result[key] = result.TryGetValue(key, out var count) ? count + 1 : 1;
|
||
}
|
||
|
||
return result.OrderBy(item => double.Parse(item.Key, CultureInfo.InvariantCulture)).ToDictionary(item => item.Key, item => item.Value, StringComparer.OrdinalIgnoreCase);
|
||
}
|
||
|
||
static Dictionary<string, object?> Stats(List<double> values)
|
||
{
|
||
if (values.Count == 0)
|
||
{
|
||
return new Dictionary<string, object?>
|
||
{
|
||
["count"] = 0
|
||
};
|
||
}
|
||
|
||
return new Dictionary<string, object?>
|
||
{
|
||
["count"] = values.Count,
|
||
["min"] = values.Min(),
|
||
["max"] = values.Max(),
|
||
["sum"] = values.Sum(),
|
||
["avg"] = values.Average()
|
||
};
|
||
}
|
||
|
||
static double? ArcSweepDeg(Dictionary<string, object?> item)
|
||
{
|
||
var start = ReadDictDouble(item, "start_angle");
|
||
var end = ReadDictDouble(item, "end_angle");
|
||
if (start == null || end == null)
|
||
return null;
|
||
|
||
var sweep = (end.Value - start.Value) * 180.0 / Math.PI;
|
||
while (sweep < 0)
|
||
sweep += 360.0;
|
||
while (sweep >= 360.0)
|
||
sweep -= 360.0;
|
||
return sweep;
|
||
}
|
||
|
||
static Manifest WriteFiles(string outputDir, string drawingPath, string progId, bool started, DocumentExtraction extraction)
|
||
{
|
||
var files = new List<CategoryFile>
|
||
{
|
||
WriteCategory(outputDir, "entities-common", "entities-common.json", extraction.EntitiesCommon),
|
||
WriteCategory(outputDir, "geometry", "geometry.json", extraction.Geometry),
|
||
WriteCategory(outputDir, "normalized-geometry", "normalized-geometry.json", extraction.NormalizedGeometry),
|
||
WriteCategory(outputDir, "merged-lines", "merged-lines.json", extraction.MergedLines),
|
||
WriteCategory(outputDir, "geometry-overlaps", "geometry-overlaps.json", extraction.GeometryOverlaps),
|
||
WriteCategory(outputDir, "normalization-summary", "normalization-summary.json", extraction.NormalizationSummary),
|
||
WriteCategory(outputDir, "main-view-geometry", "main-view-geometry.json", extraction.MainViewGeometry),
|
||
WriteCategory(outputDir, "main-view-normalized-geometry", "main-view-normalized-geometry.json", extraction.MainViewNormalizedGeometry),
|
||
WriteCategory(outputDir, "main-view-merged-lines", "main-view-merged-lines.json", extraction.MainViewMergedLines),
|
||
WriteCategory(outputDir, "main-view-overlaps", "main-view-overlaps.json", extraction.MainViewOverlaps),
|
||
WriteCategory(outputDir, "main-view-signature", "main-view-signature.json", extraction.MainViewSignature),
|
||
WriteCategory(outputDir, "bottom-view-signature", "bottom-view-signature.json", extraction.BottomViewSignature),
|
||
WriteCategory(outputDir, "section-cut-symbols", "section-cut-symbols.json", extraction.SectionCutSymbols),
|
||
WriteCategory(outputDir, "main-view-selection", "main-view-selection.json", extraction.MainViewSelection),
|
||
WriteCategory(outputDir, "view-regions", "view-regions.json", extraction.ViewRegions),
|
||
WriteCategory(outputDir, "annotations", "annotations.json", extraction.Annotations),
|
||
WriteCategory(outputDir, "dimensions", "dimensions.json", extraction.Dimensions),
|
||
WriteCategory(outputDir, "dimensional-tolerances", "dimensional-tolerances.json", extraction.DimensionalTolerances),
|
||
WriteCategory(outputDir, "roughness", "roughness.json", extraction.Roughness),
|
||
WriteCategory(outputDir, "geometric-tolerances", "geometric-tolerances.json", extraction.GeometricTolerances),
|
||
WriteCategory(outputDir, "datums", "datums.json", extraction.Datums),
|
||
WriteCategory(outputDir, "unknown-entities", "unknown-entities.json", extraction.UnknownEntities)
|
||
};
|
||
|
||
var manifest = new Manifest
|
||
{
|
||
Ok = true,
|
||
Schema = "agent4.dwg-draft.extraction.v1",
|
||
Source = "AutoCAD COM external extractor",
|
||
ProgId = progId,
|
||
StartedAutoCad = started,
|
||
DrawingPath = drawingPath,
|
||
ExportedAtUtc = DateTime.UtcNow,
|
||
ModelSpaceCount = extraction.ModelSpaceCount,
|
||
PaperSpaceCount = extraction.PaperSpaceCount,
|
||
EntityCount = extraction.EntitiesCommon.Count,
|
||
TypeCounts = extraction.TypeCounts,
|
||
CategoryFiles = files
|
||
};
|
||
WriteJson(Path.Combine(outputDir, "manifest.json"), manifest);
|
||
return manifest;
|
||
}
|
||
|
||
static DocumentExtraction LoadExistingExtraction(string inputDir)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(inputDir))
|
||
throw new ArgumentException("--reuse-extraction-dir is required for existing extraction reanalysis.");
|
||
inputDir = Path.GetFullPath(inputDir.Trim().Trim('"'));
|
||
if (!Directory.Exists(inputDir))
|
||
throw new DirectoryNotFoundException($"Existing extraction directory not found: {inputDir}");
|
||
|
||
var extraction = new DocumentExtraction
|
||
{
|
||
EntitiesCommon = ReadJsonListFile(Path.Combine(inputDir, "entities-common.json")),
|
||
Geometry = ReadJsonListFile(Path.Combine(inputDir, "geometry.json")),
|
||
Annotations = ReadJsonListFile(Path.Combine(inputDir, "annotations.json")),
|
||
Dimensions = ReadJsonListFile(Path.Combine(inputDir, "dimensions.json")),
|
||
DimensionalTolerances = ReadJsonListFile(Path.Combine(inputDir, "dimensional-tolerances.json")),
|
||
Roughness = ReadJsonListFile(Path.Combine(inputDir, "roughness.json")),
|
||
GeometricTolerances = ReadJsonListFile(Path.Combine(inputDir, "geometric-tolerances.json")),
|
||
Datums = ReadJsonListFile(Path.Combine(inputDir, "datums.json")),
|
||
UnknownEntities = ReadJsonListFile(Path.Combine(inputDir, "unknown-entities.json"))
|
||
};
|
||
|
||
extraction.TypeCounts = ReadTypeCounts(Path.Combine(inputDir, "manifest.json"));
|
||
extraction.ModelSpaceCount = extraction.EntitiesCommon.Count(item => string.Equals(ReadDictString(item, "space"), "ModelSpace", StringComparison.OrdinalIgnoreCase));
|
||
extraction.PaperSpaceCount = extraction.EntitiesCommon.Count(item => string.Equals(ReadDictString(item, "space"), "PaperSpace", StringComparison.OrdinalIgnoreCase));
|
||
return extraction;
|
||
}
|
||
|
||
static List<Dictionary<string, object?>> ReadJsonListFile(string path)
|
||
{
|
||
if (!File.Exists(path))
|
||
return new List<Dictionary<string, object?>>();
|
||
using var doc = JsonDocument.Parse(File.ReadAllText(path));
|
||
if (doc.RootElement.ValueKind != JsonValueKind.Array)
|
||
return new List<Dictionary<string, object?>>();
|
||
|
||
var result = new List<Dictionary<string, object?>>();
|
||
foreach (var item in doc.RootElement.EnumerateArray())
|
||
{
|
||
if (ConvertJsonValue(item) is Dictionary<string, object?> dict)
|
||
result.Add(dict);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
static Dictionary<string, int> ReadTypeCounts(string manifestPath)
|
||
{
|
||
var result = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
|
||
if (!File.Exists(manifestPath))
|
||
return result;
|
||
using var doc = JsonDocument.Parse(File.ReadAllText(manifestPath));
|
||
if (!doc.RootElement.TryGetProperty("type_counts", out var typeCounts) ||
|
||
typeCounts.ValueKind != JsonValueKind.Object)
|
||
{
|
||
return result;
|
||
}
|
||
|
||
foreach (var item in typeCounts.EnumerateObject())
|
||
{
|
||
if (item.Value.ValueKind == JsonValueKind.Number && item.Value.TryGetInt32(out var count))
|
||
result[item.Name] = count;
|
||
}
|
||
return result;
|
||
}
|
||
|
||
static object? ConvertJsonValue(JsonElement element)
|
||
{
|
||
return element.ValueKind switch
|
||
{
|
||
JsonValueKind.Object => element.EnumerateObject()
|
||
.ToDictionary(item => item.Name, item => ConvertJsonValue(item.Value), StringComparer.OrdinalIgnoreCase),
|
||
JsonValueKind.Array => ConvertJsonArray(element),
|
||
JsonValueKind.String => element.GetString(),
|
||
JsonValueKind.Number => element.TryGetInt32(out var intValue) ? intValue : element.GetDouble(),
|
||
JsonValueKind.True => true,
|
||
JsonValueKind.False => false,
|
||
_ => null
|
||
};
|
||
}
|
||
|
||
static object ConvertJsonArray(JsonElement element)
|
||
{
|
||
var values = element.EnumerateArray().Select(ConvertJsonValue).ToList();
|
||
if (values.All(value => value is int or double or long or float or decimal))
|
||
return values.Select(value => Convert.ToDouble(value, CultureInfo.InvariantCulture)).ToList();
|
||
return values;
|
||
}
|
||
|
||
static CategoryFile WriteCategory(string outputDir, string category, string file, object data)
|
||
{
|
||
var path = Path.Combine(outputDir, file);
|
||
WriteJson(path, data);
|
||
return new CategoryFile
|
||
{
|
||
Category = category,
|
||
File = file,
|
||
FullPath = path,
|
||
ItemCount = data is System.Collections.ICollection collection ? collection.Count : 0,
|
||
Exists = true
|
||
};
|
||
}
|
||
|
||
static void WriteJson(string path, object data)
|
||
{
|
||
File.WriteAllText(path, JsonSerializer.Serialize(data, JsonDefaults.Options));
|
||
}
|
||
|
||
static object ConnectOrCreate(string progId, bool visible, bool allowStartAutoCad, out bool started)
|
||
{
|
||
var app = TryGetActiveComObject(progId);
|
||
started = false;
|
||
if (app != null)
|
||
{
|
||
TrySetProperty(app, "Visible", visible);
|
||
return app;
|
||
}
|
||
|
||
if (!allowStartAutoCad)
|
||
{
|
||
throw new InvalidOperationException(
|
||
$"No active AutoCAD COM object: {progId}. Open AutoCAD manually, or pass --allow-start-autocad true.");
|
||
}
|
||
|
||
if (app == null)
|
||
{
|
||
LogProgress("start_autocad_process");
|
||
try
|
||
{
|
||
StartAutoCadFromRegistry(progId);
|
||
app = WaitForActiveComObject(progId, TimeSpan.FromSeconds(90));
|
||
if (app != null)
|
||
started = true;
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
LogProgress($"start_autocad_process_failed {ex.GetType().Name}: {ex.Message}");
|
||
}
|
||
}
|
||
|
||
if (app == null)
|
||
{
|
||
try
|
||
{
|
||
var type = Type.GetTypeFromProgID(progId, throwOnError: true)
|
||
?? throw new InvalidOperationException($"找不到 AutoCAD COM ProgID：{progId}");
|
||
app = Activator.CreateInstance(type)
|
||
?? throw new InvalidOperationException($"创建 AutoCAD COM 对象失败：{progId}");
|
||
started = true;
|
||
}
|
||
catch
|
||
{
|
||
StartAutoCadFromRegistry(progId);
|
||
var deadline = DateTime.UtcNow.AddSeconds(90);
|
||
while (DateTime.UtcNow < deadline)
|
||
{
|
||
Thread.Sleep(1500);
|
||
app = TryGetActiveComObject(progId);
|
||
if (app != null)
|
||
{
|
||
started = true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (app == null)
|
||
throw new InvalidOperationException($"AutoCAD 启动或 COM 连接失败：{progId}");
|
||
|
||
TrySetProperty(app, "Visible", visible);
|
||
return app;
|
||
}
|
||
|
||
static object? WaitForActiveComObject(string progId, TimeSpan timeout)
|
||
{
|
||
LogProgress("wait_autocad_com_start");
|
||
var deadline = DateTime.UtcNow.Add(timeout);
|
||
while (DateTime.UtcNow < deadline)
|
||
{
|
||
Thread.Sleep(1500);
|
||
var app = TryGetActiveComObject(progId);
|
||
if (app != null)
|
||
{
|
||
LogProgress("wait_autocad_com_ok");
|
||
return app;
|
||
}
|
||
}
|
||
|
||
LogProgress("wait_autocad_com_timeout");
|
||
return null;
|
||
}
|
||
|
||
static void StartAutoCadFromRegistry(string progId)
|
||
{
|
||
var clsid = ReadDefaultValue($@"{progId}\CLSID");
|
||
var command = string.IsNullOrWhiteSpace(clsid) ? "" : ReadDefaultValue($@"CLSID\{clsid}\LocalServer32");
|
||
var exe = ExtractExePath(command);
|
||
if (string.IsNullOrWhiteSpace(exe) || !File.Exists(exe))
|
||
exe = @"D:\Program Files\Autodesk\AutoCAD 2020\acad.exe";
|
||
if (!File.Exists(exe))
|
||
throw new FileNotFoundException($"找不到 acad.exe。ProgID={progId}, LocalServer32={command}");
|
||
|
||
Process.Start(new ProcessStartInfo
|
||
{
|
||
FileName = exe,
|
||
Arguments = "/Automation",
|
||
UseShellExecute = true,
|
||
WorkingDirectory = Path.GetDirectoryName(exe) ?? Environment.CurrentDirectory
|
||
});
|
||
}
|
||
|
||
static string ReadDefaultValue(string subKey)
|
||
{
|
||
using var key = Registry.ClassesRoot.OpenSubKey(subKey);
|
||
return key?.GetValue("")?.ToString() ?? "";
|
||
}
|
||
|
||
static string ExtractExePath(string command)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(command))
|
||
return "";
|
||
|
||
var trimmed = command.Trim();
|
||
if (trimmed.StartsWith('"'))
|
||
{
|
||
var end = trimmed.IndexOf('"', 1);
|
||
return end > 1 ? trimmed[1..end] : "";
|
||
}
|
||
|
||
var exeIndex = trimmed.IndexOf(".exe", StringComparison.OrdinalIgnoreCase);
|
||
return exeIndex >= 0 ? trimmed[..(exeIndex + 4)] : trimmed;
|
||
}
|
||
|
||
static object OpenDocument(object app, string drawingPath)
|
||
{
|
||
var documents = GetProperty(app, "Documents") ?? throw new InvalidOperationException("AutoCAD.Application.Documents 不可用。");
|
||
try
|
||
{
|
||
return TryInvoke(documents, "Open", [drawingPath, true])
|
||
?? TryInvoke(documents, "Open", [drawingPath])
|
||
?? throw new InvalidOperationException($"AutoCAD 打开 DWG 失败：{drawingPath}");
|
||
}
|
||
finally
|
||
{
|
||
ReleaseCom(documents);
|
||
}
|
||
}
|
||
|
||
static Dictionary<string, SplineEndpoint> ReadSplineEndpointsViaAutoLisp(object app, object doc, string outputDir)
|
||
{
|
||
var result = new Dictionary<string, SplineEndpoint>(StringComparer.OrdinalIgnoreCase);
|
||
try
|
||
{
|
||
Directory.CreateDirectory(outputDir);
|
||
var lispPath = Path.Combine(outputDir, "agent4-read-spline-endpoints.lsp");
|
||
var outputPath = Path.Combine(outputDir, "spline-endpoints.tsv");
|
||
if (File.Exists(outputPath))
|
||
File.Delete(outputPath);
|
||
|
||
File.WriteAllText(lispPath, BuildSplineEndpointLisp(outputPath));
|
||
TryInvoke(doc, "SendCommand", [$"(load \"{LispPath(lispPath)}\")\n"]);
|
||
|
||
var deadline = DateTime.UtcNow.AddSeconds(30);
|
||
while (DateTime.UtcNow < deadline)
|
||
{
|
||
WaitForQuiescent(app, TimeSpan.FromSeconds(2));
|
||
if (File.Exists(outputPath))
|
||
break;
|
||
Thread.Sleep(250);
|
||
}
|
||
|
||
if (!File.Exists(outputPath))
|
||
return result;
|
||
|
||
foreach (var line in File.ReadAllLines(outputPath))
|
||
{
|
||
var parts = line.Split('\t');
|
||
if (parts.Length < 5)
|
||
continue;
|
||
if (!TryParseInvariant(parts[1], out var sx) ||
|
||
!TryParseInvariant(parts[2], out var sy) ||
|
||
!TryParseInvariant(parts[3], out var ex) ||
|
||
!TryParseInvariant(parts[4], out var ey))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
result[parts[0]] = new SplineEndpoint(
|
||
new List<double> { sx, sy },
|
||
new List<double> { ex, ey },
|
||
"autolisp_vlax_curve_param_point");
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// Keep extraction usable; direct COM/control-point fallback still runs.
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
static string BuildSplineEndpointLisp(string outputPath)
|
||
{
|
||
var path = LispPath(outputPath);
|
||
return string.Join("\n", new[]
|
||
{
|
||
"(vl-load-com)",
|
||
"(defun agent4-format-point (p)",
|
||
" (if (and p (listp p) (numberp (car p)) (numberp (cadr p)))",
|
||
" (strcat (rtos (car p) 2 16) \"\\t\" (rtos (cadr p) 2 16))",
|
||
" \"\\t\"",
|
||
" )",
|
||
")",
|
||
"(defun agent4-start-point (obj / param point)",
|
||
" (setq param (vl-catch-all-apply 'vlax-curve-getStartParam (list obj)))",
|
||
" (if (not (vl-catch-all-error-p param))",
|
||
" (setq point (vl-catch-all-apply 'vlax-curve-getPointAtParam (list obj param)))",
|
||
" )",
|
||
" (if (or (null point) (vl-catch-all-error-p point))",
|
||
" (setq point (vl-catch-all-apply 'vlax-curve-getStartPoint (list obj)))",
|
||
" )",
|
||
" (if (vl-catch-all-error-p point) nil point)",
|
||
")",
|
||
"(defun agent4-end-point (obj / param point)",
|
||
" (setq param (vl-catch-all-apply 'vlax-curve-getEndParam (list obj)))",
|
||
" (if (not (vl-catch-all-error-p param))",
|
||
" (setq point (vl-catch-all-apply 'vlax-curve-getPointAtParam (list obj param)))",
|
||
" )",
|
||
" (if (or (null point) (vl-catch-all-error-p point))",
|
||
" (setq point (vl-catch-all-apply 'vlax-curve-getEndPoint (list obj)))",
|
||
" )",
|
||
" (if (vl-catch-all-error-p point) nil point)",
|
||
")",
|
||
"(defun agent4-write-spline-endpoints (/ f ss i ent obj h sp ep)",
|
||
$" (setq f (open \"{path}\" \"w\"))",
|
||
" (setq ss (ssget \"_X\" '((0 . \"SPLINE\"))))",
|
||
" (if ss",
|
||
" (progn",
|
||
" (setq i 0)",
|
||
" (while (< i (sslength ss))",
|
||
" (setq ent (ssname ss i))",
|
||
" (setq obj (vlax-ename->vla-object ent))",
|
||
" (setq h (vla-get-Handle obj))",
|
||
" (setq sp (agent4-start-point obj))",
|
||
" (setq ep (agent4-end-point obj))",
|
||
" (write-line (strcat h \"\\t\" (agent4-format-point sp) \"\\t\" (agent4-format-point ep)) f)",
|
||
" (setq i (1+ i))",
|
||
" )",
|
||
" )",
|
||
" )",
|
||
" (if f (close f))",
|
||
" (princ)",
|
||
")",
|
||
"(agent4-write-spline-endpoints)"
|
||
}) + "\n";
|
||
}
|
||
|
||
static Dictionary<string, DimensionDefinitionPoints> ReadDimensionDefinitionPointsViaAutoLisp(object app, object doc, string outputDir)
|
||
{
|
||
var result = new Dictionary<string, DimensionDefinitionPoints>(StringComparer.OrdinalIgnoreCase);
|
||
try
|
||
{
|
||
Directory.CreateDirectory(outputDir);
|
||
var lispPath = Path.Combine(outputDir, "agent4-read-dimension-definition-points.lsp");
|
||
var outputPath = Path.Combine(outputDir, "dimension-definition-points.tsv");
|
||
if (File.Exists(outputPath))
|
||
File.Delete(outputPath);
|
||
|
||
File.WriteAllText(lispPath, BuildDimensionDefinitionPointLisp(outputPath));
|
||
TryInvoke(doc, "SendCommand", [$"(load \"{LispPath(lispPath)}\")\n"]);
|
||
|
||
var deadline = DateTime.UtcNow.AddSeconds(30);
|
||
while (DateTime.UtcNow < deadline)
|
||
{
|
||
WaitForQuiescent(app, TimeSpan.FromSeconds(2));
|
||
if (File.Exists(outputPath))
|
||
break;
|
||
Thread.Sleep(250);
|
||
}
|
||
|
||
if (!File.Exists(outputPath))
|
||
return result;
|
||
|
||
foreach (var line in File.ReadAllLines(outputPath))
|
||
{
|
||
var parts = line.Split('\t');
|
||
if (parts.Length < 19)
|
||
continue;
|
||
|
||
result[parts[0]] = new DimensionDefinitionPoints(
|
||
ParsePointColumns(parts, 1),
|
||
ParsePointColumns(parts, 4),
|
||
ParsePointColumns(parts, 7),
|
||
ParsePointColumns(parts, 10),
|
||
ParsePointColumns(parts, 13),
|
||
ParsePointColumns(parts, 16));
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// Keep DWG extraction usable; ActiveX point properties remain the fallback.
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
static string BuildDimensionDefinitionPointLisp(string outputPath)
|
||
{
|
||
var path = LispPath(outputPath);
|
||
return string.Join("\n", new[]
|
||
{
|
||
"(vl-load-com)",
|
||
"(defun agent4-format-dxf-point (data code / p)",
|
||
" (setq p (cdr (assoc code data)))",
|
||
" (if (and p (listp p) (numberp (car p)) (numberp (cadr p)))",
|
||
" (strcat (rtos (car p) 2 16) \"\\t\" (rtos (cadr p) 2 16) \"\\t\" (rtos (if (numberp (caddr p)) (caddr p) 0.0) 2 16))",
|
||
" \"\\t\\t\"",
|
||
" )",
|
||
")",
|
||
"(defun agent4-write-dimension-definition-points (/ f ss i ent data obj h)",
|
||
$" (setq f (open \"{path}\" \"w\"))",
|
||
" (setq ss (ssget \"_X\" '((0 . \"*DIMENSION\"))))",
|
||
" (if ss",
|
||
" (progn",
|
||
" (setq i 0)",
|
||
" (while (< i (sslength ss))",
|
||
" (setq ent (ssname ss i))",
|
||
" (setq data (entget ent))",
|
||
" (setq obj (vlax-ename->vla-object ent))",
|
||
" (setq h (vla-get-Handle obj))",
|
||
" (write-line",
|
||
" (strcat",
|
||
" h \"\\t\"",
|
||
" (agent4-format-dxf-point data 13) \"\\t\"",
|
||
" (agent4-format-dxf-point data 14) \"\\t\"",
|
||
" (agent4-format-dxf-point data 10) \"\\t\"",
|
||
" (agent4-format-dxf-point data 11) \"\\t\"",
|
||
" (agent4-format-dxf-point data 15) \"\\t\"",
|
||
" (agent4-format-dxf-point data 16)",
|
||
" )",
|
||
" f",
|
||
" )",
|
||
" (setq i (1+ i))",
|
||
" )",
|
||
" )",
|
||
" )",
|
||
" (if f (close f))",
|
||
" (princ)",
|
||
")",
|
||
"(agent4-write-dimension-definition-points)"
|
||
}) + "\n";
|
||
}
|
||
|
||
static List<double>? ParsePointColumns(string[] parts, int start)
|
||
{
|
||
if (parts.Length <= start + 1)
|
||
return null;
|
||
if (!TryParseInvariant(parts[start], out var x) ||
|
||
!TryParseInvariant(parts[start + 1], out var y))
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var z = parts.Length > start + 2 && TryParseInvariant(parts[start + 2], out var parsedZ)
|
||
? parsedZ
|
||
: 0.0;
|
||
return new List<double> { x, y, z };
|
||
}
|
||
|
||
static Dictionary<string, List<Dictionary<string, object?>>> ReadBlockExplosionsViaAutoLisp(
|
||
object app,
|
||
object doc,
|
||
string outputDir)
|
||
{
|
||
var result = new Dictionary<string, List<Dictionary<string, object?>>>(StringComparer.OrdinalIgnoreCase);
|
||
try
|
||
{
|
||
Directory.CreateDirectory(outputDir);
|
||
var lispPath = Path.Combine(outputDir, "agent4-read-block-explosions.lsp");
|
||
var outputPath = Path.Combine(outputDir, "block-explosions.tsv");
|
||
if (File.Exists(outputPath))
|
||
File.Delete(outputPath);
|
||
|
||
File.WriteAllText(lispPath, BuildBlockExplosionLisp(outputPath));
|
||
TryInvoke(doc, "SendCommand", [$"(load \"{LispPath(lispPath)}\")\n"]);
|
||
|
||
var deadline = DateTime.UtcNow.AddSeconds(90);
|
||
while (DateTime.UtcNow < deadline)
|
||
{
|
||
WaitForQuiescent(app, TimeSpan.FromSeconds(2));
|
||
if (File.Exists(outputPath))
|
||
break;
|
||
Thread.Sleep(250);
|
||
}
|
||
|
||
if (!File.Exists(outputPath))
|
||
return result;
|
||
|
||
foreach (var line in File.ReadAllLines(outputPath))
|
||
{
|
||
var parts = line.Split('\t');
|
||
if (parts.Length < 16)
|
||
continue;
|
||
|
||
var parent = parts[0];
|
||
if (string.IsNullOrWhiteSpace(parent))
|
||
continue;
|
||
|
||
var child = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase)
|
||
{
|
||
["index"] = ToInt(parts[1]),
|
||
["object_name"] = parts[2],
|
||
["text"] = parts[3]
|
||
};
|
||
AddParsedPoint(child, "start", parts[4], parts[5]);
|
||
AddParsedPoint(child, "end", parts[6], parts[7]);
|
||
AddParsedPoint(child, "insertion_point", parts[8], parts[9]);
|
||
if (TryParseInvariant(parts[10], out var minX) &&
|
||
TryParseInvariant(parts[11], out var minY) &&
|
||
TryParseInvariant(parts[12], out var maxX) &&
|
||
TryParseInvariant(parts[13], out var maxY))
|
||
{
|
||
child["bbox"] = new BoundingBox(minX, minY, maxX, maxY).ToDictionary();
|
||
}
|
||
child["layer"] = parts[14];
|
||
child["source"] = parts[15];
|
||
|
||
if (!result.TryGetValue(parent, out var children))
|
||
{
|
||
children = new List<Dictionary<string, object?>>();
|
||
result[parent] = children;
|
||
}
|
||
children.Add(child);
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// Keep base extraction usable if a block cannot be exploded.
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
static string BuildBlockExplosionLisp(string outputPath)
|
||
{
|
||
var path = LispPath(outputPath);
|
||
return string.Join("\n", new[]
|
||
{
|
||
"(vl-load-com)",
|
||
"(defun agent4-num (v) (if (numberp v) (rtos v 2 16) \"\"))",
|
||
"(defun agent4-ptx (p) (if (and p (listp p) (numberp (car p))) (rtos (car p) 2 16) \"\"))",
|
||
"(defun agent4-pty (p) (if (and p (listp p) (numberp (cadr p))) (rtos (cadr p) 2 16) \"\"))",
|
||
"(defun agent4-clean (s) (if s (vl-string-translate \"\\t\\r\\n\" \" \" s) \"\"))",
|
||
"(defun agent4-bbox (obj / mn mx r)",
|
||
" (setq r (vl-catch-all-apply 'vla-GetBoundingBox (list obj 'mn 'mx)))",
|
||
" (if (vl-catch-all-error-p r)",
|
||
" (list \"\" \"\" \"\" \"\")",
|
||
" (progn",
|
||
" (setq mn (vlax-safearray->list mn))",
|
||
" (setq mx (vlax-safearray->list mx))",
|
||
" (list (agent4-ptx mn) (agent4-pty mn) (agent4-ptx mx) (agent4-pty mx))",
|
||
" )",
|
||
" )",
|
||
")",
|
||
"(defun agent4-prop-point (obj prop / v)",
|
||
" (setq v (vl-catch-all-apply 'vlax-get-property (list obj prop)))",
|
||
" (if (or (null v) (vl-catch-all-error-p v)) nil (vlax-safearray->list (vlax-variant-value v)))",
|
||
")",
|
||
"(defun agent4-prop-text (obj / s)",
|
||
" (setq s (vl-catch-all-apply 'vlax-get-property (list obj 'TextString)))",
|
||
" (if (vl-catch-all-error-p s) \"\" (agent4-clean s))",
|
||
")",
|
||
"(defun agent4-write-child (f parent idx obj / typ txt sp ep ip bb layer)",
|
||
" (setq typ (vla-get-ObjectName obj))",
|
||
" (setq txt (agent4-prop-text obj))",
|
||
" (setq sp (agent4-prop-point obj 'StartPoint))",
|
||
" (setq ep (agent4-prop-point obj 'EndPoint))",
|
||
" (setq ip (agent4-prop-point obj 'InsertionPoint))",
|
||
" (setq bb (agent4-bbox obj))",
|
||
" (setq layer (vl-catch-all-apply 'vlax-get-property (list obj 'Layer)))",
|
||
" (if (vl-catch-all-error-p layer) (setq layer \"\"))",
|
||
" (write-line",
|
||
" (strcat parent \"\\t\" (itoa idx) \"\\t\" typ \"\\t\" txt \"\\t\"",
|
||
" (agent4-ptx sp) \"\\t\" (agent4-pty sp) \"\\t\"",
|
||
" (agent4-ptx ep) \"\\t\" (agent4-pty ep) \"\\t\"",
|
||
" (agent4-ptx ip) \"\\t\" (agent4-pty ip) \"\\t\"",
|
||
" (nth 0 bb) \"\\t\" (nth 1 bb) \"\\t\" (nth 2 bb) \"\\t\" (nth 3 bb) \"\\t\"",
|
||
" layer \"\\t\" \"vla-explode\")",
|
||
" f)",
|
||
")",
|
||
"(defun agent4-read-block-explosions (/ f ss i ent obj parent arr children child idx)",
|
||
$" (setq f (open \"{path}\" \"w\"))",
|
||
" (setq ss (ssget \"_X\" '((0 . \"INSERT\"))))",
|
||
" (if ss",
|
||
" (progn",
|
||
" (setq i 0)",
|
||
" (while (< i (sslength ss))",
|
||
" (setq ent (ssname ss i))",
|
||
" (setq obj (vlax-ename->vla-object ent))",
|
||
" (setq parent (vla-get-Handle obj))",
|
||
" (setq arr (vl-catch-all-apply 'vla-Explode (list obj)))",
|
||
" (if (not (vl-catch-all-error-p arr))",
|
||
" (progn",
|
||
" (setq children (vlax-safearray->list (vlax-variant-value arr)))",
|
||
" (setq idx 0)",
|
||
" (foreach child children",
|
||
" (agent4-write-child f parent idx child)",
|
||
" (vl-catch-all-apply 'vla-Delete (list child))",
|
||
" (setq idx (1+ idx))",
|
||
" )",
|
||
" )",
|
||
" )",
|
||
" (setq i (1+ i))",
|
||
" )",
|
||
" )",
|
||
" )",
|
||
" (if f (close f))",
|
||
" (princ)",
|
||
")",
|
||
"(agent4-read-block-explosions)"
|
||
}) + "\n";
|
||
}
|
||
|
||
static void AddParsedPoint(Dictionary<string, object?> item, string key, string xText, string yText)
|
||
{
|
||
if (TryParseInvariant(xText, out var x) && TryParseInvariant(yText, out var y))
|
||
item[key] = new List<double> { x, y };
|
||
}
|
||
|
||
static string LispPath(string path) => Path.GetFullPath(path).Replace("\\", "/").Replace("\"", "\\\"");
|
||
|
||
static bool TryParseInvariant(string text, out double value) =>
|
||
double.TryParse(text, NumberStyles.Float, CultureInfo.InvariantCulture, out value);
|
||
|
||
static void WaitForQuiescent(object app, TimeSpan timeout)
|
||
{
|
||
var deadline = DateTime.UtcNow + timeout;
|
||
while (DateTime.UtcNow < deadline)
|
||
{
|
||
var state = TryInvoke(app, "GetAcadState", []);
|
||
if (state == null)
|
||
return;
|
||
try
|
||
{
|
||
if (ToBool(GetProperty(state, "IsQuiescent")) ?? true)
|
||
return;
|
||
}
|
||
finally
|
||
{
|
||
ReleaseCom(state);
|
||
}
|
||
Thread.Sleep(250);
|
||
}
|
||
}
|
||
|
||
static DeleteResult SaveMainViewOnlyDwg(object doc, string savePath, HashSet<string> keepHandles)
|
||
{
|
||
Directory.CreateDirectory(Path.GetDirectoryName(savePath) ?? Environment.CurrentDirectory);
|
||
var deleted = 0;
|
||
deleted += DeleteEntitiesNotInHandles(doc, "ModelSpace", keepHandles);
|
||
deleted += DeleteEntitiesNotInHandles(doc, "PaperSpace", keepHandles);
|
||
TryInvoke(doc, "SaveAs", [savePath]);
|
||
return new DeleteResult(deleted);
|
||
}
|
||
|
||
static int DeleteEntitiesNotInHandles(object doc, string spaceName, HashSet<string> keepHandles)
|
||
{
|
||
var deleted = 0;
|
||
var space = GetProperty(doc, spaceName);
|
||
if (space == null)
|
||
return deleted;
|
||
|
||
try
|
||
{
|
||
var count = ToInt(GetProperty(space, "Count")) ?? 0;
|
||
for (var i = count - 1; i >= 0; i--)
|
||
{
|
||
var entity = GetCollectionItem(space, i);
|
||
if (entity == null)
|
||
continue;
|
||
try
|
||
{
|
||
var handle = ReadString(entity, "Handle");
|
||
if (!keepHandles.Contains(handle))
|
||
{
|
||
TryInvoke(entity, "Delete", []);
|
||
deleted++;
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
ReleaseCom(entity);
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
ReleaseCom(space);
|
||
}
|
||
|
||
return deleted;
|
||
}
|
||
|
||
static object? GetProperty(object obj, string name) => RetryCom(() =>
|
||
{
|
||
try
|
||
{
|
||
return obj.GetType().InvokeMember(name, BindingFlags.GetProperty, null, obj, null, CultureInfo.InvariantCulture);
|
||
}
|
||
catch (TargetInvocationException ex) when (IsRetryableCom(ex.InnerException))
|
||
{
|
||
throw;
|
||
}
|
||
catch (COMException ex) when (IsRetryableCom(ex))
|
||
{
|
||
throw;
|
||
}
|
||
catch
|
||
{
|
||
return null;
|
||
}
|
||
});
|
||
|
||
static object? GetCollectionItem(object obj, int index) => RetryCom(() =>
|
||
{
|
||
foreach (var flags in new[] { BindingFlags.GetProperty, BindingFlags.InvokeMethod })
|
||
{
|
||
try
|
||
{
|
||
return obj.GetType().InvokeMember("Item", flags, null, obj, [index], CultureInfo.InvariantCulture);
|
||
}
|
||
catch (TargetInvocationException ex) when (IsRetryableCom(ex.InnerException))
|
||
{
|
||
throw;
|
||
}
|
||
catch (COMException ex) when (IsRetryableCom(ex))
|
||
{
|
||
throw;
|
||
}
|
||
catch
|
||
{
|
||
// Try next dispatch style.
|
||
}
|
||
}
|
||
return null;
|
||
});
|
||
|
||
static object? TryInvoke(object obj, string name, object?[] args) => RetryCom(() =>
|
||
{
|
||
try
|
||
{
|
||
return obj.GetType().InvokeMember(name, BindingFlags.InvokeMethod, null, obj, args, CultureInfo.InvariantCulture);
|
||
}
|
||
catch (TargetInvocationException ex) when (IsRetryableCom(ex.InnerException))
|
||
{
|
||
throw;
|
||
}
|
||
catch (COMException ex) when (IsRetryableCom(ex))
|
||
{
|
||
throw;
|
||
}
|
||
catch
|
||
{
|
||
return null;
|
||
}
|
||
});
|
||
|
||
static void TrySetProperty(object obj, string name, object? value)
|
||
{
|
||
RetryCom(() =>
|
||
{
|
||
try
|
||
{
|
||
obj.GetType().InvokeMember(name, BindingFlags.SetProperty, null, obj, [value], CultureInfo.InvariantCulture);
|
||
}
|
||
catch
|
||
{
|
||
// Optional.
|
||
}
|
||
return null;
|
||
});
|
||
}
|
||
|
||
static object? RetryCom(Func<object?> action)
|
||
{
|
||
Exception? last = null;
|
||
for (var i = 0; i < 180; i++)
|
||
{
|
||
try
|
||
{
|
||
return action();
|
||
}
|
||
catch (TargetInvocationException ex) when (IsRetryableCom(ex.InnerException))
|
||
{
|
||
last = ex.InnerException;
|
||
Thread.Sleep(100);
|
||
}
|
||
catch (COMException ex) when (IsRetryableCom(ex))
|
||
{
|
||
last = ex;
|
||
Thread.Sleep(100);
|
||
}
|
||
}
|
||
if (last != null)
|
||
throw last;
|
||
return action();
|
||
}
|
||
|
||
static bool IsRetryableCom(Exception? ex)
|
||
{
|
||
return ex is COMException com && unchecked((uint)com.HResult) is 0x80010001 or 0x8001010A;
|
||
}
|
||
|
||
static bool IsGeometry(string objectName)
|
||
{
|
||
return objectName.Contains("Line", StringComparison.OrdinalIgnoreCase) ||
|
||
objectName.Contains("Circle", StringComparison.OrdinalIgnoreCase) ||
|
||
objectName.Contains("Arc", StringComparison.OrdinalIgnoreCase) ||
|
||
objectName.Contains("Spline", StringComparison.OrdinalIgnoreCase) ||
|
||
objectName.Contains("Hatch", StringComparison.OrdinalIgnoreCase) ||
|
||
objectName.Contains("Wipeout", StringComparison.OrdinalIgnoreCase) ||
|
||
objectName.Contains("RasterImage", StringComparison.OrdinalIgnoreCase);
|
||
}
|
||
|
||
static bool IsPolyline(string objectName)
|
||
{
|
||
return objectName.Contains("Polyline", StringComparison.OrdinalIgnoreCase);
|
||
}
|
||
|
||
static bool IsAnnotation(string objectName)
|
||
{
|
||
return objectName.Contains("Text", StringComparison.OrdinalIgnoreCase) ||
|
||
objectName.Contains("BlockReference", StringComparison.OrdinalIgnoreCase);
|
||
}
|
||
|
||
static bool LooksLikeRoughness(string text, string blockName)
|
||
{
|
||
var merged = text + " " + blockName;
|
||
return Regex.IsMatch(merged, @"\bR[az]\s*\d", RegexOptions.IgnoreCase) ||
|
||
merged.Contains("粗糙", StringComparison.OrdinalIgnoreCase) ||
|
||
merged.Contains("其余", StringComparison.OrdinalIgnoreCase) ||
|
||
merged.Contains("rough", StringComparison.OrdinalIgnoreCase);
|
||
}
|
||
|
||
static bool LooksLikeGeometricTolerance(string text, string blockName)
|
||
{
|
||
var merged = text + " " + blockName;
|
||
return merged.Contains("位置度", StringComparison.OrdinalIgnoreCase) ||
|
||
merged.Contains("同轴度", StringComparison.OrdinalIgnoreCase) ||
|
||
merged.Contains("平行度", StringComparison.OrdinalIgnoreCase) ||
|
||
merged.Contains("垂直度", StringComparison.OrdinalIgnoreCase) ||
|
||
merged.Contains("圆跳动", StringComparison.OrdinalIgnoreCase) ||
|
||
merged.Contains("geotol", StringComparison.OrdinalIgnoreCase) ||
|
||
Regex.IsMatch(merged, @"[⊥∥⌖◎⌯⌭]");
|
||
}
|
||
|
||
static bool LooksLikeDatum(string text, string blockName)
|
||
{
|
||
var merged = text + " " + blockName;
|
||
return merged.Contains("基准", StringComparison.OrdinalIgnoreCase) ||
|
||
merged.Contains("datum", StringComparison.OrdinalIgnoreCase);
|
||
}
|
||
|
||
static List<double> ExtractNumbers(string text)
|
||
{
|
||
return Regex.Matches(text, @"[+-]?\d+(?:\.\d+)?")
|
||
.Select(match => double.TryParse(match.Value, NumberStyles.Float, CultureInfo.InvariantCulture, out var value) ? value : (double?)null)
|
||
.Where(value => value != null)
|
||
.Select(value => value!.Value)
|
||
.ToList();
|
||
}
|
||
|
||
static string CleanAcadText(string text)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(text))
|
||
return "";
|
||
var value = text.Replace("%%C", "Φ", StringComparison.OrdinalIgnoreCase)
|
||
.Replace("%%D", "°", StringComparison.OrdinalIgnoreCase)
|
||
.Replace("%%P", "±", StringComparison.OrdinalIgnoreCase);
|
||
value = Regex.Replace(value, @"\\A\d+;", "");
|
||
value = Regex.Replace(value, @"\\H[^;]+;", "");
|
||
value = Regex.Replace(value, @"\\S([^;]+)\^([^;]*);", "$1/$2");
|
||
value = Regex.Replace(value, @"\\S([^;]+);", "$1");
|
||
value = Regex.Replace(value, @"[{}]", "");
|
||
value = value.Replace(@"\P", " ");
|
||
return Regex.Replace(value, @"\s+", " ").Trim();
|
||
}
|
||
|
||
static void AddPoint(Dictionary<string, object?> details, string name, object? value)
|
||
{
|
||
var point = DoubleList(value);
|
||
if (point.Count > 0)
|
||
details[name] = point;
|
||
}
|
||
|
||
static void AddPointFromProperties(
|
||
Dictionary<string, object?> details,
|
||
string name,
|
||
object entity,
|
||
List<string> missingFields,
|
||
params string[] propertyNames)
|
||
{
|
||
foreach (var propertyName in propertyNames)
|
||
{
|
||
var point = DoubleList(GetProperty(entity, propertyName));
|
||
if (point.Count == 0)
|
||
continue;
|
||
|
||
details[name] = point;
|
||
details[$"{name}_source_property"] = propertyName;
|
||
return;
|
||
}
|
||
|
||
missingFields.Add(name);
|
||
}
|
||
|
||
static void ApplyDimensionDefinitionPoints(Dictionary<string, object?> details, DimensionDefinitionPoints definitionPoints)
|
||
{
|
||
ApplyDimensionDefinitionPoint(details, "xline1_point", "dxf_group_13", definitionPoints.Group13);
|
||
ApplyDimensionDefinitionPoint(details, "xline2_point", "dxf_group_14", definitionPoints.Group14);
|
||
ApplyDimensionDefinitionPoint(details, "dim_line_point", "dxf_group_10", definitionPoints.Group10);
|
||
ApplyDimensionDefinitionPoint(details, "text_position", "dxf_group_11", definitionPoints.Group11);
|
||
ApplyDimensionDefinitionPoint(details, "center", "dxf_group_15", definitionPoints.Group15);
|
||
ApplyDimensionDefinitionPoint(details, "chord_point", "dxf_group_16", definitionPoints.Group16);
|
||
|
||
if (details.TryGetValue("dimension_point_missing_fields", out var value) && value is List<string> missing)
|
||
{
|
||
missing.RemoveAll(field => details.ContainsKey(field));
|
||
if (missing.Count == 0)
|
||
details.Remove("dimension_point_missing_fields");
|
||
}
|
||
}
|
||
|
||
static void ApplyDimensionDefinitionPoint(
|
||
Dictionary<string, object?> details,
|
||
string field,
|
||
string source,
|
||
List<double>? point)
|
||
{
|
||
if (point is not { Count: >= 2 })
|
||
return;
|
||
|
||
details[field] = point;
|
||
details[$"{field}_source_property"] = source;
|
||
}
|
||
|
||
static void EnsureSplineEndpoint(
|
||
Dictionary<string, object?> details,
|
||
string name,
|
||
List<double> fitPoints,
|
||
List<double> controlPoints,
|
||
bool takeFirst)
|
||
{
|
||
if (details.TryGetValue(name, out var value) && DoubleList(value).Count >= 2)
|
||
return;
|
||
|
||
var point = EndpointFromFlatPoints(fitPoints, takeFirst);
|
||
if (point.Count < 2)
|
||
point = EndpointFromFlatPoints(controlPoints, takeFirst);
|
||
if (point.Count >= 2)
|
||
details[name] = point;
|
||
}
|
||
|
||
static List<double> EndpointFromFlatPoints(List<double> values, bool takeFirst)
|
||
{
|
||
if (values.Count < 2)
|
||
return new List<double>();
|
||
|
||
var stride = values.Count % 3 == 0 ? 3 : 2;
|
||
if (values.Count < stride)
|
||
return new List<double>();
|
||
|
||
var index = takeFirst ? 0 : values.Count - stride;
|
||
return new List<double> { values[index], values[index + 1] };
|
||
}
|
||
|
||
static List<double> DoubleList(object? value)
|
||
{
|
||
if (value == null)
|
||
return new List<double>();
|
||
if (value is List<double> list)
|
||
return list;
|
||
if (value is double[] doubles)
|
||
return doubles.ToList();
|
||
if (value is object[] objects)
|
||
return objects.Select(ToDouble).Where(item => item != null).Select(item => item!.Value).ToList();
|
||
if (value is Array array)
|
||
{
|
||
var result = new List<double>();
|
||
foreach (var item in array)
|
||
{
|
||
if (ToDouble(item) is { } number)
|
||
result.Add(number);
|
||
}
|
||
return result;
|
||
}
|
||
return new List<double>();
|
||
}
|
||
|
||
static List<double> ReadPolylineBulges(object entity, int coordinateCount)
|
||
{
|
||
var result = new List<double>();
|
||
var vertexCount = coordinateCount % 3 == 0 ? coordinateCount / 3 : coordinateCount / 2;
|
||
for (var i = 0; i < Math.Max(0, vertexCount); i++)
|
||
{
|
||
var bulge = ToDouble(TryInvoke(entity, "GetBulge", [i])) ?? 0.0;
|
||
result.Add(bulge);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
static Dictionary<string, object?> Merge(Dictionary<string, object?> common, Dictionary<string, object?> details)
|
||
{
|
||
var result = new Dictionary<string, object?>(common, StringComparer.OrdinalIgnoreCase);
|
||
foreach (var item in details)
|
||
result[item.Key] = item.Value;
|
||
return result;
|
||
}
|
||
|
||
static string ReadString(object obj, string name) => Convert.ToString(GetProperty(obj, name), CultureInfo.InvariantCulture) ?? "";
|
||
|
||
static int? ToInt(object? value)
|
||
{
|
||
try { return value == null ? null : Convert.ToInt32(value, CultureInfo.InvariantCulture); }
|
||
catch { return null; }
|
||
}
|
||
|
||
static double? ToDouble(object? value)
|
||
{
|
||
try { return value == null ? null : Convert.ToDouble(value, CultureInfo.InvariantCulture); }
|
||
catch { return null; }
|
||
}
|
||
|
||
static bool? ToBool(object? value)
|
||
{
|
||
try { return value == null ? null : Convert.ToBoolean(value, CultureInfo.InvariantCulture); }
|
||
catch { return null; }
|
||
}
|
||
|
||
static void ReleaseCom(object obj)
|
||
{
|
||
try
|
||
{
|
||
if (Marshal.IsComObject(obj))
|
||
Marshal.FinalReleaseComObject(obj);
|
||
}
|
||
catch
|
||
{
|
||
// Best effort.
|
||
}
|
||
}
|
||
|
||
static object? TryGetActiveComObject(string progId)
|
||
{
|
||
try
|
||
{
|
||
var hr = CLSIDFromProgID(progId, out var clsid);
|
||
if (hr < 0)
|
||
Marshal.ThrowExceptionForHR(hr);
|
||
return GetActiveObject(ref clsid, IntPtr.Zero);
|
||
}
|
||
catch
|
||
{
|
||
return null;
|
||
}
|
||
}
|
||
|
||
[DllImport("ole32.dll", CharSet = CharSet.Unicode)]
|
||
static extern int CLSIDFromProgID(string progId, out Guid clsid);
|
||
|
||
[DllImport("oleaut32.dll", PreserveSig = false)]
|
||
[return: MarshalAs(UnmanagedType.Interface)]
|
||
static extern object GetActiveObject(ref Guid clsid, IntPtr reserved);
|
||
}
|
||
|
||
sealed record SectionSymbol(
|
||
string Label,
|
||
string MatchedText,
|
||
string FullText,
|
||
BoundingBox Box,
|
||
Dictionary<string, object?> Annotation)
|
||
{
|
||
public Dictionary<string, object?> ToDictionary()
|
||
{
|
||
return new Dictionary<string, object?>
|
||
{
|
||
["label"] = Label,
|
||
["matched_text"] = MatchedText,
|
||
["full_text"] = FullText,
|
||
["bbox"] = Box.ToDictionary(),
|
||
["handle"] = Annotation.TryGetValue("handle", out var handle) ? handle : null,
|
||
["object_name"] = Annotation.TryGetValue("object_name", out var objectName) ? objectName : null,
|
||
["layer"] = Annotation.TryGetValue("layer", out var layer) ? layer : null
|
||
};
|
||
}
|
||
}
|
||
|
||
sealed record ViewRegion(HashSet<PrimitiveNode> Nodes, BoundingBox Box, List<string> Handles);
|
||
|
||
sealed class CliOptions
|
||
{
|
||
public string DrawingPath { get; set; } = "";
|
||
public string OutputDir { get; set; } = Path.Combine(Environment.CurrentDirectory, "runtime", "dwg-draft", "latest-extraction");
|
||
public string ProgId { get; set; } = "AutoCAD.Application.23.1";
|
||
public bool Visible { get; set; } = true;
|
||
public bool CloseAfterExtract { get; set; }
|
||
public int MaxEntities { get; set; } = 100_000;
|
||
public string MainViewSeedMode { get; set; } = "upper-left";
|
||
public string MainViewReferenceSelectionPath { get; set; } = "";
|
||
public string SaveMainViewOnlyDwgPath { get; set; } = "";
|
||
public string SectionViewProbeDirection { get; set; } = "down";
|
||
public string ReuseExtractionDir { get; set; } = "";
|
||
public bool AllowStartAutoCad { get; set; }
|
||
|
||
public static CliOptions Parse(string[] args)
|
||
{
|
||
var options = new CliOptions();
|
||
for (var i = 0; i < args.Length; i++)
|
||
{
|
||
var key = args[i];
|
||
var value = i + 1 < args.Length ? args[i + 1] : "";
|
||
switch (key)
|
||
{
|
||
case "--drawing-path":
|
||
options.DrawingPath = Path.GetFullPath(value.Trim().Trim('"'));
|
||
i++;
|
||
break;
|
||
case "--output-dir":
|
||
options.OutputDir = Path.GetFullPath(value.Trim().Trim('"'));
|
||
i++;
|
||
break;
|
||
case "--prog-id":
|
||
options.ProgId = value;
|
||
i++;
|
||
break;
|
||
case "--visible":
|
||
options.Visible = bool.TryParse(value, out var visible) ? visible : options.Visible;
|
||
i++;
|
||
break;
|
||
case "--close-after-extract":
|
||
options.CloseAfterExtract = bool.TryParse(value, out var close) && close;
|
||
i++;
|
||
break;
|
||
case "--max-entities":
|
||
options.MaxEntities = int.TryParse(value, out var max) ? max : options.MaxEntities;
|
||
i++;
|
||
break;
|
||
case "--main-view-seed-mode":
|
||
options.MainViewSeedMode = value.Trim();
|
||
i++;
|
||
break;
|
||
case "--main-view-reference-selection":
|
||
options.MainViewReferenceSelectionPath = Path.GetFullPath(value.Trim().Trim('"'));
|
||
i++;
|
||
break;
|
||
case "--save-main-view-only-dwg-path":
|
||
options.SaveMainViewOnlyDwgPath = Path.GetFullPath(value.Trim().Trim('"'));
|
||
i++;
|
||
break;
|
||
case "--section-view-probe-direction":
|
||
options.SectionViewProbeDirection = NormalizeSectionViewProbeDirection(value);
|
||
i++;
|
||
break;
|
||
case "--reuse-extraction-dir":
|
||
options.ReuseExtractionDir = Path.GetFullPath(value.Trim().Trim('"'));
|
||
i++;
|
||
break;
|
||
case "--allow-start-autocad":
|
||
options.AllowStartAutoCad = bool.TryParse(value, out var allowStart) && allowStart;
|
||
i++;
|
||
break;
|
||
}
|
||
}
|
||
return options;
|
||
}
|
||
|
||
static string NormalizeSectionViewProbeDirection(string value)
|
||
{
|
||
var direction = value.Trim();
|
||
if (string.Equals(direction, "up", StringComparison.OrdinalIgnoreCase))
|
||
return "up";
|
||
if (string.Equals(direction, "down", StringComparison.OrdinalIgnoreCase))
|
||
return "down";
|
||
throw new ArgumentException($"--section-view-probe-direction only supports up/down: {value}");
|
||
}
|
||
}
|
||
|
||
readonly record struct DeleteResult(int DeletedCount);
|
||
|
||
sealed record SplineEndpoint(List<double> Start, List<double> End, string Source);
|
||
|
||
sealed record DimensionDefinitionPoints(
|
||
List<double>? Group13,
|
||
List<double>? Group14,
|
||
List<double>? Group10,
|
||
List<double>? Group11,
|
||
List<double>? Group15,
|
||
List<double>? Group16);
|
||
|
||
static class StaRunner
|
||
{
|
||
public static T Run<T>(Func<T> action)
|
||
{
|
||
T? result = default;
|
||
Exception? error = null;
|
||
var thread = new Thread(() =>
|
||
{
|
||
try { result = action(); }
|
||
catch (Exception ex) { error = ex; }
|
||
});
|
||
thread.SetApartmentState(ApartmentState.STA);
|
||
thread.Start();
|
||
thread.Join();
|
||
if (error != null)
|
||
throw error;
|
||
return result!;
|
||
}
|
||
}
|
||
|
||
static class JsonDefaults
|
||
{
|
||
public static JsonSerializerOptions Options { get; } = new()
|
||
{
|
||
WriteIndented = true,
|
||
PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
|
||
DictionaryKeyPolicy = JsonNamingPolicy.SnakeCaseLower
|
||
};
|
||
}
|
||
|
||
sealed class DocumentExtraction
|
||
{
|
||
public int ModelSpaceCount { get; set; }
|
||
public int PaperSpaceCount { get; set; }
|
||
public Dictionary<string, int> TypeCounts { get; set; } = new(StringComparer.OrdinalIgnoreCase);
|
||
public List<Dictionary<string, object?>> EntitiesCommon { get; set; } = new();
|
||
public List<Dictionary<string, object?>> Geometry { get; set; } = new();
|
||
public List<Dictionary<string, object?>> NormalizedGeometry { get; set; } = new();
|
||
public List<Dictionary<string, object?>> MergedLines { get; set; } = new();
|
||
public List<Dictionary<string, object?>> GeometryOverlaps { get; set; } = new();
|
||
public Dictionary<string, object?> NormalizationSummary { get; set; } = new(StringComparer.OrdinalIgnoreCase);
|
||
public List<Dictionary<string, object?>> MainViewGeometry { get; set; } = new();
|
||
public List<Dictionary<string, object?>> MainViewNormalizedGeometry { get; set; } = new();
|
||
public List<Dictionary<string, object?>> MainViewMergedLines { get; set; } = new();
|
||
public List<Dictionary<string, object?>> MainViewOverlaps { get; set; } = new();
|
||
public Dictionary<string, object?> MainViewSignature { get; set; } = new(StringComparer.OrdinalIgnoreCase);
|
||
public Dictionary<string, object?> BottomViewSignature { get; set; } = new(StringComparer.OrdinalIgnoreCase);
|
||
public List<Dictionary<string, object?>> SectionCutSymbols { get; set; } = new();
|
||
public Dictionary<string, object?> MainViewSelection { get; set; } = new(StringComparer.OrdinalIgnoreCase);
|
||
public Dictionary<string, object?> ViewRegions { get; set; } = new(StringComparer.OrdinalIgnoreCase);
|
||
public List<Dictionary<string, object?>> Annotations { get; set; } = new();
|
||
public List<Dictionary<string, object?>> Dimensions { get; set; } = new();
|
||
public List<Dictionary<string, object?>> DimensionalTolerances { get; set; } = new();
|
||
public List<Dictionary<string, object?>> Roughness { get; set; } = new();
|
||
public List<Dictionary<string, object?>> GeometricTolerances { get; set; } = new();
|
||
public List<Dictionary<string, object?>> Datums { get; set; } = new();
|
||
public List<Dictionary<string, object?>> UnknownEntities { get; set; } = new();
|
||
}
|
||
|
||
sealed class ExtractionResult
|
||
{
|
||
public bool Ok { get; set; }
|
||
public string Source { get; set; } = "";
|
||
public string ProgId { get; set; } = "";
|
||
public bool Started { get; set; }
|
||
public string DrawingPath { get; set; } = "";
|
||
public string ExportDir { get; set; } = "";
|
||
public string ManifestPath { get; set; } = "";
|
||
public int EntityCount { get; set; }
|
||
public Dictionary<string, int> TypeCounts { get; set; } = new(StringComparer.OrdinalIgnoreCase);
|
||
public List<CategoryFile> CategoryFiles { get; set; } = new();
|
||
public string Message { get; set; } = "";
|
||
}
|
||
|
||
sealed class Manifest
|
||
{
|
||
public bool Ok { get; set; }
|
||
public string Schema { get; set; } = "";
|
||
public string Source { get; set; } = "";
|
||
public string ProgId { get; set; } = "";
|
||
public bool StartedAutoCad { get; set; }
|
||
public string DrawingPath { get; set; } = "";
|
||
public DateTime ExportedAtUtc { get; set; }
|
||
public int ModelSpaceCount { get; set; }
|
||
public int PaperSpaceCount { get; set; }
|
||
public int EntityCount { get; set; }
|
||
public Dictionary<string, int> TypeCounts { get; set; } = new(StringComparer.OrdinalIgnoreCase);
|
||
public List<CategoryFile> CategoryFiles { get; set; } = new();
|
||
}
|
||
|
||
sealed class CategoryFile
|
||
{
|
||
public string Category { get; set; } = "";
|
||
public string File { get; set; } = "";
|
||
public string FullPath { get; set; } = "";
|
||
public int ItemCount { get; set; }
|
||
public bool Exists { get; set; }
|
||
}
|
||
|
||
sealed class LinePrimitive
|
||
{
|
||
public int Index { get; init; }
|
||
public string Handle { get; init; } = "";
|
||
public string Layer { get; init; } = "";
|
||
public string Linetype { get; init; } = "";
|
||
public int? Color { get; init; }
|
||
public int? Lineweight { get; init; }
|
||
public string StyleKey { get; init; } = "";
|
||
public Dictionary<string, object?> Style { get; init; } = new(StringComparer.OrdinalIgnoreCase);
|
||
public List<string> SourceHandles { get; init; } = new();
|
||
public double StartX { get; init; }
|
||
public double StartY { get; init; }
|
||
public double EndX { get; init; }
|
||
public double EndY { get; init; }
|
||
public double Ux { get; init; }
|
||
public double Uy { get; init; }
|
||
public double Nx { get; init; }
|
||
public double Ny { get; init; }
|
||
public double T0 { get; init; }
|
||
public double T1 { get; init; }
|
||
public double Offset { get; init; }
|
||
public double Length { get; init; }
|
||
public double AngleDeg { get; init; }
|
||
|
||
public static LinePrimitive? FromDictionary(Dictionary<string, object?> item)
|
||
{
|
||
var start = ReadPoint(item, "start");
|
||
var end = ReadPoint(item, "end");
|
||
if (start.Count < 2 || end.Count < 2)
|
||
return null;
|
||
|
||
var dx = end[0] - start[0];
|
||
var dy = end[1] - start[1];
|
||
var length = Math.Sqrt(dx * dx + dy * dy);
|
||
if (length <= 1e-9)
|
||
return null;
|
||
|
||
var ux = dx / length;
|
||
var uy = dy / length;
|
||
var nx = -uy;
|
||
var ny = ux;
|
||
var angle = NormalizeAngleDeg(Math.Atan2(dy, dx) * 180.0 / Math.PI);
|
||
var handles = ReadStringList(item, "source_handles");
|
||
var handle = ReadString(item, "handle");
|
||
if (handles.Count == 0 && !string.IsNullOrWhiteSpace(handle))
|
||
handles.Add(handle);
|
||
|
||
return new LinePrimitive
|
||
{
|
||
Index = ReadInt(item, "index") ?? 0,
|
||
Handle = handle,
|
||
Layer = ReadString(item, "layer"),
|
||
Linetype = ReadString(item, "linetype"),
|
||
Color = ReadInt(item, "color"),
|
||
Lineweight = ReadInt(item, "lineweight"),
|
||
StyleKey = ReadString(item, "style_key"),
|
||
Style = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase)
|
||
{
|
||
["space"] = ReadString(item, "space"),
|
||
["layer"] = ReadString(item, "layer"),
|
||
["linetype"] = ReadString(item, "linetype"),
|
||
["color"] = ReadInt(item, "color"),
|
||
["lineweight"] = ReadInt(item, "lineweight")
|
||
},
|
||
SourceHandles = handles,
|
||
StartX = start[0],
|
||
StartY = start[1],
|
||
EndX = end[0],
|
||
EndY = end[1],
|
||
Ux = ux,
|
||
Uy = uy,
|
||
Nx = nx,
|
||
Ny = ny,
|
||
T0 = start[0] * ux + start[1] * uy,
|
||
T1 = end[0] * ux + end[1] * uy,
|
||
Offset = start[0] * nx + start[1] * ny,
|
||
Length = length,
|
||
AngleDeg = angle
|
||
};
|
||
}
|
||
|
||
public double SignedDistanceToLine(double x, double y) => x * Nx + y * Ny - Offset;
|
||
|
||
public List<double> PointAt(double t)
|
||
{
|
||
return new List<double> { Ux * t + Nx * Offset, Uy * t + Ny * Offset };
|
||
}
|
||
|
||
static double NormalizeAngleDeg(double angle)
|
||
{
|
||
angle %= 180.0;
|
||
if (angle < 0)
|
||
angle += 180.0;
|
||
return angle;
|
||
}
|
||
|
||
static List<double> ReadPoint(Dictionary<string, object?> item, string key)
|
||
{
|
||
if (!item.TryGetValue(key, out var value) || value is not IEnumerable<object> objects)
|
||
{
|
||
if (value is IEnumerable<double> doubles)
|
||
return doubles.ToList();
|
||
return new List<double>();
|
||
}
|
||
|
||
return objects
|
||
.Select(value => value == null ? (double?)null : Convert.ToDouble(value, CultureInfo.InvariantCulture))
|
||
.Where(value => value != null)
|
||
.Select(value => value!.Value)
|
||
.ToList();
|
||
}
|
||
|
||
static string ReadString(Dictionary<string, object?> item, string key)
|
||
{
|
||
return item.TryGetValue(key, out var value) ? Convert.ToString(value, CultureInfo.InvariantCulture) ?? "" : "";
|
||
}
|
||
|
||
static int? ReadInt(Dictionary<string, object?> item, string key)
|
||
{
|
||
try
|
||
{
|
||
return item.TryGetValue(key, out var value) && value != null
|
||
? Convert.ToInt32(value, CultureInfo.InvariantCulture)
|
||
: null;
|
||
}
|
||
catch
|
||
{
|
||
return null;
|
||
}
|
||
}
|
||
|
||
static List<string> ReadStringList(Dictionary<string, object?> item, string key)
|
||
{
|
||
if (!item.TryGetValue(key, out var value) || value == null)
|
||
return new List<string>();
|
||
if (value is IEnumerable<string> strings)
|
||
return strings.Where(text => !string.IsNullOrWhiteSpace(text)).ToList();
|
||
if (value is IEnumerable<object> objects)
|
||
return objects.Select(obj => Convert.ToString(obj, CultureInfo.InvariantCulture) ?? "").Where(text => !string.IsNullOrWhiteSpace(text)).ToList();
|
||
return new List<string>();
|
||
}
|
||
}
|
||
|
||
sealed record LineInterval(LinePrimitive Line, double Start, double End);
|
||
|
||
sealed record NormalizedGeometrySet(
|
||
List<Dictionary<string, object?>> Normalized,
|
||
List<Dictionary<string, object?>> MergedLines,
|
||
List<Dictionary<string, object?>> Overlaps,
|
||
Dictionary<string, object?> Summary);
|
||
|
||
sealed class PrimitiveNode
|
||
{
|
||
public string Source { get; init; } = "";
|
||
public string Kind { get; init; } = "";
|
||
public Dictionary<string, object?> Data { get; init; } = new(StringComparer.OrdinalIgnoreCase);
|
||
public BoundingBox Box { get; init; }
|
||
public List<string> SourceHandles { get; init; } = new();
|
||
public List<List<double>> AnchorPoints { get; init; } = new();
|
||
|
||
public static PrimitiveNode? FromRawGeometry(Dictionary<string, object?> item)
|
||
{
|
||
var objectName = ReadString(item, "object_name");
|
||
var handle = ReadString(item, "handle");
|
||
var kind = RawKind(objectName);
|
||
var box = TryReadRawBox(item, kind);
|
||
if (box == null)
|
||
return null;
|
||
|
||
return new PrimitiveNode
|
||
{
|
||
Source = "raw-geometry",
|
||
Kind = kind,
|
||
Data = item,
|
||
Box = box.Value,
|
||
SourceHandles = string.IsNullOrWhiteSpace(handle) ? new List<string>() : new List<string> { handle },
|
||
AnchorPoints = ReadRawAnchorPoints(item, kind, box.Value)
|
||
};
|
||
}
|
||
|
||
public static PrimitiveNode? FromDictionary(Dictionary<string, object?> item)
|
||
{
|
||
var kind = ReadString(item, "kind");
|
||
var box = TryReadBox(item, kind);
|
||
if (box == null)
|
||
return null;
|
||
|
||
return new PrimitiveNode
|
||
{
|
||
Source = item.ContainsKey("merge_type") ? "merged-line" : "normalized-geometry",
|
||
Kind = kind,
|
||
Data = item,
|
||
Box = box.Value,
|
||
SourceHandles = ReadStringList(item, "source_handles"),
|
||
AnchorPoints = ReadAnchorPoints(item, kind)
|
||
};
|
||
}
|
||
|
||
static string RawKind(string objectName)
|
||
{
|
||
if (objectName.Contains("Polyline", StringComparison.OrdinalIgnoreCase))
|
||
return "polyline";
|
||
if (objectName.Contains("Circle", StringComparison.OrdinalIgnoreCase))
|
||
return "circle";
|
||
if (objectName.Contains("Arc", StringComparison.OrdinalIgnoreCase))
|
||
return "arc";
|
||
if (objectName.Contains("Spline", StringComparison.OrdinalIgnoreCase))
|
||
return "spline";
|
||
if (objectName.Contains("Line", StringComparison.OrdinalIgnoreCase))
|
||
return "line";
|
||
if (objectName.Contains("Hatch", StringComparison.OrdinalIgnoreCase))
|
||
return "hatch";
|
||
return "geometry";
|
||
}
|
||
|
||
static BoundingBox? TryReadRawBox(Dictionary<string, object?> item, string kind)
|
||
{
|
||
if (TryReadEntityBox(item, "bbox") is { } entityBox)
|
||
return entityBox;
|
||
|
||
if (string.Equals(kind, "line", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var start = ReadPoint(item, "start");
|
||
var end = ReadPoint(item, "end");
|
||
return BoundingBox.FromPoints(new[] { start, end });
|
||
}
|
||
|
||
if (string.Equals(kind, "polyline", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var coordinates = ReadDoubleList(item, "coordinates");
|
||
var stride = coordinates.Count % 3 == 0 ? 3 : 2;
|
||
var points = new List<List<double>>();
|
||
for (var i = 0; i + stride - 1 < coordinates.Count; i += stride)
|
||
points.Add(new List<double> { coordinates[i], coordinates[i + 1] });
|
||
return BoundingBox.FromPoints(points);
|
||
}
|
||
|
||
if (string.Equals(kind, "circle", StringComparison.OrdinalIgnoreCase) ||
|
||
string.Equals(kind, "arc", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var center = ReadPoint(item, "center");
|
||
var radius = ReadDouble(item, "radius");
|
||
if (center.Count < 2 || radius == null)
|
||
return BoundingBox.FromPoints(new[] { ReadPoint(item, "start"), ReadPoint(item, "end") });
|
||
return new BoundingBox(center[0] - radius.Value, center[1] - radius.Value, center[0] + radius.Value, center[1] + radius.Value);
|
||
}
|
||
|
||
if (string.Equals(kind, "spline", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
return BoundingBox.FromPoints(new[] { ReadPoint(item, "start"), ReadPoint(item, "end") });
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
static BoundingBox? TryReadEntityBox(Dictionary<string, object?> item, string key)
|
||
{
|
||
if (!item.TryGetValue(key, out var value) || value == null)
|
||
return null;
|
||
if (value is Dictionary<string, object?> dict)
|
||
{
|
||
var minX = ReadDouble(dict, "min_x");
|
||
var minY = ReadDouble(dict, "min_y");
|
||
var maxX = ReadDouble(dict, "max_x");
|
||
var maxY = ReadDouble(dict, "max_y");
|
||
if (minX != null && minY != null && maxX != null && maxY != null)
|
||
return new BoundingBox(minX.Value, minY.Value, maxX.Value, maxY.Value);
|
||
}
|
||
return null;
|
||
}
|
||
|
||
static List<List<double>> ReadRawAnchorPoints(Dictionary<string, object?> item, string kind, BoundingBox box)
|
||
{
|
||
var points = new List<List<double>>();
|
||
if (string.Equals(kind, "polyline", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var coordinates = ReadDoubleList(item, "coordinates");
|
||
var stride = coordinates.Count % 3 == 0 ? 3 : 2;
|
||
for (var i = 0; i + stride - 1 < coordinates.Count; i += stride)
|
||
points.Add(new List<double> { coordinates[i], coordinates[i + 1] });
|
||
}
|
||
else
|
||
{
|
||
foreach (var key in new[] { "start", "end", "center" })
|
||
{
|
||
var point = ReadPoint(item, key);
|
||
if (point.Count >= 2)
|
||
points.Add(point);
|
||
}
|
||
}
|
||
|
||
if (points.Count == 0)
|
||
points.Add(new List<double> { box.CenterX, box.CenterY });
|
||
|
||
return points;
|
||
}
|
||
|
||
static BoundingBox? TryReadBox(Dictionary<string, object?> item, string kind)
|
||
{
|
||
if (string.Equals(kind, "line", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var start = ReadPoint(item, "start");
|
||
var end = ReadPoint(item, "end");
|
||
return BoundingBox.FromPoints(new[] { start, end });
|
||
}
|
||
|
||
if (string.Equals(kind, "circle", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var center = ReadPoint(item, "center");
|
||
var radius = ReadDouble(item, "radius");
|
||
if (center.Count < 2 || radius == null)
|
||
return null;
|
||
return new BoundingBox(center[0] - radius.Value, center[1] - radius.Value, center[0] + radius.Value, center[1] + radius.Value);
|
||
}
|
||
|
||
if (string.Equals(kind, "arc", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var points = new List<List<double>>
|
||
{
|
||
ReadPoint(item, "start"),
|
||
ReadPoint(item, "end")
|
||
}.Where(point => point.Count >= 2).ToList();
|
||
|
||
var center = ReadPoint(item, "center");
|
||
var radius = ReadDouble(item, "radius");
|
||
if (center.Count >= 2 && radius != null)
|
||
return new BoundingBox(center[0] - radius.Value, center[1] - radius.Value, center[0] + radius.Value, center[1] + radius.Value);
|
||
|
||
return BoundingBox.FromPoints(points);
|
||
}
|
||
|
||
if (string.Equals(kind, "spline", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var start = ReadPoint(item, "start");
|
||
var end = ReadPoint(item, "end");
|
||
return BoundingBox.FromPoints(new[] { start, end });
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
static List<List<double>> ReadAnchorPoints(Dictionary<string, object?> item, string kind)
|
||
{
|
||
var points = new List<List<double>>();
|
||
foreach (var key in new[] { "start", "end", "center" })
|
||
{
|
||
var point = ReadPoint(item, key);
|
||
if (point.Count >= 2)
|
||
points.Add(point);
|
||
}
|
||
|
||
if (points.Count == 0)
|
||
{
|
||
var box = TryReadBox(item, kind);
|
||
if (box != null)
|
||
points.Add(new List<double> { box.Value.CenterX, box.Value.CenterY });
|
||
}
|
||
|
||
return points;
|
||
}
|
||
|
||
static List<double> ReadPoint(Dictionary<string, object?> item, string key)
|
||
{
|
||
if (!item.TryGetValue(key, out var value) || value == null)
|
||
return new List<double>();
|
||
if (value is IEnumerable<double> doubles)
|
||
return doubles.ToList();
|
||
if (value is IEnumerable<object> objects)
|
||
{
|
||
return objects
|
||
.Select(obj => obj == null ? (double?)null : Convert.ToDouble(obj, CultureInfo.InvariantCulture))
|
||
.Where(value => value != null)
|
||
.Select(value => value!.Value)
|
||
.ToList();
|
||
}
|
||
return new List<double>();
|
||
}
|
||
|
||
static string ReadString(Dictionary<string, object?> item, string key)
|
||
{
|
||
return item.TryGetValue(key, out var value) ? Convert.ToString(value, CultureInfo.InvariantCulture) ?? "" : "";
|
||
}
|
||
|
||
static double? ReadDouble(Dictionary<string, object?> item, string key)
|
||
{
|
||
try
|
||
{
|
||
return item.TryGetValue(key, out var value) && value != null
|
||
? Convert.ToDouble(value, CultureInfo.InvariantCulture)
|
||
: null;
|
||
}
|
||
catch
|
||
{
|
||
return null;
|
||
}
|
||
}
|
||
|
||
static List<double> ReadDoubleList(Dictionary<string, object?> item, string key)
|
||
{
|
||
if (!item.TryGetValue(key, out var value) || value == null)
|
||
return new List<double>();
|
||
if (value is IEnumerable<double> doubles)
|
||
return doubles.ToList();
|
||
if (value is IEnumerable<object> objects)
|
||
{
|
||
return objects
|
||
.Select(obj => obj == null ? (double?)null : Convert.ToDouble(obj, CultureInfo.InvariantCulture))
|
||
.Where(value => value != null)
|
||
.Select(value => value!.Value)
|
||
.ToList();
|
||
}
|
||
return new List<double>();
|
||
}
|
||
|
||
static List<string> ReadStringList(Dictionary<string, object?> item, string key)
|
||
{
|
||
if (!item.TryGetValue(key, out var value) || value == null)
|
||
return new List<string>();
|
||
if (value is IEnumerable<string> strings)
|
||
return strings.Where(text => !string.IsNullOrWhiteSpace(text)).ToList();
|
||
if (value is IEnumerable<object> objects)
|
||
return objects.Select(obj => Convert.ToString(obj, CultureInfo.InvariantCulture) ?? "").Where(text => !string.IsNullOrWhiteSpace(text)).ToList();
|
||
return new List<string>();
|
||
}
|
||
}
|
||
|
||
readonly record struct BoundingBox(double MinX, double MinY, double MaxX, double MaxY)
|
||
{
|
||
public double Width => MaxX - MinX;
|
||
public double Height => MaxY - MinY;
|
||
public double CenterX => (MinX + MaxX) / 2.0;
|
||
public double CenterY => (MinY + MaxY) / 2.0;
|
||
|
||
public static BoundingBox? FromPoints(IEnumerable<List<double>> points)
|
||
{
|
||
var valid = points.Where(point => point.Count >= 2).ToList();
|
||
if (valid.Count == 0)
|
||
return null;
|
||
return new BoundingBox(
|
||
valid.Min(point => point[0]),
|
||
valid.Min(point => point[1]),
|
||
valid.Max(point => point[0]),
|
||
valid.Max(point => point[1]));
|
||
}
|
||
|
||
public static BoundingBox Union(IEnumerable<BoundingBox> boxes)
|
||
{
|
||
var list = boxes.ToList();
|
||
if (list.Count == 0)
|
||
return new BoundingBox(0, 0, 0, 0);
|
||
return new BoundingBox(
|
||
list.Min(box => box.MinX),
|
||
list.Min(box => box.MinY),
|
||
list.Max(box => box.MaxX),
|
||
list.Max(box => box.MaxY));
|
||
}
|
||
|
||
public BoundingBox Expand(double value) => new(MinX - value, MinY - value, MaxX + value, MaxY + value);
|
||
|
||
public bool Contains(double x, double y) => x >= MinX && x <= MaxX && y >= MinY && y <= MaxY;
|
||
|
||
public bool ContainsBox(BoundingBox other) =>
|
||
other.MinX >= MinX &&
|
||
other.MaxX <= MaxX &&
|
||
other.MinY >= MinY &&
|
||
other.MaxY <= MaxY;
|
||
|
||
public double DistanceTo(BoundingBox other)
|
||
{
|
||
var dx = Math.Max(0.0, Math.Max(other.MinX - MaxX, MinX - other.MaxX));
|
||
var dy = Math.Max(0.0, Math.Max(other.MinY - MaxY, MinY - other.MaxY));
|
||
return Math.Sqrt(dx * dx + dy * dy);
|
||
}
|
||
|
||
public Dictionary<string, object?> ToDictionary()
|
||
{
|
||
return new Dictionary<string, object?>
|
||
{
|
||
["min_x"] = MinX,
|
||
["min_y"] = MinY,
|
||
["max_x"] = MaxX,
|
||
["max_y"] = MaxY,
|
||
["center_x"] = CenterX,
|
||
["center_y"] = CenterY
|
||
};
|
||
}
|
||
}
|