CAD-Sekundärentwicklung (12) – Definition und Verwendung von Blocks

CAD-Sekundärentwicklung (12) – Definition und Verwendung von Blöcken

2024-07-12

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.

1. Konzept

1.1 Blockdefinition

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.

1.2 Definition des Eigenschaftsblocks

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:

Eine Instanz der AttributeDefinition-Klasse und legt den Attributwert des Objekts fest;
Da die Attributdefinition eines Blocks auch als Entität im Block betrachtet werden kann, kann die Attributdefinition über die Mitgliedsfunktion AppendEntity der Blocktabellen-Datensatzklasse an den Block angehängt werden.

Zu den durch Attribute definierten Attributwerten gehören hauptsächlich:

Einfügepunkt, Höhe, Drehwinkel, Ausrichtung und Breite des Textes;
Der Standardwert des Attributs;
Attributmodus, wie unsichtbarer Modus, unsichtbarer Modus, konstanter Modus, konstanter Modus, Überprüfungsmodus, Verifizierungsmodus und voreingestellter Modus, Voreinstellung;
Name des Attribut-Tags.

1.3 Dynamische Blockdefinition

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.

1.4 Blockklassifizierung und -operationen

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.

2. Blockdefinition

2.1 Blockdefinition

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:

Verwenden Sie die Funktion GetObject() der Transaction-Klasse, um das Blocktabellenobjekt abzurufen.
Erstellen Sie ein BlockTableRecord-Objekt und legen Sie den Blocknamen fest.
Erstellen Sie die Entitätsobjekte, aus denen der Block besteht.
Rufen Sie die AppendEntity-Funktion der BlockTableRecord-Klasse auf, um die Entitäten, aus denen der Block besteht, in den Blocktabellendatensatz zu schreiben.
Rufen Sie die Add-Funktion der BlockTable-Klasse auf, um die erstellten Blocktabellendatensätze in die Blocktabelle der aktuellen Zeichnung zu schreiben.

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;
        }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

2.2 Definition des Eigenschaftsblocks

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());
         }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

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);
            
       //然后将这两个属性加入到集合，再调用上面的方法即可。
1
2
3
4
5
6

Die Parameterbeschreibung lautet wie folgt:

Point3d-Position: Dies ist die Eigenschaftdefinierten Standort , angegeben in Form dreidimensionaler Koordinaten. Auch wenn Ihr Entwurf auf einer zweidimensionalen Ebene arbeitet, müssen Sie einen dreidimensionalen Koordinatenpunkt angeben, und der Z-Wert ist normalerweise auf 0 eingestellt.
Zeichenfolgenwert: Dies wird durch das Attribut definiertStandardwert . Wenn beim Einfügen des Blocks kein spezifischer Attributwert angegeben wird, wird dieser Standardwert verwendet.
String-Tag: Dies wird durch das Attribut definiertEtikett , was seine eindeutige Kennung ist. Wenn der Block eingefügt wird, kann der Attributwert über dieses Tag referenziert und geändert werden.
Zeichenfolgenaufforderung: Dies ist ein AttributSchnelle Nachricht Wenn der Benutzer beim Einfügen eines Blocks einen Attributwert eingeben muss, wird diese Eingabeaufforderung angezeigt. Dieses Feld kann leer bleiben, wenn keine Benutzereingabe erforderlich ist.
ObjectId-Stil: Dies istDie Objekt-ID des Schriftstils . In AutoCAD bestimmt der Schriftstil das Erscheinungsbild des Attributtextes, einschließlich Schriftart, Größe, Breitenverhältnis usw. Dieser Parameter muss die ID eines gültigen Schriftstilobjekts sein, andernfalls wird möglicherweise eine Ausnahme ausgelöst.

2.3 Dynamische Blockdefinition

Die Definition dynamischer Blöcke erfordert die Verwendung von Attributblöcken.DynamicBlockReferencePropertyCollectionKlassen erlegen Eigenschaften Beschränkungen auf.

3. Blockreferenz (Blockeinfügung)

3.1 Gewöhnliche Blockeinfügung

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;
        }        
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

3.2 Einfügen von Attributblöcken

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:

Öffnen Sie das Blocktabellen-Datensatzobjekt, zu dem die Blockreferenz gehört.
Durchlaufen Sie die Entitäten im Blocktabellendatensatz. Wenn es sich bei der Entität um ein durch ein Attribut definiertes Objekt handelt, legen Sie den Attributwert für das Blockreferenzattributobjekt entsprechend seiner Identifikation fest.
Rufen Sie das Attributsammlungsobjekt des Blockreferenzobjekts ab, um das neu erstellte Attributreferenzobjekt zur Blockreferenz hinzuzufügen. Das Attributsammlungsobjekt wird durch das AttributeCollection-Attribut von BlockReference identifiziert, und durch Aufrufen seiner AppendAttribute-Funktion kann das Hinzufügen des Attributs zur Blockreferenz abgeschlossen werden.

/// <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
         }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

Einige der oben genannten Parameter werden möglicherweise nicht benötigt, z. B. das Skalierungsverhältnis und das Einfügungsverhältnis.

3.3 Attributänderung

/// <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();
                     }
                 }
 
             }
 
         }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

Technologieaustausch