Desenvolvimento secundário CAD (12) - Definição e uso de blocos

Desenvolvimento secundário CAD (12) - Definição e utilização de blocos

2024-07-12

Os blocos são um ponto de conhecimento muito importante em CAD. Hoje darei a vocês algumas classificações e introdução de blocos, bem como a definição e referência de blocos.

1. Conceito

1.1 Definição de bloco

Um bloco é uma entidade definida por vários objetos gráficos relacionados logicamente. A vantagem é que pode unificar os padrões de trabalho e melhorar a eficiência do trabalho, porque um objeto na vida não é uma unidade simples, mas pode ser composto por múltiplas unidades. Os blocos podem muito bem representar esta estrutura.

A essência de um bloco é uma coleção de objetos de entidade armazenados em registros de tabelas de blocos.

1.2 Definição de bloco de propriedades

Os blocos de atributos são compostos por entidades constituídas e informações adicionais (atributos). A definição de blocos em um bloco de atributos é a mesma que em um bloco simples, e a definição de atributos é obtida principalmente por meio dos atributos e funções relevantes da AttributeDefinition do atributo. aula. . Implementações específicas incluem:

Uma instância da classe AttributeDefinition e define o valor do atributo do objeto;
Como a definição de atributo de um bloco também pode ser considerada como uma entidade no bloco, a definição de atributo pode ser anexada ao bloco por meio da função membro AppendEntity da classe de registro da tabela de blocos.

Entre eles, os valores de atributos definidos pelos atributos incluem principalmente:

O ponto de inserção, altura, ângulo de rotação, alinhamento e largura do texto;
O valor padrão do atributo;
Modo de atributo, como modo invisível, modo invisível, modo constante, modo constante, modo de verificação, modo de verificação e modo predefinido, predefinido;
Nome da tag de atributo.

1.3 Definição de bloco dinâmico

Os blocos dinâmicos nos permitem criar blocos com alto grau de flexibilidade e personalização. Porque uma vez que um bloco tradicional é inserido em um desenho, seu tamanho, forma e localização geralmente são fixos. Os blocos dinâmicos, por outro lado, podem ajustar suas propriedades geométricas por meio da interação da interface do usuário (como arrastar alças de ação) sem precisar redefinir o bloco inteiro ou editar manualmente seus componentes.

1.4 Classificação e operações de blocos

Os blocos são divididos principalmente em blocos simples, blocos de atributos e blocos dinâmicos. Para blocos, existem principalmente operações de definição de bloco, operações de referência de bloco (ou seja, operações de inserção de bloco) e edição de bloco.

2. Definição de bloco

2.1 Definição de bloco

Não importa que tipo de bloco sejam, suas definições são praticamente as mesmas (os blocos de atributos precisam adicionar objetos de atributos. As etapas específicas são as seguintes:

Utilize a função GetObject() da classe Transaction para obter o objeto da tabela de blocos;
Crie um objeto BlockTableRecord e defina o nome do bloco;
Crie os objetos de entidade que compõem o bloco;
Chame a função AppendEntity da classe BlockTableRecord para gravar as entidades que compõem o bloco no registro da tabela de blocos;
Chame a função Add da classe BlockTable para gravar os registros da tabela de blocos criados na tabela de blocos do desenho atual.

O código específico é o seguinte:

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 Definição de bloco de propriedades

O texto acima é apenas a definição de um bloco simples. Para blocos de atributos, como o nome sugere, você precisa definir os campos de atributos no bloco (podemos entendê-lo como definir variáveis de atributos, que precisam ser convertidas em valores de variáveis específicos). quando referenciado).
Definição do bloco de propriedades, podemos adicionar propriedades a ele adicionando propriedades.

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

Adiciona atributos à definição de bloco especificada. Podemos usá-lo assim:

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

A descrição do parâmetro é a seguinte:

Posição Point3d: Esta é a propriedadelocalização definida , dado na forma de coordenadas tridimensionais. Mesmo que seu projeto esteja trabalhando em um plano bidimensional, você precisa fornecer um ponto de coordenada tridimensional e o valor Z geralmente é definido como 0.
valor da string: Isso é definido pelo atributovalor padrão . Quando o bloco é inserido, se nenhum valor de atributo específico for fornecido, esse valor padrão será usado.
tag string: Isso é definido pelo atributoRótulo , que é seu identificador exclusivo. Quando o bloco é inserido, o valor do atributo pode ser referenciado e modificado através desta tag.
prompt de string: Este é um atributoMensagem de alerta , quando o usuário precisar inserir um valor de atributo ao inserir um bloco, esta mensagem de prompt será exibida. Isto pode ser deixado em branco se nenhuma entrada do usuário for necessária.
Estilo ObjectId: Este éO ID do objeto do estilo da fonte . No AutoCAD, o estilo da fonte determina a aparência do texto do atributo, incluindo fonte, tamanho, proporção de largura, etc. Este parâmetro deve ser o ID de um objeto de estilo de fonte válido, caso contrário, uma exceção poderá ser lançada.

2.3 Definição de bloco dinâmico

A definição de blocos dinâmicos requer o uso de blocos de atributos.DynamicBlockReferencePropertyCollectionAs classes impõem restrições às propriedades.

3. Referência de bloco (inserção de bloco)

3.1 Inserção de bloco comum

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 Inserção de bloco de atributos

A entidade de atributo na referência de bloco é representada pela classe AttibuteReference no namespace DatabaseServices, que na verdade é um objeto de texto de linha única derivado da classe DBText. Para adicionar atributos a uma referência de bloco, siga estas etapas:

Abra o objeto de registro da tabela de blocos ao qual pertence a referência do bloco;
Percorrer as entidades no registro da tabela de blocos Se a entidade for um objeto definido por um atributo, defina o valor do atributo para o objeto de atributo de referência do bloco de acordo com sua identificação;
Obtenha o objeto de coleção de atributos do objeto de referência de bloco para adicionar o objeto de referência de atributo recém-criado à referência de bloco. O objeto de coleção de atributos é identificado pelo atributo AttributeCollection de BlockReference, e chamar sua função AppendAttribute pode completar a adição de atributos da referência de bloco.

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

Alguns dos parâmetros acima podem não ser necessários, como taxa de escala e taxa de inserção.

3.3 Modificação de atributos

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

Compartilhamento de tecnologia