CAD secundae progressionis (12) - Definitio et usus impedimentorum

CAD secundae progressionis (12) - Definitio et usus caudices

2024-07-12

Caudices sunt gravissimae cognitionis punctum in CAD. Hodie tibi dabo aliquam classificationem et inductionem caudices, necnon definitionem et rationem caudicis.

1. conceptus

1.1 Clausus definitionis

Truncus ens est a pluribus obiectis graphicis relatis graphice definitum. Utilitas est quod signa operis augere potest et efficaciam operis emendare, quia res in vita non est simplex unitas, sed ex multiplicibus unitatibus constare potest.

Essentia scandali est collectio entium objectorum in tabulis truncis reposita.

1.2 Property obstructionum definitionem

Stipites attributi componuntur ex entibus et informationibus (attributis). Definitio clausorum in scandalo attributo eadem est ac in simplici scandalo, et definitio attributorum maxime obtinetur per attributa et functiones AttributeDefinitionis classis. . Imprimis exsecutiones includunt:

Instantia Definitionis genus et valorem attributum obiecti ponit;
Cum definitio attributi stipis etiam pro entitate in scandalo haberi potest, definitio attributa stipi applicari potest per munus membri AppendEntity of the block record record class.

Inter eas, valores attributi a attributis definiti praecipue includuntur;

Punctum insertio, altitudo, rotatio angulus, textus noctis et latitudo;
De valore defectus attributi;
Modus attributus, ut modus invisibilis, modus invisibilis, modus constans, modus constans, modus verificationis, Modus cognosce, modus preset, Preset;
Nomen tag attributum.

1.3 Dynamic obstructionum definitionem

Caudices dynamici permittunt nos creare cuneos cum eminentia flexibilitate et customizability. Quia olim truncus traditus inseritur tractus, magnitudo, figura, locusque figi solent. Stipitationes dynamicae, e contra, proprietatibus geometricis possunt accommodare per commercium interfaciei utentis (quales tractationes trahunt actionis) non habens ad rescindendum totum scandalum vel manually suas partes edit.

1.4 Clausus genus et res

Caudices principaliter dividuntur in caudices simplices, caudices attributi, et cuneos dynamicos. Ad caudices, sunt operationes definitionis maxime clausulae, operationes referentiarum clausus (id est, clausus operationum insertio), et emendatio obstantia.

2. Acta definitionis

2.1 Acta definitionis

Utcumque autem scandali sunt, eorum definitiones fere sunt idem (attribuendi caudices addendi attributi obiecti).

Utere GetObject () functionem transactionis classis ad obtinendum objectum mensae obstructionum;
Facere objectum BlockTableRecord et nomen obstructionum pone;
Creare res, quae scandalum constituunt;
Appendicem vocamus functionis BlockTableRecord classis ad scribenda entia quae scandalum constituunt in tabulae monumenti obstructionum;
Munus Addendi vocationis BlockTable classis scribenda tabulas truncos creatos in tabellam tractionem hodiernam.

In codice specifico talis est:

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 Proprietas obstructionum definitionem

Haec tantum definitio est simplicis scandali. Nam attributorum caudices, ut nomen suggerit, oportet agros attributos in stipite definire (intelligi possumus eam ut attributi definientes variabiles, quae converti debent in valores variabiles specificos. cum referenced).
Proprietas clausus definitionem, proprietates addere possumus, proprietates addere.

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

Adiungit attributa definitio clausus definitionem. sic uti possumus:

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

Parametri descriptio talis est:

Point3d positio hoc est propriumdefinito loco datis in forma coordinatarum trium dimensivarum. Etiamsi consilium tuum in plano duos dimensiva laborat, debes tria punctum coordinatum dimensivum praebere, et Z valorem plerumque 0 constituitur.
filum valorem: Hoc definitur attributumdefault pretii . Cum clausus inseritur, si nulla specifica valoris attributa praebetur, hic defectus pretii adhibetur.
chorda tag: hoc est per attributumLabel quae est eius singularis idens. Cum clausus inseritur, valorem attributum per hoc tag referri ac mutari potest.
linea promptum hoc attributumPromptus nuntius Cum usor inire debet valorem attributum cum truncum inserendo, nuntius promptus ostendetur. Hoc in blank relinquetur si nullus usor initus requiritur.
ObjectId style: Hic estObiectum ID de fonte style . In AutoCAD fons stilus determinat speciem textui attributi, incluso fonte, magnitudine, latitudine ratione, etc. Hic modulus debet ID obiecti fontis validi esse, alioquin excipi potest.

2.3 Dynamic obstructionum definitionem

Stipitibus dynamicis definitio requirit usum attributorum caudices.DynamicBlockReferencePropertyCollectionClasses angustiis proprietatibus imponunt.

3. Acta reference (obstructionum insertio)

3.1 Ordinarium insertio obstructionum

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 insertio attributum obstructionum

Relatum entitatis attributum in scandalo repraesentatur ab AttibuteReference classium in DatabaseServices spatio nominali, quod quidem objectum unius lineae ex genere DBText derivatum est. Ad truncum attributa referentia, hos gradus sequere;

Aperi tabulam clausuram obiecti ad quod pertinet referat scandalum;
Ansa per entia in tabulae monumento obstructionum. Si ens est obiectum attributum definitum, pone valorem attributum pro clauso referendi obiectum attributum secundum identitatem;
Accipere attributum collectio objectum scandalum referat objectum addere noviter creatum attributum referat objectum ad scandalum referat. Objectum collectionis attributum notatur per attributum Attribute Collectio BlockReference, eiusque munus AppendAttributum appellans, attributum adiectione impedimenti complere potest.

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

Aliquae parametrorum praedictorum non possunt esse necessaria, ut sunt scalae ratio et ratio inserendi.

3,3 attributum modificatione

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

Technology sharing