CAD:n toissijainen kehitys (12) - Blocks_developdoc-tunnisteen määritelmä ja käyttö

Toissijainen CAD-kehitys (12) - Lohkojen määrittely ja käyttö

2024-07-12

Lohkot ovat erittäin tärkeä tietopiste CAD:ssa Tänään annan sinulle lohkojen luokittelun ja esittelyn sekä lohkojen määritelmän ja viittauksen.

1. Konsepti

1.1 Lohkon määritelmä

Lohko on useiden loogisesti toisiinsa liittyvien graafisten objektien määrittelemä kokonaisuus. Sen etuna on, että se voi yhtenäistää työstandardeja ja parantaa työn tehokkuutta, koska elämän esine ei ole yksinkertainen yksikkö, vaan se voi koostua useista yksiköistä.

Lohkon ydin on kokoelma lohkotaulukon tietueisiin tallennettuja entiteettiobjekteja.

1.2 Ominaisuuslohkon määritys

Attribuuttilohkot koostuvat entiteetistä ja lisätiedoista (attribuutit) Lohkojen määritelmä attribuuttilohkossa on sama kuin yksinkertaisessa lohkossa, ja attribuuttien määrittely tapahtuu pääasiassa AttributeDefinition-luokan asiaankuuluvien attribuuttien ja funktioiden avulla. . Erityisiä toteutuksia ovat:

AttributeDefinition-luokan esiintymä ja asettaa objektin attribuutin arvon;
Koska lohkon attribuuttimäärittelyä voidaan pitää myös kokonaisuutena lohkossa, voidaan attribuuttimääritys liittää lohkoon lohkotaulukon tietueluokan jäsenfunktion AppendEntity kautta.

Niiden joukossa attribuuttien määrittämät attribuuttiarvot sisältävät pääasiassa:

Tekstin lisäyskohta, korkeus, kiertokulma, kohdistus ja leveys;
Attribuutin oletusarvo;
Attribuuttitila, kuten näkymätön tila, näkymätön tila, vakiotila, vakiotila, vahvistustila, vahvistustila ja esiasetustila, esiasetus;
Attribuuttitunnisteen nimi.

1.3 Dynaaminen lohkon määrittely

Dynaamisten lohkojen avulla voimme luoda lohkoja, jotka ovat erittäin joustavia ja mukautettavia. Koska kun perinteinen lohko on lisätty piirustukseen, sen koko, muoto ja sijainti ovat yleensä kiinteät. Dynaamiset lohkot puolestaan voivat säätää geometrisia ominaisuuksiaan käyttöliittymän vuorovaikutuksen avulla (kuten vetämällä toimintokahvoja) ilman, että koko lohkoa on määriteltävä uudelleen tai sen osia manuaalisesti muokataan.

1.4 Lohkojen luokittelu ja toiminnot

Lohkot jaetaan pääasiassa yksinkertaisiin lohkoihin, attribuuttilohkoihin ja dynaamisiin lohkoihin. Lohkoja varten on pääasiassa lohkon määrittelytoimintoja, lohkoviittausoperaatioita (eli lohkon lisäysoperaatioita) ja lohkon muokkaustoimintoja.

2. Lohkon määritelmä

2.1 Lohkon määritelmä

Riippumatta siitä, millaisia lohkoja ne ovat, niiden määritelmät ovat suunnilleen samat (attribuuttilohkojen on lisättävä attribuuttiobjekteja).

Käytä Transaction-luokan GetObject()-funktiota saadaksesi lohkotaulukkoobjektin;
Luo BlockTableRecord-objekti ja aseta lohkon nimi;
Luo entiteettiobjektit, jotka muodostavat lohkon;
Kutsu BlockTableRecord-luokan AppendEntity-funktio kirjoittaaksesi lohkon muodostavat entiteetit lohkotaulukkotietueeseen;
Kutsu BlockTable-luokan Add-funktio kirjoittaaksesi luodut lohkotaulukon tietueet nykyisen piirustuksen lohkotaulukkoon.

Tarkka koodi on seuraava:

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 Ominaisuuslohkon määritelmä

Yllä oleva on vain yksinkertaisen lohkon määritelmä Attribuuttilohkoille, kuten nimestä voi päätellä, lohkon attribuuttikentät (voimme ymmärtää sen määrittävänä attribuuttimuuttujia, jotka on muutettava tietyiksi muuttujaarvoiksi). kun viitataan).
Ominaisuuslohkon määritelmä, voimme lisätä siihen ominaisuuksia lisäämällä ominaisuuksia.

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

Lisää määritteitä määritettyyn lohkomääritykseen. Voimme käyttää sitä näin:

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

Parametrin kuvaus on seuraava:

Point3d-sijainti: Tämä on omaisuusmääritelty sijainti , annettu kolmiulotteisten koordinaattien muodossa. Vaikka suunnitelmasi toimisi kaksiulotteisessa tasossa, sinun on annettava kolmiulotteinen koordinaattipiste, ja Z-arvoksi asetetaan yleensä 0.
merkkijonoarvo: Tämä määritellään attribuutillaoletusarvo . Kun lohko lisätään, jos erityistä attribuuttiarvoa ei ole annettu, käytetään tätä oletusarvoa.
merkkijonotunniste: Tämä määritellään attribuutillaLabel , joka on sen yksilöllinen tunniste. Kun lohko on lisätty, attribuutin arvoon voidaan viitata ja sitä voidaan muokata tämän tagin kautta.
merkkijonokehote: Tämä on attribuuttiPikaviesti , kun käyttäjän on syötettävä attribuutin arvo lohkoa lisääessään, tämä kehoteviesti tulee näkyviin. Tämä voidaan jättää tyhjäksi, jos käyttäjän syöttöä ei tarvita.
ObjectId-tyyli: Tämä onFonttityylin objektitunnus . AutoCADissa kirjasintyyli määrittää määritetekstin ulkoasun, mukaan lukien fontin, koon, leveyssuhteen jne. Tämän parametrin on oltava kelvollisen kirjasintyyliobjektin tunnus, muuten voidaan tehdä poikkeus.

2.3 Dynaaminen lohkon määrittely

Dynaamisten lohkojen määrittely edellyttää attribuuttilohkojen käyttöä.DynamicBlockReferencePropertyCollectionLuokat asettavat rajoituksia ominaisuuksille.

3. Lohkon viite (lohkon lisäys)

3.1 Tavallinen lohkon lisäys

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 Attribuuttilohkon lisäys

Lohkoviittauksen attribuuttikokonaisuutta edustaa DatabaseServices-nimiavaruuden AttibuteReference-luokka, joka on itse asiassa yksirivinen tekstiobjekti, joka on johdettu DBText-luokasta. Voit lisätä attribuutteja lohkoviitteeseen seuraavasti:

Avaa lohkotaulukon tietueobjekti, johon lohkoviittaus kuuluu;
Selaa lohkotaulukkotietueen entiteetit läpi. Jos entiteetti on attribuutilla määritetty objekti, aseta lohkoviittausattribuuttiobjektin attribuutin arvo sen tunnisteen mukaan.
Hanki lohkoviittausobjektin attribuuttikokoelmaobjekti lisätäksesi juuri luotu attribuuttiviittausobjekti lohkoviittaukseen. Attribuuttikokoelmaobjektin tunnistaa BlockReferencen AttributeCollection-attribuutti, ja sen AppendAttribute-funktion kutsuminen voi suorittaa lohkoviitteen attribuutin lisäämisen.

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

Joitakin yllä olevista parametreista ei ehkä tarvita, kuten skaalaussuhdetta ja lisäyssuhdetta.

3.3 Attribuuttien muuttaminen

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

Teknologian jakaminen