Python 理解脚本

我有一个脚本，可以参数化圆。这用于模拟程序。然而，我很难理解剧本的某些部分，我想学习这一点。我参加了一些python在线课程，但我不确定这是否足以理解它。例如，下面的部分

是不是在圆的圆周上找3个点来确定它是否是圆？整个代码低于其他代码。表达式

fabs（（V1*V2）/（sqrt（V1*V1*V2*V2））>0.95中的
V1
、
V2
和
V3
是什么意思

 for i in range(skipCount):
    P1 = points[i]
    P2 = points[i+1]
    if i+2 < skipCount:
      P3 = points[i+2]
    else:
      P3 = points[i-1]
    #endif

范围内i的
（skipCount）：
P1=点[i]
P2=点[i+1]
如果i+2

整个代码：

       def OnAbort():
  cmd.Checked = False
  pass

#-------------------------------------------------------------------------------

def firstState():

  if selProg.Count != 1:
    print "Circular Move: No program selected. Aborting..."
    return False
  #endif

  cmd.Checked = True

  program = selProg.getItem(0)
  routine = program.CurrentRoutine
  controller = program.Controller
  addLimitProperty( cmd, VC_REAL, "CircularSpeed", True, False, False, 100., None, "Velocity", 0., controller.MaxCartesianSpeed )
  cmp = controller.Component

  # Fix for Main Program selection BUG
  if routine != program.MainRoutine:
    if selStmt.Count:
      stmt = selStmt.getItem(0)
      if stmt.Routine != routine:
        routine = program.MainRoutine
      #endif
    #endif
  #endif

  if not displayPropertyDialog( cmd.Name, "Circular Motion Settings", ''):
    OnAbort()
    return False
  #endif

  phName = 'CircularMove'
  ph = cmp.findBehaviour(phName)
  processName = 'CircularMove'
  if ph != None:
    if ph.Script[:12] != "#VERSION 1.2":
      print "Updating Script " + processName
      ph.delete()
      ph = None
    #endif
  #endif

  if ph == None:
    ph = cmp.createBehaviour(VC_PYTHON_PROCESS_HANDLER, phName)

    # set the bitmap of the process, that appears in the RSL statement grid
    iconuri = getCommandPath()
    iconuri = iconuri[:-3] + ".bmp"
    icon = getApplication().loadBitmap(iconuri)
    ph.Icon = icon

    # register process handler to the rsl executor behavior(s) of the robot
    xl = cmp.findBehavioursByType(VC_RSLEXECUTOR)
    for x in xl:
      phl = x.ProcessHandlers
      phl.append(ph)
      x.ProcessHandlers = phl
    #endfor

    ph.Process = processName
    ph.Script = """#VERSION 1.2
from vcRslProcessHandler import *
from math import *
import vcMatrix

RAD_TO_DEG = 90.0/atan2(1.,0.)

def OnExecuteProcess(executor, process_statement):

  # Check if at end of Circle Move
  skipProp = process_statement.getProperty( "SkipCount" )
  if skipProp != None:
    #delete all dummy statements to trick RSL program pointer
    routine = process_statement.Routine
    s = process_statement.Index - skipProp.Value + 1
    for i in range( skipProp.Value ):
      routine.deleteStatement(s)
    return
    routine.endBatch()
  #endif

  cntr = executor.Controller
  routine = process_statement.Routine
  stmts = routine.Statements

  if process_statement.getProperty( "NumPoints" ):
    skipCount = process_statement.NumPoints
  else:
    skipCount = 2
  #endif

  idx = process_statement.Index
  if idx+skipCount >= routine.StatementCount:
    return
  #endif
  for i in range(skipCount):
    if stmts[idx+1+i].Type not in [VC_STATEMENT_LINMOTION, VC_STATEMENT_PTPMOTION]:
      return
    #endif
  #endfor

  cntr.clearTargets()

  trg = cntr.createTarget()

  points = [ trg.Target ]
  for i in range(skipCount):
    points.append(stmts[idx+1+i].Target )
  #endfor

  for i in range(skipCount):
    P1 = points[i]
    P2 = points[i+1]
    if i+2 < skipCount:
      P3 = points[i+2]
    else:
      P3 = points[i-1]
    #endif

    V1 = P1.P - P2.P
    V2 = P2.P - P3.P
    V3 = P3.P - P1.P
    if fabs((V1*V2)/(sqrt(V1*V1*V2*V2))) > 0.95:
      print "ERROR: CircularMove: Points are colinear"
      getSimulation().halt()
      return
    #endif

    N = V1 ^ V2
    circleRadius = V1.length()*V2.length()*V3.length()/(2.0*N.length())

    alpha = -1.0*(V2*V2)*(V1*V3)
    beta = -1.0*(V3*V3)*(V2*V1)
    gamma = -1.0*(V1*V1)*(V3*V2)

    cP = (alpha*P1.P + beta*P2.P + gamma*P3.P)*(1.0/(2.0*N*N))

    R = P1.P - cP

    xx = P1.P - cP
    xx.normalize()
    N.normalize()

    yy = N ^ xx
    yy.normalize()

    V = P2.P - cP
    V.normalize()
    if process_statement.FullCircle:
      circleAngle = 360.0
      P3 = P1
    else:
      circleAngle = atan2( V*yy, V*xx )*RAD_TO_DEG
      if circleAngle < 0.0 :
        circleAngle += 360.0
      #endif
    #endif

    vel = process_statement.CircularSpeed
    acc = cntr.MaxCartesianAccel

    arg = vel*vel/(4.*circleRadius*acc)
    if arg > 1.0:
      arg = 1.0
    #endif

    dAngle = 2.0*asin( arg ) * RAD_TO_DEG

    i = (int) (circleAngle/dAngle)
    if i < 2:
      i = 2
    #endif

    dAngle = circleAngle/i
    if dAngle < 5.0:
      dAngle = 5.0
    #endif

    trg.MotionType = VC_MOTIONTARGET_MT_LINEAR
    trg.CartesianSpeed = vel
    trg.AccuracyMethod = VC_MOTIONTARGET_AM_VELOCITY
    trg.AccuracyValue = vel

    dC = vcMatrix.new()
    dC.setAxisAngle( N.X, N.Y, N.Z, circleAngle )
    dC.translateAbs( cP.X, cP.Y, cP.Z )

    invP1 = dC*P1
    invP1.invert()
    P12 = invP1*P2

    k12 = P12.getAxisAngle()
    if circleAngle > 180.0 and abs(k12.W) > 0.1:
      k12.W = -(360.0 - k12.W)
    #endif
    if k12.Z < -0.1:
      k12.W *= -1.0
    #endif

    dTheta = k12.W/circleAngle*dAngle
    dP12 = vcMatrix.new()

    C0 = vcMatrix.new(P1)
    C0.translateAbs( -cP.X, -cP.Y, -cP.Z )

    theta = 0.0
    angle = 0.0
    while angle < circleAngle: 

      dC.setAxisAngle( N.X, N.Y, N.Z, angle )
      dP12.setAxisAngle( k12.X, k12.Y, k12.Z, theta )

      C = dC*C0*dP12

      trg.Target = C
      cntr.addTarget(trg)
      angle += dAngle
      theta += dTheta
    #endwhile

  #endif
  trg.AccuracyValue = 0.0
  trg.Target = P2
  cntr.addTarget(trg)
  cntr.move()

  # Mark end of Circle Move 
  routine.beginBatch()
  stmt = routine.createStatement( VC_STATEMENT_PROCESS )
  stmt.Index = process_statement.Index+1
  stmt.Process = "CircularMove"
  prop = stmt.createProperty( VC_INTEGER, "SkipCount" )
  prop.Value = skipCount

  # Add dummy Comment statements to trick RSL program pointer
  for i in range( skipCount-1 ):
    stmt = routine.createStatement( VC_STATEMENT_COMMENT )
    stmt.Index = process_statement.Index+1
  #endfor

#-------------------------------------------------------------------------------
def OnFinalize():
  pass
#-------------------------------------------------------------------------------
def OnReset():
  pass
#-------------------------------------------------------------------------------
"""  
  #endif

  ps = routine.createStatement(VC_STATEMENT_PROCESS)
  ps.Name = "CM1"
  ps.Process = processName
  for p in ps.Properties:
    if p.Name == "Process":
      p.IsVisible = False

  addLimitProperty( ps, VC_INTEGER, "NumPoints", True, False, False, 2, None, "", 2, 8)
  copyProperties( cmd, ps )

  cmd.Checked = False

  stmt = selStmt.getItem(0)
  if stmt:
   ps.Index = stmt.Index+1

  return True

addState(firstState)
#endif

def OnAbort（）：
cmd.Checked=False
通过
#-------------------------------------------------------------------------------
def firstState（）：
如果selProg.Count！=1:
打印“循环移动：未选择程序。正在中止…”
返回错误
#恩迪夫
cmd.Checked=True
程序=selProg.getItem（0）
例程=程序。当前例程
控制器=程序控制器
addLimitProperty（cmd，VC_REAL，“循环速度”，真，假，假，100.，无，“速度”，0.，controller.MaxCartesianSpeed）
cmp=控制器组件
#修复主程序选择错误
如果是例行公事！=program.Main例程：
如果选择计数：
stmt=selsmt.getItem（0）
如果stmt.Routine！=例行程序：
例程=program.Main例程
#恩迪夫
#恩迪夫
#恩迪夫
如果未显示PropertyDialog（cmd.Name，“圆周运动设置”，“”）：
OnAbort（）
返回错误
#恩迪夫
phName='CircularMove'
ph=cmp.findBehaviour（phName）
processName='CircularMove'
如果ph！=无：
如果博士脚本[：12]！=“#版本1.2”：
打印“更新脚本”+进程名
删除（）
ph=无
#恩迪夫
#恩迪夫
如果ph==无：
ph=cmp.createBehavior（VC\u PYTHON\u进程\u处理程序，phName）
#设置显示在RSL语句网格中的进程位图
iconuri=getCommandPath（）
iconuri=iconuri[：-3]+“.bmp”
icon=getApplication（）.loadBitmap（iconuri）
博士图标=图标
#将进程处理程序注册到机器人的rsl执行器行为
xl=cmp.findBehavioursByType（VC\RSLEXECUTOR）
对于x英寸xl：
phl=x.ProcessHandlers
ph.附加（ph）
x、 ProcessHandlers=phl
#结束
ph.Process=processName
ph.Script=“”#版本1.2
从vcRslProcessHandler导入*
从数学导入*
导入vcMatrix
弧度至度=90.0/atan2（1,0.）
def OnExecuteProcess（执行者、过程声明）：
#检查圆的末端是否移动
skipProp=process_statement.getProperty（“SkipCount”）
如果skipplop！=无：
#删除所有伪语句以欺骗RSL程序指针
例程=过程\语句。例程
s=进程\语句索引-跳过.值+1
对于范围内的i（skipProp.Value）：
例程.delete语句
返回
routine.endBatch（）
#恩迪夫
cntr=执行器控制器
例程=过程\语句。例程
stmts=例程.语句
if process_语句.getProperty（“NumPoints”）：
skipCount=进程\语句.NumPoints
其他：
skipCount=2
#恩迪夫
idx=过程\语句索引
如果idx+skipCount>=routine.StatementCount：
返回
#恩迪夫
对于范围内的i（skipCount）：
如果stmts[idx+1+i]。未在[VC_语句\u LINMOTION，VC_语句\u PTPMOTION]中键入：
返回
#恩迪夫
#结束
cntr.clearTargets（）
trg=cntr.createTarget（）
点数=[训练目标]
对于范围内的i（skipCount）：
points.append（stmts[idx+1+i].Target）
#结束
对于范围内的i（skipCount）：
P1=点[i]
P2=点[i+1]
如果i+20.95：
打印“错误：循环移动：点共线”
getSimulation（）.halt（）
返回
#恩迪夫
N=V1^V2
circleRadius=V1.length（）*V2.length（）*V3.length（）/（2.0*N.length（））
alpha=-1.0*（V2*V2）*（V1*V3）
beta=-1.0*（V3*V3）*（V2*V1）
伽马=-1.0*（V1*V1）*（V3*V2）
cP=（α*P1.P+β*P2.P+γ*P3.P）*（1.0/（2.0*N*N））
R=P1.P-cP
xx=P1.P-cP
xx.规范化（）
正常化
yy=N^xx
yy.normalize（）
V=P2.P-cP
五、规范化
如果过程_语句.FullCircle：
圆圈角度=360.0
P3=P1
其他：
圆环角度=atan2（V*yy，V*xx）*弧度到度
如果圆圈角度<0.0：
圆圈角度+=360.0
#恩迪夫
#恩迪夫
vel=过程\报表。循环速度
acc=cntr.MaxCartesianAccel
arg=vel*vel/（4.*circleRadius*acc）
如果arg>1.0：
arg=1.0
#恩迪夫
悬挂=2.0*asin（arg）*弧度至度
i=（int）（圆圈摆动/悬挂）
如果i<2：
i=2
#恩迪夫
悬挂=圆圈摆动/i
如果悬挂<5.0：
悬挂=5.0
#恩迪夫
trg.MotionType=VC\u MOTIONTARGET\u MT\u线性
trg.CartesianSpeed=vel
训练精度方法=运动目标速度
训练精度值=水平
dC=vcMatrix.new（）
直流设置轴角（N.X、N.Y、N.Z、圆环角）
dC.可翻译性（cP.X、cP.Y、cP.Z）
invP1=dC*P1
invP1.invert（）
P12=invP1*P2
k12=P12.getAxisAngle（）
如果圆圈角度>180.0且abs（k12.W）>0.1：
k12.W=-（360.0-k12.W）
#恩迪夫
如果k12.Z<-0.1：
k12.W*=-1.0
#恩迪夫
dTheta=k12.W/圆形摆动*悬挂
dP12=vcMatrix.new（）
C0=vcMatrix.new（P1）
C0.可翻译性（-cP.X，-cP.Y，-cP.Z）
θ=0.0
角度=0.0
当角度<圆圈角度：
dC.setAxisAngle（N.X、N.Y、N.Z、角度）
设置轴角（k12.X，k12.Y，k12.Z，θ）
C=dC*C0*dP12
训练目标=C
cntr.addTarget（训练）
角度+=悬挂
θ+=dTheta
#结束时
#恩迪夫
训练精度