Développement secondaire CAO (12) - Définition et utilisation des blocs

2024-07-12

Les blocs sont un point de connaissance très important en CAO. Aujourd'hui, je vais vous donner une classification et une introduction des blocs, ainsi que la définition et la référence des blocs.

1. Concept

1.1 Définition du bloc

Un bloc est une entité définie par plusieurs objets graphiques logiquement liés. L'avantage est qu'il peut unifier les normes de travail et améliorer l'efficacité du travail, car un objet dans la vie n'est pas une simple unité, mais peut être composé de plusieurs unités. Les blocs peuvent bien représenter cette structure.

L'essence d'un bloc est une collection d'objets d'entité stockés dans des enregistrements de table de blocs.

1.2 Définition du bloc de propriétés

Les blocs d'attributs sont composés d'entités et d'informations supplémentaires (attributs). La définition des blocs dans un bloc d'attributs est la même que celle d'un bloc simple, et la définition des attributs est principalement réalisée via les attributs et fonctions pertinents de la classe AttributeDefinition. . Les implémentations spécifiques incluent :

Une instance de la classe AttributeDefinition et définit la valeur d'attribut de l'objet ;
Étant donné que la définition d'attribut d'un bloc peut également être considérée comme une entité dans le bloc, la définition d'attribut peut être attachée au bloc via la fonction membre AppendEntity de la classe d'enregistrement de la table de bloc.

Parmi eux, les valeurs d'attribut définies par attributs comprennent principalement :

Le point d'insertion, la hauteur, l'angle de rotation, l'alignement et la largeur du texte ;
La valeur par défaut de l'attribut ;
Mode d'attribut, tel que le mode invisible, le mode invisible, le mode constant, le mode constant, le mode de vérification, le mode de vérification et le mode prédéfini, prédéfini ;
Nom de la balise d'attribut.

1.3 Définition des blocs dynamiques

Les blocs dynamiques nous permettent de créer des blocs avec un haut degré de flexibilité et de personnalisation. Car une fois qu’un bloc traditionnel est inséré dans un dessin, sa taille, sa forme et son emplacement sont généralement fixes. Les blocs dynamiques, en revanche, peuvent ajuster leurs propriétés géométriques via une interaction avec l'interface utilisateur (telle que le déplacement des poignées d'action) sans avoir à redéfinir l'intégralité du bloc ou à modifier manuellement ses composants.

1.4 Classification et opérations des blocs

Les blocs sont principalement divisés en blocs simples, blocs d'attributs et blocs dynamiques. Pour les blocs, il existe principalement des opérations de définition de bloc, des opérations de référence de bloc (c'est-à-dire des opérations d'insertion de bloc) et de l'édition de bloc.

2. Définition du bloc

2.1 Définition du bloc

Quel que soit le type de bloc dont il s'agit, leurs définitions sont à peu près les mêmes (les blocs d'attributs doivent ajouter des objets d'attribut. Les étapes spécifiques sont les suivantes :

Utilisez la fonction GetObject() de la classe Transaction pour obtenir l'objet table de blocs ;
Créez un objet BlockTableRecord et définissez le nom du bloc ;
Créez les objets d'entité qui composent le bloc ;
Appelez la fonction AppendEntity de la classe BlockTableRecord pour écrire les entités qui composent le bloc dans l'enregistrement de la table des blocs ;
Appelez la fonction Add de la classe BlockTable pour écrire les enregistrements de table de blocs créés dans la table de blocs du dessin actuel.

Le code spécifique est le suivant :

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 Définition du bloc de propriété

Ce qui précède n'est que la définition d'un simple bloc. Pour les blocs d'attributs, comme son nom l'indique, vous devez définir les champs d'attributs dans le bloc (nous pouvons le comprendre comme définissant des variables d'attribut, qui doivent être converties en valeurs de variables spécifiques lorsqu'il est référencé).
Définition du bloc de propriétés, nous pouvons y ajouter des propriétés en ajoutant des propriétés.

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

Ajoute des attributs à la définition de bloc spécifiée. Nous pouvons l'utiliser comme ceci :

 		//属性添加
        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 description des paramètres est la suivante :

Position Point3d : C'est la propriétéemplacement défini , donné sous forme de coordonnées tridimensionnelles. Même si votre conception fonctionne sur un plan bidimensionnel, vous devez fournir un point de coordonnées tridimensionnelles et la valeur Z est généralement définie sur 0.
valeur de chaîne : ceci est défini par l'attributvaleur par défaut . Lorsque le bloc est inséré, si aucune valeur d'attribut spécifique n'est fournie, cette valeur par défaut est utilisée.
balise de chaîne : ceci est défini par l'attributÉtiquette , qui est son identifiant unique. Lorsque le bloc est inséré, la valeur de l'attribut peut être référencée et modifiée via cette balise.
invite de chaîne : ceci est un attributMessage rapide , lorsque l'utilisateur doit saisir une valeur d'attribut lors de l'insertion d'un bloc, ce message d'invite s'affichera. Ce champ peut rester vide si aucune entrée de l'utilisateur n'est requise.
Style ObjectId : il s’agit deL'ID d'objet du style de police . Dans AutoCAD, le style de police détermine l'apparence du texte d'attribut, notamment la police, la taille, le rapport de largeur, etc. Ce paramètre doit être l'ID d'un objet de style de police valide, sinon une exception peut être levée.

2.3 Définition des blocs dynamiques

La définition des blocs dynamiques nécessite l'utilisation de blocs d'attributs.DynamicBlockReferencePropertyCollectionLes classes imposent des contraintes sur les propriétés.

3. Référence de bloc (insertion de bloc)

3.1 Insertion de blocs ordinaires

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 Insertion de blocs d'attributs

L'entité d'attribut dans la référence de bloc est représentée par la classe AttibuteReference dans l'espace de noms DatabaseServices, qui est en fait un objet texte sur une seule ligne dérivé de la classe DBText. Pour ajouter des attributs à une référence de bloc, procédez comme suit :

Ouvrez l'objet d'enregistrement de la table de blocs auquel appartient la référence de bloc ;
Parcourez les entités dans l'enregistrement de la table de bloc. Si l'entité est un objet défini par un attribut, définissez la valeur d'attribut pour l'objet d'attribut de référence de bloc en fonction de son identification ;
Obtenez l'objet de collection d'attributs de l'objet de référence de bloc pour ajouter l'objet de référence d'attribut nouvellement créé à la référence de bloc. L'objet de collection d'attributs est identifié par l'attribut AttributeCollection de BlockReference, et l'appel de sa fonction AppendAttribute peut compléter l'ajout d'attribut de la référence de bloc.

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

Certains des paramètres ci-dessus peuvent ne pas être nécessaires, tels que le taux de mise à l'échelle et le taux d'insertion.

3.3 Modification des attributs

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

Partage de technologie