1535 lines
57 KiB
C#
1535 lines
57 KiB
C#
using System.Globalization;
|
||
using System.Diagnostics;
|
||
using System.Reflection;
|
||
using System.Runtime.InteropServices;
|
||
using System.Text;
|
||
using System.Text.Json;
|
||
using System.Text.RegularExpressions;
|
||
using Microsoft.Win32;
|
||
|
||
static class DwgDraftApi
|
||
{
|
||
public static IServiceCollection AddDwgDraft(this IServiceCollection services)
|
||
{
|
||
services.AddSingleton<DwgDraftService>();
|
||
return services;
|
||
}
|
||
|
||
public static WebApplication MapDwgDraftApi(this WebApplication app)
|
||
{
|
||
var group = app.MapGroup("/api/dwg-draft");
|
||
|
||
group.MapGet("/installation", (DwgDraftService dwg) => Results.Ok(dwg.DiscoverInstallation()));
|
||
group.MapGet("/bridge", (DwgDraftService dwg) => Results.Ok(dwg.ReadBridgeStatus()));
|
||
|
||
group.MapPost("/extract", (DwgDraftExtractRequest request, DwgDraftService dwg) =>
|
||
{
|
||
try
|
||
{
|
||
return Results.Ok(dwg.Extract(request));
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return Results.Problem($"AutoCAD DWG 提取失败：{ex.Message}", statusCode: 500);
|
||
}
|
||
});
|
||
|
||
group.MapPost("/open", (DwgDraftExtractRequest request, DwgDraftService dwg) =>
|
||
{
|
||
try
|
||
{
|
||
return Results.Ok(dwg.Extract(request));
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return Results.Problem($"AutoCAD DWG 打开/提取失败：{ex.Message}", statusCode: 500);
|
||
}
|
||
});
|
||
|
||
group.MapGet("/latest-extraction", (DwgDraftService dwg) =>
|
||
{
|
||
try
|
||
{
|
||
return Results.Ok(dwg.ReadLatestExtraction());
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return Results.Problem($"读取 DWG 提取结果失败：{ex.Message}", statusCode: 500);
|
||
}
|
||
});
|
||
|
||
group.MapGet("/latest-extraction/category/{category}", (string category, DwgDraftService dwg) =>
|
||
{
|
||
try
|
||
{
|
||
var result = dwg.ReadCategoryExtraction(category);
|
||
return result.Found ? Results.Ok(result) : Results.NotFound(result);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
return Results.Problem($"读取 DWG 分类提取结果失败：{ex.Message}", statusCode: 500);
|
||
}
|
||
});
|
||
|
||
return app;
|
||
}
|
||
}
|
||
|
||
sealed class DwgDraftService
|
||
{
|
||
const string DefaultProgId = "AutoCAD.Application.23.1";
|
||
static readonly JsonSerializerOptions JsonOptions = new()
|
||
{
|
||
WriteIndented = true,
|
||
PropertyNamingPolicy = JsonNamingPolicy.SnakeCaseLower,
|
||
DictionaryKeyPolicy = JsonNamingPolicy.SnakeCaseLower
|
||
};
|
||
|
||
static readonly string[] ProgIdCandidates =
|
||
[
|
||
"AutoCAD.Application.23.1",
|
||
"AutoCAD.Application.23",
|
||
"AutoCAD.Application"
|
||
];
|
||
|
||
readonly AppPaths _paths;
|
||
readonly object _lock = new();
|
||
|
||
public DwgDraftService(AppPaths paths)
|
||
{
|
||
_paths = paths;
|
||
}
|
||
|
||
public DwgDraftInstallation DiscoverInstallation()
|
||
{
|
||
var progIds = Registry.ClassesRoot.GetSubKeyNames()
|
||
.Where(name => name.StartsWith("AutoCAD.Application", StringComparison.OrdinalIgnoreCase))
|
||
.OrderBy(name => name, StringComparer.OrdinalIgnoreCase)
|
||
.Select(ReadProgIdInfo)
|
||
.ToList();
|
||
|
||
var exeCandidates = new[]
|
||
{
|
||
@"D:\Program Files\Autodesk\AutoCAD 2020\acad.exe",
|
||
@"C:\Program Files\Autodesk\AutoCAD 2020\acad.exe",
|
||
@"C:\Program Files\Autodesk\AutoCAD 2021\acad.exe",
|
||
@"C:\Program Files\Autodesk\AutoCAD 2022\acad.exe"
|
||
};
|
||
|
||
return new DwgDraftInstallation
|
||
{
|
||
Found = progIds.Count > 0 || exeCandidates.Any(File.Exists),
|
||
DefaultProgId = DefaultProgId,
|
||
ProgIds = progIds,
|
||
AcadExeCandidates = exeCandidates.Where(File.Exists).ToList(),
|
||
Notes =
|
||
[
|
||
"DWG 通过 AutoCAD COM 读取，后续二维图查错以 AutoCAD 路径为主。",
|
||
"AutoCAD COM 调用可能在软件忙碌时返回 RPC_E_CALL_REJECTED，后端已对属性读取和集合遍历做重试。"
|
||
]
|
||
};
|
||
}
|
||
|
||
public DwgDraftBridgeStatus ReadBridgeStatus()
|
||
{
|
||
var bridgeDir = ResolveBridgeDir();
|
||
var heartbeatPath = Path.Combine(bridgeDir, "heartbeat.json");
|
||
var alive = IsBridgeAlive(heartbeatPath);
|
||
JsonElement? heartbeat = null;
|
||
if (File.Exists(heartbeatPath))
|
||
{
|
||
using var doc = JsonDocument.Parse(File.ReadAllText(heartbeatPath));
|
||
heartbeat = doc.RootElement.Clone();
|
||
}
|
||
|
||
return new DwgDraftBridgeStatus
|
||
{
|
||
Ok = true,
|
||
Alive = alive,
|
||
BridgeDir = bridgeDir,
|
||
HeartbeatPath = heartbeatPath,
|
||
LastWriteTimeUtc = File.Exists(heartbeatPath) ? File.GetLastWriteTimeUtc(heartbeatPath) : null,
|
||
Heartbeat = heartbeat,
|
||
Message = alive ? "AutoCAD DWG bridge is online." : "AutoCAD DWG bridge is not online."
|
||
};
|
||
}
|
||
|
||
public DwgDraftExtractionResult Extract(DwgDraftExtractRequest request)
|
||
{
|
||
lock (_lock)
|
||
{
|
||
return RunExternalExtractor(request);
|
||
}
|
||
}
|
||
|
||
DwgDraftExtractionResult RunExternalExtractor(DwgDraftExtractRequest request)
|
||
{
|
||
TraceExternalExtractor("start");
|
||
ApplyDrawingPathBase64(request);
|
||
if (string.IsNullOrWhiteSpace(request.DrawingPath))
|
||
throw new ArgumentException("drawing_path 不能为空。", nameof(request));
|
||
|
||
var drawingPath = Path.GetFullPath(request.DrawingPath.Trim().Trim('"'));
|
||
TraceExternalExtractor($"drawing_path={drawingPath}");
|
||
if (!File.Exists(drawingPath))
|
||
throw new FileNotFoundException($"DWG 文件不存在：{drawingPath}");
|
||
|
||
var progId = string.IsNullOrWhiteSpace(request.ProgId) ? ResolveProgId() : request.ProgId.Trim();
|
||
TraceExternalExtractor($"prog_id={progId}");
|
||
var outputDir = ResolveOutputDir(request.OutputDir);
|
||
Directory.CreateDirectory(outputDir);
|
||
TraceExternalExtractor($"output_dir={outputDir}");
|
||
|
||
var extractorDll = Path.Combine(
|
||
_paths.Agent4Root,
|
||
"tools",
|
||
"drawing-diagnostics",
|
||
"AutoCadDwgExtractor",
|
||
"bin",
|
||
"Debug",
|
||
"net10.0",
|
||
"AutoCadDwgExtractor.dll");
|
||
TraceExternalExtractor($"extractor_dll={extractorDll}; exists={File.Exists(extractorDll)}");
|
||
if (!File.Exists(extractorDll))
|
||
throw new FileNotFoundException($"AutoCAD DWG 提取器尚未编译：{extractorDll}");
|
||
|
||
if (request.UseBridge &&
|
||
TryRunBridgeExtractor(request, drawingPath, progId, outputDir, out var bridgeResult))
|
||
{
|
||
return bridgeResult;
|
||
}
|
||
|
||
var startInfo = new ProcessStartInfo
|
||
{
|
||
FileName = "dotnet",
|
||
WorkingDirectory = _paths.Agent4Root,
|
||
UseShellExecute = false,
|
||
RedirectStandardOutput = true,
|
||
RedirectStandardError = true
|
||
};
|
||
startInfo.ArgumentList.Add(extractorDll);
|
||
startInfo.ArgumentList.Add("--drawing-path");
|
||
startInfo.ArgumentList.Add(drawingPath);
|
||
startInfo.ArgumentList.Add("--output-dir");
|
||
startInfo.ArgumentList.Add(outputDir);
|
||
startInfo.ArgumentList.Add("--prog-id");
|
||
startInfo.ArgumentList.Add(progId);
|
||
startInfo.ArgumentList.Add("--visible");
|
||
startInfo.ArgumentList.Add(request.Visible ? "true" : "false");
|
||
startInfo.ArgumentList.Add("--close-after-extract");
|
||
startInfo.ArgumentList.Add(request.CloseAfterExtract ? "true" : "false");
|
||
startInfo.ArgumentList.Add("--max-entities");
|
||
startInfo.ArgumentList.Add((request.MaxEntities <= 0 ? 100_000 : request.MaxEntities).ToString(CultureInfo.InvariantCulture));
|
||
if (!string.IsNullOrWhiteSpace(request.MainViewSeedMode))
|
||
{
|
||
startInfo.ArgumentList.Add("--main-view-seed-mode");
|
||
startInfo.ArgumentList.Add(request.MainViewSeedMode.Trim());
|
||
}
|
||
if (!string.IsNullOrWhiteSpace(request.ReuseExtractionDir))
|
||
{
|
||
startInfo.ArgumentList.Add("--reuse-extraction-dir");
|
||
startInfo.ArgumentList.Add(Path.GetFullPath(request.ReuseExtractionDir.Trim().Trim('"')));
|
||
}
|
||
|
||
TraceExternalExtractor("process_start");
|
||
using var process = Process.Start(startInfo) ?? throw new InvalidOperationException("Failed to start AutoCadDwgExtractor.");
|
||
TraceExternalExtractor($"process_started pid={process.Id}");
|
||
var stdout = process.StandardOutput.ReadToEnd();
|
||
var stderr = process.StandardError.ReadToEnd();
|
||
process.WaitForExit();
|
||
TraceExternalExtractor($"process_exit exit_code={process.ExitCode}; stdout_len={stdout.Length}; stderr_len={stderr.Length}");
|
||
|
||
if (process.ExitCode != 0)
|
||
throw new InvalidOperationException($"AutoCadDwgExtractor failed. exit={process.ExitCode}\n{stdout}\n{stderr}");
|
||
|
||
var manifestPath = Path.Combine(outputDir, "manifest.json");
|
||
TraceExternalExtractor($"manifest={manifestPath}; exists={File.Exists(manifestPath)}");
|
||
if (!File.Exists(manifestPath))
|
||
throw new FileNotFoundException($"AutoCadDwgExtractor did not write manifest: {manifestPath}\n{stdout}\n{stderr}");
|
||
|
||
using var doc = JsonDocument.Parse(File.ReadAllText(manifestPath));
|
||
var root = doc.RootElement;
|
||
var entityCount = root.TryGetProperty("entity_count", out var countElement) && countElement.ValueKind == JsonValueKind.Number
|
||
? countElement.GetInt32()
|
||
: 0;
|
||
var typeCounts = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
|
||
if (root.TryGetProperty("type_counts", out var typeCountsElement) && typeCountsElement.ValueKind == JsonValueKind.Object)
|
||
{
|
||
foreach (var item in typeCountsElement.EnumerateObject())
|
||
{
|
||
if (item.Value.ValueKind == JsonValueKind.Number)
|
||
typeCounts[item.Name] = item.Value.GetInt32();
|
||
}
|
||
}
|
||
|
||
return new DwgDraftExtractionResult
|
||
{
|
||
Ok = true,
|
||
Source = "AutoCAD COM external extractor",
|
||
ProgId = progId,
|
||
Started = root.TryGetProperty("started_auto_cad", out var startedElement) && startedElement.ValueKind is JsonValueKind.True,
|
||
DrawingPath = drawingPath,
|
||
ExportDir = outputDir,
|
||
ManifestPath = manifestPath,
|
||
EntityCount = entityCount,
|
||
TypeCounts = typeCounts,
|
||
CategoryFiles = ReadCategoryFiles(root, outputDir),
|
||
Message = $"已通过 AutoCAD COM 外部提取器提取 DWG：{Path.GetFileName(drawingPath)}"
|
||
};
|
||
}
|
||
|
||
bool TryRunBridgeExtractor(
|
||
DwgDraftExtractRequest request,
|
||
string drawingPath,
|
||
string progId,
|
||
string outputDir,
|
||
out DwgDraftExtractionResult result)
|
||
{
|
||
result = new DwgDraftExtractionResult();
|
||
var bridgeDir = ResolveBridgeDir();
|
||
var heartbeatPath = Path.Combine(bridgeDir, "heartbeat.json");
|
||
if (!IsBridgeAlive(heartbeatPath))
|
||
{
|
||
TraceExternalExtractor($"bridge_not_available heartbeat={heartbeatPath}");
|
||
return false;
|
||
}
|
||
|
||
var jobsDir = Path.Combine(bridgeDir, "jobs");
|
||
var resultsDir = Path.Combine(bridgeDir, "results");
|
||
Directory.CreateDirectory(jobsDir);
|
||
Directory.CreateDirectory(resultsDir);
|
||
|
||
var jobId = $"{DateTime.UtcNow:yyyyMMddHHmmssfff}-{Guid.NewGuid():N}";
|
||
var jobPath = Path.Combine(jobsDir, $"{jobId}.request.json");
|
||
var tempJobPath = jobPath + ".tmp";
|
||
var resultPath = Path.Combine(resultsDir, $"{jobId}.result.json");
|
||
var job = new DwgBridgeJob
|
||
{
|
||
JobId = jobId,
|
||
DrawingPath = drawingPath,
|
||
OutputDir = outputDir,
|
||
ProgId = progId,
|
||
Visible = request.Visible,
|
||
CloseAfterExtract = request.CloseAfterExtract,
|
||
MaxEntities = request.MaxEntities <= 0 ? 100_000 : request.MaxEntities,
|
||
MainViewSeedMode = request.MainViewSeedMode,
|
||
ReuseExtractionDir = string.IsNullOrWhiteSpace(request.ReuseExtractionDir) ? "" : Path.GetFullPath(request.ReuseExtractionDir.Trim().Trim('"'))
|
||
};
|
||
|
||
File.WriteAllText(tempJobPath, JsonSerializer.Serialize(job, JsonOptions));
|
||
File.Move(tempJobPath, jobPath, overwrite: true);
|
||
TraceExternalExtractor($"bridge_job_submitted job_id={jobId}; bridge_dir={bridgeDir}");
|
||
|
||
var timeout = TimeSpan.FromSeconds(request.BridgeTimeoutSeconds <= 0 ? 600 : request.BridgeTimeoutSeconds);
|
||
var deadline = DateTime.UtcNow.Add(timeout);
|
||
while (DateTime.UtcNow < deadline)
|
||
{
|
||
if (File.Exists(resultPath))
|
||
{
|
||
var bridgeResult = JsonSerializer.Deserialize<DwgBridgeJobResult>(File.ReadAllText(resultPath), JsonOptions)
|
||
?? throw new InvalidOperationException($"Invalid bridge result: {resultPath}");
|
||
TraceExternalExtractor($"bridge_job_result job_id={jobId}; ok={bridgeResult.Ok}; exit={bridgeResult.ExitCode}");
|
||
if (!bridgeResult.Ok)
|
||
{
|
||
throw new InvalidOperationException(
|
||
$"AutoCAD bridge extraction failed. job={jobId}; exit={bridgeResult.ExitCode}\n{bridgeResult.Error}\n{bridgeResult.Stdout}\n{bridgeResult.Stderr}");
|
||
}
|
||
|
||
var manifestPath = string.IsNullOrWhiteSpace(bridgeResult.ManifestPath)
|
||
? Path.Combine(outputDir, "manifest.json")
|
||
: bridgeResult.ManifestPath;
|
||
if (!File.Exists(manifestPath))
|
||
throw new FileNotFoundException($"AutoCAD bridge did not write manifest: {manifestPath}");
|
||
|
||
result = ReadExternalManifest(
|
||
manifestPath,
|
||
outputDir,
|
||
drawingPath,
|
||
progId,
|
||
"AutoCAD COM bridge extractor",
|
||
$"Read DWG through AutoCAD bridge: {Path.GetFileName(drawingPath)}");
|
||
return true;
|
||
}
|
||
|
||
Thread.Sleep(500);
|
||
}
|
||
|
||
throw new TimeoutException($"AutoCAD bridge extraction timed out. job={jobId}; timeout={timeout.TotalSeconds:0}s");
|
||
}
|
||
|
||
bool IsBridgeAlive(string heartbeatPath)
|
||
{
|
||
if (!File.Exists(heartbeatPath))
|
||
return false;
|
||
return DateTime.UtcNow - File.GetLastWriteTimeUtc(heartbeatPath) <= TimeSpan.FromSeconds(30);
|
||
}
|
||
|
||
string ResolveBridgeDir()
|
||
{
|
||
var configured = Environment.GetEnvironmentVariable("AGENT4_DWG_BRIDGE_DIR");
|
||
if (!string.IsNullOrWhiteSpace(configured))
|
||
return Path.GetFullPath(configured.Trim().Trim('"'));
|
||
return Path.Combine(_paths.RuntimeDir, "dwg-draft", "bridge");
|
||
}
|
||
|
||
DwgDraftExtractionResult ReadExternalManifest(
|
||
string manifestPath,
|
||
string outputDir,
|
||
string drawingPath,
|
||
string progId,
|
||
string source,
|
||
string message)
|
||
{
|
||
using var doc = JsonDocument.Parse(File.ReadAllText(manifestPath));
|
||
var root = doc.RootElement;
|
||
var entityCount = root.TryGetProperty("entity_count", out var countElement) && countElement.ValueKind == JsonValueKind.Number
|
||
? countElement.GetInt32()
|
||
: 0;
|
||
var typeCounts = new Dictionary<string, int>(StringComparer.OrdinalIgnoreCase);
|
||
if (root.TryGetProperty("type_counts", out var typeCountsElement) && typeCountsElement.ValueKind == JsonValueKind.Object)
|
||
{
|
||
foreach (var item in typeCountsElement.EnumerateObject())
|
||
{
|
||
if (item.Value.ValueKind == JsonValueKind.Number)
|
||
typeCounts[item.Name] = item.Value.GetInt32();
|
||
}
|
||
}
|
||
|
||
return new DwgDraftExtractionResult
|
||
{
|
||
Ok = true,
|
||
Source = source,
|
||
ProgId = progId,
|
||
Started = root.TryGetProperty("started_auto_cad", out var startedElement) && startedElement.ValueKind is JsonValueKind.True,
|
||
DrawingPath = drawingPath,
|
||
ExportDir = outputDir,
|
||
ManifestPath = manifestPath,
|
||
EntityCount = entityCount,
|
||
TypeCounts = typeCounts,
|
||
CategoryFiles = ReadCategoryFiles(root, outputDir),
|
||
Message = message
|
||
};
|
||
}
|
||
|
||
void TraceExternalExtractor(string message)
|
||
{
|
||
try
|
||
{
|
||
var dir = Path.Combine(_paths.RuntimeDir, "dwg-draft");
|
||
Directory.CreateDirectory(dir);
|
||
File.AppendAllText(
|
||
Path.Combine(dir, "extractor-dispatch.log"),
|
||
$"[{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}] {message}{Environment.NewLine}");
|
||
}
|
||
catch
|
||
{
|
||
// Diagnostics must not affect extraction.
|
||
}
|
||
}
|
||
|
||
DwgDraftExtractionResult ExtractOnSta(DwgDraftExtractRequest request)
|
||
{
|
||
ApplyDrawingPathBase64(request);
|
||
if (string.IsNullOrWhiteSpace(request.DrawingPath))
|
||
throw new ArgumentException("drawing_path 不能为空。", nameof(request));
|
||
|
||
var drawingPath = Path.GetFullPath(request.DrawingPath.Trim().Trim('"'));
|
||
if (!File.Exists(drawingPath))
|
||
throw new FileNotFoundException($"DWG 文件不存在：{drawingPath}");
|
||
|
||
var progId = string.IsNullOrWhiteSpace(request.ProgId) ? ResolveProgId() : request.ProgId.Trim();
|
||
var outputDir = ResolveOutputDir(request.OutputDir);
|
||
Directory.CreateDirectory(outputDir);
|
||
|
||
var app = ConnectOrCreate(progId, request.Visible, out var started);
|
||
object? doc = null;
|
||
try
|
||
{
|
||
WaitForQuiescent(app, TimeSpan.FromSeconds(20));
|
||
doc = OpenDocument(app, drawingPath);
|
||
WaitForQuiescent(app, TimeSpan.FromSeconds(20));
|
||
|
||
var extraction = ExtractDocument(doc, request.MaxEntities <= 0 ? 100_000 : request.MaxEntities);
|
||
var manifest = WriteExtractionFiles(outputDir, drawingPath, progId, started, extraction);
|
||
|
||
if (request.CloseAfterExtract)
|
||
TryInvoke(doc, "Close", [false]);
|
||
|
||
return new DwgDraftExtractionResult
|
||
{
|
||
Ok = true,
|
||
Source = "AutoCAD COM",
|
||
ProgId = progId,
|
||
Started = started,
|
||
DrawingPath = drawingPath,
|
||
ExportDir = outputDir,
|
||
ManifestPath = Path.Combine(outputDir, "manifest.json"),
|
||
EntityCount = extraction.EntitiesCommon.Count,
|
||
TypeCounts = extraction.TypeCounts,
|
||
CategoryFiles = manifest.CategoryFiles,
|
||
Message = $"已通过 AutoCAD COM 提取 DWG：{Path.GetFileName(drawingPath)}"
|
||
};
|
||
}
|
||
finally
|
||
{
|
||
if (doc != null)
|
||
ReleaseCom(doc);
|
||
ReleaseCom(app);
|
||
}
|
||
}
|
||
|
||
DwgDraftDocumentExtraction ExtractDocument(object doc, int maxEntities)
|
||
{
|
||
var extraction = new DwgDraftDocumentExtraction();
|
||
ExtractSpace(doc, "ModelSpace", extraction, maxEntities);
|
||
ExtractSpace(doc, "PaperSpace", extraction, maxEntities);
|
||
return extraction;
|
||
}
|
||
|
||
void ExtractSpace(object doc, string spaceName, DwgDraftDocumentExtraction extraction, int maxEntities)
|
||
{
|
||
var space = GetProperty(doc, spaceName);
|
||
if (space == null)
|
||
return;
|
||
|
||
try
|
||
{
|
||
var count = ToInt(GetProperty(space, "Count")) ?? 0;
|
||
if (string.Equals(spaceName, "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);
|
||
}
|
||
finally
|
||
{
|
||
ReleaseCom(entity);
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
ReleaseCom(space);
|
||
}
|
||
}
|
||
|
||
void ExtractEntity(object entity, string spaceName, int index, DwgDraftDocumentExtraction extraction)
|
||
{
|
||
var objectName = ReadString(entity, "ObjectName");
|
||
if (string.IsNullOrWhiteSpace(objectName))
|
||
objectName = ReadString(entity, "EntityName");
|
||
if (string.IsNullOrWhiteSpace(objectName))
|
||
objectName = entity.GetType().Name;
|
||
|
||
extraction.TypeCounts[objectName] = extraction.TypeCounts.TryGetValue(objectName, out var current) ? current + 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 item = Merge(common, details);
|
||
if (IsDimension(objectName))
|
||
{
|
||
extraction.Dimensions.Add(item);
|
||
var tolerance = ExtractDimensionalTolerance(common, details);
|
||
if (tolerance != null)
|
||
extraction.DimensionalTolerances.Add(tolerance);
|
||
}
|
||
else if (IsGeometry(objectName))
|
||
{
|
||
extraction.Geometry.Add(item);
|
||
}
|
||
else if (IsAnnotation(objectName))
|
||
{
|
||
extraction.Annotations.Add(item);
|
||
}
|
||
else
|
||
{
|
||
extraction.UnknownEntities.Add(item);
|
||
}
|
||
|
||
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(Merge(common, details));
|
||
if (LooksLikeGeometricTolerance(text, blockName))
|
||
extraction.GeometricTolerances.Add(Merge(common, details));
|
||
if (LooksLikeDatum(text, blockName))
|
||
extraction.Datums.Add(Merge(common, details));
|
||
}
|
||
|
||
static Dictionary<string, object?> ExtractDetails(object entity, string objectName)
|
||
{
|
||
var details = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);
|
||
if (objectName.Contains("Line", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
AddPoint(details, "start", GetProperty(entity, "StartPoint"));
|
||
AddPoint(details, "end", GetProperty(entity, "EndPoint"));
|
||
}
|
||
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"));
|
||
details["degree"] = ToInt(GetProperty(entity, "Degree"));
|
||
details["closed"] = ToBool(GetProperty(entity, "Closed"));
|
||
}
|
||
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 textOverride = ReadString(entity, "TextOverride");
|
||
details["measurement"] = ToDouble(GetProperty(entity, "Measurement"));
|
||
details["text_override"] = textOverride;
|
||
details["text"] = CleanAcadText(textOverride);
|
||
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"));
|
||
details["x_scale_factor"] = ToDouble(GetProperty(entity, "XScaleFactor"));
|
||
details["y_scale_factor"] = ToDouble(GetProperty(entity, "YScaleFactor"));
|
||
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"));
|
||
}
|
||
else if (objectName.Contains("RasterImage", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
details["image_file"] = ReadString(entity, "ImageFile");
|
||
}
|
||
|
||
return details;
|
||
}
|
||
|
||
static List<Dictionary<string, object?>> ReadBlockAttributes(object entity)
|
||
{
|
||
var result = new List<Dictionary<string, object?>>();
|
||
var hasAttributes = ToBool(GetProperty(entity, "HasAttributes")) ?? false;
|
||
if (!hasAttributes)
|
||
return result;
|
||
|
||
var raw = TryInvoke(entity, "GetAttributes", []);
|
||
if (raw == null)
|
||
return result;
|
||
|
||
if (raw is Array array)
|
||
{
|
||
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;
|
||
}
|
||
|
||
DwgDraftManifest WriteExtractionFiles(
|
||
string outputDir,
|
||
string drawingPath,
|
||
string progId,
|
||
bool started,
|
||
DwgDraftDocumentExtraction extraction)
|
||
{
|
||
var files = new List<DwgDraftCategoryFile>
|
||
{
|
||
WriteCategory(outputDir, "entities-common", "entities-common.json", extraction.EntitiesCommon),
|
||
WriteCategory(outputDir, "geometry", "geometry.json", extraction.Geometry),
|
||
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 DwgDraftManifest
|
||
{
|
||
Ok = true,
|
||
Schema = "agent4.dwg-draft.extraction.v1",
|
||
Source = "AutoCAD COM",
|
||
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;
|
||
}
|
||
|
||
public DwgDraftLatestExtractionResult ReadLatestExtraction()
|
||
{
|
||
var path = ResolveManifestPath("");
|
||
if (!File.Exists(path))
|
||
{
|
||
return new DwgDraftLatestExtractionResult
|
||
{
|
||
Ok = false,
|
||
Found = false,
|
||
ExportDir = Path.GetDirectoryName(path) ?? "",
|
||
ManifestPath = path,
|
||
Message = "DWG extraction manifest was not found. Call POST /api/dwg-draft/extract first."
|
||
};
|
||
}
|
||
|
||
using var doc = JsonDocument.Parse(File.ReadAllText(path));
|
||
var root = doc.RootElement.Clone();
|
||
var files = ReadCategoryFiles(root, Path.GetDirectoryName(path) ?? "");
|
||
return new DwgDraftLatestExtractionResult
|
||
{
|
||
Ok = true,
|
||
Found = true,
|
||
ExportDir = Path.GetDirectoryName(path) ?? "",
|
||
ManifestPath = path,
|
||
LastWriteTimeUtc = File.GetLastWriteTimeUtc(path),
|
||
Manifest = root,
|
||
CategoryFiles = files,
|
||
Message = "Read the latest AutoCAD DWG extraction manifest."
|
||
};
|
||
}
|
||
|
||
public DwgDraftCategoryExtractionResult ReadCategoryExtraction(string category)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(category))
|
||
throw new ArgumentException("category is required.", nameof(category));
|
||
|
||
var manifestPath = ResolveManifestPath("");
|
||
if (!File.Exists(manifestPath))
|
||
{
|
||
return new DwgDraftCategoryExtractionResult
|
||
{
|
||
Ok = false,
|
||
Found = false,
|
||
Category = category,
|
||
ManifestPath = manifestPath,
|
||
Message = "DWG extraction manifest was not found."
|
||
};
|
||
}
|
||
|
||
using var manifestDoc = JsonDocument.Parse(File.ReadAllText(manifestPath));
|
||
var exportDir = Path.GetDirectoryName(manifestPath) ?? "";
|
||
var files = ReadCategoryFiles(manifestDoc.RootElement, exportDir);
|
||
var selected = files.FirstOrDefault(file =>
|
||
string.Equals(file.Category, category, StringComparison.OrdinalIgnoreCase) ||
|
||
string.Equals(Path.GetFileNameWithoutExtension(file.File), category, StringComparison.OrdinalIgnoreCase));
|
||
|
||
if (selected == null || !File.Exists(selected.FullPath))
|
||
{
|
||
return new DwgDraftCategoryExtractionResult
|
||
{
|
||
Ok = false,
|
||
Found = false,
|
||
Category = category,
|
||
ManifestPath = manifestPath,
|
||
ExportDir = exportDir,
|
||
AvailableCategories = files.Select(file => file.Category).ToList(),
|
||
Message = $"DWG extraction category was not found: {category}"
|
||
};
|
||
}
|
||
|
||
using var categoryDoc = JsonDocument.Parse(File.ReadAllText(selected.FullPath));
|
||
return new DwgDraftCategoryExtractionResult
|
||
{
|
||
Ok = true,
|
||
Found = true,
|
||
Category = selected.Category,
|
||
ManifestPath = manifestPath,
|
||
ExportDir = exportDir,
|
||
CategoryPath = selected.FullPath,
|
||
LastWriteTimeUtc = File.GetLastWriteTimeUtc(selected.FullPath),
|
||
ItemCount = selected.ItemCount,
|
||
Data = categoryDoc.RootElement.Clone(),
|
||
AvailableCategories = files.Select(file => file.Category).ToList(),
|
||
Message = $"Read DWG extraction category: {selected.Category}"
|
||
};
|
||
}
|
||
|
||
string ResolveOutputDir(string requested)
|
||
{
|
||
if (!string.IsNullOrWhiteSpace(requested))
|
||
return Path.GetFullPath(requested.Trim().Trim('"'));
|
||
|
||
var configured = Environment.GetEnvironmentVariable("AGENT4_DWG_EXPORT_DIR");
|
||
if (!string.IsNullOrWhiteSpace(configured))
|
||
return Path.GetFullPath(configured.Trim().Trim('"'));
|
||
|
||
return Path.Combine(_paths.RuntimeDir, "dwg-draft", "latest-extraction");
|
||
}
|
||
|
||
static void ApplyDrawingPathBase64(DwgDraftExtractRequest request)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(request.DrawingPathBase64))
|
||
return;
|
||
|
||
try
|
||
{
|
||
request.DrawingPath = Encoding.UTF8.GetString(Convert.FromBase64String(request.DrawingPathBase64.Trim()));
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
throw new ArgumentException($"drawing_path_base64 不是有效的 UTF-8 Base64 路径：{ex.Message}", nameof(request));
|
||
}
|
||
}
|
||
|
||
string ResolveManifestPath(string requestedDir)
|
||
{
|
||
var dir = ResolveOutputDir(requestedDir);
|
||
return Path.Combine(dir, "manifest.json");
|
||
}
|
||
|
||
static DwgDraftCategoryFile WriteCategory(string outputDir, string category, string file, object data)
|
||
{
|
||
var path = Path.Combine(outputDir, file);
|
||
WriteJson(path, data);
|
||
var itemCount = data is System.Collections.ICollection collection ? collection.Count : 0;
|
||
return new DwgDraftCategoryFile
|
||
{
|
||
Category = category,
|
||
File = file,
|
||
FullPath = path,
|
||
ItemCount = itemCount,
|
||
Exists = true
|
||
};
|
||
}
|
||
|
||
static void WriteJson(string path, object data)
|
||
{
|
||
Directory.CreateDirectory(Path.GetDirectoryName(path) ?? ".");
|
||
File.WriteAllText(path, JsonSerializer.Serialize(data, JsonOptions));
|
||
}
|
||
|
||
static List<DwgDraftCategoryFile> ReadCategoryFiles(JsonElement manifest, string exportDir)
|
||
{
|
||
if (!manifest.TryGetProperty("category_files", out var filesElement) || filesElement.ValueKind != JsonValueKind.Array)
|
||
return [];
|
||
|
||
var result = new List<DwgDraftCategoryFile>();
|
||
foreach (var item in filesElement.EnumerateArray())
|
||
{
|
||
var category = item.TryGetProperty("category", out var categoryElement) ? categoryElement.GetString() ?? "" : "";
|
||
var file = item.TryGetProperty("file", out var fileElement) ? fileElement.GetString() ?? "" : "";
|
||
var itemCount = item.TryGetProperty("item_count", out var countElement) && countElement.ValueKind == JsonValueKind.Number
|
||
? countElement.GetInt32()
|
||
: 0;
|
||
if (string.IsNullOrWhiteSpace(category) || string.IsNullOrWhiteSpace(file))
|
||
continue;
|
||
|
||
var fullPath = Path.GetFullPath(Path.Combine(exportDir, file));
|
||
var root = Path.GetFullPath(exportDir);
|
||
if (!fullPath.StartsWith(root, StringComparison.OrdinalIgnoreCase))
|
||
continue;
|
||
|
||
result.Add(new DwgDraftCategoryFile
|
||
{
|
||
Category = category,
|
||
File = file,
|
||
FullPath = fullPath,
|
||
ItemCount = itemCount,
|
||
Exists = File.Exists(fullPath)
|
||
});
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
static string ResolveProgId()
|
||
{
|
||
foreach (var progId in ProgIdCandidates)
|
||
{
|
||
if (Type.GetTypeFromProgID(progId, throwOnError: false) != null)
|
||
return progId;
|
||
}
|
||
|
||
return DefaultProgId;
|
||
}
|
||
|
||
static object ConnectOrCreate(string progId, bool visible, out bool started)
|
||
{
|
||
var app = TryGetActiveComObject(progId, out _);
|
||
started = false;
|
||
if (app == null)
|
||
{
|
||
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;
|
||
}
|
||
|
||
TrySetProperty(app, "Visible", visible);
|
||
return app;
|
||
}
|
||
|
||
static object OpenDocument(object app, string drawingPath)
|
||
{
|
||
var documents = GetProperty(app, "Documents") ?? throw new InvalidOperationException("AutoCAD.Application.Documents 不可用。");
|
||
try
|
||
{
|
||
var doc = TryInvoke(documents, "Open", [drawingPath, true])
|
||
?? TryInvoke(documents, "Open", [drawingPath])
|
||
?? throw new InvalidOperationException($"AutoCAD 打开 DWG 失败：{drawingPath}");
|
||
return doc;
|
||
}
|
||
finally
|
||
{
|
||
ReleaseCom(documents);
|
||
}
|
||
}
|
||
|
||
static void WaitForQuiescent(object app, TimeSpan timeout)
|
||
{
|
||
var deadline = DateTime.UtcNow + timeout;
|
||
while (DateTime.UtcNow < deadline)
|
||
{
|
||
try
|
||
{
|
||
var state = TryInvoke(app, "GetAcadState", []);
|
||
if (state == null)
|
||
return;
|
||
var isQuiescent = ToBool(GetProperty(state, "IsQuiescent")) ?? true;
|
||
ReleaseCom(state);
|
||
if (isQuiescent)
|
||
return;
|
||
}
|
||
catch
|
||
{
|
||
return;
|
||
}
|
||
|
||
Thread.Sleep(250);
|
||
}
|
||
}
|
||
|
||
static object? GetProperty(object obj, string name) => RetryCom(() =>
|
||
{
|
||
try
|
||
{
|
||
return obj.GetType().InvokeMember(
|
||
name,
|
||
BindingFlags.GetProperty,
|
||
binder: null,
|
||
target: obj,
|
||
args: null,
|
||
culture: 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,
|
||
binder: null,
|
||
target: obj,
|
||
args: [index],
|
||
culture: CultureInfo.InvariantCulture);
|
||
}
|
||
catch (TargetInvocationException ex) when (IsRetryableCom(ex.InnerException))
|
||
{
|
||
throw;
|
||
}
|
||
catch (COMException ex) when (IsRetryableCom(ex))
|
||
{
|
||
throw;
|
||
}
|
||
catch
|
||
{
|
||
// Try the next dispatch style.
|
||
}
|
||
}
|
||
|
||
return null;
|
||
});
|
||
|
||
static object? TryInvoke(object obj, string name, object?[] args) => RetryCom(() =>
|
||
{
|
||
try
|
||
{
|
||
return obj.GetType().InvokeMember(
|
||
name,
|
||
BindingFlags.InvokeMethod,
|
||
binder: null,
|
||
target: obj,
|
||
args: args,
|
||
culture: 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,
|
||
binder: null,
|
||
target: obj,
|
||
args: [value],
|
||
culture: CultureInfo.InvariantCulture);
|
||
}
|
||
catch
|
||
{
|
||
// Optional property.
|
||
}
|
||
|
||
return (object?)null;
|
||
});
|
||
}
|
||
|
||
static T RunSta<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 object? RetryCom(Func<object?> action)
|
||
{
|
||
Exception? last = null;
|
||
for (var attempt = 0; attempt < 120; attempt++)
|
||
{
|
||
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)
|
||
{
|
||
if (ex is not COMException com)
|
||
return false;
|
||
return unchecked((uint)com.HResult) is 0x80010001 or 0x8001010A;
|
||
}
|
||
|
||
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 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 IsDimension(string objectName) => objectName.Contains("Dimension", 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 = ToPoint(value);
|
||
if (point != null)
|
||
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 = ToPoint(GetProperty(entity, propertyName));
|
||
if (point == null)
|
||
continue;
|
||
|
||
details[name] = point;
|
||
details[$"{name}_source_property"] = propertyName;
|
||
return;
|
||
}
|
||
|
||
missingFields.Add(name);
|
||
}
|
||
|
||
static List<double>? ToPoint(object? value)
|
||
{
|
||
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.Count > 0 ? result : null;
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
static string ReadString(object obj, string name)
|
||
{
|
||
return 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 COM cleanup.
|
||
}
|
||
}
|
||
|
||
static DwgDraftProgIdInfo ReadProgIdInfo(string progId)
|
||
{
|
||
var clsid = ReadDefaultValue($@"{progId}\CLSID");
|
||
return new DwgDraftProgIdInfo
|
||
{
|
||
ProgId = progId,
|
||
Description = ReadDefaultValue(progId),
|
||
Clsid = clsid,
|
||
LocalServer32 = string.IsNullOrWhiteSpace(clsid) ? "" : ReadDefaultValue($@"CLSID\{clsid}\LocalServer32")
|
||
};
|
||
}
|
||
|
||
static string ReadDefaultValue(string subKey)
|
||
{
|
||
using var key = Registry.ClassesRoot.OpenSubKey(subKey);
|
||
return key?.GetValue("")?.ToString() ?? "";
|
||
}
|
||
|
||
static object? TryGetActiveComObject(string progId, out string error)
|
||
{
|
||
error = "";
|
||
try
|
||
{
|
||
var hr = CLSIDFromProgID(progId, out var clsid);
|
||
if (hr < 0)
|
||
Marshal.ThrowExceptionForHR(hr);
|
||
return GetActiveObject(ref clsid, IntPtr.Zero);
|
||
}
|
||
catch (Exception ex)
|
||
{
|
||
error = ex.Message;
|
||
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 class DwgDraftExtractRequest
|
||
{
|
||
public string DrawingPath { get; set; } = "";
|
||
public string DrawingPathBase64 { get; set; } = "";
|
||
public string ProgId { get; set; } = "";
|
||
public bool Visible { get; set; } = true;
|
||
public bool CloseAfterExtract { get; set; }
|
||
public string OutputDir { get; set; } = "";
|
||
public int MaxEntities { get; set; } = 100_000;
|
||
public string MainViewSeedMode { get; set; } = "";
|
||
public string ReuseExtractionDir { get; set; } = "";
|
||
public bool UseBridge { get; set; } = true;
|
||
public int BridgeTimeoutSeconds { get; set; } = 600;
|
||
}
|
||
|
||
sealed class DwgBridgeJob
|
||
{
|
||
public string JobId { get; set; } = "";
|
||
public string DrawingPath { get; set; } = "";
|
||
public string OutputDir { get; set; } = "";
|
||
public string ProgId { get; set; } = "";
|
||
public bool Visible { get; set; } = true;
|
||
public bool CloseAfterExtract { get; set; }
|
||
public int MaxEntities { get; set; } = 100_000;
|
||
public string MainViewSeedMode { get; set; } = "";
|
||
public string ReuseExtractionDir { get; set; } = "";
|
||
}
|
||
|
||
sealed class DwgBridgeJobResult
|
||
{
|
||
public bool Ok { get; set; }
|
||
public string JobId { get; set; } = "";
|
||
public int ExitCode { get; set; }
|
||
public string Stdout { get; set; } = "";
|
||
public string Stderr { get; set; } = "";
|
||
public string OutputDir { get; set; } = "";
|
||
public string ManifestPath { get; set; } = "";
|
||
public string Error { get; set; } = "";
|
||
}
|
||
|
||
sealed class DwgDraftBridgeStatus
|
||
{
|
||
public bool Ok { get; set; }
|
||
public bool Alive { get; set; }
|
||
public string BridgeDir { get; set; } = "";
|
||
public string HeartbeatPath { get; set; } = "";
|
||
public DateTime? LastWriteTimeUtc { get; set; }
|
||
public JsonElement? Heartbeat { get; set; }
|
||
public string Message { get; set; } = "";
|
||
}
|
||
|
||
sealed class DwgDraftDocumentExtraction
|
||
{
|
||
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?>> 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 DwgDraftInstallation
|
||
{
|
||
public bool Found { get; set; }
|
||
public string DefaultProgId { get; set; } = "";
|
||
public List<DwgDraftProgIdInfo> ProgIds { get; set; } = new();
|
||
public List<string> AcadExeCandidates { get; set; } = new();
|
||
public List<string> Notes { get; set; } = new();
|
||
}
|
||
|
||
sealed class DwgDraftProgIdInfo
|
||
{
|
||
public string ProgId { get; set; } = "";
|
||
public string Description { get; set; } = "";
|
||
public string Clsid { get; set; } = "";
|
||
public string LocalServer32 { get; set; } = "";
|
||
}
|
||
|
||
sealed class DwgDraftExtractionResult
|
||
{
|
||
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<DwgDraftCategoryFile> CategoryFiles { get; set; } = new();
|
||
public string Message { get; set; } = "";
|
||
}
|
||
|
||
sealed class DwgDraftManifest
|
||
{
|
||
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<DwgDraftCategoryFile> CategoryFiles { get; set; } = new();
|
||
}
|
||
|
||
sealed class DwgDraftCategoryFile
|
||
{
|
||
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 DwgDraftLatestExtractionResult
|
||
{
|
||
public bool Ok { get; set; }
|
||
public bool Found { get; set; }
|
||
public string ExportDir { get; set; } = "";
|
||
public string ManifestPath { get; set; } = "";
|
||
public DateTime? LastWriteTimeUtc { get; set; }
|
||
public JsonElement? Manifest { get; set; }
|
||
public List<DwgDraftCategoryFile> CategoryFiles { get; set; } = new();
|
||
public string Message { get; set; } = "";
|
||
}
|
||
|
||
sealed class DwgDraftCategoryExtractionResult
|
||
{
|
||
public bool Ok { get; set; }
|
||
public bool Found { get; set; }
|
||
public string Category { get; set; } = "";
|
||
public string ExportDir { get; set; } = "";
|
||
public string ManifestPath { get; set; } = "";
|
||
public string CategoryPath { get; set; } = "";
|
||
public DateTime? LastWriteTimeUtc { get; set; }
|
||
public int ItemCount { get; set; }
|
||
public JsonElement? Data { get; set; }
|
||
public List<string> AvailableCategories { get; set; } = new();
|
||
public string Message { get; set; } = "";
|
||
}
|