vba中如何嵌套块？

tataki

0 V, n1 o- L* \  f得到斑竹上次解答后，现在可以根据blockB的数量灵活插入需要的块了，（原帖http://www.3dportal.cn/discuz/viewthread.php?tid=1140006&;extra=page%3D3）但现在遇上一个新问题，不好意思又开了一个贴....
问题是这样的，图纸上右侧是原始块，左侧是我想要做成的块。
为简化问题，现在只要插入1个blockA，n个blockB，n的数量通过文本框来确定，blockC和blockD不用插入。
3 k8 G6 _; W- E9 S# |! @" ~当我完成插入1个blockA，n个blockB后，我要把左侧这n+1个块组成一个新块 blockE，这应该算是嵌套块吧？可是这个创建blockE的代码怎么写呢？
( P- X; R6 o8 _- c1 U, s特别的是：n是不确定的，比如某一次是1个A，3个B块，另外一次是1个A，5个B块，怎么来处理这种情况呢？
我感觉不能通过块的名字嵌套吧，因为右侧的原始块有一样的名字，而且原始块是不能删除的。
谢谢，附上图纸和代码

1. Private Sub cmdInsert_Click()
   ' D3 o/ f0 Y" g2 _& |4 T
2. Dim ptInsert(2) As Double
   8 O+ F4 r4 S1 R( }: C7 N
3. Dim lastBlock As Variant
   
4. ptInsert(0) = 0
   $ |: F  s5 [3 M' Y) H  Q3 @. H4 e
5. ptInsert(1) = 0
   
6. ptInsert(2) = 0
   , U+ Q3 x. c  D" Z; g" M) d
7. 
   
8. '----------插入块A 仅仅一个---------------------------------
   
9. Dim B As AcadBlockReference '声明一个块参照变量
   
10. Dim P As Variant '声明一个变体变量用于接收三维点坐标
    
11. Set B = ThisDrawing.ModelSpace.InsertBlock(ptInsert, blkAName.Text, 1, 1, 1, 0)
    1 s: X& N8 n. \6 O8 q) v4 n+ q
12. P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    
13. '----------插入块A 完成---------------------------------
    
14. 
    
15. '----------插入块B---------------------------------
    ; I4 T8 o# W0 E
16. Dim pNew(2) As Double
    
17. pNew(0) = P(0) - 500
    
18. pNew(1) = P(1) + 1405.08
    
19. pNew(2) = P(2)
    
20. Set B = ThisDrawing.ModelSpace.InsertBlock(pNew, blkBName.Text, 1, 1, 1, 0)
      B. Z# r9 B, H6 L+ E1 [9 r( Z
21. P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    " E  _6 u. [2 ?5 y& Q& _# b
22. 
    8 \0 W' X& s5 h  p  M# ^
23. 
    
24. For i = 2 To Val(blkBNum.Text) Step 1
    ! |' j5 q+ }3 w" x0 k
25. Dim pBNew(2) As Double
    
26. pBNew(0) = P(0)
    
27. pBNew(1) = P(1) + 2000
    
28. pBNew(2) = P(2)
    
29. Set B = ThisDrawing.ModelSpace.InsertBlock(pBNew, blkBName.Text, 1, 1, 1, 0)
    
30. P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    
31. Next
    1 z, ^6 Y1 u! X$ U, h
32. '----------插入块B完成---------------------------------
    
33. '最后的效果是左侧的块A和B组成了一个最终的块BlockE
    5 X0 `) ?- _* w6 v
34. 
    # k; E! J, @+ j5 K4 c* m
35. 
    
36. ThisDrawing.Regen acActiveViewport
    
37. 
    $ `9 |% q1 L# t- w- u
38. End Sub
    " o6 M; q* s9 u

复制代码

woaishuijia

1# tataki
% B7 B1 `4 s5 k9 p9 n! s. Q

1. Private Sub cmdInsert_Click()
   ' l+ {  f8 ]; i# L& E
2. Dim ptInsert(2) As Double
   2 p0 P9 m% l' j# b% c( B) W
3. Dim lastBlock As Variant
   4 {! }( p* i3 o1 Y: L) h6 Z: s0 x
4. ptInsert(0) = 0
   3 y3 g1 h4 @$ C
5. ptInsert(1) = 0
   ) A$ u. X8 m$ {$ w1 p$ |
6. ptInsert(2) = 0
   
7. Dim BR As AcadBlock
   9 o' x4 O$ R4 d) c
8. Set BR = ThisDrawing.Blocks.Add(ptInsert, "blockE")
   ' k  T% \$ D* H* S2 X
9. 
   : y3 i7 s# q( J( K1 C" L( z
10. '----------插入块A 仅仅一个---------------------------------
    9 n( \) X* H7 y* U. \# u! y& J( w
11. Dim B As AcadBlockReference '声明一个块参照变量
    
12. Dim P As Variant '声明一个变体变量用于接收三维点坐标
    
13. 'Set B = ThisDrawing.ModelSpace.InsertBlock(ptInsert, blkAName.Text, 1, 1, 1, 0)
    
14. Set B = BR.InsertBlock(ptInsert, blkAName.Text, 1, 1, 1, 0)
    
15. P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    
16. '----------插入块A 完成---------------------------------
    2 }: F8 q# i, Y+ z- K' M. a
17. 
    " ]: m1 h" f. n7 d
18. '----------插入块B---------------------------------
    
19. Dim pNew(2) As Double
    9 B- P# E7 a& e& [/ w: v" P" h
20. pNew(0) = P(0) - 500
    9 \4 r" C2 }' W% n5 u2 F9 g, [1 l
21. pNew(1) = P(1) + 1405.08
    $ O1 J9 S/ ~" `/ }
22. pNew(2) = P(2)
    : k, u  g! G; ^- l5 n/ }4 f
23. 'Set B = ThisDrawing.ModelSpace.InsertBlock(pNew, blkBName.Text, 1, 1, 1, 0)
    
24. Set B = BR.InsertBlock(pNew, blkBName.Text, 1, 1, 1, 0)
    
25. P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    
26. 
    9 Q+ z( n! o8 }1 ]- {6 G9 X8 d
27. 
    3 s$ }1 W3 ^" f0 o% {7 Z0 R1 [* |9 h
28. For i = 2 To Val(blkBNum.Text) Step 1
      p/ ?8 z* h% Q: g. }! _1 _* L5 S
29. Dim pBNew(2) As Double
    . S& Z! `. }8 q6 l  m& `
30. pBNew(0) = P(0)
    2 F$ X4 f3 f- e& Z1 a& V
31. pBNew(1) = P(1) + 2000
    
32. pBNew(2) = P(2)
    
33. 'Set B = ThisDrawing.ModelSpace.InsertBlock(pBNew, blkBName.Text, 1, 1, 1, 0)
    9 f5 i* X8 E( H
34. Set B = BR.InsertBlock(pBNew, blkBName.Text, 1, 1, 1, 0)
    $ g7 v; o! J/ M
35. P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    
36. Next
    
37. '----------插入块B完成---------------------------------
    
38. '最后的效果是左侧的块A和B组成了一个最终的块BlockE
    2 z3 ^$ j5 \# L2 G+ t
39. 
    
40. Set B = ThisDrawing.ModelSpace.InsertBlock(ptInsert, "blockE", 1, 1, 1, 0)
    
41. 
    
42. ThisDrawing.Regen acActiveViewport
    $ D: ^  k) l! U! J% e  }
43. 
    
44. End Sub
    4 r% n! U9 ?" H; U- k6 P7 m

复制代码

tataki

9 q, ?1 M! R% S6 b; K& Z, X; p: s
4 V3 C+ z/ _0 }4 ~+ p谢谢斑竹
2 v8 [' y' W0 c( Q原来是要先创建blockE块，最后在模型空间中插入即可。我还局限在创建一个块然后和上一个块合并，依次进行呢。
1 g8 j9 ^: P6 c6 R( M另外我有一个疑惑，为什么块中嵌套块不能像块中添加实体，比如一个圆或者直线一样进行呢？
9 G8 P4 a; h9 v( z; o# i在书上见过这样的例子，给已经定义的块添加直线：

1. Dim BL As AcadBlock
   
2. 
   
3. Dim ptInsert(2) As Double
   ) }9 \) Z( L# c% M
4. ptInsert(0) = 0
   
5. ptInsert(1) = 0
   
6. ptInsert(2) = 0
   
7. 
   
8. Dim pt1(2) As Double '直线起点pt1
   
9. pt1(0)=100:pt1(1)=100:pt1(2)=100
   ) G% h  `, m$ ^& s  ]: @& F( q
10. 
    ; k  F6 z  W  u# I* J
11. Dim pt2(2) As Double '直线终点pt2
    
12. pt2(0)=500:pt2(1)=500:pt2(2)=500
    5 {) G& O+ a- q$ L/ y- n8 |% F; c
13. 
    0 E1 R% }0 ^) y6 s: T
14. Set BL = ThisDrawing.Blocks.Add(ptInsertBase, "blockE" ) '先定义
    / y' o; n7 e! ^! P% O3 `2 r
15. ThisDrawing.Blocks.Item("blockE" ).AddLine Pt1,Pt2

复制代码

'直接在块中添加直线了，这个里面  " ) .  这段代码怎么出现表情了啊？？？
后面的就不写了。。。。
( V  f/ t2 o: D( o! o: k- j
我就是有点纳闷块里有直接添加实体的方法，addline ,addcircle等等，就是没有添加块的方法，另外，我看到一个AddMInsertBlock方法，最开始还以为是添加块，结果发现不是，于是就不知道该怎么整了。恰好我看的那些VBA书中也没有提及怎么嵌套块...看了斑竹的思路才知道我的想法大方向都错了。哎，经验不足，见到的例子太少了

woaishuijia

强调一下:块是一个定义,文档中任何一个可见的"块"都是块参照,即该块定义的实例,所谓"嵌套块"是指一个块定义中包含有其它块的参照.
& t  I8 J- {+ x; d9 B无论在模型空间(ModelSpace对象),图纸空间(PaperSpace对象)还是块定义(Block对象)中添加块参照都是使用"InsertBlock"方法.
" g4 T+ b+ L7 w! d1 jPS:帖子代码中出现表情是因为代码中挨在一起的的双引号和右括号与论坛的表情代码吻合,被理解为表情了.以后发帖时在双引号和右括号之间添加一个半角空格就OK了.呵呵

tataki

4# woaishuijia
"嵌套块"是指一个块定义中包含有其它块的参照
/ \/ C3 ^0 P. N% u- b2 E原来是这样的啊，需要在“块定义”中添加“块参照”，就像在模型空间里添加块参照一样。就是说这样的嵌套块只是个定义好了块，下一步就是在模型空间里把这个块的 块参照给insertBlock出来。
弄明白了问题的本质，呵呵，谢谢斑竹。

woaishuijia

就像在模型空间里添加块参照一样。就是说这样的嵌套块只是个定义好了块，下一步就是在模型空间里把这个块的 块参照给insertBlock出来。

0 j6 [4 ?5 Q$ z! l+ @心有灵犀,甚好甚慰.

tataki

6# woaishuijia
呵呵，还有很多要向斑竹学习！
# ^3 P8 z1 e8 u2 X8 h1 ^今天我有遇见了一个问题：我把blockC里面增加了两个圆，然后把BlockE插入后整体旋转，现在我想找出blockE中的 blockC里两个圆的圆心坐标，结果失败了...
我是这么想的，用两重循环，第一层遍历blockE，找到名字是 blockC的块后就进入第二层循环，然后遍历blockC中的各个图元：圆，直线，文字等等，找到圆就提取圆心坐标。可是就在第二层遍历的时候就出错了，不知道为什么...斑竹帮忙看看怎么解决，新的图纸和代码上传了。

woaishuijia

& c" n% V6 q, K3 ~你的目的是

找到名字是 blockC的块后就进入第二层循环，然后遍历blockC中的各个图元

但你代码中

1. Dim temA As AcadBlockReference

复制代码

temA是blockC的块参照,不是blockC
2 v/ b0 l: R. g2 O" Y

1. Private Sub cmdInsert_Click()
   
2. 
   
3. Dim ptInsert(2) As Double '原点
   # n; I; e& I* X' b2 E% R
4. ptInsert(0) = 0
   4 J# Y; @6 r3 x2 u- p
5. ptInsert(1) = 0
   
6. ptInsert(2) = 0
   ' z% e+ t/ G) ~5 k. Z2 f" B9 ]1 t
7. 
   
8. Dim BR As AcadBlock '定义块
   
9. Set BR = ThisDrawing.Blocks.Add(ptInsert, "blockE")
   
10. 
    
11. '清除块E中原有的图元,否则每运行一次程序,blockE中都会添加一些块参照,越来越大了
    2 e& P/ _! H* H( I% o9 U% X
12. Dim E As AcadEntity
    
13. For Each E In BR
    
14. E.Delete
    
15. Next
    # [& l+ }, i& q* E0 p
16. 
    8 G: R$ V7 S( {0 s/ F, \* |* o
17. '----------插入块A 仅一个---------------------------------
    
18. Dim B As AcadBlockReference '声明一个块参照变量
    
19. Dim P As Variant '声明一个变体变量用于接收三维点坐标
    & r' R7 |4 L  a* ?# U4 N/ [
20. Set B = BR.InsertBlock(ptInsert, blkAName.Text, 1, 1, 1, 0)
    " X$ |) [- w, ^8 M( g
21. P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    
22. 
    
23. 
    . \' Q, @) g1 i9 L. i, p
24. '----------插入块B---------------------------------
    # U' {5 [+ _& q( O) y9 m+ _
25. 
    ! O; J* g0 e+ W( G) C
26. Dim pNew(2) As Double
    0 e" o2 ?1 T; b' X3 j( ~
27. pNew(0) = P(0) - 500
    
28. pNew(1) = P(1) + 1405.08
    
29. pNew(2) = P(2)
    + p' i" s4 |3 k) `8 _* Z0 W
30. Set B = BR.InsertBlock(pNew, blkBName.Text, 1, 1, 1, 0)
    / T* v; L7 f( x0 S
31. P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    . |+ Q4 ^, Y4 C  b0 N0 {
32. 
    
33. 
    . [$ n- a- f% E2 z
34. Dim I As Integer
    ! o% B% H$ R# X3 y9 l3 B' q
35. For I = 2 To Val(blkBNum.Text) Step 1
    
36. Dim pBNew(2) As Double
    , v8 z0 [& u7 p. P
37. pBNew(0) = P(0)
    " _- a2 n1 }+ M- B2 {
38. pBNew(1) = P(1) + 2000
    
39. pBNew(2) = P(2)
    
40. 
    
41. Set B = BR.InsertBlock(pBNew, blkBName.Text, 1, 1, 1, 0)
    
42. P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    0 z+ @. j7 V5 Z' K$ I* |/ k
43. Next
    
44. 
    7 z# X' Z' K6 P; o: P5 i
45. 
    
46. '----------插入块C 仅一个---------------------------------
    + n2 q+ R. B6 n4 {2 _" \
47. Dim pCNew(2) As Double
    
48. pCNew(0) = P(0)
    
49. pCNew(1) = P(1) + 2000
    
50. pCNew(2) = P(2)
    
51. Set B = BR.InsertBlock(pCNew, blkCName.Text, 1, 1, 1, 0)
    8 N9 m2 |+ x( p
52. Set B = ThisDrawing.ModelSpace.InsertBlock(ptInsert, "blockE", 1, 1, 1, 0)
    
53. 
    
54. 
    
55. '----------旋转块E---------------------------------
    
56. B.Rotate ptInsert, 0.2
    
57. 
    
58. '----------查找块E中的块C的两个圆的圆心坐标---------------------------------
      {3 S8 s0 f1 T: p9 F
59. 
    + u8 |8 ]8 |6 v  q4 j$ v
60. Dim temA As AcadBlockReference
    
61. Dim temB As AcadEntity
    ) M  |+ t1 J9 W+ n
62. Dim ptCir1(2) As Double '第一个圆圆心坐标
    & {3 ?2 |; ]7 p" h% i5 r( e3 F/ n
63. Dim ptCir2(2) As Double '第二个圆圆心坐标
    8 U& w& R, w8 H- k+ r/ G9 I( a
64. Dim C As Variant, J As Integer
    
65. 
    
66. For Each temA In BR '这个遍历就行
    ; f' o  z/ U- l& n9 o- h8 f$ q
67. If temA.Name = blkCName.Text Then
    0 z! e) _8 [! S7 s& \. _
68. P = temA.InsertionPoint '提取块C参照在块E中的插入点坐标
    
69. J = 1
    
70. ' For Each temB In temA '在这里就开始出错了，因为这个temA是BlockReference,是块C的参照
    3 j3 z0 a9 ?' D2 v6 F; W: M
71. For Each temB In ThisDrawing.Blocks(temA.Name) '这个才是真正的块C,呵呵
    
72. '开始找圆，找到圆就提取坐标
    2 w$ f' \; C+ r4 {9 c
73. If temB.ObjectName = "AcDbCircle" Then
    5 U/ L: W+ X! W
74. C = temB.Center '提取圆心坐标
      A& S5 L* x, X1 T& l
75. C(0) = ptInsert(0) + P(0) + C(0) '计算该圆心在模型空间的坐标--块E参照未旋转时
    6 N* s3 A5 J* X' N* _
76. C(1) = ptInsert(1) + P(1) + C(1)
    - Z9 B" M6 `5 N4 r7 w
77. C(2) = ptInsert(2) + P(2) + C(2)
    0 m. \8 ~% A% j# |3 o! }4 W
78. If J = 1 Then
    
79. ptCir1(0) = C(0) * Cos(0.2) - C(1) * Sin(0.2)
    3 u3 |" P1 j& y* i& U; p  q& ]6 t/ q0 X
80. ptCir1(1) = C(0) * Sin(0.2) + C(1) * Cos(0.2)
    
81. ptCir1(2) = C(2)
    2 T. X& A- W1 X7 s
82. J = 2
    
83. Else
    ( s( N/ E  U) h# F( w7 G& N( f: J" m
84. ptCir2(0) = C(0) * Cos(0.2) - C(1) * Sin(0.2)
    + U- x, }/ p3 ~- H/ P9 x4 b- f
85. ptCir2(1) = C(0) * Sin(0.2) + C(1) * Cos(0.2)
    
86. ptCir2(2) = C(2)
    
87. End If
    7 s  s1 Q+ W' @" h4 l% c
88. End If
    
89. Next
    8 z( @. l- F. r5 C9 ]/ J( \- a
90. End If
    + g. h( }, ?& Z& ~( S0 W. b! _
91. Next
    
92. 
    . o6 w) x: A  a) j, v' q
93. 
    9 Q6 p/ a# ^. J3 p- D+ L
94. ThisDrawing.Regen acActiveViewport
    : c: }0 y$ K0 J. Y+ w- _7 k
95. 
    & Y0 Q6 r  N. U" A2 |
96. End Sub

复制代码

* o3 J* S$ u' y4 T# E# d- j计算圆心在块E参照旋转后在模型空间的坐标,除了上面用三角函数计算的方法外,还可以借助UCS变换或使用辅助线(点)的方法,下面是UCS变换

1. Private Sub cmdInsert_Click()
   
2. Dim ptInsert(2) As Double '原点
   ) p3 `& I8 Q" `7 e
3. ptInsert(0) = 0
   ( s3 s9 d% S3 _, R. e2 W
4. ptInsert(1) = 0
   : `9 {! Z6 J. r3 ?' w
5. ptInsert(2) = 0
   
6. Dim BR As AcadBlock '定义块
   0 g+ i1 R2 J# a# p
7. Set BR = ThisDrawing.Blocks.Add(ptInsert, "blockE")
   7 F. M7 g) [8 q' ?, |2 P
8. '清除块E中原有的图元,否则每运行一次程序,blockE中都会添加一些块参照,越来越大了
   
9. Dim E As AcadEntity
   & I( i% x# s2 ?
10. For Each E In BR
    3 b" S7 T* ~, R6 O. \5 o$ P
11.     E.Delete
    0 w3 J, U8 L0 h' x) s
12. Next
    
13. 
    3 ], ^% X! B% X" V( V9 w& w/ n
14. '----------插入块A 仅一个---------------------------------
    " h" Q2 I; B  X$ T: ^  ]
15. Dim B As AcadBlockReference '声明一个块参照变量
    1 C) p" {1 i6 E* K
16. Dim P As Variant '声明一个变体变量用于接收三维点坐标
    & a9 L6 o3 U; P1 z3 I$ n, R
17. Set B = BR.InsertBlock(ptInsert, blkAName.Text, 1, 1, 1, 0)
    
18. P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    
19. 
    , c* M7 R# O3 h% V
20. '----------插入块B---------------------------------
    , D6 e, u# H( @; Y
21. Dim pNew(2) As Double
    + @2 H4 A9 M# s5 {8 t- w
22. pNew(0) = P(0) - 500
    
23. pNew(1) = P(1) + 1405.08
    / a# }+ R. H9 ^& v% ~% i
24. pNew(2) = P(2)
    
25. Set B = BR.InsertBlock(pNew, blkBName.Text, 1, 1, 1, 0)
    
26. P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    
27. Dim I As Integer
    
28. For I = 2 To Val(blkBNum.Text) Step 1
    0 ^& G9 c& \& O) l6 X7 u: N0 s, D
29.     Dim pBNew(2) As Double
    . c9 A* O5 {# q. y, Z5 F
30.     pBNew(0) = P(0)
    9 E0 V9 t! h  p& R! f6 `/ u7 {
31.     pBNew(1) = P(1) + 2000
    ( w+ D3 V# U3 X0 D5 \
32.     pBNew(2) = P(2)
    
33.    
    ' f! n$ i; V" X- n
34.     Set B = BR.InsertBlock(pBNew, blkBName.Text, 1, 1, 1, 0)
    0 x8 q* y* |* e! B4 N
35.     P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    
36. Next
    
37. 
    
38. '----------插入块C 仅一个---------------------------------
    2 z5 D8 M  i" J* B3 E; ?+ f
39. Dim pCNew(2) As Double
      S0 b7 l) R" e" K: M0 L0 j7 _
40. pCNew(0) = P(0)
    ( n' `5 h& W4 _% W# G
41. pCNew(1) = P(1) + 2000
    $ d+ {: }1 `  n- C# o
42. pCNew(2) = P(2)
    
43. Set B = BR.InsertBlock(pCNew, blkCName.Text, 1, 1, 1, 0)
    
44. Set B = ThisDrawing.ModelSpace.InsertBlock(ptInsert, "blockE", 1, 1, 1, 0)
    7 w4 V1 H6 i  t9 b; M  r9 B6 J0 |
45. 
    
46. '----------旋转块E---------------------------------
    
47. B.Rotate ptInsert, 0.2
    
48. '创建两个UCS,用于下一步转换圆心在模型空间的坐标
    
49. '其中,MyUcs是绕原点右旋0.2弧度,对应块E左旋的0.2弧度
    
50. Dim MyUcs As AcadUCS, MyWcs As AcadUCS
    
51. Dim XP As Variant, YP As Variant
    ; x' o5 q. Z# |4 Q
52. With ThisDrawing
    $ y6 u) f8 S7 @' r
53.     With .Utility
    
54.         XP = .PolarPoint(ptInsert, -0.2, 1)
    
55.         YP = .PolarPoint(ptInsert, -0.2 + .AngleToReal(90, acDegrees), 1)
    ' L5 R# {4 S% t' d4 q: u
56.     End With
    ) n6 W  d: ~2 A: X* b
57.     Set MyUcs = .UserCoordinateSystems.Add(ptInsert, XP, YP, "MyUcs")
    
58.     XP(0) = 1: XP(1) = 0
    
59.     YP(0) = 0: YP(1) = 1
    
60.     Set MyWcs = .UserCoordinateSystems.Add(ptInsert, XP, YP, "MyWcs")
    
61. End With
    
62. 
    
63. '----------查找块E中的块C的两个圆的圆心坐标---------------------------------
    9 Z( R4 B+ Y( p# k: o) M$ d
64. Dim temA As AcadBlockReference
    
65. Dim temB As AcadEntity
    9 v4 K% g2 \& `% @& V
66. Dim ptCir1(2) As Double '第一个圆圆心坐标
    : \0 \' o; q/ r) D: ?
67. Dim ptCir2(2) As Double  '第二个圆圆心坐标
    " @2 J4 ?) B+ [
68. Dim C As Variant, J As Integer
    $ b9 a8 |4 y( P7 C0 `
69. For Each temA In BR '这个遍历就行
    + J5 ]1 P) {4 E5 K4 @9 v- E) \% C$ I4 N
70. If temA.Name = blkCName.Text Then
    9 \  e8 f! m( U  p; ^9 b
71.    P = temA.InsertionPoint '提取块C参照在块E中的插入点坐标
    
72.    J = 1
    
73. '   For Each temB In temA   '在这里就开始出错了，因为这个temA是BlockReference,是块C的参照
    
74.    For Each temB In ThisDrawing.Blocks(temA.Name) '这个才是真正的块C,呵呵
    
75.    '开始找圆，找到圆就提取坐标
    7 c6 K7 N, `+ u. i
76.     If temB.ObjectName = "AcDbCircle" Then
    2 @+ `9 X* ?7 [1 I, ^8 Z
77.         C = temB.Center '提取圆心坐标
    
78.         C(0) = ptInsert(0) + P(0) + C(0) '计算该圆心在模型空间的坐标--块E参照未旋转时
    ! M5 A3 P4 q* v; u
79.         C(1) = ptInsert(1) + P(1) + C(1)
    0 m) K" @* z& W- i. o0 y
80.         C(2) = ptInsert(2) + P(2) + C(2)
    : b" N) F% o/ Q! ]) t- O; J
81.         ThisDrawing.ActiveUCS = MyUcs '把当前坐标系改为MyUcs
    ' L+ \" }0 l4 Z3 ]
82.         C = ThisDrawing.Utility.TranslateCoordinates(C, acWorld, acUCS, False) '得到该圆心在UCS中的坐标--块E参照旋转0.2弧度后该圆心在模型空间的真正位置
    2 W9 s# t. m% k4 i# H5 l
83.         ThisDrawing.ActiveUCS = MyWcs '把当前坐标系改回WCS
    / Y, D# m: j. s- r
84.         If J = 1 Then
    
85.             ptCir1(0) = C(0)
    1 N9 {5 j: U9 _
86.             ptCir1(1) = C(1)
    
87.             ptCir1(2) = C(2)
    
88.             J = 2
    
89.         Else
    
90.             ptCir2(0) = C(0)
    
91.             ptCir2(1) = C(1)
    
92.             ptCir2(2) = C(2)
    
93.         End If
    
94.     End If
    
95.    Next
    ' j; Y) e: Z( z& o5 ^* v) z1 [
96. End If
    ( [, o5 @9 V3 g* {6 b1 J7 t7 q
97. Next
    6 l% [# {. S6 t* n9 R
98. 
    6 Y4 b7 i: o1 u+ K8 S
99. 
    / M; N4 N9 \9 k
100. ThisDrawing.Regen acActiveViewport
     
101. End Sub

复制代码

8 Q" {( T( k4 d8 _. W  ?6 \- k下面是使用辅助点
! @5 [$ m: Y. A3 F( j+ b4 t$ S" S

1. Private Sub cmdInsert_Click()
   ) L4 g" O2 C# k9 N0 u8 \
2. Dim ptInsert(2) As Double '原点
   
3. ptInsert(0) = 0
   * q, [6 `, t2 r  S0 E
4. ptInsert(1) = 0
   
5. ptInsert(2) = 0
   $ t0 C; O6 `7 [- ?
6. Dim BR As AcadBlock '定义块
   5 O6 Q9 \! N* F: Z1 w+ {9 Q3 \
7. Set BR = ThisDrawing.Blocks.Add(ptInsert, "blockE")
   
8. '清除块E中原有的图元,否则每运行一次程序,blockE中都会添加一些块参照,越来越大了
   
9. Dim E As AcadEntity
   
10. For Each E In BR
    
11.     E.Delete
      {6 W! Q) P) @
12. Next
    ) S5 y! r/ H7 w9 r9 z/ I6 [
13. '----------插入块A 仅一个---------------------------------
    
14. Dim B As AcadBlockReference '声明一个块参照变量
    5 P" V- R5 D( U
15. Dim P As Variant '声明一个变体变量用于接收三维点坐标
    # w$ t: o1 G" v0 }) V/ d- D0 L
16. Set B = BR.InsertBlock(ptInsert, blkAName.Text, 1, 1, 1, 0)
    
17. P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    
18. 
    * I+ z* Q3 y# L
19. '----------插入块B---------------------------------
    ; A3 k1 @0 k$ g0 {& Q7 H
20. Dim pNew(2) As Double
    & D' R! K; D* B! q' F
21. pNew(0) = P(0) - 500
    
22. pNew(1) = P(1) + 1405.08
    4 N6 Y# O" r% i4 c$ i0 |) x1 ^
23. pNew(2) = P(2)
    
24. Set B = BR.InsertBlock(pNew, blkBName.Text, 1, 1, 1, 0)
    
25. P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    
26. 
    7 K4 D$ Z8 E5 r
27. Dim I As Integer
    
28. For I = 2 To Val(blkBNum.Text) Step 1
    8 G  ?. A* A5 ?
29.     Dim pBNew(2) As Double
    2 c2 m2 B, |% O9 J' v
30.     pBNew(0) = P(0)
    ) p0 t6 p7 i7 [4 a% O* B
31.     pBNew(1) = P(1) + 2000
    3 }& J% J6 N; a
32.     pBNew(2) = P(2)
    . Y& j! X: f1 I+ t4 u: A
33.    
    
34.     Set B = BR.InsertBlock(pBNew, blkBName.Text, 1, 1, 1, 0)
    
35.     P = B.InsertionPoint '提取上一步插入的块参照的插入点坐标,返回值是三元素双精度数组
    * B4 l" n. `( V/ H
36. Next
    
37. 
    & m- G3 _- X2 c! J6 a! K; z
38. '----------插入块C 仅一个---------------------------------
    
39. Dim pCNew(2) As Double
    / @5 J9 ^9 m4 j% i' U
40. pCNew(0) = P(0)
    " m8 H8 b( I  F2 H, V7 p
41. pCNew(1) = P(1) + 2000
    5 ~( w$ m0 [' ^
42. pCNew(2) = P(2)
    6 S/ v) j2 i' S1 i/ Q1 X7 J
43. Set B = BR.InsertBlock(pCNew, blkCName.Text, 1, 1, 1, 0)
    
44. Set B = ThisDrawing.ModelSpace.InsertBlock(ptInsert, "blockE", 1, 1, 1, 0)
    
45. 
    ; v$ v0 A8 p, {0 N
46. '----------旋转块E---------------------------------
    % J0 |) m+ u, \+ N6 r9 m
47. B.Rotate ptInsert, 0.2
    3 o- L# k5 t4 N& H
48. '----------查找块E中的块C的两个圆的圆心坐标---------------------------------
    
49. Dim temA As AcadBlockReference
    
50. Dim temB As AcadEntity
    ( w6 x" h% D- m! A( j
51. Dim ptCir1(2) As Double '第一个圆圆心坐标
    6 x! @5 s" x+ Y9 D$ n8 j
52. Dim ptCir2(2) As Double  '第二个圆圆心坐标
    
53. Dim C As Variant, J As Integer
    
54. Dim ObjP As AcadPoint '点对象,用于下一步计算圆心坐标
    
55. For Each temA In BR '这个遍历就行
    ( ?. @7 l8 X6 I6 b+ ?- Q
56. If temA.Name = blkCName.Text Then
    1 m' N/ T8 W2 t: l" ]
57.    P = temA.InsertionPoint '提取块C参照在块E中的插入点坐标
    & @8 w1 V, X9 d$ R1 U
58.    J = 1
    
59. '   For Each temB In temA   '在这里就开始出错了，因为这个temA是BlockReference,是块C的参照
    
60.    For Each temB In ThisDrawing.Blocks(temA.Name) '这个才是真正的块C,呵呵
    . c( t! ?) F0 R+ s4 H6 Y
61.    '开始找圆，找到圆就提取坐标
    
62.     If temB.ObjectName = "AcDbCircle" Then
    5 n/ N% {6 y) S+ j
63.         C = temB.Center '提取圆心坐标
    5 g1 i2 Y; K# I# ^' o
64.         C(0) = ptInsert(0) + P(0) + C(0) '计算该圆心在模型空间的坐标--块E参照未旋转时
    ( T7 D1 v! O/ C7 M! f
65.         C(1) = ptInsert(1) + P(1) + C(1)
    
66.         C(2) = ptInsert(2) + P(2) + C(2)
    + C* V& a4 y) Q# W/ e1 [. i
67.         Set ObjP = ThisDrawing.ModelSpace.AddPoint(C) '在块E参照未旋转时的该圆圆心画一个辅助点
    
68.         ObjP.Rotate ptInsert, 0.2 '和块E一样,让该点以原点为基点旋转0.2弧度
    
69.         C = ObjP.Coordinates '提取点坐标,即该圆心在模型空间真正的位置
    # G7 O! t% f& y1 A
70.         ObjP.Delete '删除用过的辅助点
    6 X% a8 l* D5 y1 p9 r4 \* G9 M
71.         If J = 1 Then
      n+ o8 t. K1 e( |0 p
72.             ptCir1(0) = C(0)
    
73.             ptCir1(1) = C(1)
    
74.             ptCir1(2) = C(2)
    
75.             J = 2
    
76.         Else
    ' e, h# v: m$ r/ R+ Q0 a
77.             ptCir2(0) = C(0)
    & P, O& H7 |% g3 O9 N
78.             ptCir2(1) = C(1)
    4 x$ i; Y! ^/ }$ |1 a1 l0 \6 U4 I
79.             ptCir2(2) = C(2)
    3 o) V9 |7 X- p) E3 z
80.         End If
    
81.     End If
    
82.    Next
    
83. End If
    1 L3 S( @2 i( C6 m2 n3 `7 A
84. Next
    3 ^( o# U0 [) p' ^
85. 
    3 g% c3 i& N+ t: t& A% t- d& j
86. ThisDrawing.Regen acActiveViewport
    , ~5 g* O! C7 L4 V1 G, k
87. End Sub

复制代码

tataki

$ a$ M3 a. R4 F& @% j 8# woaishuijia
$ C4 ?. G% u4 E8 ?昨晚看到斑竹的回复，今天早上正准备给回复呢，没想到你一大早就重新编辑了帖子，还把圆心坐标的算法都用了三种方法给求解，让我这个7点还在睡觉的无地自容....
你以前说过“所谓"嵌套块"是指一个块定义中包含有其它块的参照.3 G* n9 B1 ?% L) K( U4 \+ Q”，所以我temA定义的是AcadBlockReference，呵呵，这个我觉得没问题。
0 p: Q5 K4 T1 K% `# m/ Y) Z当然我也想过定义 temA为 AcadEntity 或者 Object，不过遇到了错误，这里一并询问（稍后我问，呵呵，先说block）

; X1 j. n$ z# `3 a( r" a斑竹的意思是不是说不论给“块”添加图元或者要遍历，都是以“块”为对象的，而不是块参照。
我第一层遍历 For Each temA In BR 没有错，因为BR就是我定义的“块”，属于blocks集合里面，
$ B1 b6 W* f6 V1 r' F& k! n而到了第二层 ，我原来写的是 For Each temB In temA  ‘temA定义的是“块参照”，当然也就错了...应该从blocks这个集合里面找到原始的"块" blockC 来遍历，所以你用了.Blocks(temA.Name)这个写法找到了“块”，嘿嘿 ，understand！

另外，斑竹写的这一段让我发现自己考虑不周到，呵呵，确实是没运行一次，blockE里面的东西越来越多...
! N1 t* O$ o# O3 b0 G5 b- Q'清除块E中原有的图元,否则每运行一次程序,blockE中都会添加一些块参照,越来越大了
Dim E As AcadEntity
For Each E In BR
, L6 A* z& a% v8 c% tE.Delete
8 H9 y% _7 l# Y) M' U9 a7 ], F' {7 SNext
5 |3 l3 J; G' f/ t+ r


第二个就是圆心坐标，我昨晚这么写了一下:
Dim temA As AcadBlockReference
$ _* w, z5 u+ J) s8 I7 f9 }Dim temB As AcadEntity
2 n1 Y5 b% Y! i" WDim ptCir(1) As Variant  '圆心坐标
, i8 _3 ~9 U( l5 G! b3 |1 }
6 Y$ o/ C; Q3 A6 Q. y* A+ mFor Each temA In BR '这个遍历就行
8 C2 n7 ?! g& C! s If temA.Name = blkCName.Text Then
! P- ^7 c0 @/ k6 r i = 0
   For Each temB In ThisDrawing.Blocks(temA.Name)
8 a. g: q4 `* p  M5 I    '开始找圆，找到圆就提取坐标
3 t) y3 [8 G0 H0 u& U, q" R2 k6 M    If temB.ObjectName = "AcDbCircle" Then
       ptCir(i) = temB.Center: i = i + 1
8 ?4 |# _0 }  J" x    End If
  Next
# ~, ]* e) }6 E  q& e; S End If
2 L( S  `( n. i! GNext

/ a, [5 J6 _3 ~4 p4 k这样找到的圆心坐标并不是我要求的，我调试了一下发现，这样求的坐标实际上是“块” blockC里两个圆的圆心坐标，而这两个坐标应该是从blockC 的“坐标系”开始算的吧，我的blockC刚好是矩形，所以计算坐标原点恰好是矩形左下角点，我推测，如果blockC不规则，那么坐标原点应该是对blockC使用getboundary后确定的那个边框的左下角点，呵呵，猜测的，还没验证。
+ q) [+ y2 o) y) e所以斑竹用了三种方法算需要的坐标，当然，用三角函数这个确实最合理，呵呵。我能看懂。
; O/ y* F+ u! h, I6 x8 O另外使用UCS，这个方法好~上周发过贴恰好问过lisp中trans的用法，这次在vba中见到你那篇帖子里提到的对应的TranslateCoordinates的用法了，我得学习消化下
0 E' c+ e/ L8 Y4 E6 k2 \辅助点这个方法，说实话，我都不敢用，我怕的就是往图纸上添加一个点容易，删除一个点麻烦了，呵呵，水平不够，要努力！

5 w- b; h5 D% }& M7 Q说完了这个，我再问问定义temA的问题，我是这么想的：
因为blockE里面只有块参照，所以temA自然而然的定义成了AcadBlockReference，对应的使用temA.Name就行
1 e+ M! I- g5 |- U' p! l后来我想过为什么不定义temA为AcadEntity（我也试过了定义AcadObject）呢，因为这样的用法很常见啊，但是发现错了，因为就没有temA.Name属性了，只有temA.ObjectName属性，但是后者返回的是“AcdbBlockReference”，并不是块的名字...我再想是不是因为“块”比较特殊，有特定的名字，所以只能定义temA为AcadBlockReference后才能找到块的名字，其他的都不行。
6 P- j: |& N+ q进一步讲，定义temA为AcadBlockReference，我觉得局限性挺大的，因为我这里的blockE确实只含有“块参照”，没有其他图元，比如直线，文字等，如果我给blockE里面再添加一点直线或者文字（块里面添加文字应该很常用），这样我遍历BlockE的时候，就会出错，因为文字里面没有temA.Name属性...所以要想完整的遍历包含块参照和各种图元的块且不出错该怎么做好呢？

woaishuijia

; `; @0 h  l4 R8 ?
' l  s5 k8 N7 O1 \" ]5 N2 V( ?9# tataki
. o; H2 j: l* \1 k3 Q, f' \

斑竹的意思是不是说不论给“块”添加图元或者要遍历，都是以“块”为对象的，而不是块参照。

' P/ j: c& B6 Y+ T正确.
0 z3 E, J9 N( K' E0 I多说几句:能够"遍历"的前提是对象是一个集合,而集合是有"Item"方法的.比如Documents,ModelSpace,PaperSpace,SelectionSets,SelectionSet,Groups,Group,Blocks,Block,TextStyles,Layers,LineTypes等等,都是集合,都可以遍历.但BlockReference不行,它不是集合,而是一个块定义的实例.文档中同一个块的每个参照包含的子对象都是一样的(除其中的属性值外),它包含的图元种类数量位置都完全相同,因为这取决于其定义,所以想提取任何一个块参照内部子对象的特性,只能到其定义中去找.除了块参照对象的属性值是用BlockReference的GetAttributes方法,获取其属性参照对象数组.而属性定义对象本身的添加和编辑也是要在Block对象中进行

我调试了一下发现，这样求的坐标实际上是“块” blockC里两个圆的圆心坐标，而这两个坐标应该是从blockC 的“坐标系”开始算的吧

9 E5 S- L6 A* `' W4 t正确

我的blockC刚好是矩形，所以计算坐标原点恰好是矩形左下角点，我推测，如果blockC不规则，那么坐标原点应该是对blockC使用getboundary后确定的那个边框的左下角点，呵呵，猜测的，还没验证。

4 D. j) U1 z( v错了.
我们在使用Blocks集合对象的Add方法新建Block对象时有两个参数,第二个是块名称字符串,你懂的;而第一个InsertionPoint,就是块基点.我们在图形界面选择一个块参照对象时,块参照会有一个蓝色亮显的夹持点,这就是块基点.正像你前面说是那样,块定义是有自己的坐标系的.我们往块定义中添加图元是使用块定义的坐标系,同样,创建块定义时给定的块基点也是使用这个坐标系.通常我们在创建块时把块基点放在块定义的坐标系的原点,就是InsertionPoint参数使用(0,0,0).这样可以减少坐标换算的麻烦.
: |& w- P6 p% G& U- h- B在我们向模型空间或图纸空间或其它块定义中添加块参照时,块参照是以块基点为准放到插入点(就是InsertBlock方法的InsertionPoint参数)上的.
就是说,当我们把块定义的块基点设为(0,0,0)时,块参照的子对象的位置坐标就等于其在块中的坐标与块参照的插入点坐标之和.
1 q; W& e5 L! c5 g当块定义的块基点不是(0,0,0)时,块参照的子对象的位置坐标等于其在块中的坐标与块基点坐标之差再与块参照的插入点坐标之和.
GetBoundingBox方法可以得到的矩形框的左下角点,在本例中与块C参照的块基点坐标重合,只是巧合而已.如果块C的块基点不在左下角,或块C参照被旋转了一个角度,就不重合了.

要想完整的遍历包含块参照和各种图元的块且不出错该怎么做好呢？

- |- p3 r2 v5 [2 C6 B4 Q5 j增加一个条件语句就可以了

1. Dim temA As AcadEntity
   , ~* T8 D5 w8 r) _3 O# n
2. Dim temB As AcadEntity
   7 e7 b8 h. x# ]! B/ I% h
3. Dim ptCir(1) As Variant  '圆心坐标
   
4. For Each temA In BR '这个遍历针对块中的Entity
   / U7 V# f9 H6 M2 g4 e7 c
5.     If temA.ObjectName = "AcDbBlockReference" Then'先检查temA是否块参照
   3 F6 n$ n& d  U3 p
6.         If temA.Name = blkCName.Text Then'确定是块参照后再检查其名称
   
7.             i = 0
   / d5 x* e  m0 b$ n' X% o
8.             For Each temB In ThisDrawing.Blocks(temA.Name)
   
9.                 '开始找圆，找到圆就提取坐标
   
10.                 If temB.ObjectName = "AcDbCircle" Then
    6 `( w. |) P& W5 a# u
11.                    ptCir(i) = temB.Center: i = i + 1
    6 w* r$ j7 a+ Q5 u- {( i( H+ d
12.                 End If
    
13.             Next
    
14.         End If
    % n+ b5 N# q6 ~( @0 z1 Y
15.     End If
    6 d0 p6 y: Z2 M! ~) ]- \  ?5 r
16. Next

复制代码

tataki

1 |: l! c( l- G
6 t; i: U1 j# F* ^# z9 T“通常我们在创建块时把块基点放在块定义的坐标系的原点,就是InsertionPoint参数使用(0,0,0).这样可以减少坐标换算的麻烦.”
你这一句一下让我想到了一件事：
我的blockE是我在代码中指定的基点 0,0,0
0 R5 k. Y! H! ?5 F' W) g* L但是其他几个块A B C D是我用GUI方式定义在图纸里面的，当时我觉得方便就把C块基点设置在了左下角（cad提示我选择基点）
对于GUI方式设置的基点，cad会默认把块坐标系的原点设置在这个基点上！而且基点的坐标就是0,0,0，感觉很诡异，这个在cad2011里面很明显，打开块编辑器后，明显的看到块坐标系的原点就是默认设置到我选择的基点上，图里左边是模型空间的坐标显示，右边就是块编辑的坐标显示！！！！这个我一直没注意！而我当初给blockE设置基点的时候只是图了方便设置到原点上，看来真是碰巧！也就是说，如果通过GUI方式，默认的就是基点和原点重合且是0,0,0，这样确实方便了以后的编辑！而用代码方式就是要指定基点了。
我这样理解的对吗？

呵呵，还有后面那个完整的遍历包含块参照和各种图元的块且不出错的代码真好，先用objectName找出是块参照的，然后再查询块参照的name进行对比，满足后再进入块的子项

woaishuijia

11# tataki 完全正确

cctv9527

“就像在模型空间里添加块参照一样。就是说这样的嵌套块只是个定义好了块，下一步就是在模型空间里把这个块的 块参照给insertBlock出来”
这话还是有点不明白
子函数1 我定义块A  里面放个梯形
! [2 l6 R: X% q4 K子函数2 再定义块B 里面放个矩形 再插入块A
图形空间中我会反复调用A B
画图能画 VBA B插入A 不明白  
新手 望指导下

weisad

插入块好像挺难的