2024-07-12
한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina
Blöcke sind ein sehr wichtiger Wissenspunkt im CAD. Heute werde ich Ihnen einige Klassifizierungen und Einführungen von Blöcken sowie die Definition und Referenz von Blöcken geben.
Ein Block ist eine Einheit, die durch mehrere logisch verbundene grafische Objekte definiert wird. Der Vorteil besteht darin, dass Arbeitsstandards vereinheitlicht und die Arbeitseffizienz verbessert werden können, da ein Objekt im Leben keine einfache Einheit ist, sondern aus mehreren Einheiten bestehen kann. Blöcke können diese Struktur gut darstellen.
Das Wesen eines Blocks ist eine Sammlung von Entitätsobjekten, die in Blocktabellendatensätzen gespeichert sind.
Attributblöcke bestehen aus Entitäten und zusätzlichen Informationen (Attributen). Die Definition von Blöcken in einem Attributblock ist die gleiche wie in einem einfachen Block, und die Definition von Attributen wird hauptsächlich durch die relevanten Attribute und Funktionen der AttributeDefinition-Klasse erreicht. . Spezifische Implementierungen umfassen:
Zu den durch Attribute definierten Attributwerten gehören hauptsächlich:
Dynamische Blöcke ermöglichen es uns, Blöcke mit einem hohen Maß an Flexibilität und Anpassbarkeit zu erstellen. Denn sobald ein herkömmlicher Block in eine Zeichnung eingefügt wird, sind seine Größe, Form und Position normalerweise festgelegt. Dynamische Blöcke hingegen können ihre geometrischen Eigenschaften durch Interaktion mit der Benutzeroberfläche anpassen (z. B. durch Ziehen von Aktionspunkten), ohne den gesamten Block neu definieren oder seine Komponenten manuell bearbeiten zu müssen.
Blöcke werden hauptsächlich in einfache Blöcke, Attributblöcke und dynamische Blöcke unterteilt. Bei Blöcken gibt es hauptsächlich Blockdefinitionsoperationen, Blockreferenzoperationen (d. h. Blockeinfügungsoperationen) und Blockbearbeitungsoperationen.
Unabhängig davon, um welche Art von Block es sich handelt, sind ihre Definitionen ungefähr gleich (Attributblöcke müssen Attributobjekte hinzufügen. Die spezifischen Schritte sind wie folgt:
Der spezifische Code lautet wie folgt:
public static ObjectId AddBlockThroughDB(this Database db, string blockName, List<Entity> ents)
{
//声明ObjectId,用于返回
ObjectId entId = ObjectId.Null;
using (Transaction tr = db.TransactionManager.StartTransaction())
{
BlockTable bt = (BlockTable)db.BlockTableId.GetObject(OpenMode.ForWrite);
BlockTableRecord btr = new BlockTableRecord();
btr.Name = blockName;
for (int ii = 0; ii < ents.Count; ii++)
{
Entity ent = ents[ii];
btr.AppendEntity(ent);
}
entId = bt.Add(btr);
tr.AddNewlyCreatedDBObject(btr, true);
tr.Commit();
}
return entId;
}
Das Obige ist nur die Definition eines einfachen Blocks. Wie der Name schon sagt, müssen Sie die Attributfelder im Block definieren (wir können es als Definition von Attributvariablen verstehen, die in bestimmte Variablenwerte umgewandelt werden müssen). wenn darauf verwiesen wird).
Bei der Definition des Eigenschaftsblocks können wir Eigenschaften hinzufügen, indem wir Eigenschaften hinzufügen.
/// <summary>
/// 块添加属性
/// </summary>
/// <param name="blockId"></param>
/// <param name="atts"></param>
public static void AddAttsToBlocks(this ObjectId blockId, List<AttributeDefinition> atts)
{
Database db = blockId.Database;//获取数据库对象
BlockTableRecord btr = blockId.GetObject(OpenMode.ForWrite) as BlockTableRecord;
foreach (AttributeDefinition att in atts)
{
btr.AppendEntity(att);
db.TransactionManager.AddNewlyCreatedDBObject(att, true);
}
btr.DowngradeOpen();
}
public static void AddAttsToBlocks(this ObjectId blockId, params AttributeDefinition[] atts)
{
blockId.AddAttsToBlocks(atts.ToList());
}
Fügt der angegebenen Blockdefinition Attribute hinzu. Wir können es so verwenden:
//属性添加
AttributeDefinition attr1 = new AttributeDefinition(Point3d.Origin, "箱变", "箱变编号", "请输入箱变编号", ObjectId.Null);
AttributeDefinition attr2 = new AttributeDefinition(Point3d.Origin + new Vector3d(0, 0.25, 0),
"变电站", "变电站编号", "请输入变电站编号", ObjectId.Null);
//然后将这两个属性加入到集合,再调用上面的方法即可。
Die Parameterbeschreibung lautet wie folgt:
Die Definition dynamischer Blöcke erfordert die Verwendung von Attributblöcken.DynamicBlockReferencePropertyCollection
Klassen erlegen Eigenschaften Beschränkungen auf.
public void Insert()
{
Database db = HostApplicationServices.WorkingDatabase;
using (Transaction trans = db.TransactionManager.StartTransaction())
{
BlockTable bt = (BlockTable)db.BlockTableId.GetObject(OpenMode.ForRead);
BlockTableRecord space = db.CurrentSpaceId.GetObject(OpenMode.ForWrite) as BlockTableRecord;
//判断名为“块1”的块是否存在
if(! bt["块1"].IsNull)
{
BlockReference br = new BlockReference(Point3d.Origin, bt["块1"]);
br.ScaleFactors = new Scale3d(2.0);//设置尺寸为原来2倍
space.AppendEntity(br);
trans.AddNewlyCreatedDBObject(br, true);
trans.Commit();
}
else
{
return;
}
}
}
Die Attributentität in der Blockreferenz wird durch die AttibuteReference-Klasse im DatabaseServices-Namespace dargestellt, bei der es sich tatsächlich um ein einzeiliges Textobjekt handelt, das von der DBText-Klasse abgeleitet ist. Um Attribute zu einer Blockreferenz hinzuzufügen, gehen Sie folgendermaßen vor:
/// <summary>
/// 插入带属性的参照快
/// </summary>
/// <param name="spaceId">空间的ID</param>
/// <param name="layer">块要加入的图层名</param>
/// <param name="blockName">快参照所属的快名</param>
/// <param name="postion">插入点</param>
/// <param name="scale">缩放比例</param>
/// <param name="rotateAngle">旋转角度</param>
/// <param name="attNameValues">属性名称与取值</param>
/// <returns></returns>
public static ObjectId InsertBlockrefence(this ObjectId spaceId, string layer, string blockName, Point3d postion, Scale3d scale, double rotateAngle, Dictionary<string, string> attNameValues)
{
// 获取数据库对象
Database db = spaceId.Database;
//以读的方式打开块表
BlockTable bt = db.BlockTableId.GetObject(OpenMode.ForRead) as BlockTable;
//如果没有blockName d的块,则程序返回
if (!bt.Has(blockName))
return ObjectId.Null;//如果没有blockName的块,程序返回
//以写的模式打开空间
BlockTableRecord space = (BlockTableRecord)spaceId.GetObject(OpenMode.ForWrite);
//获取块表的记录ID
ObjectId btrId = bt[blockName];
//打开块表记录
BlockTableRecord record = btrId.GetObject(OpenMode.ForRead) as BlockTableRecord;
//创建一个快参照并设置插入点
BlockReference br = new BlockReference(postion, bt[blockName]);
br.ScaleFactors = scale;
br.Layer = layer;
br.Rotation = rotateAngle;
space.AppendEntity(br);
//判断块表记录是否包含属性定义
if (record.HasAttributeDefinitions)
{
//若包含,则遍历属性定义
foreach (ObjectId id in record)
{
//检查是否是属性定义
AttributeDefinition attDef = id.GetObject(OpenMode.ForRead) as AttributeDefinition;
if (attDef != null)
{
//创建一个新的属性对象
AttributeReference attribute = new AttributeReference();
//从属性定义获取属性对象的对象特性
attribute.SetAttributeFromBlock(attDef, br.BlockTransform);
attribute.Rotation = attDef.Rotation;
attribute.Position = attDef.Position.TransformBy(br.BlockTransform);
attribute.AdjustAlignment(db);
//判断是否包含指定的属性名称
if (attNameValues.ContainsKey(attDef.Tag.ToUpper()))
{
//设置属性值
attribute.TextString = attNameValues[attDef.Tag.ToUpper()].ToString();
}
// 向块参照添加属性对象
br.AttributeCollection.AppendAttribute(attribute);
db.TransactionManager.AddNewlyCreatedDBObject(attribute, true);
}
}
}
db.TransactionManager.AddNewlyCreatedDBObject(br, true);
return br.ObjectId;//返回添加的快参照的ID
}
Einige der oben genannten Parameter werden möglicherweise nicht benötigt, z. B. das Skalierungsverhältnis und das Einfügungsverhältnis.
/// <summary>
/// 更新属性名称与取值
/// </summary>
/// <param name="blockRefId"></param>
/// <param name="attNameValues"></param>
public static void UpdateAttributesInBlock(this ObjectId blockRefId, Dictionary<string, string> attNameValues)
{
BlockReference blockRef = blockRefId.GetObject(OpenMode.ForRead) as BlockReference;
if (blockRef != null)
{
foreach (ObjectId id in blockRef.AttributeCollection)
{
AttributeReference attref = id.GetObject(OpenMode.ForRead) as AttributeReference;
if (attNameValues.ContainsKey(attref.Tag.ToUpper()))
{
attref.UpgradeOpen();
//设置属性值
attref.TextString = attNameValues[attref.Tag.ToUpper()].ToString();
attref.DowngradeOpen();
}
}
}
}