3778 lines
144 KiB
C#
3778 lines
144 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Linq;
|
||
using System.Text.RegularExpressions;
|
||
using Autodesk.AutoCAD.ApplicationServices;
|
||
using Autodesk.AutoCAD.DatabaseServices;
|
||
using Autodesk.AutoCAD.Geometry;
|
||
using Autodesk.AutoCAD.Runtime;
|
||
using CadParamPluging.Common;
|
||
using CadParamPluging.Domain.Models;
|
||
|
||
namespace CadParamPluging.Cad
|
||
{
|
||
public static class TemplateDrawingService
|
||
{
|
||
private static readonly Regex MatchFieldRegex = new Regex(
|
||
@"^\s*(交付状态|工艺方法|结构特征|特殊条件)\s*[:：]\s*(.+?)\s*$",
|
||
RegexOptions.Compiled);
|
||
|
||
private static readonly Regex MTextFormatRegex = new Regex(@"\\[A-Za-z]+[^;]*;", RegexOptions.Compiled);
|
||
|
||
// 匹配MText中残留的格式代码片段（如 Xt31.278; 或 qj,tz; 等）
|
||
// 匹配模式：1-4个字母开头，后面可以是数字/点/逗号/字母的组合，最后以分号结尾
|
||
private static readonly Regex MTextResidualFormatRegex = new Regex(@"^[A-Za-z]{1,4}[\d.,A-Za-z]*;", RegexOptions.Compiled);
|
||
|
||
// 外框图层名称集合
|
||
private static readonly HashSet<string> OuterFrameLayerNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
|
||
{
|
||
"图框", "边框", "外框", "FRAME", "BORDER", "粗实线"
|
||
};
|
||
|
||
private static readonly Regex CaxaLayerRegex = new Regex(@"^CAXA\d$", RegexOptions.Compiled | RegexOptions.IgnoreCase);
|
||
|
||
private static readonly HashSet<string> DimensionLayerNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase)
|
||
{
|
||
"尺寸标注", "标注", "DIM", "DIMENSION", "DIMENSIONS"
|
||
};
|
||
|
||
public static Document OpenTemplateDrawing(TemplateInfo template)
|
||
{
|
||
if (template == null || string.IsNullOrWhiteSpace(template.FilePath))
|
||
{
|
||
throw new ArgumentException("Template path is invalid");
|
||
}
|
||
|
||
var docMgr = Application.DocumentManager;
|
||
foreach (Document doc in docMgr)
|
||
{
|
||
if (string.Equals(doc.Name, template.FilePath, StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
docMgr.MdiActiveDocument = doc;
|
||
return doc;
|
||
}
|
||
}
|
||
|
||
var newDoc = docMgr.Open(template.FilePath, false);
|
||
docMgr.MdiActiveDocument = newDoc;
|
||
return newDoc;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 移除模板中用于“匹配模板/图纸”的参数标注文本（交付状态/工艺方法/结构特征/特殊条件）。
|
||
/// 仅清理当前生成图纸中目标空间（Layout 或 ModelSpace）里的文本实体/块属性。
|
||
/// </summary>
|
||
public static int RemoveMatchParameterAnnotations(CadContext ctx, string layoutName, bool scanModelSpace)
|
||
{
|
||
if (ctx == null)
|
||
{
|
||
throw new ArgumentNullException(nameof(ctx));
|
||
}
|
||
|
||
var db = ctx.Database;
|
||
var tr = ctx.Transaction;
|
||
|
||
if (scanModelSpace)
|
||
{
|
||
var bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
|
||
var ms = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
|
||
return EraseMatchTextEntities(tr, ms);
|
||
}
|
||
|
||
if (string.IsNullOrWhiteSpace(layoutName))
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
var layoutDict = (DBDictionary)tr.GetObject(db.LayoutDictionaryId, OpenMode.ForRead);
|
||
ObjectId layoutId = ObjectId.Null;
|
||
foreach (DBDictionaryEntry entry in layoutDict)
|
||
{
|
||
if (string.Equals(entry.Key, layoutName, StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
layoutId = entry.Value;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (layoutId.IsNull)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
var layout = (Layout)tr.GetObject(layoutId, OpenMode.ForRead);
|
||
var btr = (BlockTableRecord)tr.GetObject(layout.BlockTableRecordId, OpenMode.ForWrite);
|
||
return EraseMatchTextEntities(tr, btr);
|
||
}
|
||
|
||
private static int EraseMatchTextEntities(Transaction tr, BlockTableRecord btr)
|
||
{
|
||
if (tr == null || btr == null)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
var removed = 0;
|
||
var ids = btr.Cast<ObjectId>().ToList();
|
||
foreach (var id in ids)
|
||
{
|
||
var ent = tr.GetObject(id, OpenMode.ForWrite, false) as Entity;
|
||
if (ent == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (ent is DBText t)
|
||
{
|
||
if (ContainsMatchField(t.TextString))
|
||
{
|
||
ent.Erase(true);
|
||
removed++;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (ent is MText mt)
|
||
{
|
||
var plain = SimplifyMText(mt.Contents);
|
||
if (ContainsMatchField(plain))
|
||
{
|
||
ent.Erase(true);
|
||
removed++;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (ent is BlockReference br)
|
||
{
|
||
foreach (ObjectId attId in br.AttributeCollection)
|
||
{
|
||
var att = tr.GetObject(attId, OpenMode.ForWrite, false) as AttributeReference;
|
||
if (att == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (ContainsMatchField(att.TextString))
|
||
{
|
||
try
|
||
{
|
||
att.Erase(true);
|
||
removed++;
|
||
}
|
||
catch
|
||
{
|
||
// ignore
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return removed;
|
||
}
|
||
|
||
private static bool ContainsMatchField(string raw)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(raw))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
var lines = raw
|
||
.Replace("\r\n", "\n")
|
||
.Replace("\r", "\n")
|
||
.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries)
|
||
.Select(s => (s ?? string.Empty).Trim())
|
||
.Where(s => s.Length > 0);
|
||
|
||
foreach (var line in lines)
|
||
{
|
||
if (MatchFieldRegex.IsMatch(line))
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
private static string SimplifyMText(string contents)
|
||
{
|
||
if (string.IsNullOrEmpty(contents))
|
||
{
|
||
return string.Empty;
|
||
}
|
||
|
||
var s = contents
|
||
.Replace("\\P", "\n")
|
||
.Replace("\\p", "\n")
|
||
.Replace("\\~", " ");
|
||
|
||
s = s.Replace("{", string.Empty).Replace("}", string.Empty);
|
||
s = MTextFormatRegex.Replace(s, string.Empty);
|
||
|
||
// 处理每行开头可能残留的格式代码片段（如 Xt31.278; 或 qj,tz;）
|
||
var lines = s.Split(new[] { '\n' }, StringSplitOptions.None);
|
||
for (var i = 0; i < lines.Length; i++)
|
||
{
|
||
lines[i] = CleanLineResidualFormat(lines[i]);
|
||
}
|
||
s = string.Join("\n", lines);
|
||
|
||
return s;
|
||
}
|
||
|
||
private static string CleanLineResidualFormat(string line)
|
||
{
|
||
if (string.IsNullOrEmpty(line))
|
||
{
|
||
return line;
|
||
}
|
||
|
||
// 循环清理行首的格式代码残留，直到没有匹配为止
|
||
var result = line;
|
||
while (true)
|
||
{
|
||
var trimmed = result.TrimStart();
|
||
var match = MTextResidualFormatRegex.Match(trimmed);
|
||
if (match.Success && match.Index == 0)
|
||
{
|
||
// 移除匹配的格式代码
|
||
var leadingSpaces = result.Length - result.TrimStart().Length;
|
||
result = new string(' ', leadingSpaces) + trimmed.Substring(match.Length);
|
||
}
|
||
else
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
public sealed class NoteApplyResult
|
||
{
|
||
public bool Applied { get; set; }
|
||
public string RenderedText { get; set; }
|
||
public int PlaceholderCountInDwg { get; set; }
|
||
public string TargetKind { get; set; }
|
||
public string Message { get; set; }
|
||
}
|
||
|
||
private sealed class NoteCandidate
|
||
{
|
||
public int Score;
|
||
public string Kind;
|
||
public ObjectId TargetId; // Added for persistence tracking
|
||
public string PlainText;
|
||
public string OriginalContents;
|
||
public Action<string> Apply;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 在实体扩展字典中保存原始模板文本，以便下次重新生成时可以再次使用
|
||
/// </summary>
|
||
private static void SetNoteTemplateData(Transaction tr, ObjectId id, string template)
|
||
{
|
||
if (string.IsNullOrEmpty(template)) return;
|
||
|
||
var ent = tr.GetObject(id, OpenMode.ForWrite) as Entity;
|
||
if (ent == null) return;
|
||
|
||
if (ent.ExtensionDictionary.IsNull)
|
||
{
|
||
ent.CreateExtensionDictionary();
|
||
}
|
||
|
||
var dict = (DBDictionary)tr.GetObject(ent.ExtensionDictionary, OpenMode.ForWrite);
|
||
const string DictName = "CadParamPluging_NoteData";
|
||
|
||
// XRecord limits text to 255 characters per element.
|
||
// Split string into 250 character chunks using DxfCode.XTextString (301)
|
||
var rb = new ResultBuffer();
|
||
var temp = template;
|
||
while (temp.Length > 0)
|
||
{
|
||
var chunk = temp.Length > 250 ? temp.Substring(0, 250) : temp;
|
||
rb.Add(new TypedValue(301, chunk)); // 301 = DxfCode.XTextString
|
||
temp = temp.Length > 250 ? temp.Substring(250) : "";
|
||
}
|
||
|
||
var xrec = new Xrecord { Data = rb };
|
||
|
||
if (dict.Contains(DictName))
|
||
{
|
||
var oldId = dict.GetAt(DictName);
|
||
var oldXrec = (Xrecord)tr.GetObject(oldId, OpenMode.ForWrite);
|
||
oldXrec.Data = rb;
|
||
}
|
||
else
|
||
{
|
||
dict.SetAt(DictName, xrec);
|
||
tr.AddNewlyCreatedDBObject(xrec, true);
|
||
}
|
||
}
|
||
|
||
private static string GetNoteTemplateData(Transaction tr, ObjectId id)
|
||
{
|
||
var ent = tr.GetObject(id, OpenMode.ForRead) as Entity;
|
||
if (ent == null || ent.ExtensionDictionary.IsNull) return null;
|
||
|
||
var dict = (DBDictionary)tr.GetObject(ent.ExtensionDictionary, OpenMode.ForRead);
|
||
const string DictName = "CadParamPluging_NoteData";
|
||
|
||
if (!dict.Contains(DictName)) return null;
|
||
|
||
var xrec = (Xrecord)tr.GetObject(dict.GetAt(DictName), OpenMode.ForRead);
|
||
var rb = xrec.Data;
|
||
if (rb == null) return null;
|
||
|
||
var sb = new System.Text.StringBuilder();
|
||
bool hasCode301 = false;
|
||
foreach (var tv in rb)
|
||
{
|
||
if (tv.TypeCode == 301)
|
||
{
|
||
hasCode301 = true;
|
||
if (tv.Value is string s) sb.Append(s);
|
||
}
|
||
}
|
||
|
||
if (hasCode301) return sb.ToString();
|
||
|
||
// Fallback for old code format
|
||
foreach (var tv in rb)
|
||
{
|
||
if (tv.TypeCode == (int)DxfCode.Text)
|
||
{
|
||
return tv.Value as string;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
private sealed class FeatureCategoryData
|
||
{
|
||
public string OriginalTemplate;
|
||
public string GroupId;
|
||
public string Role;
|
||
}
|
||
|
||
private const string FeatureCategoryDictName = "CadParamPluging_FeatureCategory";
|
||
|
||
private static void SetFeatureCategoryData(Transaction tr, ObjectId id, string originalTemplate, string groupId, string role)
|
||
{
|
||
var ent = tr.GetObject(id, OpenMode.ForWrite) as Entity;
|
||
if (ent == null) return;
|
||
|
||
if (ent.ExtensionDictionary.IsNull)
|
||
{
|
||
ent.CreateExtensionDictionary();
|
||
}
|
||
|
||
var dict = (DBDictionary)tr.GetObject(ent.ExtensionDictionary, OpenMode.ForWrite);
|
||
|
||
var rb = new ResultBuffer(
|
||
new TypedValue((int)DxfCode.Text, originalTemplate ?? string.Empty),
|
||
new TypedValue((int)DxfCode.Text, groupId ?? string.Empty),
|
||
new TypedValue((int)DxfCode.Text, role ?? string.Empty)
|
||
);
|
||
var xrec = new Xrecord { Data = rb };
|
||
|
||
if (dict.Contains(FeatureCategoryDictName))
|
||
{
|
||
var oldId = dict.GetAt(FeatureCategoryDictName);
|
||
var oldXrec = (Xrecord)tr.GetObject(oldId, OpenMode.ForWrite);
|
||
oldXrec.Data = rb;
|
||
}
|
||
else
|
||
{
|
||
dict.SetAt(FeatureCategoryDictName, xrec);
|
||
tr.AddNewlyCreatedDBObject(xrec, true);
|
||
}
|
||
}
|
||
|
||
private static FeatureCategoryData GetFeatureCategoryData(Transaction tr, ObjectId id)
|
||
{
|
||
var ent = tr.GetObject(id, OpenMode.ForRead) as Entity;
|
||
if (ent == null || ent.ExtensionDictionary.IsNull) return null;
|
||
|
||
var dict = (DBDictionary)tr.GetObject(ent.ExtensionDictionary, OpenMode.ForRead);
|
||
if (!dict.Contains(FeatureCategoryDictName)) return null;
|
||
|
||
var xrec = (Xrecord)tr.GetObject(dict.GetAt(FeatureCategoryDictName), OpenMode.ForRead);
|
||
var rb = xrec.Data;
|
||
if (rb == null) return null;
|
||
|
||
var texts = new List<string>();
|
||
foreach (var tv in rb)
|
||
{
|
||
if (tv.TypeCode == (int)DxfCode.Text)
|
||
{
|
||
texts.Add(tv.Value as string);
|
||
}
|
||
}
|
||
|
||
if (texts.Count == 0) return null;
|
||
|
||
return new FeatureCategoryData
|
||
{
|
||
OriginalTemplate = texts.Count >= 1 ? texts[0] : null,
|
||
GroupId = texts.Count >= 2 ? texts[1] : null,
|
||
Role = texts.Count >= 3 ? texts[2] : null
|
||
};
|
||
}
|
||
|
||
private static string ExtractMTextPlainText(string contents)
|
||
{
|
||
if (string.IsNullOrEmpty(contents)) return string.Empty;
|
||
|
||
var s = contents;
|
||
// Common pattern we generate: {\fSimSun|...;TEXT}
|
||
var semi = s.LastIndexOf(';');
|
||
if (semi >= 0)
|
||
{
|
||
s = s.Substring(semi + 1);
|
||
}
|
||
|
||
s = s.Trim();
|
||
if (s.EndsWith("}", StringComparison.Ordinal))
|
||
{
|
||
s = s.Substring(0, s.Length - 1);
|
||
}
|
||
|
||
s = s.Replace("\\P", "\n");
|
||
return s.Trim();
|
||
}
|
||
|
||
public static NoteApplyResult ApplyNoteTemplate(CadContext ctx, string layoutName, bool scanModelSpace, TemplateSchemaDefinition schema, ParamBag bag)
|
||
{
|
||
if (ctx == null)
|
||
{
|
||
throw new ArgumentNullException(nameof(ctx));
|
||
}
|
||
|
||
if (schema == null)
|
||
{
|
||
return new NoteApplyResult { Applied = false, Message = "Schema is null" };
|
||
}
|
||
|
||
if (bag == null)
|
||
{
|
||
return new NoteApplyResult { Applied = false, Message = "ParamBag is null" };
|
||
}
|
||
|
||
if (schema.NoteBindings == null || schema.NoteBindings.Count == 0)
|
||
{
|
||
return new NoteApplyResult { Applied = false, Message = "未配置附注绑定，跳过。" };
|
||
}
|
||
|
||
var db = ctx.Database;
|
||
var tr = ctx.Transaction;
|
||
|
||
var space = GetTargetSpace(tr, db, layoutName, scanModelSpace);
|
||
if (space == null)
|
||
{
|
||
return new NoteApplyResult { Applied = false, Message = "未找到目标空间，跳过附注替换。" };
|
||
}
|
||
|
||
Func<string, string> getValueW = (k) =>
|
||
{
|
||
var val = bag.GetString(k);
|
||
if (k != null && k.StartsWith("MarkingContent", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
if (bag.GetString(k + "_ShowInNote") == "0") return "__SKIP_NOTE__";
|
||
}
|
||
return val;
|
||
};
|
||
|
||
// 1. 优先查找已经标记过的 Note Entity (重生成场景)
|
||
foreach (ObjectId id in space)
|
||
{
|
||
var storedTemplate = GetNoteTemplateData(tr, id);
|
||
if (!string.IsNullOrEmpty(storedTemplate))
|
||
{
|
||
// 找到了之前的附注，使用存储的模板重新渲染
|
||
var effectiveStored = NoteTemplateEngine.BuildEffectiveValueKeyBindings(schema.NoteBindings);
|
||
var renderedStored = NoteTemplateEngine.Render(storedTemplate, effectiveStored, getValueW);
|
||
|
||
ApplyNoteTextToObject(tr, id, "ExistingTaggedNote", renderedStored, null);
|
||
|
||
return new NoteApplyResult
|
||
{
|
||
Applied = true,
|
||
TargetKind = "ExistingTaggedNote",
|
||
PlaceholderCountInDwg = 0,
|
||
RenderedText = renderedStored,
|
||
Message = "已更新现有附注 (基于存储的模板)。"
|
||
};
|
||
}
|
||
}
|
||
|
||
var candidates = new List<NoteCandidate>();
|
||
var visitedBlocks = new HashSet<ObjectId>();
|
||
foreach (ObjectId id in space)
|
||
{
|
||
var ent = tr.GetObject(id, OpenMode.ForRead, false) as Entity;
|
||
if (ent != null)
|
||
{
|
||
CollectNoteCandidates(tr, ent, visitedBlocks, candidates);
|
||
}
|
||
}
|
||
|
||
if (candidates.Count == 0)
|
||
{
|
||
// 尝试基于白框定位自动创建附注
|
||
if (!string.IsNullOrWhiteSpace(schema.NoteTemplateText))
|
||
{
|
||
// 基于当前 Space 查找白框，以支持 Layout
|
||
var spaceEntList = space.Cast<ObjectId>()
|
||
.Select(id =>
|
||
{
|
||
try { return tr.GetObject(id, OpenMode.ForRead, false) as Entity; }
|
||
catch { return null; }
|
||
})
|
||
.Where(e => e != null && !e.IsErased)
|
||
.ToList();
|
||
|
||
var frame = ComputeWhiteFrameExtentsFromEntities(tr, spaceEntList);
|
||
if (frame.HasValue)
|
||
{
|
||
var f = frame.Value;
|
||
var w = f.MaxPoint.X - f.MinPoint.X;
|
||
var h = f.MaxPoint.Y - f.MinPoint.Y;
|
||
|
||
// 改为左下角锚定 (BottomLeft)，实现"贴合左边和下边"的效果
|
||
// MText 以 BottomLeft 对齐时，插入点位于文字块左下角，内容向上生长
|
||
var insertX = f.MinPoint.X + w * 0.005; // 左边距 0.5%
|
||
var insertY = f.MinPoint.Y + h * 0.005; // 下边距 0.5%
|
||
var insertPoint = new Point3d(insertX, insertY, 0);
|
||
|
||
var effectiveForCreation = NoteTemplateEngine.BuildEffectiveValueKeyBindings(schema.NoteBindings);
|
||
var renderedForCreation = NoteTemplateEngine.Render(schema.NoteTemplateText, effectiveForCreation, getValueW);
|
||
|
||
var mt = new MText();
|
||
mt.Contents = ToMTextContents(renderedForCreation);
|
||
mt.Location = insertPoint;
|
||
mt.TextHeight = 3.0;
|
||
mt.Attachment = AttachmentPoint.BottomLeft; // 关键：锚点在左下，文字向上延伸
|
||
|
||
|
||
// 智能动态宽度：尝试检测右下角标题栏（表格）的左边界
|
||
// 修正：搜索区域扩大，防止表格过宽（超过50%）导致检测不到左边界，从而产生重叠
|
||
// X方向：从左侧 25% 开始扫描（涵盖右侧 75% 区域）
|
||
// Y方向：从底部扫描至 50% 高度（防止标题栏上方有较高的更改栏）
|
||
var searchMinX = f.MinPoint.X + w * 0.25;
|
||
var searchMaxX = f.MaxPoint.X - 5.0;
|
||
var searchMinY = f.MinPoint.Y;
|
||
var searchMaxY = f.MinPoint.Y + h * 0.5;
|
||
|
||
var candidatesX = new List<double>();
|
||
|
||
foreach (var ent in spaceEntList)
|
||
{
|
||
if (ent is Line ln)
|
||
{
|
||
// 垂直线
|
||
if (Math.Abs(ln.StartPoint.X - ln.EndPoint.X) < 1.0 &&
|
||
ln.StartPoint.X > searchMinX && ln.StartPoint.X < searchMaxX &&
|
||
Math.Max(ln.StartPoint.Y, ln.EndPoint.Y) > searchMinY &&
|
||
Math.Min(ln.StartPoint.Y, ln.EndPoint.Y) < searchMaxY)
|
||
{
|
||
candidatesX.Add(ln.StartPoint.X);
|
||
}
|
||
}
|
||
else if (ent is Polyline pl)
|
||
{
|
||
for (int i = 0; i < pl.NumberOfVertices; i++)
|
||
{
|
||
var pt = pl.GetPoint3dAt(i);
|
||
if (pt.X > searchMinX && pt.X < searchMaxX && pt.Y > searchMinY && pt.Y < searchMaxY)
|
||
{
|
||
candidatesX.Add(pt.X);
|
||
}
|
||
}
|
||
}
|
||
else if (ent is BlockReference br)
|
||
{
|
||
try
|
||
{
|
||
var ext = br.GeometricExtents;
|
||
// 只要块的一部分落在搜索区域内，我们就考虑其最左边界
|
||
if (ext.MaxPoint.X > searchMinX && ext.MinPoint.X < searchMaxX &&
|
||
ext.MaxPoint.Y > searchMinY && ext.MinPoint.Y < searchMaxY)
|
||
{
|
||
// 确保最左边界在合理范围内（不小于搜索起点）
|
||
// 如果块非常大（如整个图框块），我们要小心不要把图框左边当成表格左边
|
||
// 假设表格块通常比起点 (0.25w) 要靠右
|
||
if (ext.MinPoint.X > searchMinX)
|
||
{
|
||
candidatesX.Add(ext.MinPoint.X);
|
||
}
|
||
}
|
||
}
|
||
catch { }
|
||
}
|
||
}
|
||
|
||
// 默认最左边界为图框右边界
|
||
double boundaryX = f.MaxPoint.X;
|
||
bool foundTable = false;
|
||
|
||
if (candidatesX.Count > 0)
|
||
{
|
||
// 取最小值作为表格左边界
|
||
boundaryX = candidatesX.Min();
|
||
foundTable = true;
|
||
}
|
||
|
||
double availableWidth;
|
||
if (foundTable)
|
||
{
|
||
// 如果找到了表格，宽度 = 表格左边界 - 插入点 - 留白
|
||
availableWidth = boundaryX - insertX - 5.0;
|
||
}
|
||
else
|
||
{
|
||
// 没找到表格 -> 使用更保守的默认比例 (33%)，避免覆盖
|
||
availableWidth = w * 0.33;
|
||
}
|
||
|
||
// 安全检查：如果计算出的宽度太小（比如小于总宽 10%），保留最小可读宽度或回退
|
||
if (availableWidth < w * 0.10)
|
||
{
|
||
// 空间过小，强行给予 30% 宽度，可能会重叠但保证文字显示
|
||
availableWidth = w * 0.30;
|
||
}
|
||
|
||
mt.Width = availableWidth;
|
||
mt.ColorIndex = 7;
|
||
mt.Layer = "0";
|
||
|
||
try
|
||
{
|
||
var layerTbl = (LayerTable)tr.GetObject(db.LayerTableId, OpenMode.ForRead);
|
||
if (layerTbl.Has("TEXT"))
|
||
{
|
||
mt.Layer = "TEXT";
|
||
}
|
||
else if (layerTbl.Has("文字"))
|
||
{
|
||
mt.Layer = "文字";
|
||
}
|
||
}
|
||
catch { }
|
||
|
||
space.AppendEntity(mt);
|
||
tr.AddNewlyCreatedDBObject(mt, true);
|
||
|
||
// 关键：标记该实体，保存模板文本
|
||
SetNoteTemplateData(tr, mt.ObjectId, schema.NoteTemplateText);
|
||
|
||
return new NoteApplyResult
|
||
{
|
||
Applied = true,
|
||
TargetKind = "CreatedMText",
|
||
PlaceholderCountInDwg = 0,
|
||
RenderedText = renderedForCreation,
|
||
Message = "未找到附注定位，已自动创建并标记。"
|
||
};
|
||
}
|
||
}
|
||
|
||
return new NoteApplyResult { Applied = false, Message = "未找到附注文本目标（包含‘附注’且包含占位符*），且无法自动定位创建，跳过。" };
|
||
}
|
||
|
||
var best = candidates.OrderByDescending(c => c.Score).FirstOrDefault();
|
||
if (best == null || best.Apply == null)
|
||
{
|
||
return new NoteApplyResult { Applied = false, Message = "未找到可替换的附注文本目标，跳过。" };
|
||
}
|
||
|
||
var templateText = best.PlainText ?? string.Empty;
|
||
var placeholderCount = NoteTemplateEngine.CountPlaceholders(templateText);
|
||
if (placeholderCount <= 0)
|
||
{
|
||
return new NoteApplyResult
|
||
{
|
||
Applied = false,
|
||
TargetKind = best.Kind,
|
||
PlaceholderCountInDwg = placeholderCount,
|
||
Message = "附注目标中未检测到有效占位符（*，忽略****），跳过。"
|
||
};
|
||
}
|
||
|
||
var effective = NoteTemplateEngine.BuildEffectiveValueKeyBindings(schema.NoteBindings);
|
||
var rendered = NoteTemplateEngine.Render(templateText, effective, getValueW);
|
||
best.Apply(rendered);
|
||
|
||
if (!best.TargetId.IsNull)
|
||
{
|
||
SetNoteTemplateData(tr, best.TargetId, templateText);
|
||
}
|
||
|
||
return new NoteApplyResult
|
||
{
|
||
Applied = true,
|
||
TargetKind = best.Kind,
|
||
PlaceholderCountInDwg = placeholderCount,
|
||
RenderedText = rendered,
|
||
Message = "附注已替换并标记。"
|
||
};
|
||
}
|
||
|
||
private static BlockTableRecord GetTargetSpace(Transaction tr, Database db, string layoutName, bool scanModelSpace)
|
||
{
|
||
if (tr == null || db == null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
// Default to ModelSpace if scanModelSpace requested OR layoutName is null/empty implicitly aiming for Model
|
||
if (scanModelSpace || string.IsNullOrWhiteSpace(layoutName) || string.Equals(layoutName, "Model", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
|
||
return (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
|
||
}
|
||
|
||
var layoutDict = (DBDictionary)tr.GetObject(db.LayoutDictionaryId, OpenMode.ForRead);
|
||
ObjectId layoutId = ObjectId.Null;
|
||
foreach (DBDictionaryEntry entry in layoutDict)
|
||
{
|
||
if (string.Equals(entry.Key, layoutName, StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
layoutId = entry.Value;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (layoutId.IsNull)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var layout = (Layout)tr.GetObject(layoutId, OpenMode.ForRead);
|
||
return (BlockTableRecord)tr.GetObject(layout.BlockTableRecordId, OpenMode.ForWrite);
|
||
}
|
||
|
||
private static void CollectNoteCandidates(Transaction tr, Entity ent, HashSet<ObjectId> visitedBlocks, List<NoteCandidate> candidates)
|
||
{
|
||
if (tr == null || ent == null || candidates == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (ent is DBText t)
|
||
{
|
||
AddNoteCandidateIfMatch(t.TextString, "DBText", t.ObjectId, tr, candidates);
|
||
return;
|
||
}
|
||
|
||
if (ent is MText mt)
|
||
{
|
||
var plain = SimplifyMText(mt.Contents);
|
||
AddNoteCandidateIfMatch(plain, "MText", mt.ObjectId, tr, candidates, mt.Contents);
|
||
return;
|
||
}
|
||
|
||
if (ent is BlockReference br)
|
||
{
|
||
foreach (ObjectId attId in br.AttributeCollection)
|
||
{
|
||
var att = tr.GetObject(attId, OpenMode.ForRead, false) as AttributeReference;
|
||
if (att == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
AddNoteCandidateIfMatch(att.TextString, "Attribute", attId, tr, candidates);
|
||
}
|
||
|
||
var blockId = br.BlockTableRecord;
|
||
if (blockId.IsNull)
|
||
{
|
||
return;
|
||
}
|
||
|
||
if (visitedBlocks == null)
|
||
{
|
||
visitedBlocks = new HashSet<ObjectId>();
|
||
}
|
||
|
||
if (visitedBlocks.Contains(blockId))
|
||
{
|
||
return;
|
||
}
|
||
visitedBlocks.Add(blockId);
|
||
|
||
var btr = tr.GetObject(blockId, OpenMode.ForRead, false) as BlockTableRecord;
|
||
if (btr == null)
|
||
{
|
||
return;
|
||
}
|
||
|
||
foreach (ObjectId childId in btr)
|
||
{
|
||
var child = tr.GetObject(childId, OpenMode.ForRead, false) as Entity;
|
||
if (child != null)
|
||
{
|
||
CollectNoteCandidates(tr, child, visitedBlocks, candidates);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private static void AddNoteCandidateIfMatch(string plainText, string kind, ObjectId id, Transaction tr, List<NoteCandidate> candidates, string originalContents = null)
|
||
{
|
||
if (!IsLikelyNoteText(plainText))
|
||
{
|
||
return;
|
||
}
|
||
|
||
var score = ComputeNoteScore(plainText);
|
||
if (score <= 0)
|
||
{
|
||
return;
|
||
}
|
||
|
||
candidates.Add(new NoteCandidate
|
||
{
|
||
Score = score,
|
||
Kind = kind,
|
||
TargetId = id, // Store ID
|
||
PlainText = plainText,
|
||
OriginalContents = originalContents,
|
||
Apply = rendered => ApplyNoteTextToObject(tr, id, kind, rendered, originalContents)
|
||
});
|
||
}
|
||
|
||
private static bool IsLikelyNoteText(string plain)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(plain))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (!plain.Contains("*"))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (plain.Contains("附注"))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
// fallback: numbered note line
|
||
return plain.Contains("1*") || plain.Contains("1 *");
|
||
}
|
||
|
||
private static int ComputeNoteScore(string plain)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(plain))
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
var score = 0;
|
||
var lines = SplitLines(plain).ToList();
|
||
|
||
if (plain.Contains("附注"))
|
||
{
|
||
score += 10;
|
||
}
|
||
|
||
if (lines.Count > 0 && string.Equals(lines[0].Trim(), "附注", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
score += 10;
|
||
}
|
||
|
||
if (plain.Contains("*"))
|
||
{
|
||
score += 5;
|
||
}
|
||
|
||
if (plain.Contains("1*"))
|
||
{
|
||
score += 3;
|
||
}
|
||
|
||
return score;
|
||
}
|
||
|
||
private static IEnumerable<string> SplitLines(string text)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(text))
|
||
{
|
||
return Enumerable.Empty<string>();
|
||
}
|
||
|
||
return (text ?? string.Empty)
|
||
.Replace("\r\n", "\n")
|
||
.Replace("\r", "\n")
|
||
.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries)
|
||
.Select(s => (s ?? string.Empty).Trim());
|
||
}
|
||
|
||
private static void ApplyNoteTextToObject(Transaction tr, ObjectId id, string kind, string rendered, string originalContents = null)
|
||
{
|
||
if (tr == null || id.IsNull)
|
||
{
|
||
return;
|
||
}
|
||
|
||
rendered = rendered ?? string.Empty;
|
||
|
||
// We try multiple types regardless of recorded kind to be safe.
|
||
var obj = tr.GetObject(id, OpenMode.ForWrite, false);
|
||
if (obj is MText mt)
|
||
{
|
||
// 如果有原始内容，在原始内容中直接替换占位符以保留格式
|
||
if (!string.IsNullOrEmpty(originalContents))
|
||
{
|
||
mt.Contents = ReplaceStarsInOriginalContents(originalContents, rendered);
|
||
}
|
||
else
|
||
{
|
||
mt.Contents = ToMTextContents(rendered);
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (obj is DBText t)
|
||
{
|
||
var collapsed = CollapseToSingleLine(rendered);
|
||
if (collapsed.Length > 250)
|
||
{
|
||
// DBText 在 CAD 中有硬性的 255 长度限制，长文本需升级为 MText
|
||
var newMt = new MText();
|
||
newMt.Contents = ToMTextContents(rendered); // 恢复原有折行
|
||
newMt.Location = t.Position;
|
||
newMt.TextHeight = t.Height;
|
||
newMt.Layer = t.Layer;
|
||
newMt.ColorIndex = t.ColorIndex;
|
||
newMt.TextStyleId = t.TextStyleId;
|
||
newMt.Rotation = t.Rotation;
|
||
|
||
if (!t.BlockId.IsNull)
|
||
{
|
||
var btr = (BlockTableRecord)tr.GetObject(t.BlockId, OpenMode.ForWrite);
|
||
btr.AppendEntity(newMt);
|
||
tr.AddNewlyCreatedDBObject(newMt, true);
|
||
t.Erase(true);
|
||
}
|
||
else
|
||
{
|
||
t.TextString = collapsed.Substring(0, 250);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
t.TextString = collapsed;
|
||
}
|
||
return;
|
||
}
|
||
|
||
if (obj is AttributeReference att)
|
||
{
|
||
var collapsed = CollapseToSingleLine(rendered);
|
||
if (collapsed.Length > 250)
|
||
{
|
||
// AttributeReference 同样受 255 长度限制，用同等 MText 挂载并隐去原文本
|
||
var newMt = new MText();
|
||
newMt.Contents = ToMTextContents(rendered);
|
||
newMt.Location = att.Position;
|
||
newMt.TextHeight = att.Height;
|
||
newMt.Layer = att.Layer;
|
||
newMt.ColorIndex = att.ColorIndex;
|
||
newMt.TextStyleId = att.TextStyleId;
|
||
newMt.Rotation = att.Rotation;
|
||
|
||
if (!att.OwnerId.IsNull)
|
||
{
|
||
var blk = tr.GetObject(att.OwnerId, OpenMode.ForRead) as BlockReference;
|
||
if (blk != null && !blk.OwnerId.IsNull)
|
||
{
|
||
var space = (BlockTableRecord)tr.GetObject(blk.OwnerId, OpenMode.ForWrite);
|
||
space.AppendEntity(newMt);
|
||
tr.AddNewlyCreatedDBObject(newMt, true);
|
||
|
||
att.TextString = "";
|
||
att.Invisible = true;
|
||
}
|
||
else
|
||
{
|
||
att.TextString = collapsed.Substring(0, 250);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
att.TextString = collapsed.Substring(0, 250);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
att.TextString = collapsed;
|
||
}
|
||
}
|
||
}
|
||
|
||
private static string ReplaceStarsInOriginalContents(string originalContents, string renderedPlainText)
|
||
{
|
||
if (string.IsNullOrEmpty(originalContents) || string.IsNullOrEmpty(renderedPlainText))
|
||
{
|
||
return ToMTextContents(renderedPlainText);
|
||
}
|
||
|
||
// 从SimplifyMText处理后的纯文本和渲染后的纯文本中提取*被替换成什么
|
||
var plainTemplate = SimplifyMText(originalContents);
|
||
|
||
// 提取每个占位符被替换成的值
|
||
var replacements = ExtractPlaceholderReplacements(plainTemplate, renderedPlainText);
|
||
if (replacements == null || replacements.Count == 0)
|
||
{
|
||
string newContents = ToMTextContents(renderedPlainText);
|
||
if (originalContents.StartsWith("{") && originalContents.Contains(";"))
|
||
{
|
||
var match = System.Text.RegularExpressions.Regex.Match(originalContents, @"^(\{\\[^;]+;)");
|
||
if (match.Success)
|
||
{
|
||
newContents = match.Groups[1].Value + newContents + "}";
|
||
}
|
||
}
|
||
return newContents;
|
||
}
|
||
|
||
// 在原始MText内容中直接替换*占位符
|
||
var result = new System.Text.StringBuilder();
|
||
var replacementIndex = 0;
|
||
|
||
for (var i = 0; i < originalContents.Length;)
|
||
{
|
||
var c = originalContents[i];
|
||
|
||
// 检查是否是占位符*
|
||
if (c == '*')
|
||
{
|
||
// 计算连续的*数量
|
||
var starCount = 0;
|
||
var j = i;
|
||
while (j < originalContents.Length && originalContents[j] == '*')
|
||
{
|
||
starCount++;
|
||
j++;
|
||
}
|
||
|
||
if (starCount == 4)
|
||
{
|
||
// 保留****
|
||
result.Append("****");
|
||
i += 4;
|
||
}
|
||
else
|
||
{
|
||
// 替换每个*
|
||
for (var k = 0; k < starCount; k++)
|
||
{
|
||
if (replacementIndex < replacements.Count)
|
||
{
|
||
result.Append(replacements[replacementIndex]);
|
||
replacementIndex++;
|
||
}
|
||
else
|
||
{
|
||
result.Append('*');
|
||
}
|
||
}
|
||
i += starCount;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
result.Append(c);
|
||
i++;
|
||
}
|
||
}
|
||
|
||
return result.ToString();
|
||
}
|
||
|
||
private static List<string> ExtractPlaceholderReplacements(string plainTemplate, string renderedText)
|
||
{
|
||
var replacements = new List<string>();
|
||
|
||
// 将两个文本按相同方式处理
|
||
var template = (plainTemplate ?? string.Empty)
|
||
.Replace("\r\n", "\n")
|
||
.Replace("\r", "\n");
|
||
var rendered = (renderedText ?? string.Empty)
|
||
.Replace("\r\n", "\n")
|
||
.Replace("\r", "\n");
|
||
|
||
var ti = 0; // template index
|
||
var ri = 0; // rendered index
|
||
|
||
while (ti < template.Length && ri < rendered.Length)
|
||
{
|
||
var tc = template[ti];
|
||
|
||
if (tc == '*')
|
||
{
|
||
// 检查是否是****
|
||
var starCount = 0;
|
||
var j = ti;
|
||
while (j < template.Length && template[j] == '*')
|
||
{
|
||
starCount++;
|
||
j++;
|
||
}
|
||
|
||
if (starCount == 4)
|
||
{
|
||
// ****保持不变，rendered中也应该有****
|
||
ti += 4;
|
||
if (ri + 4 <= rendered.Length && rendered.Substring(ri, 4) == "****")
|
||
{
|
||
ri += 4;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
// 提取替换内容
|
||
int nextTi = ti + starCount;
|
||
string nextLiteral = "";
|
||
while (nextTi < template.Length && template[nextTi] != '*')
|
||
{
|
||
nextLiteral += template[nextTi];
|
||
nextTi++;
|
||
}
|
||
|
||
if (string.IsNullOrEmpty(nextLiteral))
|
||
{
|
||
// 如果后面没有文字了，那么直接把 rendered 中剩下的所有文字都给第一颗 *
|
||
string rep = rendered.Substring(ri);
|
||
for (int k = 0; k < starCount; k++)
|
||
{
|
||
replacements.Add(k == 0 ? rep : "");
|
||
}
|
||
ri = rendered.Length;
|
||
ti += starCount;
|
||
}
|
||
else
|
||
{
|
||
// 在 rendered 中寻找 nextLiteral
|
||
int foundIndex = rendered.IndexOf(nextLiteral, ri);
|
||
if (foundIndex >= 0)
|
||
{
|
||
string rep = rendered.Substring(ri, foundIndex - ri);
|
||
for (int k = 0; k < starCount; k++)
|
||
{
|
||
replacements.Add(k == 0 ? rep : "");
|
||
}
|
||
ri = foundIndex;
|
||
ti += starCount;
|
||
}
|
||
else
|
||
{
|
||
// 找不到说明因为换行、标点清理或重编号导致了较大差异，直接回退整段格式
|
||
return new List<string>();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if (tc == rendered[ri])
|
||
{
|
||
ti++;
|
||
ri++;
|
||
}
|
||
else
|
||
{
|
||
// 不匹配说明有由于处理（如空行、或者清理了符号）导致文字不一致
|
||
// 直接返回以使用完全的 ToMTextContents(rendered) 包含 MText 的原字体格式
|
||
return new List<string>();
|
||
}
|
||
}
|
||
}
|
||
|
||
return replacements;
|
||
}
|
||
|
||
private static string ToMTextContents(string plainText)
|
||
{
|
||
if (string.IsNullOrEmpty(plainText))
|
||
{
|
||
return string.Empty;
|
||
}
|
||
|
||
var s = plainText
|
||
.Replace("\r\n", "\n")
|
||
.Replace("\r", "\n")
|
||
.Replace("\n", "\\P");
|
||
return s;
|
||
}
|
||
|
||
private static string CollapseToSingleLine(string text)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(text))
|
||
{
|
||
return string.Empty;
|
||
}
|
||
|
||
var parts = (text ?? string.Empty)
|
||
.Replace("\r\n", "\n")
|
||
.Replace("\r", "\n")
|
||
.Split(new[] { '\n' }, StringSplitOptions.RemoveEmptyEntries)
|
||
.Select(s => (s ?? string.Empty).Trim())
|
||
.Where(s => s.Length > 0)
|
||
.ToArray();
|
||
|
||
return string.Join(" ", parts);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 确保特性分类文字周围有框体，如果没有则创建
|
||
/// </summary>
|
||
private static void EnsureFeatureCategoryBox(Transaction tr, Database db, BlockTableRecord space, List<Entity> spaceEntList, ObjectId textEntityId, Action<string> logAction)
|
||
{
|
||
// 获取文字实体的最新范围
|
||
Extents3d textExt;
|
||
try
|
||
{
|
||
var textEnt = tr.GetObject(textEntityId, OpenMode.ForRead, false) as Entity;
|
||
if (textEnt == null || textEnt.IsErased) return;
|
||
|
||
// 针对 MText，使用实际文字范围而非控制框范围
|
||
if (textEnt is MText mt)
|
||
{
|
||
// MText 的 Location 是插入点，根据 Attachment 不同位置不同
|
||
// 使用 ActualWidth 和 ActualHeight 获取实际文字尺寸
|
||
var loc = mt.Location;
|
||
var actualW = mt.ActualWidth;
|
||
var actualH = mt.ActualHeight;
|
||
|
||
// 根据 Attachment 计算实际边界
|
||
double minX, maxX, minY, maxY;
|
||
switch (mt.Attachment)
|
||
{
|
||
case AttachmentPoint.TopLeft:
|
||
minX = loc.X; maxX = loc.X + actualW;
|
||
minY = loc.Y - actualH; maxY = loc.Y;
|
||
break;
|
||
case AttachmentPoint.TopCenter:
|
||
minX = loc.X - actualW / 2; maxX = loc.X + actualW / 2;
|
||
minY = loc.Y - actualH; maxY = loc.Y;
|
||
break;
|
||
case AttachmentPoint.TopRight:
|
||
minX = loc.X - actualW; maxX = loc.X;
|
||
minY = loc.Y - actualH; maxY = loc.Y;
|
||
break;
|
||
case AttachmentPoint.MiddleLeft:
|
||
minX = loc.X; maxX = loc.X + actualW;
|
||
minY = loc.Y - actualH / 2; maxY = loc.Y + actualH / 2;
|
||
break;
|
||
case AttachmentPoint.MiddleCenter:
|
||
minX = loc.X - actualW / 2; maxX = loc.X + actualW / 2;
|
||
minY = loc.Y - actualH / 2; maxY = loc.Y + actualH / 2;
|
||
break;
|
||
case AttachmentPoint.MiddleRight:
|
||
minX = loc.X - actualW; maxX = loc.X;
|
||
minY = loc.Y - actualH / 2; maxY = loc.Y + actualH / 2;
|
||
break;
|
||
case AttachmentPoint.BottomLeft:
|
||
minX = loc.X; maxX = loc.X + actualW;
|
||
minY = loc.Y; maxY = loc.Y + actualH;
|
||
break;
|
||
case AttachmentPoint.BottomCenter:
|
||
minX = loc.X - actualW / 2; maxX = loc.X + actualW / 2;
|
||
minY = loc.Y; maxY = loc.Y + actualH;
|
||
break;
|
||
case AttachmentPoint.BottomRight:
|
||
minX = loc.X - actualW; maxX = loc.X;
|
||
minY = loc.Y; maxY = loc.Y + actualH;
|
||
break;
|
||
default:
|
||
// 兜底使用 GeometricExtents
|
||
textExt = textEnt.GeometricExtents;
|
||
goto afterExtents;
|
||
}
|
||
textExt = new Extents3d(new Point3d(minX, minY, 0), new Point3d(maxX, maxY, 0));
|
||
|
||
logAction?.Invoke($"[DEBUG] MText: Loc=({loc.X:F1},{loc.Y:F1}), W={actualW:F1}, H={actualH:F1}, Attach={mt.Attachment}");
|
||
logAction?.Invoke($"[DEBUG] 计算范围: ({minX:F1},{minY:F1})->({maxX:F1},{maxY:F1})");
|
||
}
|
||
else
|
||
{
|
||
textExt = textEnt.GeometricExtents;
|
||
}
|
||
afterExtents:;
|
||
|
||
logAction?.Invoke($"[DEBUG] 最终范围: Min=({textExt.MinPoint.X:F1},{textExt.MinPoint.Y:F1}), Max=({textExt.MaxPoint.X:F1},{textExt.MaxPoint.Y:F1})");
|
||
}
|
||
catch (System.Exception ex)
|
||
{
|
||
logAction?.Invoke($"[DEBUG] 获取范围失败: {ex.Message}");
|
||
return;
|
||
}
|
||
|
||
// 检查是否已经有包围该文字的闭合 Polyline（大小匹配）
|
||
bool hasBox = false;
|
||
var textWidth = textExt.MaxPoint.X - textExt.MinPoint.X;
|
||
var textHeight = textExt.MaxPoint.Y - textExt.MinPoint.Y;
|
||
// 框体最大允许尺寸 = 文字尺寸 + 最大 padding (5mm)
|
||
var maxBoxWidth = textWidth + 10.0; // 两边各5mm
|
||
var maxBoxHeight = textHeight + 10.0; // 上下各5mm
|
||
|
||
foreach (var ent in spaceEntList)
|
||
{
|
||
if (ent is Polyline pl && pl.Closed && !pl.IsErased)
|
||
{
|
||
try
|
||
{
|
||
var ex = pl.GeometricExtents;
|
||
var boxWidth = ex.MaxPoint.X - ex.MinPoint.X;
|
||
var boxHeight = ex.MaxPoint.Y - ex.MinPoint.Y;
|
||
|
||
// 检查 Polyline 是否包围文字（有 0.1 的容差）
|
||
// 并且大小接近文字大小（不能太大，避免误判表格边框）
|
||
if (ex.MinPoint.X <= textExt.MinPoint.X - 0.1
|
||
&& ex.MaxPoint.X >= textExt.MaxPoint.X + 0.1
|
||
&& ex.MinPoint.Y <= textExt.MinPoint.Y - 0.1
|
||
&& ex.MaxPoint.Y >= textExt.MaxPoint.Y + 0.1
|
||
&& boxWidth <= maxBoxWidth
|
||
&& boxHeight <= maxBoxHeight)
|
||
{
|
||
hasBox = true;
|
||
logAction?.Invoke($"[DEBUG] 已找到匹配框体: 框体尺寸({boxWidth:F1}x{boxHeight:F1}), 文字尺寸({textWidth:F1}x{textHeight:F1}), 图层={pl.Layer}");
|
||
|
||
// 将框体移动到安全图层，防止被 RemoveTemplateOriginalDrawing 删除
|
||
try
|
||
{
|
||
var plWrite = (Polyline)tr.GetObject(pl.ObjectId, OpenMode.ForWrite, false);
|
||
var layerTbl = (LayerTable)tr.GetObject(db.LayerTableId, OpenMode.ForRead);
|
||
string safeLayer = "0";
|
||
if (layerTbl.Has("TEXT")) safeLayer = "TEXT";
|
||
else if (layerTbl.Has("文字")) safeLayer = "文字";
|
||
plWrite.Layer = safeLayer;
|
||
plWrite.ColorIndex = 7; // 设置为白色
|
||
logAction?.Invoke($"[DEBUG] 已将框体移动到安全图层: {safeLayer}, 颜色已设置为白色");
|
||
|
||
// 标记此框体，便于后续识别
|
||
var groupId = Guid.NewGuid().ToString("N");
|
||
SetFeatureCategoryData(tr, pl.ObjectId, string.Empty, groupId, "FallbackBox");
|
||
}
|
||
catch { }
|
||
|
||
break;
|
||
}
|
||
}
|
||
catch { }
|
||
}
|
||
}
|
||
|
||
// 如果没有框体，则创建一个
|
||
if (!hasBox)
|
||
{
|
||
double paddingH = 1.5;
|
||
double paddingV = 1.5;
|
||
|
||
var boxMinX = textExt.MinPoint.X - paddingH;
|
||
var boxMaxX = textExt.MaxPoint.X + paddingH;
|
||
var boxMinY = textExt.MinPoint.Y - paddingV;
|
||
var boxMaxY = textExt.MaxPoint.Y + paddingV;
|
||
|
||
logAction?.Invoke($"[DEBUG] 创建框体: ({boxMinX:F1},{boxMinY:F1})->({boxMaxX:F1},{boxMaxY:F1})");
|
||
|
||
var poly = new Polyline();
|
||
poly.AddVertexAt(0, new Point2d(boxMinX, boxMinY), 0, 0, 0);
|
||
poly.AddVertexAt(1, new Point2d(boxMaxX, boxMinY), 0, 0, 0);
|
||
poly.AddVertexAt(2, new Point2d(boxMaxX, boxMaxY), 0, 0, 0);
|
||
poly.AddVertexAt(3, new Point2d(boxMinX, boxMaxY), 0, 0, 0);
|
||
poly.Closed = true;
|
||
poly.ColorIndex = 7; // White
|
||
|
||
try
|
||
{
|
||
var layerTbl = (LayerTable)tr.GetObject(db.LayerTableId, OpenMode.ForRead);
|
||
string targetLayer = "0";
|
||
if (layerTbl.Has("TEXT")) targetLayer = "TEXT";
|
||
else if (layerTbl.Has("文字")) targetLayer = "文字";
|
||
poly.Layer = targetLayer;
|
||
}
|
||
catch { }
|
||
|
||
space.AppendEntity(poly);
|
||
tr.AddNewlyCreatedDBObject(poly, true);
|
||
|
||
var groupId = Guid.NewGuid().ToString("N");
|
||
try { SetFeatureCategoryData(tr, poly.ObjectId, string.Empty, groupId, "FallbackBox"); } catch { }
|
||
}
|
||
}
|
||
|
||
public static int ApplyFeatureCategory(CadContext ctx, string layoutName, bool scanModelSpace, ParamBag bag, Action<string> logAction = null)
|
||
{
|
||
if (ctx == null || bag == null)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
var category = bag.GetString("FeatureCategory");
|
||
|
||
// Logic: Is "一般件" -> show blank.
|
||
// Is "关键件"/"重要件" -> show text.
|
||
|
||
var textToShow = category;
|
||
if (string.IsNullOrWhiteSpace(textToShow) || string.Equals(textToShow, "一般件", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
textToShow = string.Empty; // Show blank
|
||
}
|
||
|
||
logAction?.Invoke($"[DEBUG] ApplyFeatureCategory: category='{category}', textToShow='{textToShow}'");
|
||
|
||
var db = ctx.Database;
|
||
var tr = ctx.Transaction;
|
||
var space = GetTargetSpace(tr, db, layoutName, scanModelSpace);
|
||
|
||
if (space == null) return 0;
|
||
|
||
var ids = space.Cast<ObjectId>().ToArray();
|
||
logAction?.Invoke($"[DEBUG] Space实体数量: {ids.Length}");
|
||
|
||
int count = 0;
|
||
|
||
// 0) If we previously created fallback feature-category texts, update or remove them (prevents duplication).
|
||
var fallbackGroupIdsToRemove = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
|
||
foreach (var id in ids)
|
||
{
|
||
FeatureCategoryData fcData = null;
|
||
try { fcData = GetFeatureCategoryData(tr, id); } catch { }
|
||
if (fcData == null || string.IsNullOrWhiteSpace(fcData.Role))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (string.Equals(fcData.Role, "FallbackText", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var ent = tr.GetObject(id, OpenMode.ForWrite, false) as Entity;
|
||
if (ent == null) continue;
|
||
|
||
if (string.IsNullOrWhiteSpace(textToShow))
|
||
{
|
||
if (!ent.IsErased) ent.Erase();
|
||
if (!string.IsNullOrWhiteSpace(fcData.GroupId)) fallbackGroupIdsToRemove.Add(fcData.GroupId);
|
||
continue;
|
||
}
|
||
|
||
if (ent is MText mt)
|
||
{
|
||
mt.Contents = @"{\fSimSun|b0|i0|c134|p2;" + ToMTextContents(textToShow) + "}";
|
||
count++;
|
||
}
|
||
}
|
||
else if (string.Equals(fcData.Role, "FallbackBox", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
if (string.IsNullOrWhiteSpace(textToShow) && !string.IsNullOrWhiteSpace(fcData.GroupId))
|
||
{
|
||
fallbackGroupIdsToRemove.Add(fcData.GroupId);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
if (fallbackGroupIdsToRemove.Count > 0)
|
||
{
|
||
foreach (var id in ids)
|
||
{
|
||
FeatureCategoryData fcData = null;
|
||
try { fcData = GetFeatureCategoryData(tr, id); } catch { }
|
||
if (fcData == null || string.IsNullOrWhiteSpace(fcData.GroupId)) continue;
|
||
if (!fallbackGroupIdsToRemove.Contains(fcData.GroupId)) continue;
|
||
|
||
var ent = tr.GetObject(id, OpenMode.ForWrite, false) as Entity;
|
||
if (ent == null) continue;
|
||
if (!ent.IsErased) ent.Erase();
|
||
}
|
||
}
|
||
|
||
// 1) Update previously replaced placeholder entities using stored original template.
|
||
// 收集被替换的占位符文字实体ID，以便后续检查框体
|
||
var replacedPlaceholderIds = new List<ObjectId>();
|
||
|
||
foreach (var id in ids)
|
||
{
|
||
var ent = tr.GetObject(id, OpenMode.ForWrite, false) as Entity;
|
||
if (ent == null) continue;
|
||
|
||
if (ent is DBText t)
|
||
{
|
||
FeatureCategoryData fcData = null;
|
||
try { fcData = GetFeatureCategoryData(tr, id); } catch { }
|
||
|
||
if (fcData != null && string.Equals(fcData.Role, "Placeholder", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var original = fcData.OriginalTemplate ?? string.Empty;
|
||
t.TextString = original.Contains("******") ? original.Replace("******", textToShow) : textToShow;
|
||
count++;
|
||
replacedPlaceholderIds.Add(id);
|
||
continue;
|
||
}
|
||
|
||
if (t.TextString != null && t.TextString.Contains("******"))
|
||
{
|
||
var original = t.TextString;
|
||
t.TextString = original.Replace("******", textToShow);
|
||
try { SetFeatureCategoryData(tr, id, original, null, "Placeholder"); } catch { }
|
||
count++;
|
||
replacedPlaceholderIds.Add(id);
|
||
}
|
||
}
|
||
else if (ent is MText mt)
|
||
{
|
||
FeatureCategoryData fcData = null;
|
||
try { fcData = GetFeatureCategoryData(tr, id); } catch { }
|
||
|
||
if (fcData != null && string.Equals(fcData.Role, "Placeholder", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var original = fcData.OriginalTemplate ?? string.Empty;
|
||
mt.Contents = original.Contains("******") ? original.Replace("******", textToShow) : textToShow;
|
||
count++;
|
||
replacedPlaceholderIds.Add(id);
|
||
continue;
|
||
}
|
||
|
||
if (mt.Contents != null && mt.Contents.Contains("******"))
|
||
{
|
||
var original = mt.Contents;
|
||
mt.Contents = original.Replace("******", textToShow);
|
||
try { SetFeatureCategoryData(tr, id, original, null, "Placeholder"); } catch { }
|
||
count++;
|
||
replacedPlaceholderIds.Add(id);
|
||
}
|
||
}
|
||
else if (ent is BlockReference br)
|
||
{
|
||
foreach (ObjectId attId in br.AttributeCollection)
|
||
{
|
||
var att = tr.GetObject(attId, OpenMode.ForWrite, false) as AttributeReference;
|
||
if (att == null) continue;
|
||
|
||
FeatureCategoryData fcData = null;
|
||
try { fcData = GetFeatureCategoryData(tr, attId); } catch { }
|
||
|
||
if (fcData != null && string.Equals(fcData.Role, "Placeholder", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
var original = fcData.OriginalTemplate ?? string.Empty;
|
||
att.TextString = original.Contains("******") ? original.Replace("******", textToShow) : textToShow;
|
||
count++;
|
||
replacedPlaceholderIds.Add(attId);
|
||
continue;
|
||
}
|
||
|
||
if (att.TextString != null && att.TextString.Contains("******"))
|
||
{
|
||
var original = att.TextString;
|
||
att.TextString = original.Replace("******", textToShow);
|
||
try { SetFeatureCategoryData(tr, attId, original, null, "Placeholder"); } catch { }
|
||
count++;
|
||
replacedPlaceholderIds.Add(attId);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
logAction?.Invoke($"[DEBUG] 替换占位符数量: {replacedPlaceholderIds.Count}, count: {count}");
|
||
|
||
// 2) 如果有被替换的占位符且内容不为空（非"一般件"），检查并确保每个占位符都有框体
|
||
if (replacedPlaceholderIds.Count > 0 && !string.IsNullOrWhiteSpace(textToShow))
|
||
{
|
||
logAction?.Invoke($"[DEBUG] 进入框体检查逻辑，textToShow='{textToShow}'");
|
||
|
||
// 获取实体列表用于框体检查
|
||
var spaceEntListForBox = ids
|
||
.Select(x =>
|
||
{
|
||
try { return tr.GetObject(x, OpenMode.ForRead, false) as Entity; }
|
||
catch { return null; }
|
||
})
|
||
.Where(e => e != null && !e.IsErased)
|
||
.ToList();
|
||
|
||
foreach (var placeholderId in replacedPlaceholderIds)
|
||
{
|
||
logAction?.Invoke($"[DEBUG] 调用 EnsureFeatureCategoryBox, placeholderId={placeholderId}");
|
||
EnsureFeatureCategoryBox(tr, db, space, spaceEntListForBox, placeholderId, logAction);
|
||
}
|
||
}
|
||
|
||
// If the category is blank ("一般件"), also try to remove previously inserted bottom-right category texts/boxes (legacy, unmarked).
|
||
if (string.IsNullOrWhiteSpace(textToShow))
|
||
{
|
||
try
|
||
{
|
||
var spaceEntList = ids
|
||
.Select(x =>
|
||
{
|
||
try { return tr.GetObject(x, OpenMode.ForRead, false) as Entity; }
|
||
catch { return null; }
|
||
})
|
||
.Where(e => e != null && !e.IsErased)
|
||
.ToList();
|
||
|
||
var frame = ComputeWhiteFrameExtentsFromEntities(tr, spaceEntList);
|
||
if (frame.HasValue)
|
||
{
|
||
var f = frame.Value;
|
||
var known = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "关键件", "重要件" };
|
||
var regionMinX = f.MaxPoint.X - 220.0;
|
||
var regionMaxX = f.MaxPoint.X + 5.0;
|
||
var regionMinY = f.MinPoint.Y - 5.0;
|
||
var regionMaxY = f.MinPoint.Y + 140.0;
|
||
|
||
var candidates = new List<Tuple<ObjectId, Extents3d>>();
|
||
foreach (var e in spaceEntList)
|
||
{
|
||
try
|
||
{
|
||
var ex = e.GeometricExtents;
|
||
if (ex.MaxPoint.X < regionMinX || ex.MinPoint.X > regionMaxX || ex.MaxPoint.Y < regionMinY || ex.MinPoint.Y > regionMaxY)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (e is DBText dt)
|
||
{
|
||
var txt = (dt.TextString ?? string.Empty).Trim();
|
||
if (known.Contains(txt)) candidates.Add(Tuple.Create(e.ObjectId, ex));
|
||
}
|
||
else if (e is MText mtt)
|
||
{
|
||
var txt = ExtractMTextPlainText(mtt.Contents);
|
||
if (known.Contains(txt)) candidates.Add(Tuple.Create(e.ObjectId, ex));
|
||
}
|
||
}
|
||
catch { }
|
||
}
|
||
|
||
if (candidates.Count > 0)
|
||
{
|
||
foreach (var c in candidates)
|
||
{
|
||
try
|
||
{
|
||
var w = tr.GetObject(c.Item1, OpenMode.ForWrite, false) as Entity;
|
||
if (w != null && !w.IsErased) w.Erase();
|
||
}
|
||
catch { }
|
||
}
|
||
|
||
foreach (var e in spaceEntList)
|
||
{
|
||
if (e is Polyline pl)
|
||
{
|
||
try
|
||
{
|
||
if (!pl.Closed) continue;
|
||
var ex = pl.GeometricExtents;
|
||
var matchesAny = candidates.Any(c =>
|
||
ex.MinPoint.X <= c.Item2.MinPoint.X - 0.1
|
||
&& ex.MaxPoint.X >= c.Item2.MaxPoint.X + 0.1
|
||
&& ex.MinPoint.Y <= c.Item2.MinPoint.Y - 0.1
|
||
&& ex.MaxPoint.Y >= c.Item2.MaxPoint.Y + 0.1);
|
||
if (matchesAny)
|
||
{
|
||
var w = tr.GetObject(pl.ObjectId, OpenMode.ForWrite, false) as Entity;
|
||
if (w != null && !w.IsErased) w.Erase();
|
||
}
|
||
}
|
||
catch { }
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// ignore
|
||
}
|
||
|
||
return count;
|
||
}
|
||
|
||
// Fallback: If no placeholder found AND we have text to show (e.g. "关键件"), create it manually.
|
||
if (count == 0 && !string.IsNullOrWhiteSpace(textToShow))
|
||
{
|
||
// Try to find white frame to determine position
|
||
var spaceEntList = space.Cast<ObjectId>()
|
||
.Select(id =>
|
||
{
|
||
try { return tr.GetObject(id, OpenMode.ForRead, false) as Entity; }
|
||
catch { return null; }
|
||
})
|
||
.Where(e => e != null && !e.IsErased)
|
||
.ToList();
|
||
|
||
var frame = ComputeWhiteFrameExtentsFromEntities(tr, spaceEntList);
|
||
if (frame.HasValue)
|
||
{
|
||
var f = frame.Value;
|
||
|
||
// 1) Heuristic: update/cleanup existing (older) feature-category texts in the bottom-right area
|
||
var known = new HashSet<string>(StringComparer.OrdinalIgnoreCase) { "关键件", "重要件" };
|
||
var regionMinX = f.MaxPoint.X - 220.0;
|
||
var regionMaxX = f.MaxPoint.X + 5.0;
|
||
var regionMinY = f.MinPoint.Y - 5.0;
|
||
var regionMaxY = f.MinPoint.Y + 140.0;
|
||
|
||
var candidates = new List<Tuple<ObjectId, Extents3d, string>>();
|
||
foreach (var ent in spaceEntList)
|
||
{
|
||
if (ent == null) continue;
|
||
try
|
||
{
|
||
var ex = ent.GeometricExtents;
|
||
if (ex.MaxPoint.X < regionMinX || ex.MinPoint.X > regionMaxX || ex.MaxPoint.Y < regionMinY || ex.MinPoint.Y > regionMaxY)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (ent is DBText dt)
|
||
{
|
||
var txt = (dt.TextString ?? string.Empty).Trim();
|
||
if (known.Contains(txt))
|
||
{
|
||
candidates.Add(Tuple.Create(ent.ObjectId, ex, txt));
|
||
}
|
||
}
|
||
else if (ent is MText mtt)
|
||
{
|
||
var txt = ExtractMTextPlainText(mtt.Contents);
|
||
if (known.Contains(txt))
|
||
{
|
||
candidates.Add(Tuple.Create(ent.ObjectId, ex, txt));
|
||
}
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// ignore
|
||
}
|
||
}
|
||
|
||
if (candidates.Count > 0)
|
||
{
|
||
// Keep the right-most (then top-most) one, erase the rest.
|
||
var keep = candidates
|
||
.OrderByDescending(c => c.Item2.MaxPoint.X)
|
||
.ThenByDescending(c => c.Item2.MaxPoint.Y)
|
||
.First();
|
||
|
||
var keepId = keep.Item1;
|
||
var keepExt = keep.Item2;
|
||
|
||
foreach (var c in candidates)
|
||
{
|
||
if (c.Item1 == keepId) continue;
|
||
try
|
||
{
|
||
var e = tr.GetObject(c.Item1, OpenMode.ForWrite, false) as Entity;
|
||
if (e != null && !e.IsErased) e.Erase();
|
||
}
|
||
catch { }
|
||
}
|
||
|
||
// Remove boxes that belong to removed texts (keep the one containing kept text)
|
||
foreach (var ent in spaceEntList)
|
||
{
|
||
if (ent is Polyline pl)
|
||
{
|
||
try
|
||
{
|
||
if (!pl.Closed) continue;
|
||
var ex = pl.GeometricExtents;
|
||
|
||
var containsKept = ex.MinPoint.X <= keepExt.MinPoint.X - 0.1
|
||
&& ex.MaxPoint.X >= keepExt.MaxPoint.X + 0.1
|
||
&& ex.MinPoint.Y <= keepExt.MinPoint.Y - 0.1
|
||
&& ex.MaxPoint.Y >= keepExt.MaxPoint.Y + 0.1;
|
||
if (containsKept) continue;
|
||
|
||
var matchesAnyRemoved = candidates.Any(c => c.Item1 != keepId
|
||
&& ex.MinPoint.X <= c.Item2.MinPoint.X - 0.1
|
||
&& ex.MaxPoint.X >= c.Item2.MaxPoint.X + 0.1
|
||
&& ex.MinPoint.Y <= c.Item2.MinPoint.Y - 0.1
|
||
&& ex.MaxPoint.Y >= c.Item2.MaxPoint.Y + 0.1);
|
||
|
||
if (matchesAnyRemoved)
|
||
{
|
||
var w = tr.GetObject(pl.ObjectId, OpenMode.ForWrite, false) as Entity;
|
||
if (w != null && !w.IsErased) w.Erase();
|
||
}
|
||
}
|
||
catch { }
|
||
}
|
||
}
|
||
|
||
// Update kept text and mark it so next run won't fall back.
|
||
try
|
||
{
|
||
var e = tr.GetObject(keepId, OpenMode.ForWrite, false) as Entity;
|
||
if (e is DBText dt)
|
||
{
|
||
dt.TextString = textToShow;
|
||
SetFeatureCategoryData(tr, keepId, "******", null, "Placeholder");
|
||
|
||
// 检查是否有包围该文字的框体，如果没有则创建
|
||
EnsureFeatureCategoryBox(tr, db, space, spaceEntList, keepId, logAction);
|
||
return 1;
|
||
}
|
||
if (e is MText mtt)
|
||
{
|
||
// Preserve its formatting if any; otherwise use our default.
|
||
var plain = ExtractMTextPlainText(mtt.Contents);
|
||
if (string.Equals(plain, mtt.Contents, StringComparison.Ordinal))
|
||
{
|
||
mtt.Contents = @"{\fSimSun|b0|i0|c134|p2;" + ToMTextContents(textToShow) + "}";
|
||
}
|
||
else
|
||
{
|
||
mtt.Contents = mtt.Contents.Replace(plain, textToShow);
|
||
}
|
||
SetFeatureCategoryData(tr, keepId, "******", null, "Placeholder");
|
||
|
||
// 检查是否有包围该文字的框体，如果没有则创建
|
||
EnsureFeatureCategoryBox(tr, db, space, spaceEntList, keepId, logAction);
|
||
return 1;
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// ignore
|
||
}
|
||
}
|
||
|
||
// Strategy:
|
||
// 1. Align Right: Use f.MaxX as the right boundary anchor.
|
||
// 2. Find Table Top: Look for horizontal lines in the bottom-right quadrant to find the top of the title block.
|
||
// If found, place text above that line. If not, use a safe default from bottom.
|
||
|
||
var searchRegionMinX = f.MaxPoint.X - 200.0; // Assume title block width < 200
|
||
var searchRegionMinY = f.MinPoint.Y;
|
||
var searchRegionMaxY = f.MinPoint.Y + 80.0; // Reduce to avoid picking up drawing lines (Title block usually < 80mm)
|
||
|
||
double tableTopY = f.MinPoint.Y + 60.0; // Default fallback (e.g. 60mm from bottom)
|
||
|
||
// Scan lines to find the highest horizontal line in this region which represents the table top
|
||
var candidatesY = new List<double>();
|
||
foreach (var ent in spaceEntList)
|
||
{
|
||
if (ent is Line ln)
|
||
{
|
||
if (ln.StartPoint.X > searchRegionMinX && ln.EndPoint.X > searchRegionMinX &&
|
||
ln.StartPoint.Y > searchRegionMinY && ln.StartPoint.Y < searchRegionMaxY &&
|
||
Math.Abs(ln.StartPoint.Y - ln.EndPoint.Y) < 1.0) // Horizontal
|
||
{
|
||
candidatesY.Add(ln.StartPoint.Y);
|
||
}
|
||
}
|
||
else if (ent is Polyline pl)
|
||
{
|
||
for (int i = 0; i < pl.NumberOfVertices; i++)
|
||
{
|
||
var pt = pl.GetPoint3dAt(i);
|
||
if (pt.X > searchRegionMinX && pt.Y > searchRegionMinY && pt.Y < searchRegionMaxY)
|
||
{
|
||
candidatesY.Add(pt.Y);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
if (candidatesY.Count > 0)
|
||
{
|
||
// The "Title Block" usually consists of many lines.
|
||
// We want the top-most line of the block, but "below" the drawing area.
|
||
// Let's take the max Y found in that bottom-right corner zone.
|
||
tableTopY = candidatesY.Max();
|
||
}
|
||
|
||
// Position:
|
||
// X: f.MaxX - 5 (margin) - (TextWidth/2 treated by Attachment) => Let's use TopRight or MiddleRight alignment
|
||
// Anchor at f.MaxX - 2.0 (small margin from right border line)
|
||
// Y: tableTopY + 2.0 (small gap above the table line)
|
||
// Anchor BottomRight or BottomLeft?
|
||
// User image shows text centered in a box-like area ABOVE the table rows.
|
||
// Let's align BottomRight to (MaxX - margin, TableTop + margin)
|
||
|
||
var insertX = f.MaxPoint.X - 5.0;
|
||
var insertY = tableTopY + 2.0;
|
||
var insertPoint = new Point3d(insertX, insertY, 0);
|
||
|
||
var groupId = Guid.NewGuid().ToString("N");
|
||
|
||
var textHeight = 3.2; // 9号字 (interpreted as 9pt approx 3.2mm)
|
||
var mt = new MText();
|
||
// Set font to SimSun (宋体)
|
||
mt.Contents = @"{\fSimSun|b0|i0|c134|p2;" + ToMTextContents(textToShow) + "}";
|
||
mt.Location = insertPoint;
|
||
mt.TextHeight = textHeight;
|
||
mt.Attachment = AttachmentPoint.BottomRight; // Anchor at bottom-right
|
||
mt.Width = 0; // No wrap width, auto
|
||
mt.ColorIndex = 7; // White
|
||
|
||
// Create White Border
|
||
// Estimate dimensions: Chinese char width approx equals height
|
||
// Adding padding to visually center the text in the box
|
||
double charWidthFactor = 1.0;
|
||
double estimatedTextWidth = textToShow.Length * textHeight * charWidthFactor;
|
||
double paddingH = 1.5; // Horizontal padding
|
||
double paddingV = 1.5; // Vertical padding
|
||
|
||
// Since Attachment is BottomRight:
|
||
// Text occupies roughly: [X - Width, X] x [Y, Y + Height]
|
||
// We draw box around this area with padding
|
||
|
||
var boxMinX = insertX - estimatedTextWidth - paddingH;
|
||
var boxMaxX = insertX + paddingH;
|
||
var boxMinY = insertY - paddingV;
|
||
var boxMaxY = insertY + textHeight + paddingV;
|
||
|
||
var poly = new Polyline();
|
||
poly.AddVertexAt(0, new Point2d(boxMinX, boxMinY), 0, 0, 0);
|
||
poly.AddVertexAt(1, new Point2d(boxMaxX, boxMinY), 0, 0, 0);
|
||
poly.AddVertexAt(2, new Point2d(boxMaxX, boxMaxY), 0, 0, 0);
|
||
poly.AddVertexAt(3, new Point2d(boxMinX, boxMaxY), 0, 0, 0);
|
||
poly.Closed = true;
|
||
poly.ColorIndex = 7; // White (Index 7 is White/Black depending on bg, usually White for plot)
|
||
|
||
try
|
||
{
|
||
var layerTbl = (LayerTable)tr.GetObject(db.LayerTableId, OpenMode.ForRead);
|
||
string targetLayer = "0";
|
||
if (layerTbl.Has("TEXT")) targetLayer = "TEXT";
|
||
else if (layerTbl.Has("文字")) targetLayer = "文字";
|
||
|
||
// Assign layer to both MText and Box
|
||
mt.Layer = targetLayer;
|
||
poly.Layer = targetLayer;
|
||
}
|
||
catch { }
|
||
|
||
space.AppendEntity(poly);
|
||
tr.AddNewlyCreatedDBObject(poly, true);
|
||
try { SetFeatureCategoryData(tr, poly.ObjectId, string.Empty, groupId, "FallbackBox"); } catch { }
|
||
|
||
|
||
|
||
space.AppendEntity(mt);
|
||
tr.AddNewlyCreatedDBObject(mt, true);
|
||
try { SetFeatureCategoryData(tr, mt.ObjectId, string.Empty, groupId, "FallbackText"); } catch { }
|
||
count++;
|
||
}
|
||
}
|
||
|
||
return count;
|
||
}
|
||
|
||
public static void KeepOnlyLayout(Document doc, string layoutName)
|
||
{
|
||
if (doc == null)
|
||
{
|
||
throw new ArgumentNullException(nameof(doc));
|
||
}
|
||
|
||
if (string.IsNullOrWhiteSpace(layoutName))
|
||
{
|
||
return;
|
||
}
|
||
|
||
using (doc.LockDocument())
|
||
{
|
||
var db = doc.Database;
|
||
var prevDb = HostApplicationServices.WorkingDatabase;
|
||
HostApplicationServices.WorkingDatabase = db;
|
||
try
|
||
{
|
||
List<string> layoutNames;
|
||
using (var tr = db.TransactionManager.StartTransaction())
|
||
{
|
||
var layoutDict = (DBDictionary)tr.GetObject(db.LayoutDictionaryId, OpenMode.ForRead);
|
||
layoutNames = layoutDict.Cast<DBDictionaryEntry>().Select(e => e.Key).ToList();
|
||
tr.Commit();
|
||
}
|
||
|
||
if (!layoutNames.Any(n => string.Equals(n, layoutName, StringComparison.OrdinalIgnoreCase)))
|
||
{
|
||
return;
|
||
}
|
||
|
||
var lm = LayoutManager.Current;
|
||
lm.CurrentLayout = layoutName;
|
||
|
||
foreach (var name in layoutNames)
|
||
{
|
||
if (string.Equals(name, "Model", StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (string.Equals(name, layoutName, StringComparison.OrdinalIgnoreCase))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
try
|
||
{
|
||
lm.DeleteLayout(name);
|
||
}
|
||
catch
|
||
{
|
||
// ignore
|
||
}
|
||
}
|
||
}
|
||
finally
|
||
{
|
||
HostApplicationServices.WorkingDatabase = prevDb;
|
||
}
|
||
}
|
||
}
|
||
|
||
public static void KeepOnlyModelWindow(Document doc, Extents3d window)
|
||
{
|
||
if (doc == null)
|
||
{
|
||
throw new ArgumentNullException(nameof(doc));
|
||
}
|
||
|
||
using (doc.LockDocument())
|
||
{
|
||
var db = doc.Database;
|
||
using (var tr = db.TransactionManager.StartTransaction())
|
||
{
|
||
var bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
|
||
var ms = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
|
||
|
||
var erased = 0;
|
||
var kept = 0;
|
||
|
||
foreach (ObjectId id in ms)
|
||
{
|
||
var ent = tr.GetObject(id, OpenMode.ForWrite) as Entity;
|
||
if (ent == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
try
|
||
{
|
||
var ext = ent.GeometricExtents;
|
||
if (!Intersects(ext, window))
|
||
{
|
||
ent.Erase(true);
|
||
erased++;
|
||
}
|
||
else
|
||
{
|
||
kept++;
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// 无法获取范围的对象默认保留，避免误删关键对象
|
||
kept++;
|
||
}
|
||
}
|
||
|
||
tr.Commit();
|
||
}
|
||
}
|
||
}
|
||
|
||
private static bool Intersects(Extents3d a, Extents3d b)
|
||
{
|
||
return a.MinPoint.X <= b.MaxPoint.X
|
||
&& a.MaxPoint.X >= b.MinPoint.X
|
||
&& a.MinPoint.Y <= b.MaxPoint.Y
|
||
&& a.MaxPoint.Y >= b.MinPoint.Y;
|
||
}
|
||
|
||
public sealed class RemoveOriginalDrawingResult
|
||
{
|
||
public int CaxaLayerErased { get; set; }
|
||
public int DimensionLayerErased { get; set; }
|
||
public int DimensionLayerKept { get; set; }
|
||
public int OuterFrameErased { get; set; }
|
||
public Point3d OriginalCenter { get; set; }
|
||
public Extents3d? OriginalExtents { get; set; }
|
||
public Extents3d? WhiteFrameExtents { get; set; }
|
||
}
|
||
|
||
private static readonly Regex DimensionPlaceholderRegex = new Regex(
|
||
@"(%%c|[Φφ∅Ø]|\\U\+03A6|\\U\+2205|\\U\+00D8)\s*\*",
|
||
RegexOptions.Compiled | RegexOptions.IgnoreCase);
|
||
|
||
/// <summary>
|
||
/// 删除模板中原有的图纸图形，保留右上角区域的内容（如粗糙度标注）。
|
||
/// </summary>
|
||
/// <param name="ctx">CAD上下文</param>
|
||
/// <param name="topRightThreshold">右上角保留区域阈值，0.70表示X和Y都超过70%的位置</param>
|
||
/// <returns>删除结果，包含原图形中心点位置</returns>
|
||
public static RemoveOriginalDrawingResult RemoveTemplateOriginalDrawing(CadContext ctx, double topRightThreshold = 0.70)
|
||
{
|
||
if (ctx == null)
|
||
{
|
||
throw new ArgumentNullException(nameof(ctx));
|
||
}
|
||
|
||
var result = new RemoveOriginalDrawingResult();
|
||
var db = ctx.Database;
|
||
var tr = ctx.Transaction;
|
||
|
||
var bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
|
||
var ms = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
|
||
|
||
var allEntities = ms.Cast<ObjectId>()
|
||
.Select(id => tr.GetObject(id, OpenMode.ForRead, false) as Entity)
|
||
.Where(e => e != null)
|
||
.ToList();
|
||
|
||
var layoutExtents = ComputeLayoutExtents(allEntities);
|
||
var caxaExtents = ComputeCaxaLayerExtents(tr, allEntities);
|
||
// Calculate white frame extents
|
||
var whiteFrameExtents = ComputeWhiteFrameExtentsFromEntities(tr, allEntities) ?? ComputeLayoutExtents(allEntities);
|
||
result.WhiteFrameExtents = whiteFrameExtents;
|
||
var titleBlockExtents = whiteFrameExtents.HasValue
|
||
? ComputeTitleBlockExtentsFromEntities(tr, allEntities, whiteFrameExtents.Value)
|
||
: (Extents3d?)null;
|
||
|
||
if (caxaExtents.HasValue)
|
||
{
|
||
result.OriginalExtents = caxaExtents;
|
||
result.OriginalCenter = new Point3d(
|
||
(caxaExtents.Value.MinPoint.X + caxaExtents.Value.MaxPoint.X) / 2,
|
||
(caxaExtents.Value.MinPoint.Y + caxaExtents.Value.MaxPoint.Y) / 2,
|
||
0);
|
||
}
|
||
else if (whiteFrameExtents.HasValue)
|
||
{
|
||
// Fallback to center of the upper half of the white frame if no CAXA layer found
|
||
var frame = whiteFrameExtents.Value;
|
||
var centerX = (frame.MinPoint.X + frame.MaxPoint.X) / 2.0;
|
||
var height = frame.MaxPoint.Y - frame.MinPoint.Y;
|
||
// Default to 70% height (center of upper area approximately) or just center?
|
||
// User said "upper half center". Top half is [0.5, 1.0], center is 0.75.
|
||
var centerY = frame.MinPoint.Y + height * 0.75;
|
||
result.OriginalCenter = new Point3d(centerX, centerY, 0);
|
||
}
|
||
|
||
// 使用CAXA图层范围作为图形区域，用于判断右上角
|
||
var graphicExtents = caxaExtents ?? layoutExtents;
|
||
|
||
// 先计算红色线框的范围
|
||
var redFrameExtents = ComputeRedFrameExtents(tr, allEntities);
|
||
|
||
foreach (var ent in allEntities)
|
||
{
|
||
if (ent.IsErased)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
var layerName = GetLayerName(tr, ent.LayerId);
|
||
|
||
// 删除红色外框线（红色的Line/Polyline，且在红色框的边界上）
|
||
if (IsOuterFrameEntity(ent, redFrameExtents, tr))
|
||
{
|
||
// [Modified] Skip erasing outer frame to keep the template's original frame and title block
|
||
// Explicitly continue to prevent it being caught by subsequent checks (e.g. CAXA layer)
|
||
continue;
|
||
|
||
/* Original deletion logic:
|
||
var entForWrite = tr.GetObject(ent.ObjectId, OpenMode.ForWrite) as Entity;
|
||
if (entForWrite != null)
|
||
{
|
||
entForWrite.Erase(true);
|
||
result.OuterFrameErased++;
|
||
}
|
||
continue;
|
||
*/
|
||
}
|
||
|
||
if (IsWithinTitleBlock(ent, titleBlockExtents))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (IsCaxaLayer(layerName))
|
||
{
|
||
var entForWrite = tr.GetObject(ent.ObjectId, OpenMode.ForWrite) as Entity;
|
||
if (entForWrite != null)
|
||
{
|
||
entForWrite.Erase(true);
|
||
result.CaxaLayerErased++;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (IsDimensionLayer(layerName) || IsDimensionEntity(ent))
|
||
{
|
||
if (IsWithinTitleBlock(ent, titleBlockExtents))
|
||
{
|
||
result.DimensionLayerKept++;
|
||
continue;
|
||
}
|
||
|
||
// 基于CAXA图形区域判断是否在右上角
|
||
if (graphicExtents.HasValue && IsInTopRightCorner(ent, graphicExtents.Value, topRightThreshold))
|
||
{
|
||
result.DimensionLayerKept++;
|
||
continue;
|
||
}
|
||
|
||
var entForWrite = tr.GetObject(ent.ObjectId, OpenMode.ForWrite) as Entity;
|
||
if (entForWrite != null)
|
||
{
|
||
entForWrite.Erase(true);
|
||
result.DimensionLayerErased++;
|
||
}
|
||
}
|
||
}
|
||
|
||
try
|
||
{
|
||
// Keep the template's white frame but enforce the desired lineweight.
|
||
ApplyWhiteFrameLineWeight(ctx, LineWeight.LineWeight015);
|
||
}
|
||
catch
|
||
{
|
||
// ignore
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
private static int ApplyWhiteFrameLineWeight(CadContext ctx, LineWeight lineWeight)
|
||
{
|
||
if (ctx == null)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
var db = ctx.Database;
|
||
var tr = ctx.Transaction;
|
||
|
||
var frameExtents = ComputeWhiteFrameExtents(ctx);
|
||
if (!frameExtents.HasValue)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
var frame = frameExtents.Value;
|
||
var w = frame.MaxPoint.X - frame.MinPoint.X;
|
||
var h = frame.MaxPoint.Y - frame.MinPoint.Y;
|
||
var tol = Math.Max(w, h) * 0.01; // 1%
|
||
|
||
var bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
|
||
var ms = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
|
||
|
||
var updated = 0;
|
||
foreach (ObjectId id in ms)
|
||
{
|
||
var ent = tr.GetObject(id, OpenMode.ForWrite, false) as Entity;
|
||
if (ent == null || ent.IsErased)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!(ent is Line) && !(ent is Polyline))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!IsWhiteColor(ent, tr))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!IsOnFrameBoundary(ent, frame, tol))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
try { ent.LineWeight = lineWeight; } catch { }
|
||
|
||
try
|
||
{
|
||
var layer = tr.GetObject(ent.LayerId, OpenMode.ForWrite) as LayerTableRecord;
|
||
if (layer != null)
|
||
{
|
||
layer.LineWeight = lineWeight;
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// ignore
|
||
}
|
||
|
||
updated++;
|
||
}
|
||
|
||
return updated;
|
||
}
|
||
|
||
private static bool IsOnFrameBoundary(Entity ent, Extents3d frame, double tol)
|
||
{
|
||
try
|
||
{
|
||
if (ent is Line line)
|
||
{
|
||
var sp = line.StartPoint;
|
||
var ep = line.EndPoint;
|
||
|
||
var minX = Math.Min(sp.X, ep.X);
|
||
var maxX = Math.Max(sp.X, ep.X);
|
||
var minY = Math.Min(sp.Y, ep.Y);
|
||
var maxY = Math.Max(sp.Y, ep.Y);
|
||
|
||
var isHorizontal = Math.Abs(sp.Y - ep.Y) <= tol;
|
||
if (isHorizontal)
|
||
{
|
||
var y = (sp.Y + ep.Y) / 2.0;
|
||
var onTop = Math.Abs(y - frame.MaxPoint.Y) <= tol;
|
||
var onBottom = Math.Abs(y - frame.MinPoint.Y) <= tol;
|
||
if ((onTop || onBottom)
|
||
&& minX <= frame.MinPoint.X + tol
|
||
&& maxX >= frame.MaxPoint.X - tol)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
var isVertical = Math.Abs(sp.X - ep.X) <= tol;
|
||
if (isVertical)
|
||
{
|
||
var x = (sp.X + ep.X) / 2.0;
|
||
var onLeft = Math.Abs(x - frame.MinPoint.X) <= tol;
|
||
var onRight = Math.Abs(x - frame.MaxPoint.X) <= tol;
|
||
if ((onLeft || onRight)
|
||
&& minY <= frame.MinPoint.Y + tol
|
||
&& maxY >= frame.MaxPoint.Y - tol)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
var ext = ent.GeometricExtents;
|
||
var matchX = Math.Abs(ext.MinPoint.X - frame.MinPoint.X) <= tol && Math.Abs(ext.MaxPoint.X - frame.MaxPoint.X) <= tol;
|
||
var matchY = Math.Abs(ext.MinPoint.Y - frame.MinPoint.Y) <= tol && Math.Abs(ext.MaxPoint.Y - frame.MaxPoint.Y) <= tol;
|
||
return matchX && matchY;
|
||
}
|
||
catch
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 删除模板中残留的“尺寸占位符”文本（例如 (Φ*)），避免与新生成的真实尺寸标注混淆。
|
||
/// </summary>
|
||
/// <remarks>
|
||
/// 仅清理文本类实体（DBText/MText/块属性），不影响真正的 Dimension 实体。
|
||
/// </remarks>
|
||
public static int RemoveTemplateDimensionPlaceholderTexts(
|
||
CadContext ctx,
|
||
Extents3d? graphicExtents = null,
|
||
double topRightThreshold = 0.70,
|
||
bool scanBlockDefinitions = false)
|
||
{
|
||
if (ctx == null)
|
||
{
|
||
throw new ArgumentNullException(nameof(ctx));
|
||
}
|
||
|
||
var db = ctx.Database;
|
||
var tr = ctx.Transaction;
|
||
|
||
var bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
|
||
var ms = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
|
||
|
||
var allEntities = ms.Cast<ObjectId>()
|
||
.Select(id => tr.GetObject(id, OpenMode.ForRead, false) as Entity)
|
||
.Where(e => e != null)
|
||
.ToList();
|
||
|
||
var targetExtents = graphicExtents
|
||
?? ComputeWhiteFrameExtentsFromEntities(tr, allEntities)
|
||
?? ComputeLayoutExtents(allEntities);
|
||
|
||
var titleBlockExtents = targetExtents.HasValue
|
||
? ComputeTitleBlockExtentsFromEntities(tr, allEntities, targetExtents.Value)
|
||
: (Extents3d?)null;
|
||
|
||
var removed = 0;
|
||
foreach (ObjectId id in ms)
|
||
{
|
||
var ent = tr.GetObject(id, OpenMode.ForWrite, false) as Entity;
|
||
if (ent == null || ent.IsErased)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (targetExtents.HasValue && IsInTopRightCorner(ent, targetExtents.Value, topRightThreshold))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (IsWithinTitleBlock(ent, titleBlockExtents))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!IsWithin(ent, targetExtents))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (ent is DBText t)
|
||
{
|
||
if (LooksLikeDimensionPlaceholder(t.TextString))
|
||
{
|
||
ent.Erase(true);
|
||
removed++;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (ent is MText mt)
|
||
{
|
||
var plain = SimplifyMText(mt.Contents);
|
||
if (LooksLikeDimensionPlaceholder(plain) || LooksLikeDimensionPlaceholder(mt.Contents))
|
||
{
|
||
ent.Erase(true);
|
||
removed++;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (ent is BlockReference br)
|
||
{
|
||
removed += RemovePlaceholderAttributes(tr, br, targetExtents, topRightThreshold);
|
||
|
||
// Keep default behavior conservative: do not edit block definitions unless explicitly enabled.
|
||
if (scanBlockDefinitions && IsWithin(br, targetExtents))
|
||
{
|
||
removed += RemovePlaceholderTextsInBlockDefinition(tr, br.BlockTableRecord, new HashSet<ObjectId>());
|
||
}
|
||
}
|
||
}
|
||
|
||
return removed;
|
||
}
|
||
|
||
private static int RemovePlaceholderAttributes(Transaction tr, BlockReference br, Extents3d? targetExtents, double topRightThreshold)
|
||
{
|
||
if (tr == null || br == null)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
var removed = 0;
|
||
foreach (ObjectId attId in br.AttributeCollection)
|
||
{
|
||
var att = tr.GetObject(attId, OpenMode.ForWrite, false) as AttributeReference;
|
||
if (att == null || att.IsErased)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (targetExtents.HasValue && IsInTopRightCorner(att, targetExtents.Value, topRightThreshold))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!IsWithin(att, targetExtents))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (LooksLikeDimensionPlaceholder(att.TextString))
|
||
{
|
||
try
|
||
{
|
||
att.Erase(true);
|
||
removed++;
|
||
}
|
||
catch
|
||
{
|
||
// ignore
|
||
}
|
||
}
|
||
}
|
||
|
||
return removed;
|
||
}
|
||
|
||
private static int RemovePlaceholderTextsInBlockDefinition(Transaction tr, ObjectId blockId, HashSet<ObjectId> visited)
|
||
{
|
||
if (tr == null || blockId.IsNull)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
if (visited == null)
|
||
{
|
||
visited = new HashSet<ObjectId>();
|
||
}
|
||
|
||
if (visited.Contains(blockId))
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
visited.Add(blockId);
|
||
|
||
var btr = tr.GetObject(blockId, OpenMode.ForWrite, false) as BlockTableRecord;
|
||
if (btr == null)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
var removed = 0;
|
||
foreach (ObjectId childId in btr)
|
||
{
|
||
var child = tr.GetObject(childId, OpenMode.ForWrite, false) as Entity;
|
||
if (child == null || child.IsErased)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (child is DBText t)
|
||
{
|
||
if (LooksLikeDimensionPlaceholder(t.TextString))
|
||
{
|
||
child.Erase(true);
|
||
removed++;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (child is MText mt)
|
||
{
|
||
var plain = SimplifyMText(mt.Contents);
|
||
if (LooksLikeDimensionPlaceholder(plain) || LooksLikeDimensionPlaceholder(mt.Contents))
|
||
{
|
||
child.Erase(true);
|
||
removed++;
|
||
}
|
||
continue;
|
||
}
|
||
|
||
if (child is BlockReference br)
|
||
{
|
||
removed += RemovePlaceholderAttributes(tr, br, null, 1.0);
|
||
removed += RemovePlaceholderTextsInBlockDefinition(tr, br.BlockTableRecord, visited);
|
||
}
|
||
}
|
||
|
||
return removed;
|
||
}
|
||
|
||
private static bool LooksLikeDimensionPlaceholder(string raw)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(raw))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
var s = (raw ?? string.Empty).Replace(" ", string.Empty).Replace(" ", string.Empty);
|
||
if (!s.Contains("*"))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// Typical placeholder examples: (Φ*), Φ*, %%c*, (\U+03A6*)
|
||
return DimensionPlaceholderRegex.IsMatch(s);
|
||
}
|
||
|
||
/// <summary>
|
||
/// 删除白色线框范围内上半部分的所有内容（用于清理模板残留的图形/占位符）。
|
||
/// 保留：右上角区域（如粗糙度标注）与下半部分（附注/表格）。
|
||
/// </summary>
|
||
/// <param name="keepBottomRatio">保留下半部比例（0.5 表示保留下半部分）</param>
|
||
/// <param name="topRightThreshold">右上角保留阈值，0.70表示X和Y都超过70%的位置</param>
|
||
public static int RemoveWhiteFrameUpperContent(CadContext ctx, double keepBottomRatio = 0.50, double topRightThreshold = 0.70)
|
||
{
|
||
if (ctx == null)
|
||
{
|
||
throw new ArgumentNullException(nameof(ctx));
|
||
}
|
||
|
||
keepBottomRatio = Math.Max(0.0, Math.Min(1.0, keepBottomRatio));
|
||
|
||
var db = ctx.Database;
|
||
var tr = ctx.Transaction;
|
||
|
||
var bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
|
||
var ms = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
|
||
|
||
var allEntities = ms.Cast<ObjectId>()
|
||
.Select(id => tr.GetObject(id, OpenMode.ForRead, false) as Entity)
|
||
.Where(e => e != null && !e.IsErased)
|
||
.ToList();
|
||
|
||
var whiteFrame = ComputeWhiteFrameExtentsFromEntities(tr, allEntities) ?? ComputeLayoutExtents(allEntities);
|
||
if (!whiteFrame.HasValue)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
var titleBlockExtents = ComputeTitleBlockExtentsFromEntities(tr, allEntities, whiteFrame.Value);
|
||
|
||
var frame = whiteFrame.Value;
|
||
var height = frame.MaxPoint.Y - frame.MinPoint.Y;
|
||
if (height <= 0)
|
||
{
|
||
return 0;
|
||
}
|
||
|
||
var cutY = frame.MinPoint.Y + height * keepBottomRatio;
|
||
|
||
// [Modified] Compute Red Frame Extents to protect it from deletion
|
||
var redFrameExtents = ComputeRedFrameExtents(tr, allEntities);
|
||
|
||
var removed = 0;
|
||
foreach (ObjectId id in ms)
|
||
{
|
||
var ent = tr.GetObject(id, OpenMode.ForWrite, false) as Entity;
|
||
if (ent == null || ent.IsErased)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// Keep white frame boundary itself.
|
||
if (IsWhiteFrameEntity(ent, frame, tr))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// [Modified] Keep Red Outer Frame
|
||
if (IsOuterFrameEntity(ent, redFrameExtents, tr))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!IsWithin(ent, frame))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// Keep top-right corner content.
|
||
if (IsInTopRightCorner(ent, frame, topRightThreshold))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (IsWithinTitleBlock(ent, titleBlockExtents))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!TryGetEntityCenterY(ent, out var centerY))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// Keep bottom area (notes/table).
|
||
if (centerY < cutY)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
try
|
||
{
|
||
ent.Erase(true);
|
||
removed++;
|
||
}
|
||
catch
|
||
{
|
||
// ignore
|
||
}
|
||
}
|
||
|
||
return removed;
|
||
}
|
||
|
||
private static bool TryGetEntityCenterY(Entity ent, out double centerY)
|
||
{
|
||
centerY = 0;
|
||
if (ent == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
try
|
||
{
|
||
var ext = ent.GeometricExtents;
|
||
centerY = (ext.MinPoint.Y + ext.MaxPoint.Y) / 2.0;
|
||
return true;
|
||
}
|
||
catch
|
||
{
|
||
return false;
|
||
}
|
||
}
|
||
|
||
private static bool IsWithin(Entity ent, Extents3d frame)
|
||
{
|
||
if (ent == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
try
|
||
{
|
||
var ext = ent.GeometricExtents;
|
||
return Intersects(ext, frame);
|
||
}
|
||
catch
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
private static bool IsWhiteFrameEntity(Entity ent, Extents3d frame, Transaction tr)
|
||
{
|
||
if (ent == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (!(ent is Line) && !(ent is Polyline))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (!IsWhiteColor(ent, tr))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
try
|
||
{
|
||
var ext = ent.GeometricExtents;
|
||
var frameW = frame.MaxPoint.X - frame.MinPoint.X;
|
||
var frameH = frame.MaxPoint.Y - frame.MinPoint.Y;
|
||
var tol = Math.Max(frameW, frameH) * 0.01; // 1%
|
||
|
||
// On outer border lines.
|
||
var nearLeft = Math.Abs(ext.MinPoint.X - frame.MinPoint.X) < tol;
|
||
var nearRight = Math.Abs(ext.MaxPoint.X - frame.MaxPoint.X) < tol;
|
||
var nearBottom = Math.Abs(ext.MinPoint.Y - frame.MinPoint.Y) < tol;
|
||
var nearTop = Math.Abs(ext.MaxPoint.Y - frame.MaxPoint.Y) < tol;
|
||
|
||
// Rough heuristic: if it touches two sides or spans most of a side, treat as frame.
|
||
if ((nearLeft && nearBottom) || (nearLeft && nearTop) || (nearRight && nearBottom) || (nearRight && nearTop))
|
||
{
|
||
return true;
|
||
}
|
||
|
||
if (ent is Line)
|
||
{
|
||
var spansWidth = (ext.MaxPoint.X - ext.MinPoint.X) > frameW * 0.90;
|
||
var spansHeight = (ext.MaxPoint.Y - ext.MinPoint.Y) > frameH * 0.90;
|
||
if ((nearTop || nearBottom) && spansWidth)
|
||
{
|
||
return true;
|
||
}
|
||
if ((nearLeft || nearRight) && spansHeight)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
if (ent is Polyline)
|
||
{
|
||
var spansWidth = (ext.MaxPoint.X - ext.MinPoint.X) > frameW * 0.90;
|
||
var spansHeight = (ext.MaxPoint.Y - ext.MinPoint.Y) > frameH * 0.90;
|
||
if (spansWidth && spansHeight)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
private static bool IsWithin(Entity ent, Extents3d? targetExtents)
|
||
{
|
||
if (ent == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
if (!targetExtents.HasValue)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
try
|
||
{
|
||
var ext = ent.GeometricExtents;
|
||
return Intersects(ext, targetExtents.Value);
|
||
}
|
||
catch
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
private static bool IsOuterFrameEntity(Entity ent, Extents3d? layoutExtents, Transaction tr = null)
|
||
{
|
||
if (ent == null || !layoutExtents.HasValue)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 必须是Line或Polyline
|
||
if (!(ent is Line) && !(ent is Polyline))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 检查颜色是否为红色（ColorIndex=1，或者通过图层颜色）
|
||
if (!IsRedColor(ent, tr))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 检查是否位于最外围（实体的范围接近或等于整体布局范围）
|
||
try
|
||
{
|
||
var ext = ent.GeometricExtents;
|
||
var layout = layoutExtents.Value;
|
||
|
||
var layoutWidth = layout.MaxPoint.X - layout.MinPoint.X;
|
||
var layoutHeight = layout.MaxPoint.Y - layout.MinPoint.Y;
|
||
|
||
// 容差值（放宽到5%）
|
||
var tolerance = Math.Max(layoutWidth, layoutHeight) * 0.05;
|
||
|
||
// 检查Line是否位于布局边界上
|
||
if (ent is Line line)
|
||
{
|
||
var startPt = line.StartPoint;
|
||
var endPt = line.EndPoint;
|
||
|
||
// 检查是否是水平线（上边或下边）
|
||
var isHorizontal = Math.Abs(startPt.Y - endPt.Y) < tolerance;
|
||
if (isHorizontal)
|
||
{
|
||
// 检查Y坐标是否在布局的上边界或下边界
|
||
var isTopEdge = Math.Abs(startPt.Y - layout.MaxPoint.Y) < tolerance;
|
||
var isBottomEdge = Math.Abs(startPt.Y - layout.MinPoint.Y) < tolerance;
|
||
if (isTopEdge || isBottomEdge)
|
||
{
|
||
// 增加长度判断：防止误删位于边界上的短线（如标题栏边框）
|
||
// 只有长度超过布局宽度 50% 的线才认为是外框
|
||
if (Math.Abs(startPt.X - endPt.X) > layoutWidth * 0.5)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 检查是否是垂直线（左边或右边）
|
||
var isVertical = Math.Abs(startPt.X - endPt.X) < tolerance;
|
||
if (isVertical)
|
||
{
|
||
// 检查X坐标是否在布局的左边界或右边界
|
||
var isLeftEdge = Math.Abs(startPt.X - layout.MinPoint.X) < tolerance;
|
||
var isRightEdge = Math.Abs(startPt.X - layout.MaxPoint.X) < tolerance;
|
||
if (isLeftEdge || isRightEdge)
|
||
{
|
||
// 增加长度判断
|
||
if (Math.Abs(startPt.Y - endPt.Y) > layoutHeight * 0.5)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// Polyline可能是完整的矩形外框
|
||
if (ent is Polyline poly)
|
||
{
|
||
var entWidth = ext.MaxPoint.X - ext.MinPoint.X;
|
||
var entHeight = ext.MaxPoint.Y - ext.MinPoint.Y;
|
||
if (entWidth > layoutWidth * 0.90 && entHeight > layoutHeight * 0.90)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
private static bool IsRedColor(Entity ent, Transaction tr)
|
||
{
|
||
if (ent == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 检查实体自身颜色
|
||
var colorIndex = ent.ColorIndex;
|
||
|
||
// ColorIndex=1 是红色
|
||
if (colorIndex == 1)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
// ColorIndex=256 表示 ByLayer，需要检查图层颜色
|
||
if (colorIndex == 256 && tr != null)
|
||
{
|
||
try
|
||
{
|
||
var layer = tr.GetObject(ent.LayerId, OpenMode.ForRead) as LayerTableRecord;
|
||
if (layer != null && layer.Color.ColorIndex == 1)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// 忽略
|
||
}
|
||
}
|
||
|
||
// 检查Color属性
|
||
try
|
||
{
|
||
var color = ent.Color;
|
||
if (color != null)
|
||
{
|
||
// 红色的RGB大约是(255, 0, 0)或接近
|
||
if (color.ColorIndex == 1)
|
||
{
|
||
return true;
|
||
}
|
||
if (color.ColorMethod == Autodesk.AutoCAD.Colors.ColorMethod.ByColor)
|
||
{
|
||
var r = color.Red;
|
||
var g = color.Green;
|
||
var b = color.Blue;
|
||
// 红色：R高，G和B低
|
||
if (r > 200 && g < 100 && b < 100)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// 忽略
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
private static string GetLayerName(Transaction tr, ObjectId layerId)
|
||
{
|
||
if (layerId.IsNull)
|
||
{
|
||
return string.Empty;
|
||
}
|
||
|
||
try
|
||
{
|
||
var layer = tr.GetObject(layerId, OpenMode.ForRead) as LayerTableRecord;
|
||
return layer?.Name ?? string.Empty;
|
||
}
|
||
catch
|
||
{
|
||
return string.Empty;
|
||
}
|
||
}
|
||
|
||
private static bool IsCaxaLayer(string layerName)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(layerName))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return CaxaLayerRegex.IsMatch(layerName);
|
||
}
|
||
|
||
private static bool IsDimensionLayer(string layerName)
|
||
{
|
||
if (string.IsNullOrWhiteSpace(layerName))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
return DimensionLayerNames.Contains(layerName);
|
||
}
|
||
|
||
private static bool IsDimensionEntity(Entity ent)
|
||
{
|
||
return ent is Dimension
|
||
|| ent is RotatedDimension
|
||
|| ent is AlignedDimension
|
||
|| ent is RadialDimension
|
||
|| ent is DiametricDimension
|
||
|| ent is ArcDimension
|
||
|| ent is OrdinateDimension
|
||
|| ent is Leader;
|
||
}
|
||
|
||
private static Extents3d? ComputeLayoutExtents(IEnumerable<Entity> entities)
|
||
{
|
||
Extents3d? result = null;
|
||
|
||
foreach (var ent in entities)
|
||
{
|
||
if (ent == null || ent.IsErased)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
try
|
||
{
|
||
var ext = ent.GeometricExtents;
|
||
if (result == null)
|
||
{
|
||
result = ext;
|
||
}
|
||
else
|
||
{
|
||
result = new Extents3d(
|
||
new Point3d(
|
||
Math.Min(result.Value.MinPoint.X, ext.MinPoint.X),
|
||
Math.Min(result.Value.MinPoint.Y, ext.MinPoint.Y),
|
||
Math.Min(result.Value.MinPoint.Z, ext.MinPoint.Z)),
|
||
new Point3d(
|
||
Math.Max(result.Value.MaxPoint.X, ext.MaxPoint.X),
|
||
Math.Max(result.Value.MaxPoint.Y, ext.MaxPoint.Y),
|
||
Math.Max(result.Value.MaxPoint.Z, ext.MaxPoint.Z)));
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// 忽略无法获取范围的实体
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
private static Extents3d? ComputeRedFrameExtents(Transaction tr, IEnumerable<Entity> entities)
|
||
{
|
||
Extents3d? result = null;
|
||
|
||
foreach (var ent in entities)
|
||
{
|
||
if (ent == null || ent.IsErased)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 只处理红色的Line或Polyline
|
||
if (!(ent is Line) && !(ent is Polyline))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (!IsRedColor(ent, tr))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
try
|
||
{
|
||
var ext = ent.GeometricExtents;
|
||
if (result == null)
|
||
{
|
||
result = ext;
|
||
}
|
||
else
|
||
{
|
||
result = new Extents3d(
|
||
new Point3d(
|
||
Math.Min(result.Value.MinPoint.X, ext.MinPoint.X),
|
||
Math.Min(result.Value.MinPoint.Y, ext.MinPoint.Y),
|
||
Math.Min(result.Value.MinPoint.Z, ext.MinPoint.Z)),
|
||
new Point3d(
|
||
Math.Max(result.Value.MaxPoint.X, ext.MaxPoint.X),
|
||
Math.Max(result.Value.MaxPoint.Y, ext.MaxPoint.Y),
|
||
Math.Max(result.Value.MaxPoint.Z, ext.MaxPoint.Z)));
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// 忽略
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
private static Extents3d? ComputeCaxaLayerExtents(Transaction tr, IEnumerable<Entity> entities)
|
||
{
|
||
Extents3d? result = null;
|
||
|
||
foreach (var ent in entities)
|
||
{
|
||
if (ent == null || ent.IsErased)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
var layerName = GetLayerName(tr, ent.LayerId);
|
||
if (!IsCaxaLayer(layerName))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
try
|
||
{
|
||
var ext = ent.GeometricExtents;
|
||
if (result == null)
|
||
{
|
||
result = ext;
|
||
}
|
||
else
|
||
{
|
||
result = new Extents3d(
|
||
new Point3d(
|
||
Math.Min(result.Value.MinPoint.X, ext.MinPoint.X),
|
||
Math.Min(result.Value.MinPoint.Y, ext.MinPoint.Y),
|
||
Math.Min(result.Value.MinPoint.Z, ext.MinPoint.Z)),
|
||
new Point3d(
|
||
Math.Max(result.Value.MaxPoint.X, ext.MaxPoint.X),
|
||
Math.Max(result.Value.MaxPoint.Y, ext.MaxPoint.Y),
|
||
Math.Max(result.Value.MaxPoint.Z, ext.MaxPoint.Z)));
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// 忽略
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
private static Extents3d? ComputeTitleBlockExtentsFromEntities(Transaction tr, IEnumerable<Entity> entities, Extents3d frame)
|
||
{
|
||
if (entities == null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var w = frame.MaxPoint.X - frame.MinPoint.X;
|
||
var h = frame.MaxPoint.Y - frame.MinPoint.Y;
|
||
if (w <= 0 || h <= 0)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var searchMinX = frame.MinPoint.X + w * 0.25;
|
||
var searchMaxX = frame.MaxPoint.X - 5.0;
|
||
var searchMinY = frame.MinPoint.Y;
|
||
var searchMaxY = frame.MinPoint.Y + h * 0.50;
|
||
|
||
var candidatesX = new List<double>();
|
||
var candidatesY = new List<double>();
|
||
|
||
foreach (var ent in entities)
|
||
{
|
||
if (ent == null || ent.IsErased)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (ent is Line ln)
|
||
{
|
||
if (Math.Abs(ln.StartPoint.X - ln.EndPoint.X) < 1.0
|
||
&& ln.StartPoint.X > searchMinX && ln.StartPoint.X < searchMaxX
|
||
&& Math.Max(ln.StartPoint.Y, ln.EndPoint.Y) > searchMinY
|
||
&& Math.Min(ln.StartPoint.Y, ln.EndPoint.Y) < searchMaxY)
|
||
{
|
||
candidatesX.Add(ln.StartPoint.X);
|
||
}
|
||
|
||
if (ln.StartPoint.X > frame.MaxPoint.X - Math.Min(200.0, w * 0.5)
|
||
&& ln.EndPoint.X > frame.MaxPoint.X - Math.Min(200.0, w * 0.5)
|
||
&& ln.StartPoint.Y > searchMinY && ln.StartPoint.Y < frame.MinPoint.Y + Math.Min(80.0, h * 0.40)
|
||
&& Math.Abs(ln.StartPoint.Y - ln.EndPoint.Y) < 1.0)
|
||
{
|
||
candidatesY.Add(ln.StartPoint.Y);
|
||
}
|
||
}
|
||
else if (ent is Polyline pl)
|
||
{
|
||
for (int i = 0; i < pl.NumberOfVertices; i++)
|
||
{
|
||
var pt = pl.GetPoint3dAt(i);
|
||
if (pt.X > searchMinX && pt.X < searchMaxX && pt.Y > searchMinY && pt.Y < searchMaxY)
|
||
{
|
||
candidatesX.Add(pt.X);
|
||
}
|
||
if (pt.X > frame.MaxPoint.X - Math.Min(200.0, w * 0.5)
|
||
&& pt.Y > searchMinY && pt.Y < frame.MinPoint.Y + Math.Min(80.0, h * 0.40))
|
||
{
|
||
candidatesY.Add(pt.Y);
|
||
}
|
||
}
|
||
}
|
||
else if (ent is BlockReference br)
|
||
{
|
||
try
|
||
{
|
||
var ext = br.GeometricExtents;
|
||
if (ext.MaxPoint.X > searchMinX && ext.MinPoint.X < searchMaxX
|
||
&& ext.MaxPoint.Y > searchMinY && ext.MinPoint.Y < searchMaxY)
|
||
{
|
||
if (ext.MinPoint.X > searchMinX)
|
||
{
|
||
candidatesX.Add(ext.MinPoint.X);
|
||
}
|
||
if (ext.MaxPoint.Y < frame.MinPoint.Y + Math.Min(80.0, h * 0.40))
|
||
{
|
||
candidatesY.Add(ext.MaxPoint.Y);
|
||
}
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// ignore
|
||
}
|
||
}
|
||
}
|
||
|
||
if (candidatesY.Count == 0)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var tableTopY = candidatesY.Max();
|
||
var boundaryX = candidatesX.Count > 0 ? candidatesX.Min() : (frame.MaxPoint.X - Math.Min(200.0, w * 0.5));
|
||
|
||
if (boundaryX >= frame.MaxPoint.X - 1.0 || tableTopY <= frame.MinPoint.Y + 1.0)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
return new Extents3d(
|
||
new Point3d(boundaryX, frame.MinPoint.Y, 0),
|
||
new Point3d(frame.MaxPoint.X, tableTopY, 0));
|
||
}
|
||
|
||
private static bool IsWithinTitleBlock(Entity ent, Extents3d? titleBlock)
|
||
{
|
||
if (ent == null || !titleBlock.HasValue)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
try
|
||
{
|
||
return Intersects(ent.GeometricExtents, titleBlock.Value);
|
||
}
|
||
catch
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
private static bool IsInTopRightCorner(Entity ent, Extents3d layoutExtents, double threshold)
|
||
{
|
||
try
|
||
{
|
||
var ext = ent.GeometricExtents;
|
||
var centerX = (ext.MinPoint.X + ext.MaxPoint.X) / 2;
|
||
var centerY = (ext.MinPoint.Y + ext.MaxPoint.Y) / 2;
|
||
|
||
var layoutWidth = layoutExtents.MaxPoint.X - layoutExtents.MinPoint.X;
|
||
var layoutHeight = layoutExtents.MaxPoint.Y - layoutExtents.MinPoint.Y;
|
||
|
||
var thresholdX = layoutExtents.MinPoint.X + layoutWidth * threshold;
|
||
var thresholdY = layoutExtents.MinPoint.Y + layoutHeight * threshold;
|
||
|
||
return centerX > thresholdX && centerY > thresholdY;
|
||
}
|
||
catch
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检测白色外框（图纸边界）的范围
|
||
/// 白色外框通常是 ColorIndex=7 的 Line 或 Polyline，构成图纸的可绘图区域
|
||
/// </summary>
|
||
public static Extents3d? ComputeWhiteFrameExtents(CadContext ctx)
|
||
{
|
||
if (ctx == null)
|
||
{
|
||
return null;
|
||
}
|
||
|
||
var db = ctx.Database;
|
||
var tr = ctx.Transaction;
|
||
|
||
var bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
|
||
var ms = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForRead);
|
||
|
||
var allEntities = ms.Cast<ObjectId>()
|
||
.Select(id => tr.GetObject(id, OpenMode.ForRead, false) as Entity)
|
||
.Where(e => e != null && !e.IsErased)
|
||
.ToList();
|
||
|
||
return ComputeWhiteFrameExtentsFromEntities(tr, allEntities);
|
||
}
|
||
|
||
private static Extents3d? ComputeWhiteFrameExtentsFromEntities(Transaction tr, IEnumerable<Entity> entities)
|
||
{
|
||
Extents3d? result = null;
|
||
|
||
foreach (var ent in entities)
|
||
{
|
||
if (ent == null || ent.IsErased)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 只处理 Line 或 Polyline
|
||
if (!(ent is Line) && !(ent is Polyline))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
// 检查是否是白色（ColorIndex=7）
|
||
if (!IsWhiteColor(ent, tr))
|
||
{
|
||
continue;
|
||
}
|
||
|
||
try
|
||
{
|
||
var ext = ent.GeometricExtents;
|
||
if (result == null)
|
||
{
|
||
result = ext;
|
||
}
|
||
else
|
||
{
|
||
result = new Extents3d(
|
||
new Point3d(
|
||
Math.Min(result.Value.MinPoint.X, ext.MinPoint.X),
|
||
Math.Min(result.Value.MinPoint.Y, ext.MinPoint.Y),
|
||
Math.Min(result.Value.MinPoint.Z, ext.MinPoint.Z)),
|
||
new Point3d(
|
||
Math.Max(result.Value.MaxPoint.X, ext.MaxPoint.X),
|
||
Math.Max(result.Value.MaxPoint.Y, ext.MaxPoint.Y),
|
||
Math.Max(result.Value.MaxPoint.Z, ext.MaxPoint.Z)));
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// 忽略
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
private static bool IsWhiteColor(Entity ent, Transaction tr)
|
||
{
|
||
if (ent == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// ColorIndex=7 是白色
|
||
var colorIndex = ent.ColorIndex;
|
||
if (colorIndex == 7)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
// ColorIndex=256 表示 ByLayer，需要检查图层颜色
|
||
if (colorIndex == 256 && tr != null)
|
||
{
|
||
try
|
||
{
|
||
var layer = tr.GetObject(ent.LayerId, OpenMode.ForRead) as LayerTableRecord;
|
||
if (layer != null && layer.Color.ColorIndex == 7)
|
||
{
|
||
return true;
|
||
}
|
||
}
|
||
catch
|
||
{
|
||
// 忽略
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 图形尺寸检查结果
|
||
/// </summary>
|
||
public sealed class DrawingSizeCheckResult
|
||
{
|
||
public bool NeedsScaling { get; set; }
|
||
public double ScaleFactor { get; set; } = 1.0;
|
||
public double DrawingWidth { get; set; }
|
||
public double DrawingHeight { get; set; }
|
||
public double AvailableWidth { get; set; }
|
||
public double AvailableHeight { get; set; }
|
||
public string Message { get; set; }
|
||
}
|
||
|
||
/// <summary>
|
||
/// 检查图形是否会超出图纸边界，如果超出则计算缩放比例
|
||
/// </summary>
|
||
/// <param name="whiteFrameExtents">白色外框范围</param>
|
||
/// <param name="drawingWidth">预期绘制图形的宽度</param>
|
||
/// <param name="drawingHeight">预期绘制图形的高度</param>
|
||
/// <param name="margin">边距（默认50）</param>
|
||
/// <returns>检查结果，包含是否需要缩放和缩放比例</returns>
|
||
public static DrawingSizeCheckResult CheckDrawingSize(Extents3d? whiteFrameExtents, double drawingWidth, double drawingHeight, double margin = 50)
|
||
{
|
||
var result = new DrawingSizeCheckResult
|
||
{
|
||
DrawingWidth = drawingWidth,
|
||
DrawingHeight = drawingHeight
|
||
};
|
||
|
||
if (!whiteFrameExtents.HasValue)
|
||
{
|
||
result.Message = "未检测到白色外框，跳过尺寸检查";
|
||
return result;
|
||
}
|
||
|
||
var frame = whiteFrameExtents.Value;
|
||
var availableWidth = frame.MaxPoint.X - frame.MinPoint.X - margin * 2;
|
||
var availableHeight = frame.MaxPoint.Y - frame.MinPoint.Y - margin * 2;
|
||
|
||
result.AvailableWidth = availableWidth;
|
||
result.AvailableHeight = availableHeight;
|
||
|
||
if (availableWidth <= 0 || availableHeight <= 0)
|
||
{
|
||
result.Message = "白色外框范围无效";
|
||
return result;
|
||
}
|
||
|
||
// 计算宽度和高度的缩放比例，取较小值（等比例缩放）
|
||
var scaleX = availableWidth / drawingWidth;
|
||
var scaleY = availableHeight / drawingHeight;
|
||
|
||
if (scaleX >= 1.0 && scaleY >= 1.0)
|
||
{
|
||
result.NeedsScaling = false;
|
||
result.ScaleFactor = 1.0;
|
||
result.Message = $"图形尺寸正常，无需缩放 (图形: {drawingWidth:F1}x{drawingHeight:F1}, 可用: {availableWidth:F1}x{availableHeight:F1})";
|
||
return result;
|
||
}
|
||
|
||
// 需要缩放，取较小的比例以确保两个方向都不超出
|
||
result.NeedsScaling = true;
|
||
result.ScaleFactor = Math.Min(scaleX, scaleY);
|
||
result.Message = $"图形超出边界，将等比例缩放至 {result.ScaleFactor:P1} (图形: {drawingWidth:F1}x{drawingHeight:F1}, 可用: {availableWidth:F1}x{availableHeight:F1})";
|
||
|
||
return result;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新图纸标题栏中的比例 - 查找"比例"标题文字并在其下方创建比例值文本
|
||
/// </summary>
|
||
public static bool UpdateScaleAttribute(CadContext ctx, string layoutName, bool scanModelSpace, double scaleFactor)
|
||
{
|
||
if (ctx == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
var db = ctx.Database;
|
||
var tr = ctx.Transaction;
|
||
|
||
// 格式化比例文本
|
||
var scaleText = FormatScaleText(scaleFactor);
|
||
|
||
// 在ModelSpace中查找"比例"标题文字
|
||
var bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
|
||
var ms = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
|
||
|
||
Point3d? scaleLabelPos = null;
|
||
double textHeight = 2.5;
|
||
string textStyle = "STANDARD";
|
||
|
||
// 遍历所有实体，查找"比例"文字
|
||
foreach (ObjectId id in ms)
|
||
{
|
||
var ent = tr.GetObject(id, OpenMode.ForRead, false) as Entity;
|
||
if (ent == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (ent is DBText dbText)
|
||
{
|
||
var content = dbText.TextString?.Trim() ?? string.Empty;
|
||
var contentNoSpace = content.Replace(" ", "").Replace(" ", "");
|
||
// 匹配：去掉空格后是"比例"
|
||
if (contentNoSpace == "比例")
|
||
{
|
||
scaleLabelPos = dbText.Position;
|
||
textHeight = dbText.Height;
|
||
textStyle = dbText.TextStyleName ?? "STANDARD";
|
||
break;
|
||
}
|
||
}
|
||
else if (ent is MText mText)
|
||
{
|
||
var content = mText.Contents?.Trim() ?? string.Empty;
|
||
var contentNoSpace = content.Replace(" ", "").Replace(" ", "");
|
||
if (contentNoSpace == "比例")
|
||
{
|
||
scaleLabelPos = mText.Location;
|
||
textHeight = mText.TextHeight;
|
||
textStyle = mText.TextStyleName ?? "STANDARD";
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!scaleLabelPos.HasValue)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
// 在"比例"文字下方创建比例值文本
|
||
var valuePos = new Point3d(
|
||
scaleLabelPos.Value.X,
|
||
scaleLabelPos.Value.Y - textHeight * 2.5,
|
||
scaleLabelPos.Value.Z
|
||
);
|
||
|
||
var newText = new DBText
|
||
{
|
||
Position = valuePos,
|
||
TextString = scaleText,
|
||
Height = textHeight,
|
||
ColorIndex = 7,
|
||
Layer = "0"
|
||
};
|
||
|
||
// 设置文字样式
|
||
var textStyleTbl = (TextStyleTable)tr.GetObject(db.TextStyleTableId, OpenMode.ForRead);
|
||
if (textStyleTbl.Has(textStyle))
|
||
{
|
||
newText.TextStyleId = textStyleTbl[textStyle];
|
||
}
|
||
|
||
ms.AppendEntity(newText);
|
||
tr.AddNewlyCreatedDBObject(newText, true);
|
||
|
||
return true;
|
||
}
|
||
|
||
private static string FormatScaleText(double scaleFactor)
|
||
{
|
||
if (scaleFactor >= 0.9999 && scaleFactor <= 1.0001)
|
||
{
|
||
return "1:1";
|
||
}
|
||
|
||
var ratio = 1.0 / scaleFactor;
|
||
|
||
if (Math.Abs(ratio - Math.Round(ratio)) < 0.05)
|
||
{
|
||
return $"1:{Math.Round(ratio)}";
|
||
}
|
||
|
||
return $"1:{ratio:F1}";
|
||
}
|
||
|
||
/// <summary>
|
||
/// 更新图纸标题栏中的检验类别 - 查找"检验类别"标题文字并在其下方创建检验类别值文本
|
||
/// </summary>
|
||
public static bool UpdateInspectionCategoryAttribute(CadContext ctx, string layoutName, bool scanModelSpace, string inspectionCategory)
|
||
{
|
||
if (ctx == null || string.IsNullOrWhiteSpace(inspectionCategory))
|
||
{
|
||
return false;
|
||
}
|
||
|
||
var db = ctx.Database;
|
||
var tr = ctx.Transaction;
|
||
|
||
var bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
|
||
var ms = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
|
||
|
||
Point3d? labelPos = null;
|
||
double textHeight = 2.5;
|
||
string textStyle = "STANDARD";
|
||
|
||
foreach (ObjectId id in ms)
|
||
{
|
||
var ent = tr.GetObject(id, OpenMode.ForRead, false) as Entity;
|
||
if (ent == null)
|
||
{
|
||
continue;
|
||
}
|
||
|
||
if (ent is DBText dbText)
|
||
{
|
||
var content = dbText.TextString?.Trim() ?? string.Empty;
|
||
var contentNoSpace = content.Replace(" ", "").Replace(" ", "");
|
||
if (contentNoSpace == "检验类别")
|
||
{
|
||
labelPos = dbText.Position;
|
||
textHeight = dbText.Height;
|
||
textStyle = dbText.TextStyleName ?? "STANDARD";
|
||
break;
|
||
}
|
||
}
|
||
else if (ent is MText mText)
|
||
{
|
||
var content = mText.Contents?.Trim() ?? string.Empty;
|
||
var contentNoSpace = content.Replace(" ", "").Replace(" ", "");
|
||
if (contentNoSpace == "检验类别")
|
||
{
|
||
labelPos = mText.Location;
|
||
textHeight = mText.TextHeight;
|
||
textStyle = mText.TextStyleName ?? "STANDARD";
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!labelPos.HasValue)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
var valuePos = new Point3d(
|
||
labelPos.Value.X,
|
||
labelPos.Value.Y - textHeight * 2.5,
|
||
labelPos.Value.Z
|
||
);
|
||
|
||
var newText = new DBText
|
||
{
|
||
Position = valuePos,
|
||
TextString = inspectionCategory,
|
||
Height = textHeight,
|
||
ColorIndex = 7,
|
||
Layer = "0"
|
||
};
|
||
|
||
var textStyleTbl = (TextStyleTable)tr.GetObject(db.TextStyleTableId, OpenMode.ForRead);
|
||
if (textStyleTbl.Has(textStyle))
|
||
{
|
||
newText.TextStyleId = textStyleTbl[textStyle];
|
||
}
|
||
|
||
ms.AppendEntity(newText);
|
||
tr.AddNewlyCreatedDBObject(newText, true);
|
||
|
||
return true;
|
||
}
|
||
|
||
/// <summary>
|
||
/// 在红色边框与白色边框之间的左上角添加"内部资料，控制范围"文字标记
|
||
/// </summary>
|
||
/// <param name="ctx">CAD上下文</param>
|
||
/// <param name="layoutName">布局名称</param>
|
||
/// <param name="isModelSpace">是否为模型空间</param>
|
||
/// <returns>是否成功添加</returns>
|
||
public static bool AddInternalMaterialLabel(CadContext ctx, string layoutName, bool isModelSpace)
|
||
{
|
||
if (ctx == null)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
var db = ctx.Database;
|
||
var tr = ctx.Transaction;
|
||
|
||
var bt = (BlockTable)tr.GetObject(db.BlockTableId, OpenMode.ForRead);
|
||
var ms = (BlockTableRecord)tr.GetObject(bt[BlockTableRecord.ModelSpace], OpenMode.ForWrite);
|
||
|
||
var allEntities = ms.Cast<ObjectId>()
|
||
.Select(id => tr.GetObject(id, OpenMode.ForRead, false) as Entity)
|
||
.Where(e => e != null && !e.IsErased)
|
||
.ToList();
|
||
|
||
// 获取红色边框和白色边框范围
|
||
var redFrameExtents = ComputeRedFrameExtents(tr, allEntities);
|
||
var whiteFrameExtents = ComputeWhiteFrameExtentsFromEntities(tr, allEntities);
|
||
|
||
if (!redFrameExtents.HasValue || !whiteFrameExtents.HasValue)
|
||
{
|
||
return false;
|
||
}
|
||
|
||
var redFrame = redFrameExtents.Value;
|
||
var whiteFrame = whiteFrameExtents.Value;
|
||
|
||
// 计算插入点：在红框和白框之间的左上角
|
||
// X: 红框左边界稍内侧
|
||
// Y: 红框顶部和白框顶部之间，偏上方
|
||
var insertX = redFrame.MinPoint.X + 2.0; // 距红框左边2mm
|
||
var insertY = (redFrame.MaxPoint.Y + whiteFrame.MaxPoint.Y) / 2.0; // 红框与白框顶部中间
|
||
|
||
var insertPoint = new Point3d(insertX, insertY, 0);
|
||
|
||
// 创建 MText
|
||
var mt = new MText();
|
||
// 使用宋体格式
|
||
mt.Contents = @"{\fSimSun|b0|i0|c134|p2;内部资料，控制范围}";
|
||
mt.Location = insertPoint;
|
||
mt.TextHeight = 3.5;
|
||
mt.Attachment = AttachmentPoint.MiddleLeft; // 左对齐，垂直居中
|
||
mt.Width = 0; // 不换行
|
||
mt.ColorIndex = 4; // 青色
|
||
|
||
// 尝试设置图层
|
||
try
|
||
{
|
||
var layerTbl = (LayerTable)tr.GetObject(db.LayerTableId, OpenMode.ForRead);
|
||
string targetLayer = "0";
|
||
if (layerTbl.Has("TEXT")) targetLayer = "TEXT";
|
||
else if (layerTbl.Has("文字")) targetLayer = "文字";
|
||
mt.Layer = targetLayer;
|
||
}
|
||
catch { }
|
||
|
||
ms.AppendEntity(mt);
|
||
tr.AddNewlyCreatedDBObject(mt, true);
|
||
|
||
return true;
|
||
}
|
||
}
|
||
}
|