rep1/bin/pyScripts/CAD.py

3135 lines
84 KiB
Python
Raw Normal View History

2024-11-21 09:00:42 +08:00
import platform
import ctypes
from ctypes import *
from xmlrpc.server import DocXMLRPCRequestHandler
system = platform.system()
if system == "Windows":
pre = "./"
suff = ".dll"
else:
pre = "./lib"
suff = ".so"
libfile = ctypes.cdll.LoadLibrary
filename = pre + "GeometryCommand" + suff
command = libfile(filename)
# C语言结构体映射与“GeometryCommand\GeoCommandPy.h”中ShapePara一一对应
class ShapePara(Structure):
_fields_ = [
("ID", c_int),
("name", c_char * 64),
("coorSysID", c_int),
("variableParaStr", c_char * 128),
("x1", c_double),
("y1", c_double),
("z1", c_double),
("x2", c_double),
("y2", c_double),
("z2", c_double),
("radius1", c_double),
("radius2", c_double),
("length", c_double),
("planeType", c_int),
("normalLength", c_double),
("isExists", c_bool),
("isFace", c_bool),
]
# 基础形状类,其他形状集成该类
class BaseShape:
def __init__(self):
self.para = ShapePara()
self.para.ID = -1
self.para.name = b""
self.para.coorSysID = 0
self.para.variableParaStr = b""
self.para.x1 = 0.0
self.para.y1 = 0.0
self.para.z1 = 0.0
self.para.x2 = 10.0
self.para.y2 = 10.0
self.para.z2 = 10.0
self.para.radius1 = 1.0
self.para.radius2 = 10.0
self.para.length = 10.0
self.para.planeType = 0
self.para.normalLength = 0.0
self.para.isExists = 0
self.para.isFace = 1
def setName(self, name):
self.para.name = bytes(name, encoding="utf-8")
def setEditID(self, ID):
self.para.ID = c_int(ID)
def setCoorSysID(self, csid):
self.para.coorSysID = c_int(csid)
def setXYZ1(self, x1, y1, z1):
self.para.x1 = c_double(x1)
self.para.y1 = c_double(y1)
self.para.z1 = c_double(z1)
def setXYZ2(self, x2, y2, z2):
self.para.x2 = c_double(x2)
self.para.y2 = c_double(y2)
self.para.z2 = c_double(z2)
def setRadius1(self, radius1):
self.para.radius1 = c_double(radius1)
def setRadius2(self, radius2):
self.para.radius2 = c_double(radius2)
def setLength(self, length):
self.para.length = c_double(length)
def setPlanePara(self, planeType, normalLength):
self.para.planeType = c_int(planeType)
self.para.normalLength = c_double(normalLength)
def setIsExistsVariableParameter(self, isExists):
self.para.isExists = c_bool(isExists)
def setIsFace(self, isFace):
self.para.isFace = c_bool(isFace)
def setVariableParaStr(self, variableParameter):
self.para.variableParaStr = bytes(variableParameter, encoding="utf-8")
# 二维直线类
class Line2d(BaseShape):
def __init__(self):
BaseShape.__init__(self)
def create(self):
command.CreateLine2d(self.para)
del self
def edit(self):
command.EditLine2d(self.para)
del self
# 二维圆弧类
class CircularArc(BaseShape):
def __init__(self):
BaseShape.__init__(self)
self.x3 = c_double(0.0)
self.y3 = c_double(0.0)
self.z3 = c_double(0.0)
self.x4 = c_double(0.0)
self.y4 = c_double(0.0)
self.z4 = c_double(0.0)
def setXYZ3(self, x3, y3, z3):
self.x3 = x3
self.y3 = y3
self.z3 = z3
def setXYZ4(self, x4, y4, z4):
self.x4 = x4
self.y4 = y4
self.z4 = z4
def create(self):
command.CreateCircularArc(
self.para, c_double(self.x3), c_double(self.y3), c_double(self.z3)
)
del self
def edit(self):
command.EditCircularArc(
self.para, c_double(self.x3), c_double(self.y3), c_double(self.z3)
)
del self
# 二维矩形类
class Rectangle(BaseShape):
def __init__(self):
BaseShape.__init__(self)
def create(self):
command.CreateRectangle(self.para)
del self
def edit(self):
command.EditRectangle(self.para)
del self
# 二维圆形类
class Circular(BaseShape):
def __init__(self):
BaseShape.__init__(self)
def create(self):
command.CreateCircular(self.para)
del self
def edit(self):
command.EditCircular(self.para)
del self
# 二维正多边形类
class RegularPolygon(BaseShape):
def __init__(self):
BaseShape.__init__(self)
self.edgeCount = c_int(3)
def create(self):
command.CreateRegularPolygon(self.para, c_int(self.edgeCount))
del self
def edit(self):
command.EditRegularPolygon(self.para, c_int(self.edgeCount))
del self
def setEdgeCount(self, edgeCount):
self.edgeCount = edgeCount
# 二维多边形类
class Polygon(BaseShape):
def __init__(self):
BaseShape.__init__(self)
self.pntCnt = c_int(3)
self.points = ""
def setEdgeCount(self, pntCnt):
self.pntCnt = pntCnt
def setPoints(self, points):
self.points = points
def create(self):
pointsStr = bytes(self.points, encoding="utf-8")
command.CreatePolygon(self.para, pointsStr, c_int(self.pntCnt))
del self
def importGeometry(filename):
fileName = bytes(filename, encoding="utf-8")
command.importGeometry(fileName)
pass
def exportGeometry(filename):
fileName = bytes(filename, encoding="utf-8")
command.exportGeometry(fileName)
pass
def DeleteModel(idString):
idstr = bytes(idString, encoding="utf-8")
command.DeleteModel(
idstr,
)
pass
def DeleteModelsRelatedCoordinateSystem(idString):
idstr = bytes(idString, encoding="utf-8")
command.DeleteModelsRelatedCoordinateSystem(
idstr,
)
pass
class Almond:
def __init__(self):
self.name = ""
self.editID = -1
self.coorSysID = 0
self.xMin = -5
self.xMax = 5
self.puxiMin = -180
self.puxiMax = 180
def setName(self, name):
self.name = name
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setXRange(self, xMin, xMax):
self.xMin = xMin
self.xMax = xMax
def setPuxiRange(self, puxiMin, puxiMax):
self.puxiMin = puxiMin
self.puxiMax = puxiMax
def create(self):
sname = bytes(self.name, encoding="utf-8")
command.CreateAlmond(
sname,
c_int(self.coorSysID),
c_double(self.xMin),
c_double(self.xMax),
c_double(self.puxiMin),
c_double(self.puxiMax),
)
del self
def edit(self):
command.EditAlmond(
c_int(self.editID),
c_int(self.coorSysID),
c_double(self.xMin),
c_double(self.xMax),
c_double(self.puxiMin),
c_double(self.puxiMax),
)
del self
class Box:
def __init__(self):
self.name = ""
self.editID = -1
self.coorSysID = 0
self.planeType = 0
self.x = 0
self.y = 0
self.z = 0
self.l = 10
self.w = 10
self.h = 10
self.isExists = 0
self.variablePara = ""
def setName(self, name):
self.name = name
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setPlaneType(self, planeType):
self.planeType = planeType
def setLocation(self, x, y, z):
self.x = x
self.y = y
self.z = z
def setPara(self, l, w, h):
self.l = l
self.w = w
self.h = h
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
sname = bytes(self.name, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreateBox(
sname,
c_int(self.coorSysID),
c_int(self.planeType),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.l),
c_double(self.w),
c_double(self.h),
c_bool(self.isExists),
variableParaStr,
)
del self
def edit(self):
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.EditBox(
c_int(self.editID),
c_int(self.coorSysID),
c_int(self.planeType),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.l),
c_double(self.w),
c_double(self.h),
c_bool(self.isExists),
variableParaStr,
)
del self
class TruncationBoundary:
def __init__(self):
self.name = ""
self.editID = -1
self.index = 0
self.x = 0
self.y = 0
self.z = 0
self.l = 0
self.w = 0
self.h = 0
self.newdistancex = 0
self.newdistancey = 0
self.newdistancez = 0
self.ratiox = 1
self.ratioy = 1
self.ratioz = 1
self.distancex = 0
self.distancey = 0
self.distancez = 0
self.isExists = 0
self.variablePara = ""
def setName(self, name):
self.name = name
def setEditID(self, id):
self.editID = id
def setindex(self, index):
self.index = index
def setLocation(self, x, y, z):
self.x = x
self.y = y
self.z = z
def setPara(self, l, w, h):
self.l = l
self.w = w
self.h = h
def setNewDistanceXYZ(self, newDistancex, newDistancey, newDistancez):
self.newdistancex = newDistancex
self.newdistancey = newDistancey
self.newdistancez = newDistancez
def setRatioXYZ(self, ratiox, ratioy, ratioz):
self.ratiox = ratiox
self.ratioy = ratioy
self.ratioz = ratioz
def setDistanceXYZ(self, distancex, distancey, distancez):
self.distancex = distancex
self.distancey = distancey
self.distancez = distancez
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
sname = bytes(self.name, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreateTruncationBoundary(
sname,
c_int(self.index),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.l),
c_double(self.w),
c_double(self.h),
c_double(self.newdistancex),
c_double(self.newdistancey),
c_double(self.newdistancez),
c_double(self.ratiox),
c_double(self.ratioy),
c_double(self.ratioz),
c_double(self.distancex),
c_double(self.distancey),
c_double(self.distancez),
c_bool(self.isExists),
variableParaStr,
)
del self
def edit(self):
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.EditTruncationBoundary(
c_int(self.editID),
c_int(self.index),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.l),
c_double(self.w),
c_double(self.h),
c_double(self.newdistancex),
c_double(self.newdistancey),
c_double(self.newdistancez),
c_double(self.ratiox),
c_double(self.ratioy),
c_double(self.ratioz),
c_double(self.distancex),
c_double(self.distancey),
c_double(self.distancez),
c_bool(self.isExists),
variableParaStr,
)
del self
class Wedge:
def __init__(self):
self.name = ""
self.editID = -1
self.coorSysID = 0
self.xBottom = 0
self.yBottom = 0
self.zBottom = 0
self.xTop = 0
self.yTop = 0
self.zTop = 0
self.dirX = 0
self.dirY = -1
self.dirZ = 0
self.bottomDx = 10
self.bottomDy = 10
self.topDx = 0
self.topDy = 0
self.height = 10
self.isExists = 0
self.variablePara = ""
def setName(self, name):
self.name = name
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setBottomLocation(self, xBottom, yBottom, zBottom):
self.XBottom = xBottom
self.YBottom = yBottom
self.ZBottom = zBottom
def setTopLocation(self, xTop, yTop, zTop):
self.XTop = xTop
self.YTop = yTop
self.ZTop = zTop
def setAxis(self, dirX, dirY, dirZ):
self.DirX = dirX
self.DirY = dirY
self.DirZ = dirZ
def setSize(self, bottomDx, bottomDy, topDx, topDy, height):
self.BottomDx = bottomDx
self.BottomDy = bottomDy
self.TopDx = topDx
self.TopDy = topDy
self.Height = height
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
sname = bytes(self.name, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreateWedge(
sname,
c_int(self.coorSysID),
c_double(self.XBottom),
c_double(self.YBottom),
c_double(self.ZBottom),
c_double(self.XTop),
c_double(self.YTop),
c_double(self.ZTop),
c_double(self.DirX),
c_double(self.DirY),
c_double(self.DirZ),
c_double(self.BottomDx),
c_double(self.BottomDy),
c_double(self.TopDx),
c_double(self.TopDy),
c_double(self.Height),
c_bool(self.isExists),
variableParaStr,
)
del self
def edit(self):
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.EditWedge(
c_int(self.editID),
c_int(self.coorSysID),
c_double(self.XBottom),
c_double(self.YBottom),
c_double(self.ZBottom),
c_double(self.XTop),
c_double(self.YTop),
c_double(self.ZTop),
c_double(self.DirX),
c_double(self.DirY),
c_double(self.DirZ),
c_double(self.BottomDx),
c_double(self.BottomDy),
c_double(self.TopDx),
c_double(self.TopDy),
c_double(self.Height),
c_bool(self.isExists),
variableParaStr,
)
del self
class Antenna:
def setName(self, name):
self.name = name
def setEditID(self, id):
self.editID = id
def setLocation(self, x, y, z):
self.x = x
self.y = y
self.z = z
def setPara(self, l, w, h):
self.l = l
self.w = w
self.h = h
def create(self):
sname = bytes(self.name, encoding="utf-8")
command.CreateAntenna(
sname,
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.l),
c_double(self.w),
c_double(self.h),
)
del self
def edit(self):
command.EditAntenna(
c_int(self.editID),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.l),
c_double(self.w),
c_double(self.h),
)
del self
class Cylinder:
def __init__(self):
self.name = ""
self.editID = -1
self.coorSysID = 0
self.planeType = 0
self.x = 0
self.y = 0
self.z = 0
self.l = 0
self.w = 0
self.h = 1
self.radius = 5
self.length = 10
self.isExists = 0
self.variablePara = ""
def setName(self, name):
self.name = name
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setPlaneType(self, planeType):
self.planeType = planeType
def setLocation(self, x, y, z):
self.x = x
self.y = y
self.z = z
def setAxis(self, l, w, h):
self.l = l
self.w = w
self.h = h
def setRadius(self, radius):
self.radius = radius
def setLength(self, length):
self.length = length
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
sname = bytes(self.name, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreateCylinder(
sname,
c_int(self.coorSysID),
c_int(self.planeType),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.l),
c_double(self.w),
c_double(self.h),
c_double(self.radius),
c_double(self.length),
c_bool(self.isExists),
variableParaStr,
)
del self
def edit(self):
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.EditCylinder(
c_int(self.editID),
c_int(self.coorSysID),
c_int(self.planeType),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.l),
c_double(self.w),
c_double(self.h),
c_double(self.radius),
c_double(self.length),
c_bool(self.isExists),
variableParaStr,
)
del self
class Cone:
def __init__(self):
self.name = ""
self.editID = -1
self.coorSysID = 0
self.planeType = 0
self.x = 0
self.y = 0
self.z = 0
self.l = 0
self.w = 0
self.h = 1
self.radius = 5
self.radius2 = 0
self.length = 10
self.isExists = 0
self.variablePara = ""
def setName(self, name):
self.name = name
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setPlaneType(self, planeType):
self.planeType = planeType
def setLocation(self, x, y, z):
self.x = x
self.y = y
self.z = z
def setAxis(self, l, w, h):
self.l = l
self.w = w
self.h = h
def setRadius(self, radius, radius2):
self.radius = radius
self.radius2 = radius2
def setLength(self, length):
self.length = length
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
sname = bytes(self.name, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreateCone(
sname,
c_int(self.coorSysID),
c_int(self.planeType),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.l),
c_double(self.w),
c_double(self.h),
c_double(self.radius),
c_double(self.radius2),
c_double(self.length),
c_bool(self.isExists),
variableParaStr,
)
del self
def edit(self):
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.EditCone(
c_int(self.editID),
c_int(self.coorSysID),
c_int(self.planeType),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.l),
c_double(self.w),
c_double(self.h),
c_double(self.radius),
c_double(self.radius2),
c_double(self.length),
c_bool(self.isExists),
variableParaStr,
)
del self
class Sphere:
def __init__(self):
self.name = ""
self.editID = -1
self.coorSysID = 0
self.x = 0
self.y = 0
self.z = 0
self.radius = 5
self.isExists = 0
self.variablePara = ""
def setName(self, name):
self.name = name
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setLocation(self, x, y, z):
self.x = x
self.y = y
self.z = z
def setRadius(self, radius):
self.radius = radius
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
sname = bytes(self.name, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreateSphere(
sname,
c_int(self.coorSysID),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.radius),
c_bool(self.isExists),
variableParaStr,
)
del self
def edit(self):
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.EditSphere(
c_int(self.editID),
c_int(self.coorSysID),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.radius),
c_bool(self.isExists),
variableParaStr,
)
del self
# 三维球体拓展1
class SphereExpansion1(BaseShape):
def _init_(self):
BaseShape.__init__(self)
def create(self):
command.CreateSphereExpansion1(self.para)
del self
def edit(self):
command.EditSphereExpansion1(self.para)
del self
class Torus:
def __init__(self):
self.name = ""
self.editID = -1
self.coorSysID = 0
self.planeType = 0
self.x = 0
self.y = 0
self.z = 0
self.l = 0
self.w = 0
self.h = 1
self.radius1 = 5
self.radius2 = 1
self.isExists = 0
self.variablePara = ""
def setName(self, name):
self.name = name
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setPlaneType(self, planeType):
self.planeType = planeType
def setLocation(self, x, y, z):
self.x = x
self.y = y
self.z = z
def setAxis(self, l, w, h):
self.l = l
self.w = w
self.h = h
def setRadius(self, radius1, radius2):
self.radius1 = radius1
self.radius2 = radius2
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
sname = bytes(self.name, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreateTorus(
sname,
c_int(self.coorSysID),
c_int(self.planeType),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.l),
c_double(self.w),
c_double(self.h),
c_double(self.radius1),
c_double(self.radius2),
c_bool(self.isExists),
variableParaStr,
)
del self
def edit(self):
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.EditTorus(
c_int(self.editID),
c_int(self.coorSysID),
c_int(self.planeType),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.l),
c_double(self.w),
c_double(self.h),
c_double(self.radius1),
c_double(self.radius2),
c_bool(self.isExists),
variableParaStr,
)
del self
class RegularPrism:
def __init__(self):
self.name = ""
self.editID = -1
self.coorSysID = 0
self.planeType = 0
self.x = 0
self.y = 0
self.z = 0
self.xe = 0
self.ye = 0
self.ze = 0
self.l = 0
self.w = 0
self.h = 1
self.edgeNum = 6
self.edgeLen = 5
self.Hei = 10
self.isExists = 0
self.variablePara = ""
def setName(self, name):
self.name = name
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setPlaneType(self, planeType):
self.planeType = planeType
def setLocation(self, x, y, z):
self.x = x
self.y = y
self.z = z
def setEdgePnt(self, xe, ye, ze):
self.xe = xe
self.ye = ye
self.ze = ze
def setAxis(self, l, w, h):
self.l = l
self.w = w
self.h = h
def setedgeNumber(self, edgeNum):
self.edgeNum = edgeNum
def setedgeLength(self, edgeLen):
self.edgeLen = edgeLen
def setHeight(self, Hei):
self.Hei = Hei
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
sname = bytes(self.name, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreateRegularPrism(
sname,
c_int(self.coorSysID),
c_int(self.planeType),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.xe),
c_double(self.ye),
c_double(self.ze),
c_double(self.l),
c_double(self.w),
c_double(self.h),
c_int(self.edgeNum),
c_double(self.edgeLen),
c_double(self.Hei),
c_bool(self.isExists),
variableParaStr,
)
del self
def edit(self):
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.EditRegularPrism(
c_int(self.editID),
c_int(self.coorSysID),
c_int(self.planeType),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.xe),
c_double(self.ye),
c_double(self.ze),
c_double(self.l),
c_double(self.w),
c_double(self.h),
c_int(self.edgeNum),
c_double(self.edgeLen),
c_double(self.Hei),
c_bool(self.isExists),
variableParaStr,
)
del self
class Helix:
def __init__(self):
self.name = ""
self.editID = -1
self.coorSysID = 0
self.x = 0
self.y = 0
self.z = 0
self.Cylindrical = 1
self.pitch = 2
self.helixRadius = 5
self.cylinderNumber = 5
self.halfAngle = 30
self.GenerateSolid = 1
self.circleRadius = 0.5
self.method = 0
self.planemethod = '"XOY"'
self.reverse = 0
self.isExists = 0
self.variablePara = ""
def setName(self, name):
self.name = name
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setLocation(self, x, y, z):
self.x = x
self.y = y
self.z = z
def setCylindrical(self, Cylindrical):
self.Cylindrical = Cylindrical
def setpitch(self, pitch):
self.pitch = pitch
def sethelixRadius(self, helixRadius):
self.helixRadius = helixRadius
def setcylinderNumber(self, cylinderNumber):
self.cylinderNumber = cylinderNumber
def sethalfAngle(self, halfAngle):
self.halfAngle = halfAngle
def setGenerateSolid(self, GenerateSolid):
self.GenerateSolid = GenerateSolid
def setcircleRadius(self, circleRadius):
self.circleRadius = circleRadius
def setSymmetricPlaneMethod(self, method):
self.method = method
def setPlaneMethod(self, planemethod):
self.planemethod = planemethod
def setreverse(self, reverse):
self.reverse = reverse
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
sname = bytes(self.name, encoding="utf-8")
methodstr = bytes(self.method, encoding="utf-8")
planemestr = bytes(self.planemethod, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreateHelix(
sname,
c_int(self.coorSysID),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_bool(self.Cylindrical),
c_double(self.pitch),
c_double(self.helixRadius),
c_double(self.cylinderNumber),
c_double(self.halfAngle),
c_bool(self.GenerateSolid),
c_double(self.circleRadius),
methodstr,
planemestr,
c_bool(self.reverse),
c_bool(self.isExists),
variableParaStr,
)
del self
def edit(self):
methodstr = bytes(self.method, encoding="utf-8")
planemestr = bytes(self.planemethod, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.EditHelix(
c_int(self.editID),
c_int(self.coorSysID),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_bool(self.Cylindrical),
c_double(self.pitch),
c_double(self.helixRadius),
c_double(self.cylinderNumber),
c_double(self.halfAngle),
c_bool(self.GenerateSolid),
c_double(self.circleRadius),
methodstr,
planemestr,
c_bool(self.reverse),
c_bool(self.isExists),
variableParaStr,
)
del self
class Point:
def __init__(self):
self.x = 0
self.y = 0
self.z = 0
self.name = ""
self.editID = -1
self.p1 = 0
self.p2 = 0
self.p3 = 0
self.isExists = 0
self.variablePara = ""
def setName(self, name):
self.name = name
def setEditID(self, id):
self.editID = id
def setLocation(self, x, y, z):
self.x = x
self.y = y
self.z = z
def setOffset(self, p1, p2, p3):
self.p1 = p1
self.p2 = p2
self.p3 = p3
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
sname = bytes(self.name, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreatePoint(
sname,
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.p1),
c_double(self.p2),
c_double(self.p3),
c_bool(self.isExists),
variableParaStr,
)
del self
def edit(self):
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.EditPoint(
c_int(self.editID),
c_double(self.x),
c_double(self.y),
c_double(self.z),
c_double(self.p1),
c_double(self.p2),
c_double(self.p3),
c_bool(self.isExists),
variableParaStr,
)
del self
class Line:
def __init__(self):
self.startpoint0 = 0
self.startpoint1 = 0
self.startpoint2 = 0
self.name = ""
self.editID = -1
self.method = 0
self.coor0 = 0
self.coor1 = 0
self.coor2 = 0
self.len = 10
self.reverse = 0
self.dir0 = 0
self.dir1 = 0
self.dir2 = 0
self.isExists = 0
self.variablePara = ""
def setName(self, name):
self.name = name
def setEditID(self, id):
self.editID = id
def setStartPoint(self, startpoint0, startpoint1, startpoint2):
self.startpoint0 = startpoint0
self.startpoint1 = startpoint1
self.startpoint2 = startpoint2
def setEndPoint(self, coor0, coor1, coor2):
self.method = 0
self.coor0 = coor0
self.coor1 = coor1
self.coor2 = coor2
def setDirection(self, dir0, dir1, dir2):
self.method = 1
self.dir0 = dir0
self.dir1 = dir1
self.dir2 = dir2
def setLength(self, len):
self.len = len
def setDirectionReverse(self, reverse):
self.reverse = reverse
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
sname = bytes(self.name, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreateLine(
sname,
c_double(self.startpoint0),
c_double(self.startpoint1),
c_double(self.startpoint2),
c_int(self.method),
c_double(self.coor0),
c_double(self.coor1),
c_double(self.coor2),
c_double(self.len),
c_double(self.dir0),
c_double(self.dir1),
c_double(self.dir2),
c_int(self.reverse),
c_bool(self.isExists),
variableParaStr,
)
del self
def edit(self):
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.EditLine(
c_int(self.editID),
c_double(self.startpoint0),
c_double(self.startpoint1),
c_double(self.startpoint2),
c_int(self.method),
c_double(self.coor0),
c_double(self.coor1),
c_double(self.coor2),
c_double(self.len),
c_double(self.dir0),
c_double(self.dir1),
c_double(self.dir2),
c_int(self.reverse),
c_bool(self.isExists),
variableParaStr,
)
del self
class Face:
def __init__(self):
self.edges = dict()
self.editID = -1
self.name = ""
self.coorSysID = 0
def setName(self, name):
self.name = name
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def appendEdge(self, geoset, index):
self.edges.setdefault(geoset, set()).add(index)
def create(self):
keyList = self.edges.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.edges.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
edgestr = bytes(strcom, encoding="utf-8")
sname = bytes(self.name, encoding="utf-8")
command.CreateFace(c_int(self.coorSysID), edgestr, sname, c_int(self.editID))
def edit(self):
self.create()
class Chamfer:
def __init__(self):
self.edges = dict()
self.editID = -1
self.coorSysID = 0
self.type = 0
self.d1 = 1.0
self.d2 = 1.0
self.typestr = "Symmetrical"
self.chamferType = 0
self.isExists = 0
self.variablePara = ""
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setSectionType(self, typestr):
self.typestr = typestr
def setChamferType(self, chamferType):
self.chamferType = chamferType
def setSymmetricalDistance(self, d1):
self.d1 = d1
def setAsymmetricalDistances(self, d1, d2):
self.d1 = d1
self.d2 = d2
def appendEdge(self, geoset, index):
self.edges.setdefault(geoset, set()).add(index)
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
keyList = self.edges.keys()
variableParaStr = bytes(self.variablePara, encoding="utf-8")
strcom = ""
for key in keyList:
setstr = ""
values = self.edges.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
edgestr = bytes(strcom, encoding="utf-8")
if self.typestr == "Symmetrical":
self.type = 0
elif self.typestr == "Asymmetrical":
self.type = 1
command.CreateChamfer(
c_int(self.coorSysID),
edgestr,
c_int(self.editID),
c_double(self.d1),
c_double(self.d2),
c_int(self.type),
c_int(self.chamferType),
c_bool(self.isExists),
variableParaStr,
)
def edit(self):
self.create()
class Fillet:
def __init__(self):
self.edges = dict()
self.editID = -1
self.coorSysID = 0
self.isExists = 0
self.filletType = 0
self.variablePara = ""
def setCoorSysID(self, csid):
self.coorSysID = csid
def appendEdge(self, geoset, index):
self.edges.setdefault(geoset, set()).add(index)
def setFilletType(self, filletType):
self.filletType = filletType
def setRadius(self, r):
self.radius = r
def setEditID(self, id):
self.editID = id
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
keyList = self.edges.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.edges.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
edgestr = bytes(strcom, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreateFillet(
c_int(self.coorSysID),
edgestr,
c_int(self.filletType),
c_double(self.radius),
c_int(self.editID),
c_bool(self.isExists),
variableParaStr,
)
def edit(self):
self.create()
class VariableFillet:
def __init__(self):
self.edges = dict()
self.editID = -1
self.coorSysID = 0
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def VariableFilletOnEdge(self, setid, edgeindex):
self.setid = setid
self.edgeindex = edgeindex
def AppendVariablePoint(self, location, radius):
self.edges.setdefault(location, radius)
def setBasicRad(self, basicRad):
self.basicRad = basicRad
def create(self):
keyList = self.edges.keys()
strcom = ""
for key in keyList:
setstr = ""
# values = self.edges.get(key)
# for v in values:
setstr = setstr + str(self.edges[key]) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
edgestr = bytes(strcom, encoding="utf-8")
command.CreateVariableFillet(
c_int(self.coorSysID),
edgestr,
c_double(self.basicRad),
c_int(self.editID),
c_int(self.setid),
c_int(self.edgeindex),
)
def edit(self):
self.create()
class UnionOperation:
def __init__(self):
self.coorSysID = 0
self.selectModelType = 0
self.geometryModels = dict()
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setSelectModelType(self, modelType):
self.selectModelType = modelType
def appendGeometryModel(self, setid, modelIndex):
self.geometryModels.setdefault(setid, set()).add(modelIndex)
def create(self):
keyList1 = self.geometryModels.keys()
strcom1 = ""
for key in keyList1:
setstr1 = ""
values = self.geometryModels.get(key)
for v in values:
setstr1 = setstr1 + str(v) + ","
setstr1 = str(key) + ":" + setstr1[:-1]
strcom1 = strcom1 + setstr1 + ";"
strcom1 = strcom1[:-1]
bodystr1 = bytes(strcom1, encoding="utf-8")
command.CreateUnionOperation(
c_int(self.coorSysID),
c_int(self.selectModelType),
bodystr1,
)
del self
def edit(self):
keyList1 = self.geometryModels.keys()
strcom1 = ""
for key in keyList1:
setstr1 = ""
values = self.geometryModels.get(key)
for v in values:
setstr1 = setstr1 + str(v) + ","
setstr1 = str(key) + ":" + setstr1[:-1]
strcom1 = strcom1 + setstr1 + ";"
strcom1 = strcom1[:-1]
bodystr1 = bytes(strcom1, encoding="utf-8")
command.EditUnionOperation(
c_int(self.coorSysID),
c_int(self.selectModelType),
c_int(self.editID),
bodystr1,
)
del self
class BooLOperation:
def __init__(self):
self.coorSysID = 0
self.bodys1 = dict()
self.bodys2 = dict()
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setBoolType(self, booltype):
self.booltype = booltype
def set2d(self, bool2d):
self.bool2d = int(bool2d)
def appendBody1(self, setid, bodyindex):
self.bodys1.setdefault(setid, set()).add(bodyindex)
def appendBody2(self, setid, bodyindex):
self.bodys2.setdefault(setid, set()).add(bodyindex)
def SaveOrigin(self, saveBox2):
self.saveBox2 = saveBox2
def create(self):
keyList1 = self.bodys1.keys()
strcom1 = ""
for key in keyList1:
setstr1 = ""
values = self.bodys1.get(key)
for v in values:
setstr1 = setstr1 + str(v) + ","
setstr1 = str(key) + ":" + setstr1[:-1]
strcom1 = strcom1 + setstr1 + ";"
strcom1 = strcom1[:-1]
bodystr1 = bytes(strcom1, encoding="utf-8")
keyList2 = self.bodys2.keys()
strcom2 = ""
for key in keyList2:
setstr2 = ""
values = self.bodys2.get(key)
for v in values:
setstr2 = setstr2 + str(v) + ","
setstr2 = str(key) + ":" + setstr2[:-1]
strcom2 = strcom2 + setstr2 + ";"
strcom2 = strcom2[:-1]
bodystr2 = bytes(strcom2, encoding="utf-8")
typestr = bytes(self.booltype, encoding="utf-8")
savestr = bytes(self.saveBox2, encoding="utf-8")
command.CreateBooLOperation(
c_int(self.coorSysID),
typestr,
bodystr1,
bodystr2,
c_int(self.bool2d),
savestr,
)
del self
def edit(self):
keyList1 = self.bodys1.keys()
strcom1 = ""
for key in keyList1:
setstr1 = ""
values = self.bodys1.get(key)
for v in values:
setstr1 = setstr1 + str(v) + ","
setstr1 = str(key) + ":" + setstr1[:-1]
strcom1 = strcom1 + setstr1 + ";"
strcom1 = strcom1[:-1]
bodystr1 = bytes(strcom1, encoding="utf-8")
keyList2 = self.bodys2.keys()
strcom2 = ""
for key in keyList2:
setstr2 = ""
values = self.bodys2.get(key)
for v in values:
setstr2 = setstr2 + str(v) + ","
setstr2 = str(key) + ":" + setstr2[:-1]
strcom2 = strcom2 + setstr2 + ";"
strcom2 = strcom2[:-1]
bodystr2 = bytes(strcom2, encoding="utf-8")
typestr = bytes(self.booltype, encoding="utf-8")
savestr = bytes(self.saveBox2, encoding="utf-8")
command.EditBooLOperation(
c_int(self.coorSysID),
c_int(self.editID),
typestr,
bodystr1,
bodystr2,
c_int(self.bool2d),
savestr,
)
del self
class BooLCutOperation:
def __init__(self):
self.coorSysID = 0
self.bodys1 = dict()
self.bodys2 = dict()
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def set2d(self, bool2d):
self.bool2d = int(bool2d)
def appendBody1(self, setid, bodyindex):
self.bodys1.setdefault(setid, set()).add(bodyindex)
def appendBody2(self, setid, bodyindex):
self.bodys2.setdefault(setid, set()).add(bodyindex)
def SaveOrigin(self, saveBox2):
self.saveBox2 = saveBox2
def create(self):
keyList1 = self.bodys1.keys()
strcom1 = ""
for key in keyList1:
setstr1 = ""
values = self.bodys1.get(key)
for v in values:
setstr1 = setstr1 + str(v) + ","
setstr1 = str(key) + ":" + setstr1[:-1]
strcom1 = strcom1 + setstr1 + ";"
strcom1 = strcom1[:-1]
bodystr1 = bytes(strcom1, encoding="utf-8")
keyList2 = self.bodys2.keys()
strcom2 = ""
for key in keyList2:
setstr2 = ""
values = self.bodys2.get(key)
for v in values:
setstr2 = setstr2 + str(v) + ","
setstr2 = str(key) + ":" + setstr2[:-1]
strcom2 = strcom2 + setstr2 + ";"
strcom2 = strcom2[:-1]
bodystr2 = bytes(strcom2, encoding="utf-8")
savestr = bytes(self.saveBox2, encoding="utf-8")
command.CreateBooLCutOperation(
c_int(self.coorSysID), bodystr1, bodystr2, c_int(self.bool2d), savestr
)
del self
def edit(self):
keyList1 = self.bodys1.keys()
strcom1 = ""
for key in keyList1:
setstr1 = ""
values = self.bodys1.get(key)
for v in values:
setstr1 = setstr1 + str(v) + ","
setstr1 = str(key) + ":" + setstr1[:-1]
strcom1 = strcom1 + setstr1 + ";"
strcom1 = strcom1[:-1]
bodystr1 = bytes(strcom1, encoding="utf-8")
keyList2 = self.bodys2.keys()
strcom2 = ""
for key in keyList2:
setstr2 = ""
values = self.bodys2.get(key)
for v in values:
setstr2 = setstr2 + str(v) + ","
setstr2 = str(key) + ":" + setstr2[:-1]
strcom2 = strcom2 + setstr2 + ";"
strcom2 = strcom2[:-1]
bodystr2 = bytes(strcom2, encoding="utf-8")
savestr = bytes(self.saveBox2, encoding="utf-8")
command.EditBooLCutOperation(
c_int(self.coorSysID),
c_int(self.editID),
bodystr1,
bodystr2,
c_int(self.bool2d),
savestr,
)
del self
class MirrorFeature:
def __init__(self):
self.coorSysID = 0
self.faceindex = 0
self.facebody = 0
self.method = 0
self.planemethod = '"XOY"'
self.basepoint0 = 0
self.basepoint1 = 0
self.basepoint2 = 0
self.random0 = 0
self.random1 = 0
self.random2 = 0
self.save = 0
self.bodys = dict()
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def appendBody(self, setid, bodyindex):
self.bodys.setdefault(setid, set()).add(bodyindex)
def SaveOrigin(self, save):
self.save = save
def setSymmetricPlaneMethod(self, method):
self.method = method
def setFace(self, facebody, faceindex):
self.faceindex = faceindex
self.facebody = facebody
def setPlaneMethod(self, planemethod):
self.planemethod = planemethod
def setFeature(self, selectFeatures):
self.selectFeatures = selectFeatures
def setDir(self, random0, random1, random2):
self.random0 = random0
self.random1 = random1
self.random2 = random2
def setBasePt(self, basepoint0, basepoint1, basepoint2):
self.basepoint0 = basepoint0
self.basepoint1 = basepoint1
self.basepoint2 = basepoint2
def create(self):
keyList = self.bodys.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.bodys.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
bodystr = bytes(strcom, encoding="utf-8")
methodstr = bytes(self.method, encoding="utf-8")
savestr = bytes(self.save, encoding="utf-8")
planemestr = bytes(self.planemethod, encoding="utf-8")
command.CreateMirrorFeature(
c_int(self.coorSysID),
bodystr,
methodstr,
c_int(self.faceindex),
c_int(self.facebody),
planemestr,
c_double(self.random0),
c_double(self.random1),
c_double(self.random2),
c_double(self.basepoint0),
c_double(self.basepoint1),
c_double(self.basepoint2),
savestr,
c_int(self.selectFeatures),
)
del self
def edit(self):
keyList = self.bodys.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.bodys.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
bodystr = bytes(strcom, encoding="utf-8")
methodstr = bytes(self.method, encoding="utf-8")
savestr = bytes(self.save, encoding="utf-8")
planemestr = bytes(self.planemethod, encoding="utf-8")
command.EditMirrorFeature(
c_int(self.coorSysID),
c_int(self.editID),
bodystr,
methodstr,
c_int(self.faceindex),
c_int(self.facebody),
planemestr,
c_double(self.random0),
c_double(self.random1),
c_double(self.random2),
c_double(self.basepoint0),
c_double(self.basepoint1),
c_double(self.basepoint2),
savestr,
c_int(self.selectFeatures),
)
del self
class MoveFeature:
def __init__(self):
self.coorSysID = 0
self.startpt0 = 0
self.startpt1 = 0
self.startpt2 = 0
self.endpt0 = 0
self.endpt1 = 0
self.endpt2 = 0
self.length = 10
self.dir0 = 0
self.dir1 = 0
self.dir2 = 0
self.reverse = "false"
self.bodys = dict()
self.isExists = 0
self.variablePara = ""
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def appendBody(self, setid, bodyindex):
self.bodys.setdefault(setid, set()).add(bodyindex)
def TransformMethod(self, method):
self.method = method
def setStartPoint(self, startpt0, startpt1, startpt2):
self.startpt0 = startpt0
self.startpt1 = startpt1
self.startpt2 = startpt2
def setEndPoint(self, endpt0, endpt1, endpt2):
self.endpt0 = endpt0
self.endpt1 = endpt1
self.endpt2 = endpt2
def SaveOrigin(self, saveori):
self.saveori = saveori
def setReverse(self, reverse):
self.reverse = reverse
def setFeature(self, selectFeatures):
self.selectFeatures = selectFeatures
def setLength(self, length):
self.length = length
def setDirection(self, dir0, dir1, dir2):
self.dir0 = dir0
self.dir1 = dir1
self.dir2 = dir2
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
keyList = self.bodys.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.bodys.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
bodystr = bytes(strcom, encoding="utf-8")
methstr = bytes(self.method, encoding="utf-8")
saveoristr = bytes(self.saveori, encoding="utf-8")
reversestr = bytes(self.reverse, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreateMoveFeature(
c_int(self.coorSysID),
bodystr,
methstr,
c_double(self.startpt0),
c_double(self.startpt1),
c_double(self.startpt2),
c_double(self.endpt0),
c_double(self.endpt1),
c_double(self.endpt2),
saveoristr,
reversestr,
c_double(self.length),
c_double(self.dir0),
c_double(self.dir1),
c_double(self.dir2),
c_int(self.selectFeatures),
c_bool(self.isExists),
variableParaStr,
)
del self
def edit(self):
keyList = self.bodys.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.bodys.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
bodystr = bytes(strcom, encoding="utf-8")
methstr = bytes(self.method, encoding="utf-8")
saveoristr = bytes(self.saveori, encoding="utf-8")
reversestr = bytes(self.reverse, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.EditMoveFeature(
c_int(self.coorSysID),
c_int(self.editID),
bodystr,
methstr,
c_double(self.startpt0),
c_double(self.startpt1),
c_double(self.startpt2),
c_double(self.endpt0),
c_double(self.endpt1),
c_double(self.endpt2),
saveoristr,
reversestr,
c_double(self.length),
c_double(self.dir0),
c_double(self.dir1),
c_double(self.dir2),
c_int(self.selectFeatures),
c_bool(self.isExists),
variableParaStr,
)
del self
class TransformCopy:
def __init__(self):
self.startpt0 = 0
self.startpt1 = 0
self.startpt2 = 0
self.endpt0 = 0
self.endpt1 = 0
self.endpt2 = 0
self.selectFeatures = 0
self.copyCnt = 0
self.bodys = dict()
def appendBody(self, setid, bodyindex):
self.bodys.setdefault(setid, set()).add(bodyindex)
def setStartPoint(self, startpt0, startpt1, startpt2):
self.startpt0 = startpt0
self.startpt1 = startpt1
self.startpt2 = startpt2
def setEndPoint(self, endpt0, endpt1, endpt2):
self.endpt0 = endpt0
self.endpt1 = endpt1
self.endpt2 = endpt2
def setFeature(self, selectFeatures):
self.selectFeatures = selectFeatures
def setCopyCnt(self, copyCnt):
self.copyCnt = copyCnt
def create(self):
keyList = self.bodys.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.bodys.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
bodystr = bytes(strcom, encoding="utf-8")
command.CreateTransformCopy(
bodystr,
c_double(self.startpt0),
c_double(self.startpt1),
c_double(self.startpt2),
c_double(self.endpt0),
c_double(self.endpt1),
c_double(self.endpt2),
c_int(self.selectFeatures),
c_int(self.copyCnt),
)
del self
class ProjectionOnSurface:
def __init__(self):
self.coorSysID = 0
self.faceindex = 0
self.facebody = 0
self.method = 0
self.planemethod = '"XOY"'
self.projDir0 = 0
self.projDir1 = 0
self.projDir2 = 0
self.generateFace = 0
self.bodys = dict()
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def appendBody(self, setid, bodyindex):
self.bodys.setdefault(setid, set()).add(bodyindex)
def GenerateFace(self, generateFace):
self.generateFace = generateFace
def setProjPlaneMethod(self, method):
self.method = method
def setFace(self, facebody, faceindex):
self.faceindex = faceindex
self.facebody = facebody
def setPlaneMethod(self, planemethod):
self.planemethod = planemethod
def setFeature(self, selectFeatures):
self.selectFeatures = selectFeatures
def setProjextionDirection(self, projDir0, projDir1, projDir2):
self.projDir0 = projDir0
self.projDir1 = projDir1
self.projDir2 = projDir2
def create(self):
keyList = self.bodys.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.bodys.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
bodystr = bytes(strcom, encoding="utf-8")
methodstr = bytes(self.method, encoding="utf-8")
generateFacestr = bytes(self.generateFace, encoding="utf-8")
planemestr = bytes(self.planemethod, encoding="utf-8")
command.CreateProjectionOnSurface(
c_int(self.coorSysID),
bodystr,
methodstr,
c_int(self.faceindex),
c_int(self.facebody),
planemestr,
c_double(self.projDir0),
c_double(self.projDir1),
c_double(self.projDir2),
generateFacestr,
c_int(self.selectFeatures),
)
del self
def edit(self):
keyList = self.bodys.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.bodys.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
bodystr = bytes(strcom, encoding="utf-8")
methodstr = bytes(self.method, encoding="utf-8")
generateFacestr = bytes(self.generateFace, encoding="utf-8")
planemestr = bytes(self.planemethod, encoding="utf-8")
command.EditProjectionOnSurface(
c_int(self.coorSysID),
c_int(self.editID),
bodystr,
methodstr,
c_int(self.faceindex),
c_int(self.facebody),
planemestr,
c_double(self.projDir0),
c_double(self.projDir1),
c_double(self.projDir2),
generateFacestr,
c_int(self.selectFeatures),
)
del self
class RotateFeature:
def __init__(self):
self.coorSysID = 0
self.saveOri = 0
self.rever = 0
self.body = 0
self.edge = 0
self.axisx = 0
self.axisy = 0
self.axisz = 0
self.axisMethod = 0
self.bodys = dict()
self.isExists = 0
self.variablePara = ""
def setCoorSysID(self, csid):
self.coorSysID = csid
def saveOrigin(self):
self.saveOri = 1
def appendBody(self, setid, bodyindex):
self.bodys.setdefault(setid, set()).add(bodyindex)
def setBasicPoint(self, x, y, z):
self.basicx = x
self.basicy = y
self.basicz = z
def setAxisFromBody(self, body, edge):
self.axisMethod = 0
self.body = body
self.edge = edge
def setAxis(self, x, y, z):
self.axisMethod = 1
self.axisx = x
self.axisy = y
self.axisz = z
def reverse(self):
self.rever = 1
def setAngle(self, ang):
self.angle = ang
def setRotateFeature(self, selectRotateFeatures):
self.selectRotateFeatures = selectRotateFeatures
def setEditID(self, id):
self.editID = id
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def rotate(self):
keyList = self.bodys.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.bodys.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
objstr = bytes(strcom, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.RotateFeature(
c_int(self.coorSysID),
objstr,
c_double(self.basicx),
c_double(self.basicy),
c_double(self.basicz),
c_int(self.axisMethod),
c_int(self.body),
c_int(self.edge),
c_double(self.axisx),
c_double(self.axisy),
c_double(self.axisz),
c_int(self.rever),
c_double(self.angle),
c_int(self.saveOri),
c_int(self.selectRotateFeatures),
c_bool(self.isExists),
variableParaStr,
)
del self
def edit(self):
keyList = self.bodys.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.bodys.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
objstr = bytes(strcom, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.EditRotateFeature(
c_int(self.coorSysID),
c_int(self.editID),
objstr,
c_double(self.basicx),
c_double(self.basicy),
c_double(self.basicz),
c_int(self.axisMethod),
c_int(self.body),
c_int(self.edge),
c_double(self.axisx),
c_double(self.axisy),
c_double(self.axisz),
c_int(self.rever),
c_double(self.angle),
c_int(self.saveOri),
c_int(self.selectRotateFeatures),
c_bool(self.isExists),
variableParaStr,
)
del self
class MakeMatrix:
def __init__(self):
self.coorSysID = 0
self.optionindex = 0
self.dir10 = 0
self.dir11 = 0
self.dir12 = 0
self.reverse1 = 0
self.dis1 = 15
self.count1 = 2
self.showdir2 = 0
self.dir20 = 0
self.dir21 = 0
self.dir22 = 0
self.reverse2 = 0
self.dis2 = 15
self.count2 = 2
self.basept0 = 0
self.basept1 = 0
self.basept2 = 0
self.axis0 = 0
self.axis1 = 0
self.axis2 = 0
self.wirereverse = 0
self.wirecount = 2
self.degree = 30
self.DistanceX = 0
self.DistanceY = 0
self.DistanceZ = 0
self.CountX = 1
self.CountY = 1
self.CountZ = 1
self.bodys = dict()
self.isExists = 0
self.variablePara = ""
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def appendBody(self, setid, bodyindex):
self.bodys.setdefault(setid, set()).add(bodyindex)
def setOptionMethod(self, optionstr):
if optionstr == "Liear Matrix":
self.optionindex = 0
elif optionstr == "Wire Matrix":
self.optionindex = 1
elif optionstr == "Large Matrix":
self.optionindex = 2
def setDirection1(self, dir10, dir11, dir12):
self.dir10 = dir10
self.dir11 = dir11
self.dir12 = dir12
def setReverseOfDirection1(self, revstr):
if revstr == "Yes":
self.reverse1 = 1
elif revstr == "No":
self.reverse1 = 0
def setMatrix(self, selectFeatures):
self.selectFeatures = selectFeatures
def setDistance1(self, dis1):
self.dis1 = dis1
def setCount1(self, count1):
self.count1 = count1
def showDirection2(self, showdir2str):
if showdir2str == "Yes":
self.showdir2 = 1
elif showdir2str == "No":
self.showdir2 = 0
def setDirection2(self, dir20, dir21, dir22):
self.dir20 = dir20
self.dir21 = dir21
self.dir22 = dir22
def setReverseOfDirection2(self, revstr):
if revstr == "Yes":
self.reverse2 = 1
elif revstr == "No":
self.reverse2 = 0
def setDistance2(self, dis2):
self.dis2 = dis2
def setCount2(self, count2):
self.count2 = count2
def setBasicPoint(self, basepoint0, basepoint1, basepoint2):
self.basept0 = basepoint0
self.basept1 = basepoint1
self.basept2 = basepoint2
def setAxis(self, axis0, axis1, axis2):
self.axis0 = axis0
self.axis1 = axis1
self.axis2 = axis2
def setWireReverse(self, wirerestr):
if wirerestr == "Yes":
self.wirereverse = 1
elif wirerestr == "No":
self.wirereverse = 0
def setWireCount(self, wirecount):
self.wirecount = wirecount
def setDegree(self, degree):
self.degree = degree
def setXYZDistance(self, dx, dy, dz):
self.DistanceX = dx
self.DistanceY = dy
self.DistanceZ = dz
def setXYZCount(self, cx, cy, cz):
self.CountX = cx
self.CountY = cy
self.CountZ = cz
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
keyList = self.bodys.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.bodys.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
bodystr = bytes(strcom, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.MakeMatrix(
c_int(self.coorSysID),
bodystr,
c_int(self.optionindex),
c_double(self.dir10),
c_double(self.dir11),
c_double(self.dir12),
c_int(self.reverse1),
c_double(self.dis1),
c_int(self.count1),
c_int(self.showdir2),
c_double(self.dir20),
c_double(self.dir21),
c_double(self.dir22),
c_int(self.reverse2),
c_double(self.dis2),
c_int(self.count2),
c_double(self.basept0),
c_double(self.basept1),
c_double(self.basept2),
c_double(self.axis0),
c_double(self.axis1),
c_double(self.axis2),
c_int(self.wirereverse),
c_int(self.wirecount),
c_double(self.degree),
c_double(self.DistanceX),
c_double(self.DistanceY),
c_double(self.DistanceZ),
c_int(self.CountX),
c_int(self.CountY),
c_int(self.CountZ),
c_int(self.selectFeatures),
c_bool(self.isExists),
variableParaStr,
)
del self
def edit(self):
keyList = self.bodys.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.bodys.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
bodystr = bytes(strcom, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.EditMatrix(
c_int(self.coorSysID),
c_int(self.editID),
bodystr,
c_int(self.optionindex),
c_double(self.dir10),
c_double(self.dir11),
c_double(self.dir12),
c_int(self.reverse1),
c_double(self.dis1),
c_int(self.count1),
c_int(self.showdir2),
c_double(self.dir20),
c_double(self.dir21),
c_double(self.dir22),
c_int(self.reverse2),
c_double(self.dis2),
c_int(self.count2),
c_double(self.basept0),
c_double(self.basept1),
c_double(self.basept2),
c_double(self.axis0),
c_double(self.axis1),
c_double(self.axis2),
c_int(self.wirereverse),
c_int(self.wirecount),
c_double(self.degree),
c_int(self.selectFeatures),
c_bool(self.isExists),
variableParaStr,
)
del self
class Extrusion:
def __init__(self):
self.edges = dict()
self.editID = -1
self.coorSysID = 0
self.pt0 = 0
self.pt1 = 0
self.pt2 = 0
self.distance = 10
self.reverse = "No"
self.solid = "Yes"
self.isExists = 0
self.variablePara = ""
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setName(self, name):
self.name = name
def setDistance(self, distance):
self.distance = distance
def setDirection(self, pt0, pt1, pt2):
self.pt0 = pt0
self.pt1 = pt1
self.pt2 = pt2
def appendEdge(self, geoset, index):
self.edges.setdefault(geoset, set()).add(index)
def Reverse(self, reverse):
self.reverse = reverse
def GenerateSolid(self, solid):
self.solid = solid
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
keyList = self.edges.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.edges.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
edgestr = bytes(strcom, encoding="utf-8")
reversestr = bytes(self.reverse, encoding="utf-8")
solidstr = bytes(self.solid, encoding="utf-8")
namestr = bytes(self.name, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreateExtrusion(
c_int(self.coorSysID),
c_int(self.editID),
namestr,
edgestr,
c_double(self.distance),
c_double(self.pt0),
c_double(self.pt1),
c_double(self.pt2),
reversestr,
solidstr,
c_bool(self.isExists),
variableParaStr,
)
def edit(self):
self.create()
class Revol:
def __init__(self):
self.edges = dict()
self.editID = -1
self.coorSysID = 0
self.basicpt0 = 0
self.basicpt1 = 0
self.basicpt2 = 0
self.coor0 = 0
self.coor1 = 0
self.coor2 = 0
self.degree = 90
self.reverse = "No"
self.solid = "Yes"
self.axisset = -1
self.edgeindex = -1
self.isExists = 0
self.variablePara = ""
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setName(self, name):
self.name = name
def setDegree(self, degree):
self.degree = degree
def setBasicPoint(self, basicpt0, basicpt1, basicpt2):
self.basicpt0 = basicpt0
self.basicpt1 = basicpt1
self.basicpt2 = basicpt2
def setAxisMethod(self, optionindex):
self.optionindex = optionindex
def setCoordinate(self, coor0, coor1, coor2):
self.coor0 = coor0
self.coor1 = coor1
self.coor2 = coor2
def selectAxisOnGeo(self, axisset, edgeindex):
self.axisset = axisset
self.edgeindex = edgeindex
def appendEdge(self, geoset, index):
self.edges.setdefault(geoset, set()).add(index)
def Reverse(self, reverse):
self.reverse = reverse
def GenerateSolid(self, solid):
self.solid = solid
def setIsExistsVariableParameter(self, isExists):
self.isExists = isExists
def setVariableHash(self, variableParameter):
self.variablePara = variableParameter
def create(self):
keyList = self.edges.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.edges.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
edgestr = bytes(strcom, encoding="utf-8")
reversestr = bytes(self.reverse, encoding="utf-8")
solidstr = bytes(self.solid, encoding="utf-8")
namestr = bytes(self.name, encoding="utf-8")
optionindexstr = bytes(self.optionindex, encoding="utf-8")
variableParaStr = bytes(self.variablePara, encoding="utf-8")
command.CreateRevol(
c_int(self.coorSysID),
c_int(self.editID),
namestr,
edgestr,
c_double(self.basicpt0),
c_double(self.basicpt1),
c_double(self.basicpt2),
c_double(self.degree),
optionindexstr,
c_int(self.axisset),
c_int(self.edgeindex),
c_double(self.coor0),
c_double(self.coor1),
c_double(self.coor2),
reversestr,
solidstr,
c_bool(self.isExists),
variableParaStr,
)
def edit(self):
self.create()
class Loft:
def __init__(self):
self.editID = -1
self.coorSysID = 0
self.solid = "No"
self.secstr = ""
def setEditID(self, id):
self.editID = id
def setCoorSysID(self, csid):
self.coorSysID = csid
def setName(self, name):
self.name = name
def isSolid(self, solid):
self.solid = solid
def appendSection(self, sec):
self.secstr += sec
self.secstr += " "
def create(self):
sectionstr = bytes(self.secstr, encoding="utf-8")
solidstr = bytes(self.solid, encoding="utf-8")
namestr = bytes(self.name, encoding="utf-8")
command.CreateLoft(
c_int(self.coorSysID), c_int(self.editID), namestr, solidstr, sectionstr
)
def edit(self):
self.create()
class Sweep:
def __init__(self):
self.edges = dict()
self.editID = -1
self.coorSysID = 0
self.solid = "No"
def setCoorSysID(self, csid):
self.coorSysID = csid
def appendEdge(self, geoset, index):
self.edges.setdefault(geoset, set()).add(index)
def setEditID(self, id):
self.editID = id
def setPath(self, pathset, pathedge):
self.pathset = pathset
self.pathedge = pathedge
def isSolid(self, solid):
self.solid = solid
def create(self):
keyList = self.edges.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.edges.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
edgestr = bytes(strcom, encoding="utf-8")
solidstr = bytes(self.solid, encoding="utf-8")
command.CreateSweep(
c_int(self.coorSysID),
c_int(self.editID),
edgestr,
solidstr,
c_int(self.pathset),
c_int(self.pathedge),
)
def edit(self):
self.create()
class GeoSplitter:
def __init__(self):
self.coorSysID = 0
self.modelTypeIndex = -1
self.faceindex = -1
self.facebody = -1
self.editID = -1
self.method = 0
self.planemethod = '"XOY"'
self.basepoint0 = 0
self.basepoint1 = 0
self.basepoint2 = 0
self.random0 = 0
self.random1 = 0
self.random2 = 0
self.bodys = dict()
def setCoorSysID(self, csid):
self.coorSysID = csid
def setSplitterModelType(self, modelTypeIndex):
self.modelType = modelTypeIndex
def appendBody(self, setid, bodyindex):
self.bodys.setdefault(setid, set()).add(bodyindex)
def setSymmetricPlaneMethod(self, method):
self.method = method
def setEditID(self, id):
self.editID = id
def setFace(self, facebody, faceindex):
self.facebody = facebody
self.faceindex = faceindex
def setPlaneMethod(self, planemethod):
self.planemethod = planemethod
def setDir(self, random0, random1, random2):
self.random0 = random0
self.random1 = random1
self.random2 = random2
def setBasePt(self, basepoint0, basepoint1, basepoint2):
self.basepoint0 = basepoint0
self.basepoint1 = basepoint1
self.basepoint2 = basepoint2
def create(self):
keyList = self.bodys.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.bodys.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
bodystr = bytes(strcom, encoding="utf-8")
methodstr = bytes(self.method, encoding="utf-8")
planemestr = bytes(self.planemethod, encoding="utf-8")
command.MakeGeoSplitter(
c_int(self.coorSysID),
c_int(self.modelType),
bodystr,
methodstr,
c_int(self.faceindex),
c_int(self.facebody),
planemestr,
c_double(self.random0),
c_double(self.random1),
c_double(self.random2),
c_double(self.basepoint0),
c_double(self.basepoint1),
c_double(self.basepoint2),
)
del self
def edit(self):
keyList = self.bodys.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.bodys.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
bodystr = bytes(strcom, encoding="utf-8")
methodstr = bytes(self.method, encoding="utf-8")
planemestr = bytes(self.planemethod, encoding="utf-8")
command.EditGeoSplitter(
c_int(self.coorSysID),
c_int(self.modelType),
c_int(self.editID),
bodystr,
methodstr,
c_int(self.faceindex),
c_int(self.facebody),
planemestr,
c_double(self.random0),
c_double(self.random1),
c_double(self.random2),
c_double(self.basepoint0),
c_double(self.basepoint1),
c_double(self.basepoint2),
)
del self
class FillHole:
def __init__(self):
self.faces = dict()
self.editID = -1
def appendFace(self, geoset, index):
self.faces.setdefault(geoset, set()).add(index)
def setEditID(self, id):
self.editID = id
def create(self):
keyList = self.faces.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.faces.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
facestr = bytes(strcom, encoding="utf-8")
command.MakeFillHole(facestr, c_int(self.editID))
def edit(self):
self.create()
class RemoveSurface:
def __init__(self):
self.faces = dict()
self.editID = -1
def appendFace(self, geoset, index):
self.faces.setdefault(geoset, set()).add(index)
def setEditID(self, id):
self.editID = id
def create(self):
keyList = self.faces.keys()
strcom = ""
for key in keyList:
setstr = ""
values = self.faces.get(key)
for v in values:
setstr = setstr + str(v) + ","
setstr = str(key) + ":" + setstr[:-1]
strcom = strcom + setstr + ";"
strcom = strcom[:-1]
facestr = bytes(strcom, encoding="utf-8")
command.MakeRemoveSurface(facestr, c_int(self.editID))
def edit(self):
self.create()
class FillGap:
def setEditID(self, id):
self.editID = id
def setFillGapType(self, type):
self.fillgaptype = type
def setIndexOfShape1(self, set1, body1Index):
self.set1 = set1
self.body1Index = body1Index
def setIndexOfShape2(self, set2, body2Index):
self.set2 = set2
self.body2Index = body2Index
def create(self):
typestr = bytes(self.fillgaptype, encoding="utf-8")
command.CreateFillGap(
typestr,
c_int(self.set1),
c_int(self.body1Index),
c_int(self.set2),
c_int(self.body2Index),
)
del self
def edit(self):
typestr = bytes(self.fillgaptype, encoding="utf-8")
command.EditFillGap(
c_int(self.editID),
typestr,
c_int(self.set1),
c_int(self.body1Index),
c_int(self.set2),
c_int(self.body2Index),
)
del self
class ModifyVariableParameter:
def __init__(self):
self.value = 0
self.variablePara = ""
def setVariableName(self, variableParameter):
self.variablePara = variableParameter
def setVariableValue(self, val):
self.value = val
def create(self):
variableParaStr = bytes(self.variablePara, encoding="utf-8")
variablevalueStr = bytes(self.value, encoding="utf-8")
command.MVP_setVariablePara(variableParaStr, variablevalueStr)
del self