Sviluppo secondario CAD (12) - Definizione e utilizzo di block

Sviluppo secondario CAD (12) - Definizione e utilizzo dei blocchi

2024-07-12

I blocchi sono un punto di conoscenza molto importante nel CAD Oggi ti fornirò alcune classificazione e introduzione dei blocchi, nonché la definizione e il riferimento dei blocchi.

1. Concetto

1.1 Definizione del blocco

Un blocco è un'entità definita da più oggetti grafici logicamente correlati. Il vantaggio è che può unificare gli standard di lavoro e migliorare l'efficienza del lavoro, perché un oggetto nella vita non è un'unità semplice, ma può essere composto da più unità. I blocchi possono ben rappresentare questa struttura.

L'essenza di un blocco è una raccolta di oggetti entità archiviati nei record della tabella dei blocchi.

1.2 Definizione del blocco proprietà

I blocchi di attributi sono composti da entità costituite e informazioni aggiuntive (attributi). La definizione dei blocchi in un blocco di attributi è la stessa di quella in un blocco semplice e la definizione degli attributi viene ottenuta principalmente attraverso gli attributi e le funzioni rilevanti dell'AttributeDefinition dell'attributo. classe. . Le implementazioni specifiche includono:

Un'istanza della classe AttributeDefinition e imposta il valore dell'attributo dell'oggetto;
Poiché la definizione dell'attributo di un blocco può anche essere considerata come un'entità nel blocco, la definizione dell'attributo può essere allegata al blocco tramite la funzione membro AppendEntity della classe record della tabella del blocco.

Tra questi, i valori degli attributi definiti dagli attributi includono principalmente:

Il punto di inserimento, altezza, angolo di rotazione, allineamento e larghezza del testo;
Il valore predefinito dell'attributo;
Modalità attributo, come modalità invisibile, modalità invisibile, modalità costante, modalità costante, modalità di verifica, modalità di verifica e modalità preimpostata, Preimpostazione;
Nome del tag dell'attributo.

1.3 Definizione di blocco dinamico

I blocchi dinamici ci consentono di creare blocchi con un elevato grado di flessibilità e personalizzazione. Perché una volta inserito un blocco tradizionale in un disegno, le sue dimensioni, forma e posizione vengono generalmente fisse. I blocchi dinamici, d'altro canto, possono regolare le proprie proprietà geometriche attraverso l'interazione dell'interfaccia utente (come il trascinamento delle maniglie di azione) senza dover ridefinire l'intero blocco o modificare manualmente i suoi componenti.

1.4 Classificazione e operazioni dei blocchi

I blocchi sono principalmente suddivisi in blocchi semplici, blocchi di attributi e blocchi dinamici. Per i blocchi, esistono principalmente operazioni di definizione del blocco, operazioni di riferimento del blocco (ovvero operazioni di inserimento del blocco) e modifica del blocco.

2. Definizione del blocco

2.1 Definizione del blocco

Non importa che tipo di blocco siano, le loro definizioni sono più o meno le stesse (i blocchi di attributi devono aggiungere oggetti di attributo. I passaggi specifici sono i seguenti:

Utilizzare la funzione GetObject() della classe Transaction per ottenere l'oggetto tabella blocchi;
Crea un oggetto BlockTableRecord e imposta il nome del blocco;
Creare gli oggetti entità che compongono il blocco;
Chiama la funzione AppendEntity della classe BlockTableRecord per scrivere le entità che compongono il blocco nel record della tabella dei blocchi;
Chiama la funzione Add della classe BlockTable per scrivere i record della tabella dei blocchi creati nella tabella dei blocchi del disegno corrente.

Il codice specifico è il seguente:

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 Definizione del blocco proprietà

Quanto sopra è solo la definizione di un blocco semplice. Per i blocchi di attributi, come suggerisce il nome, è necessario definire i campi degli attributi nel blocco (possiamo intenderlo come la definizione delle variabili degli attributi, che devono essere convertite in valori di variabili specifici). quando referenziato).
Definizione del blocco proprietà, possiamo aggiungervi proprietà aggiungendo proprietà.

		 /// <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

Aggiunge attributi alla definizione di blocco specificata. Possiamo usarlo in questo modo:

 		//属性添加
        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

La descrizione dei parametri è la seguente:

Posizione Point3d: questa è la proprietàposizione definita , dato sotto forma di coordinate tridimensionali. Anche se il tuo progetto funziona su un piano bidimensionale, devi fornire un punto di coordinate tridimensionale e il valore Z è solitamente impostato su 0.
valore stringa: questo è definito dall'attributovalore di default . Quando viene inserito il blocco, se non viene fornito alcun valore di attributo specifico, viene utilizzato questo valore predefinito.
tag stringa: questo è definito dall'attributoEtichetta , che è il suo identificatore univoco. Quando il blocco viene inserito, il valore dell'attributo può essere referenziato e modificato tramite questo tag.
prompt stringa: questo è un attributoMessaggio di richiesta , quando l'utente deve inserire un valore di attributo durante l'inserimento di un blocco, verrà visualizzato questo messaggio di richiesta. Questo può essere lasciato vuoto se non è richiesto alcun input da parte dell'utente.
Stile ObjectId: questo èL'ID oggetto dello stile del carattere . In AutoCAD, lo stile del carattere determina l'aspetto del testo degli attributi, inclusi carattere, dimensione, rapporto di larghezza, ecc. Questo parametro deve essere l'ID di un oggetto di stile di carattere valido, altrimenti potrebbe essere generata un'eccezione.

2.3 Definizione di blocco dinamico

La definizione dei blocchi dinamici richiede l'utilizzo di blocchi di attributi.DynamicBlockReferencePropertyCollectionLe classi impongono vincoli sulle proprietà.

3. Riferimento di blocco (inserimento di blocco)

3.1 Inserimento blocco ordinario

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 Inserimento del blocco di attributi

L'entità dell'attributo nel riferimento al blocco è rappresentata dalla classe AttibuteReference nello spazio dei nomi DatabaseServices, che in realtà è un oggetto di testo a riga singola derivato dalla classe DBText. Per aggiungere attributi a un riferimento di blocco, attenersi alla seguente procedura:

Aprire l'oggetto record della tabella dei blocchi a cui appartiene il riferimento del blocco;
Passare in rassegna le entità nel record della tabella dei blocchi Se l'entità è un oggetto definito da un attributo, impostare il valore dell'attributo per l'oggetto dell'attributo di riferimento del blocco in base alla sua identificazione;
Ottieni l'oggetto raccolta attributi dell'oggetto riferimento blocco per aggiungere l'oggetto riferimento attributo appena creato al riferimento blocco. L'oggetto della raccolta di attributi è identificato dall'attributo AttributeCollection di BlockReference e la chiamata alla relativa funzione AppendAttribute può completare l'aggiunta dell'attributo del riferimento al blocco.

/// <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

Alcuni dei parametri sopra indicati potrebbero non essere necessari, come il rapporto di scala e il rapporto di inserimento.

3.3 Modifica degli attributi

/// <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

Condivisione della tecnologia