Skip to content
  • Register

    • How to find the rigid transformation data for External Data?

    Member, Moderator, Employee Posts: 108
    25 Answers Second Anniversary 10 Comments 25 Likes
    ✭✭✭✭
    edited June 2023 in Structures

    External Data allows to enter a rigid transformation in the global coordinate system in order to orient data that could be misaligned with the geometry. Finding the proper angles and translation data is not obvious when the data is not oriented along the axis of the global CS and could require a long "trial and error" process.

    How can we automate this within Mechanical? The assumption is that we have the "geometry" of the data to be imported either in geometric form or as STL or as a mesh.

    Tagged:

    Answers

    • Member, Moderator, Employee Posts: 108
      25 Answers Second Anniversary 10 Comments 25 Likes
      ✭✭✭✭
      Answer ✓

      Here's a proposal. For comprehensiveness, it is assumed that the user has been able to get a representation of the data to be imported as geometry in Mechanical (either from a CAD/STL file or a mesh). The geometry is used to visually check the alignment. Yet it is not mandatory, as the script will only compute the transformation if no body is selected.

      The principle is the following: the user will define two coordinate systems to be aligned. One is created on the target geometry (the one on which data will be mapped) and another one on the data to be imported. The user then selects in the tree both coordinate systems and the body to be moved (the one correspionding the data to be imported). A Part Transform will be created to show how the alignment has been achieved. If no body is selected, a message box with the rigid transformation between the two coordinate systems is displayed.

      1. # Compute Rigid Transformation between two coordinate systems
      2. # Optionally create a Part transform on a body
      3. # Created by P. Thieffry
      4. # Last update: 2021/04/07
      5.  
      6.  
      7. import math
      8. import units
      9.  
      10. clr.AddReference("Ans.UI.Toolkit.Base")
      11. clr.AddReference("Ans.UI.Toolkit")
      12. from Ansys.UI.Toolkit import *
      13.  
      14.  
      15. # Utility functions
      16.  
      17.  
      18.  
      19. def dotProduct(v1,v2):
      20.     return v2[0]*v1[0]+v2[1]*v1[1]+v2[2]*v1[2]
      21.     
      22. def matProduct(m1,m2):
      23.     nr1=len(m1)
      24.     nc1=len(m1[0])
      25.     nc2=len(m2[0])
      26.     resM = [([0]*nc2) for i in range(nr1)]
      27.     for i in range(0,nr1):
      28.         for j in range(0,nc2):
      29.             val=0.
      30.             for k in range(0,nc1):
      31.                 val+=resM[i][j]+m1[i][k]*m2[k][j]
      32.             resM[i][j]=val
      33.     return resM
      34.     
      35. def InverseTransformationMatrix(m):
      36.     mt=[[0.,0.,0.,0.],[0.,0.,0.,0.],[0.,0.,0.,0.],[0.,0.,0.,0.]]
      37.     for i in range(0,4):
      38.         for j in range(0,4):
      39.             mt[i][j]=m[j][i]
      40.             
      41.     tVec=matProduct(mt,[[-m[0][3]],[-m[1][3]],[-m[2][3]],[-m[3][3]]])
      42.     
      43.     for i in range(0,4):
      44.         mt[i][3]=tVec[i][0]
      45.         mt[3][i]=0.
      46.     mt[3][3]=1.
      47.     return mt
      48.  
      49.  
      50. def CSBodyDistance(csys,body):
      51.     op_unit=csys.OriginX.Unit
      52.     orX=units.ConvertUnit(csys.OriginX.Value, fromUnit=op_unit, toUnit='m')
      53.     orY=units.ConvertUnit(csys.OriginY.Value, fromUnit=op_unit, toUnit='m')
      54.     orZ=units.ConvertUnit(csys.OriginZ.Value, fromUnit=op_unit, toUnit='m')
      55.     dist=(body.Centroid[0]-orX)**2+(body.Centroid[1]-orY)**2+(body.Centroid[2]-orZ)**2
      56.     return dist
      57.  
      58. def CreateSelection(body):
      59.     # Create selection from body
      60.     ExtAPI.SelectionManager.ClearSelection()        
      61.     temp_sel= ExtAPI.SelectionManager.CreateSelectionInfo(SelectionTypeEnum.GeometryEntities)                
      62.     temp_sel.Ids=[body.Id]
      63.     ExtAPI.SelectionManager.NewSelection(temp_sel)
      64.     
      65. def CreateCSOnBody(body):
      66.     # Create coordinate system on body so axes are along the axis of inertia of the body
      67.     CreateSelection(body)
      68.     csGroup=ExtAPI.DataModel.GetObjectsByType(DataModelObjectCategory.CoordinateSystems)[0]
      69.     newCS=csGroup.AddCoordinateSystem()
      70.     newCS.Name='CS_body_'+body.Name
      71. #    newCS.OriginDefineBy=Ansys.Mechanical.DataModel.Enums.CoordinateSystemAlignmentType.Fixed
      72.     return newCS
      73.     
      74.  
      75.  
      76. def anglesFromTransMatrix(tmat):
      77.     pi=math.pi
      78.     sY=-tmat[2][0]
      79.     
      80.     if sY < 1.:
      81.         if (sY > -1.):
      82.             rotY=math.asin(sY)
      83.             rotX = math.atan2(tmat[2][1],tmat[2][2])
      84.             rotZ = math.atan2(tmat[1][0],tmat[0][0])
      85.         else: # sY = -1
      86.             rotY= -pi/2
      87.             rotX = -math.atan2(tmat[1][0],tmat[1][1])
      88.             rotZ = 0.
      89.     else: # sY=1
      90.         rotY= pi/2
      91.         rotX = -math.atan2(tmat[0][1],tmat[1][1])
      92.         rotZ = 0.
      93.     
      94.     return rotX*180./pi,rotY*180./pi,rotZ*180./pi
      95.     
      96. def TransformationMatrix(origCS,targCS):
      97.     # compute transformation matrix to align origCS to targCS
      98.     # All coordinates are expressed in the global CS
      99.     #
      100.     # Retrieve CS origins in m
      101.     op_unit=origCS.OriginX.Unit
      102.     orX=units.ConvertUnit(origCS.OriginX.Value, fromUnit=op_unit, toUnit='m')
      103.     orY=units.ConvertUnit(origCS.OriginY.Value, fromUnit=op_unit, toUnit='m')
      104.     orZ=units.ConvertUnit(origCS.OriginZ.Value, fromUnit=op_unit, toUnit='m')
      105.     taX=units.ConvertUnit(targCS.OriginX.Value, fromUnit=op_unit, toUnit='m')
      106.     taY=units.ConvertUnit(targCS.OriginY.Value, fromUnit=op_unit, toUnit='m')
      107.     taZ=units.ConvertUnit(targCS.OriginZ.Value, fromUnit=op_unit, toUnit='m')
      108.     
      109.     tMat=[[dotProduct(origCS.XAxis,targCS.XAxis),dotProduct(origCS.XAxis,targCS.YAxis),dotProduct(origCS.XAxis,targCS.ZAxis),-orX+taX],
      110.     [dotProduct(origCS.YAxis,targCS.XAxis),dotProduct(origCS.YAxis,targCS.YAxis),dotProduct(origCS.YAxis,targCS.ZAxis),-orY+taY],
      111.     [dotProduct(origCS.ZAxis,targCS.XAxis),dotProduct(origCS.ZAxis,targCS.YAxis),dotProduct(origCS.ZAxis,targCS.ZAxis),-orZ+taZ],
      112.     [0.,0.,0.,1.]]
      113.    
      114.     
      115.     return tMat
      116.     
      117. def TransformationData(origCS,targCS):
      118.     # compute angles and translations to be used in part transforms
      119.     # based on transformation matrix between two CS
      120.     #
      121.     
      122.     csGroup=ExtAPI.DataModel.GetObjectsByType(DataModelObjectCategory.CoordinateSystems)[0]
      123.     globalCS=csGroup.Children[0] # get global CS as this is the one we want angles and translations expressed in
      124.     
      125.     # First transform from globalCS to origCS
      126.     mGlobalToOrig=TransformationMatrix(globalCS,origCS)
      127.  
      128.     # Compute inverse transformation
      129.     mOrigToGlobal=InverseTransformationMatrix(mGlobalToOrig)
      130.     # Transfom from global to targ
      131.     mGlobalToTarg=TransformationMatrix(globalCS,targCS)
      132.     # Now combine them
      133.     mOrigToTarg=matProduct(mGlobalToTarg,mOrigToGlobal)
      134.     
      135.     # Now retrieve angle for transformation in global CS
      136.     rotX,rotY,rotZ=anglesFromTransMatrix(mOrigToTarg)
      137.     # Get translations in global CS
      138.     trX=mOrigToTarg[0][3]
      139.     trY=mOrigToTarg[1][3]
      140.     trZ=mOrigToTarg[2][3]
      141.     
      142.  
      143.     return trX,trY,trZ,rotX,rotY,rotZ
      144.  
      145.     
      146.     
      147. def CreateTransform(body,bodyCS,targCS):    
      148.     # Transform body from bodyCS to targCS 
      149.     # bodyCS and targCS should be oriented along axes of inertia
      150.     # Angles and translations to be computed based on global Coordinate System so they can be reused in External Data
      151.     #
      152.     csGroup=ExtAPI.DataModel.GetObjectsByType(DataModelObjectCategory.CoordinateSystems)[0]
      153.     globalCS=csGroup.Children[0] # get global CS as this is the one we want angles and translations expressed in
      154.     
      155.     # get translations and angles
      156.     tX,tY,tZ,rotX,rotY,rotZ=TransformationData(bodyCS,targCS)
      157.     
      158.     # create part transform
      159.     # first check if Transforms group exist, if not create it with a dummy part transform
      160.     trGroup=ExtAPI.DataModel.GetObjectsByType(DataModelObjectCategory.PartTransformGroup)
      161.     if len(trGroup)==0:
      162.         dummyT=ExtAPI.DataModel.Project.Model.AddPartTransform()
      163.         dummyT.Delete()
      164.     trGroup=ExtAPI.DataModel.GetObjectsByType(DataModelObjectCategory.PartTransformGroup)[0]
      165.     # create part transform
      166.     newTR=trGroup.AddPartTransform()
      167.     # Set geometry scoping on body
      168.     CreateSelection(body)
      169.     newTR.Location=ExtAPI.SelectionManager.CurrentSelection
      170.     
      171.     # All data expressed in globalCS for reuse in External Data
      172.     newTR.CoordinateSystem=globalCS
      173.     
      174.     # Set transformation data
      175.     newTR.TranslationX=Quantity(tX,'m')
      176.     newTR.TranslationY=Quantity(tY,'m')
      177.     newTR.TranslationZ=Quantity(tZ,'m')
      178.  
      179.     newTR.RotationX=Quantity(rotX,'deg')
      180.     newTR.RotationY=Quantity(rotY,'deg')
      181.     newTR.RotationZ=Quantity(rotZ,'deg')
      182.         
      183.     # transform gemetry
      184.     newTR.TransformGeometry()
      185.     
      186.     return newTR
      187.  
      188. curSel=ExtAPI.DataModel.Tree.ActiveObjects
      189.  
      190. # Need to have two CS selected, otherwise stop
      191. mess_line1 = 'Please select at least 2 coordinate systems in the tree and a maximum of one body if you want to visually check the transformation'
      192. if (curSel.Count<2):
      193.     MessageBox.Show(mess_line1)
      194.     pass
      195. else:        
      196.     bodies=[]
      197.     cSyst=[]
      198.     for sel in curSel:
      199.         if sel.GetType()==Ansys.ACT.Automation.Mechanical.Body:
      200.             bodies.append(sel.GetGeoBody())
      201.         if sel.GetType()==Ansys.ACT.Automation.Mechanical.CoordinateSystem:
      202.             cSyst.append(sel)
      203.             
      204.     if cSyst.Count!=2:
      205.         MessageBox.Show(mess_line1)
      206.         pass
      207.     
      208.     if cSyst.Count==2 and bodies.Count>1:
      209.         MessageBox.Show(mess_line1)
      210.         pass
      211.  
      212.     if bodies.Count == 1: # a body has been selected, we'll create a part transform
      213.         #find CS closest to selected body
      214.         
      215.         d1=CSBodyDistance(cSyst[0],bodies[0])
      216.         d2=CSBodyDistance(cSyst[1],bodies[0])
      217.         
      218.         if d1<d2:
      219.             origCS=cSyst[0]
      220.             targCS=cSyst[1]
      221.         
      222.         else:
      223.             origCS=cSyst[1]
      224.             targCS=cSyst[0]
      225.                 
      226.         CreateTransform(bodies[0],origCS,targCS)
      227.     else: # no body has been selected, just compute transformation data and display in a message box
      228.         origCS=cSyst[0] # first selected CS is the one corresponding to external data
      229.         targCS=cSyst[1] # second CS is the one corresponding to actual geometry to be mapped on
      230.         tX,tY,tZ,rotX,rotY,rotZ=TransformationData(origCS,targCS)
      231.         op_Unit=origCS.OriginX.Unit
      232.         
      233.         mess_line = 'Computed data for rigid transformation:\n\n'
      234.         
      235.         mess_line+='  Orign X : '+str(Quantity(units.ConvertUnit(tX, fromUnit='m', toUnit=op_Unit),op_Unit))+'\n'
      236.         mess_line+='  Orign Y : '+str(Quantity(units.ConvertUnit(tY, fromUnit='m', toUnit=op_Unit),op_Unit))+'\n'
      237.         mess_line+='  Orign Z : '+str(Quantity(units.ConvertUnit(tZ, fromUnit='m', toUnit=op_Unit),op_Unit))+'\n'
      238.         mess_line+='\n'
      239.         mess_line+='  Rotation X : '+ str(Quantity(rotX,'deg'))+'\n'
      240.         mess_line+='  Rotation Y : '+ str(Quantity(rotY,'deg'))+'\n'
      241.         mess_line+='  Rotation Z : '+ str(Quantity(rotZ,'deg'))+'\n'        
      242.         
      243.         MessageBox.Show(mess_line)
      244.
    • Member, Moderator, Employee Posts: 108
      25 Answers Second Anniversary 10 Comments 25 Likes
      ✭✭✭✭
      Answer ✓

      Erratum: I realized the order of transformations is NOT the same in Mechanical and External data. A part transform in Mechanical will do RX, RY, RZ and then translations. External data does RY RX RZ then translations (RX and RY are in reverse order). So the following script will compute both configurations and display the ones for External Data in a message box.

      BTW, it will also copy the data to the clipboard for further reuse.

      1. # Compute Rigid Transformation between two coordinate systems
      2. # Optionally create a Part transform on a body
      3. # Created by P. Thieffry
      4. # Last update: 2021/04/07
      5.  
      6.  
      7. import math
      8. import units
      9. import clr
      10.  
      11.  
      12. clr.AddReference("Ans.UI.Toolkit.Base")
      13. clr.AddReference("Ans.UI.Toolkit")
      14. from Ansys.UI.Toolkit import *
      15.  
      16. clr.AddReference('System.Windows.Forms')
      17. from System.Windows.Forms import Clipboard
      18. def setText(text):
      19.     Clipboard.SetText(text)
      20.     
      21. def getText():
      22.     return Clipboard.GetText()
      23.  
      24.  
      25.  
      26. # Utility functions
      27.  
      28. def dotProduct(v1,v2):
      29.     return v2[0]*v1[0]+v2[1]*v1[1]+v2[2]*v1[2]
      30.     
      31. def matProduct(m1,m2):
      32.     nr1=len(m1)
      33.     nc1=len(m1[0])
      34.     nc2=len(m2[0])
      35.     resM = [([0]*nc2) for i in range(nr1)]
      36.     for i in range(0,nr1):
      37.         for j in range(0,nc2):
      38.             val=0.
      39.             for k in range(0,nc1):
      40.                 val+=resM[i][j]+m1[i][k]*m2[k][j]
      41.             resM[i][j]=val
      42.     return resM
      43.     
      44. def InverseTransformationMatrix(m):
      45.     mt=[[0.,0.,0.,0.],[0.,0.,0.,0.],[0.,0.,0.,0.],[0.,0.,0.,0.]]
      46.     for i in range(0,4):
      47.         for j in range(0,4):
      48.             mt[i][j]=m[j][i]
      49.             
      50.     tVec=matProduct(mt,[[-m[0][3]],[-m[1][3]],[-m[2][3]],[-m[3][3]]])
      51.     
      52.     for i in range(0,4):
      53.         mt[i][3]=tVec[i][0]
      54.         mt[3][i]=0.
      55.     mt[3][3]=1.
      56.     return mt
      57.  
      58.  
      59. def CSBodyDistance(csys,body):
      60.     op_unit=csys.OriginX.Unit
      61.     orX=units.ConvertUnit(csys.OriginX.Value, fromUnit=op_unit, toUnit='m')
      62.     orY=units.ConvertUnit(csys.OriginY.Value, fromUnit=op_unit, toUnit='m')
      63.     orZ=units.ConvertUnit(csys.OriginZ.Value, fromUnit=op_unit, toUnit='m')
      64.     dist=(body.Centroid[0]-orX)**2+(body.Centroid[1]-orY)**2+(body.Centroid[2]-orZ)**2
      65.     return dist
      66.  
      67. def CreateSelection(body):
      68.     # Create selection from body
      69.     ExtAPI.SelectionManager.ClearSelection()        
      70.     temp_sel= ExtAPI.SelectionManager.CreateSelectionInfo(SelectionTypeEnum.GeometryEntities)                
      71.     temp_sel.Ids=[body.Id]
      72.     ExtAPI.SelectionManager.NewSelection(temp_sel)
      73.     
      74. def CreateCSOnBody(body):
      75.     # Create coordinate system on body so axes are along the axis of inertia of the body
      76.     CreateSelection(body)
      77.     csGroup=ExtAPI.DataModel.GetObjectsByType(DataModelObjectCategory.CoordinateSystems)[0]
      78.     newCS=csGroup.AddCoordinateSystem()
      79.     newCS.Name='CS_body_'+body.Name
      80. #    newCS.OriginDefineBy=Ansys.Mechanical.DataModel.Enums.CoordinateSystemAlignmentType.Fixed
      81.     return newCS
      82.     
      83.  
      84.  
      85. def anglesFromTransMatrixXYZ(tmat):
      86.     pi=math.pi
      87.     sY=-tmat[2][0]
      88.     
      89.     if sY < 1.:
      90.         if (sY > -1.):
      91.             rotY=math.asin(sY)
      92.             rotX = math.atan2(tmat[2][1],tmat[2][2])
      93.             rotZ = math.atan2(tmat[1][0],tmat[0][0])
      94.         else: # sY = -1
      95.             rotY= -pi/2
      96.             rotX = -math.atan2(tmat[1][0],tmat[1][1])
      97.             rotZ = 0.
      98.     else: # sY=1
      99.         rotY= pi/2
      100.         rotX = -math.atan2(tmat[0][1],tmat[1][1])
      101.         rotZ = 0.
      102.     
      103.     return rotX*180./pi,rotY*180./pi,rotZ*180./pi
      104.     
      105. def anglesFromTransMatrixYXZ(tmat):
      106.     pi=math.pi
      107.     sX=tmat[2][1]
      108.     
      109.     if sX < 1.:
      110.         if (sX > -1.):
      111.             rotX=math.asin(sX)
      112.             rotY = math.atan2(-tmat[2][0],tmat[2][2])
      113.             rotZ = math.atan2(-tmat[0][1],tmat[1][1])
      114.         else: # sX = -1
      115.             rotX= -pi/2
      116.             rotY = -math.atan2(tmat[1][0],tmat[1][2])
      117.             rotZ = 0.
      118.     else: # sX=1
      119.         rotX= pi/2
      120.         rotY = -math.atan2(tmat[1][0],tmat[1][2])
      121.         rotZ = 0.
      122.     
      123.     return rotX*180./pi,rotY*180./pi,rotZ*180./pi
      124.     
      125. def TransformationMatrix(origCS,targCS):
      126.     # compute transformation matrix to align origCS to targCS
      127.     # All coordinates are expressed in the global CS
      128.     #
      129.     # Retrieve CS origins in m
      130.     op_unit=origCS.OriginX.Unit
      131.     orX=units.ConvertUnit(origCS.OriginX.Value, fromUnit=op_unit, toUnit='m')
      132.     orY=units.ConvertUnit(origCS.OriginY.Value, fromUnit=op_unit, toUnit='m')
      133.     orZ=units.ConvertUnit(origCS.OriginZ.Value, fromUnit=op_unit, toUnit='m')
      134.     taX=units.ConvertUnit(targCS.OriginX.Value, fromUnit=op_unit, toUnit='m')
      135.     taY=units.ConvertUnit(targCS.OriginY.Value, fromUnit=op_unit, toUnit='m')
      136.     taZ=units.ConvertUnit(targCS.OriginZ.Value, fromUnit=op_unit, toUnit='m')
      137.     
      138.     tMat=[[dotProduct(origCS.XAxis,targCS.XAxis),dotProduct(origCS.XAxis,targCS.YAxis),dotProduct(origCS.XAxis,targCS.ZAxis),-orX+taX],
      139.     [dotProduct(origCS.YAxis,targCS.XAxis),dotProduct(origCS.YAxis,targCS.YAxis),dotProduct(origCS.YAxis,targCS.ZAxis),-orY+taY],
      140.     [dotProduct(origCS.ZAxis,targCS.XAxis),dotProduct(origCS.ZAxis,targCS.YAxis),dotProduct(origCS.ZAxis,targCS.ZAxis),-orZ+taZ],
      141.     [0.,0.,0.,1.]]
      142.    
      143.     
      144.     return tMat
      145.   
      146.     
      147. def TransformationData(origCS,targCS):
      148.     # compute angles and translations to be used in part transforms
      149.     # based on transformation matrix between two CS
      150.     #
      151.     
      152.     csGroup=ExtAPI.DataModel.GetObjectsByType(DataModelObjectCategory.CoordinateSystems)[0]
      153.     globalCS=csGroup.Children[0] # get global CS as this is the one we want angles and translations expressed in
      154.     
      155.     # First transform from globalCS to origCS
      156.     mGlobalToOrig=TransformationMatrix(globalCS,origCS)
      157.  
      158.     # Compute inverse transformation
      159.     mOrigToGlobal=InverseTransformationMatrix(mGlobalToOrig)
      160.     # Transfom from global to targ
      161.     mGlobalToTarg=TransformationMatrix(globalCS,targCS)
      162.     # Now combine them
      163.     mOrigToTarg=matProduct(mGlobalToTarg,mOrigToGlobal)
      164.     
      165.     # Now retrieve angle for transformation in global CS
      166.     rotX,rotY,rotZ=anglesFromTransMatrixXYZ(mOrigToTarg)
      167.     # Get translations in global CS
      168.     trX=mOrigToTarg[0][3]
      169.     trY=mOrigToTarg[1][3]
      170.     trZ=mOrigToTarg[2][3]
      171.     
      172.     rXExtData,rYExtData,rZExtData=anglesFromTransMatrixYXZ(mOrigToTarg)    
      173.     
      174.     return trX,trY,trZ,rotX,rotY,rotZ,rXExtData,rYExtData,rZExtData
      175.  
      176.     
      177.     
      178. def CreateTransform(body,bodyCS,targCS):    
      179.     # Transform body from bodyCS to targCS 
      180.     # bodyCS and targCS should be oriented along axes of inertia
      181.     # Angles and translations to be computed based on global Coordinate System so they can be reused in External Data
      182.     #
      183.     csGroup=ExtAPI.DataModel.GetObjectsByType(DataModelObjectCategory.CoordinateSystems)[0]
      184.     globalCS=csGroup.Children[0] # get global CS as this is the one we want angles and translations expressed in
      185.     
      186.     # get translations and angles
      187.     tX,tY,tZ,rotX,rotY,rotZ,rXExtData,rYExtData,rZExtData=TransformationData(bodyCS,targCS)
      188.     
      189.     # create part transform
      190.     # first check if Transforms group exist, if not create it with a dummy part transform
      191.     trGroup=ExtAPI.DataModel.GetObjectsByType(DataModelObjectCategory.PartTransformGroup)
      192.     if len(trGroup)==0:
      193.         dummyT=ExtAPI.DataModel.Project.Model.AddPartTransform()
      194.         dummyT.Delete()
      195.     trGroup=ExtAPI.DataModel.GetObjectsByType(DataModelObjectCategory.PartTransformGroup)[0]
      196.     # create part transform
      197.     newTR=trGroup.AddPartTransform()
      198.     # Set geometry scoping on body
      199.     CreateSelection(body)
      200.     newTR.Location=ExtAPI.SelectionManager.CurrentSelection
      201.     
      202.     # All data expressed in globalCS for reuse in External Data
      203.     newTR.CoordinateSystem=globalCS
      204.     
      205.     # Set transformation data
      206.     newTR.TranslationX=Quantity(tX,'m')
      207.     newTR.TranslationY=Quantity(tY,'m')
      208.     newTR.TranslationZ=Quantity(tZ,'m')
      209.  
      210.     newTR.RotationX=Quantity(rotX,'deg')
      211.     newTR.RotationY=Quantity(rotY,'deg')
      212.     newTR.RotationZ=Quantity(rotZ,'deg')
      213.         
      214.     # transform gemetry
      215.     newTR.TransformGeometry()
      216.     
      217.     # return newly created object and rotations for ExternalData
      218.     return newTR,tX,tY,tZ,rotX,rotY,rotZ,rXExtData,rYExtData,rZExtData
      219.  
      220. curSel=ExtAPI.DataModel.Tree.ActiveObjects
      221.  
      222. # Need to have two CS selected, otherwise stop
      223. mess_line1 = 'Please select at least 2 coordinate systems in the tree and a maximum of one body if you want to visually check the transformation'
      224. if (curSel.Count<2):
      225.     MessageBox.Show(mess_line1)
      226.     pass
      227. else:        
      228.     bodies=[]
      229.     cSyst=[]
      230.     for sel in curSel:
      231.         if sel.GetType()==Ansys.ACT.Automation.Mechanical.Body:
      232.             bodies.append(sel.GetGeoBody())
      233.         if sel.GetType()==Ansys.ACT.Automation.Mechanical.CoordinateSystem:
      234.             cSyst.append(sel)
      235.             
      236.     if cSyst.Count!=2:
      237.         MessageBox.Show(mess_line1)
      238.         pass
      239.     
      240.     if cSyst.Count==2 and bodies.Count>1:
      241.         MessageBox.Show(mess_line1)
      242.         pass
      243.  
      244.     if bodies.Count == 1: # a body has been selected, we'll create a part transform
      245.         #find CS closest to selected body
      246.         
      247.         d1=CSBodyDistance(cSyst[0],bodies[0])
      248.         d2=CSBodyDistance(cSyst[1],bodies[0])
      249.         
      250.         if d1<d2:
      251.             origCS=cSyst[0]
      252.             targCS=cSyst[1]
      253.         
      254.         else:
      255.             origCS=cSyst[1]
      256.             targCS=cSyst[0]
      257.                 
      258.         pTrans,tX,tY,tZ,rotX,rotY,rotZ,rotXExtData,rotYExtData,rotZExtData=CreateTransform(bodies[0],origCS,targCS)
      259.         
      260.     else: # no body has been selected, just compute transformation data and display in a message box
      261.         origCS=cSyst[0] # first selected CS is the one corresponding to external data
      262.         targCS=cSyst[1] # second CS is the one corresponding to actual geometry to be mapped on
      263.         tX,tY,tZ,rotX,rotY,rotZ,rotXExtData,rotYExtData,rotZExtData=TransformationData(origCS,targCS)
      264.         
      265.     # Message Box with results
      266.     op_Unit=origCS.OriginX.Unit
      267.     orX=units.ConvertUnit(origCS.OriginX.Value, fromUnit='m', toUnit=op_Unit)
      268.         
      269.     mess_line = 'Computed data for rigid transformation in External data:\n'
      270.     
      271.     mess_line+='\tOrign X : '+str(Quantity(units.ConvertUnit(tX, fromUnit='m', toUnit=op_Unit),op_Unit))+'\n'
      272.     mess_line+='\tOrign Y : '+str(Quantity(units.ConvertUnit(tY, fromUnit='m', toUnit=op_Unit),op_Unit))+'\n'
      273.     mess_line+='\tOrign Z : '+str(Quantity(units.ConvertUnit(tZ, fromUnit='m', toUnit=op_Unit),op_Unit))+'\n'
      274.     mess_line+='\n'
      275.     mess_line+='\tRotation Theta XY :'+ str(Quantity(rotZExtData,'deg'))+'\n'
      276.     mess_line+='\tRotation Theta YZ :'+ str(Quantity(rotXExtData,'deg'))+'\n'
      277.     mess_line+='\tRotation Theta ZX :'+ str(Quantity(rotYExtData,'deg'))+'\n'        
      278.     MessageBox.Show(mess_line)
      279.         
      280.     Clipboard.SetText(mess_line)

    Welcome!

    It looks like you're new here. Sign in or register to get started.
    Sign In
    Register

    Welcome!

    It looks like you're new here. Sign in or register to get started.
    Sign In
    Register

    Quick Links

    Categories