def __init__(self, parent=None):
super(GLWidget, self).__init__(parent)
self.squares = []
self.width = 1000
self.height = 1000
self.running = False
self.square_size = 80
self.density = 50
self.grid_vao = -1
self.cell_vao = -1
self.cell_vbo = -1
self.grid_vbo = -1
self.timer = QTimer()
self.timer.setSingleShot(False)
self.timer.timeout.connect(self.step)
self.timer.start(500)
self.timer2 = QTimer()
self.timer2.setSingleShot(False)
self.timer2.timeout.connect(self.update_loop)
self.timer2.start(10)
self.white = QColor.fromCmykF(0, 0, 0, 0.0)
self.black = QColor.fromCmykF(1, 1, 1, 0.0)
self.gray = QColor.fromCmykF(0.5, 0.5, 0.5, 0.0)
def __init__(self, parent=None):
super(PWidgetGL, self).__init__(parent)
self.object = 0
self.xRot = 500
self.yRot = 500
self.zRot = 0
self.coordLength = 3.0
self.lastPos = QPoint()
self.rn = 0.0
self.Trn = 0.0
self.trolltechBlue = QColor.fromCmykF(1.0, 0.40, 0.0, 0.0)
self.trolltechRed = QColor.fromCmykF(0.0, 1.0, 0.40, 0.0)
self.trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.trolltechBlack = QColor.fromCmykF(0.0, 0.0, 0.0, 1.0)
self.timer = QTimer(self)
self.timer.timeout.connect(self.animate)
self.inited = False
self.rcount = 0
self.tcount = 0
self.vcount = 0.0
def __init__(self, parent=None):
super(GLWidget, self).__init__(parent)
midnight = QTime(0, 0, 0)
random.seed(midnight.secsTo(QTime.currentTime()))
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.image = QImage()
self.bubbles = []
self.lastPos = QPoint()
self.trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.trolltechPurple = QColor.fromCmykF(0.39, 0.39, 0.0, 0.0)
self.animationTimer = QTimer()
self.animationTimer.setSingleShot(False)
self.animationTimer.timeout.connect(self.animate)
self.animationTimer.start(25)
self.setAutoFillBackground(False)
self.setMinimumSize(200, 200)
self.setWindowTitle("Overpainting a Scene")
def __init__(self, parent=None):
QGLWidget.__init__(self, parent)
ObjectRotationManager.__init__(self)
self.object = 0
self.trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.trolltechPurple = QColor.fromCmykF(0.39, 0.39, 0.0, 0.0)
def __init__(self, parent=None):
super(GLWidget, self).__init__(parent)
midnight = QTime(0, 0, 0)
random.seed(midnight.secsTo(QTime.currentTime()))
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.image = QImage()
self.bubbles = []
self.lastPos = QPoint()
self.trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.trolltechPurple = QColor.fromCmykF(0.39, 0.39, 0.0, 0.0)
self.animationTimer = QTimer()
self.animationTimer.setSingleShot(False)
self.animationTimer.timeout.connect(self.animate)
self.animationTimer.start(25)
self.setAutoFillBackground(False)
self.setMinimumSize(200, 200)
self.setWindowTitle("Overpainting a Scene")
def __init__(self, parent=None):
super(GLWidget, self).__init__(parent)
self.timer = QTimer(self)
self.timer.setSingleShot(False)
self.timer.setInterval(16)
self.timer.timeout.connect(self.animateFigures)
self.timer.start()
# parameters of the robot (square base)
# length of arms of the robot
self.fl = 0.4
self.sl = 0.3
self.tl = 0.3
# width of arms of the robot
self.width = 0.1
# distance from each joint to end edge of the robot
self.free_dist = 0.05
# 0 - rotation, 1 - position
self.mode = 0
# start position of the handle
self.x = 0
self.y = 0
self.z = 0.9
# target position of the handle
self.xTarget = 0
self.yTarget = 0
self.zTarget = 0.9
# camera settings
self.xRot = 60 * 16
self.yRot = 0 * 16
self.zRot = 0 * 16
self.cameraDepth = 0.7
self.cameraTransX = 0.0
self.cameraTransY = 0.2
# start position of joints
self.curFirstRotate = 0.0
self.curSecondRotate = 0.0
self.curThirdRotate = 0.0
# target position of joints
self.targetFirstRotate = 0.0
self.targetSecondRotate = 0.0
self.targetThirdRotate = 0.0
# result precesion for minimizing algorithm
self.precision = 1e-1
#
self.model = ModelLoader("models//sphere//point.obj")
self.lastPos = QPoint()
self.colorRed = QColor.fromRgbF(1.0, 0.0, 0.0, 0.0)
self.colorBlue = QColor.fromRgbF(0.0, 0.0, 1.0, 0.0)
self.colorGreen2 = QColor.fromRgbF(0.0, 1.0, 0.0, 0.0)
self.colorGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.colorPurple = QColor.fromCmykF(0.39, 0.39, 0.0, 0.0)
self.colorGray = QColor.fromCmykF(0.5, 0.5, 0.5, 0.5)
self.setMinimumSize(500, 500)
def __init__(self, parent=None):
super(GLWidget, self).__init__(parent)
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.lastPos = QPoint()
self.trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.trolltechPurple = QColor.fromCmykF(0.39, 0.39, 0.0, 0.0)
def __init__(self, parent=None):
super(GLWidget, self).__init__(parent)
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.lastPos = QPoint()
self.trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.trolltechPurple = QColor.fromCmykF(0.39, 0.39, 0.0, 0.0)
def __init__(self, parent=None):
super(PWidgetGL, self).__init__(parent)
self.object = 0
self.xRot = 500
self.yRot = 500
self.zRot = 0
self.coordLength = 3.0
self.lastPos = QPoint()
self.rn = 50
self.Trn = 1
self.dt = 0.1
self.rad = np.zeros(self.rn+1, float)
self.Trad = np.zeros(self.Trn+1, float)
self.colr = np.zeros(self.rn+1, float)
self.colg = np.zeros(self.rn+1, float)
self.colb = np.zeros(self.rn+1, float)
self.Tcolr = np.zeros(self.Trn+1, float)
self.Tcolg = np.zeros(self.Trn+1, float)
self.Tcolb = np.zeros(self.Trn+1, float)
self.rx = np.zeros(self.rn+1, float)
self.ry = np.zeros(self.rn+1, float)
self.rz = np.zeros(self.rn+1, float)
self.Trx = np.zeros(self.Trn+1, float)
self.Try = np.zeros(self.Trn+1, float)
self.Trz = np.zeros(self.Trn+1, float)
self.vx = np.zeros(self.rn+1, float)
self.vy = np.zeros(self.rn+1, float)
self.vz = np.zeros(self.rn+1, float)
self.Tvx = np.zeros(self.Trn+1, float)
self.Tvy = np.zeros(self.Trn+1, float)
self.Tvz = np.zeros(self.Trn+1, float)
self.dx = np.zeros(self.rn+1, float)
self.dy = np.zeros(self.rn+1, float)
self.dz = np.zeros(self.rn+1, float)
self.trolltechBlue = QColor.fromCmykF(1.0, 0.40, 0.0, 0.0)
self.trolltechRed = QColor.fromCmykF(0.0, 1.0, 0.40, 0.0)
self.trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.trolltechBlack = QColor.fromCmykF(0.0, 0.0, 0.0, 1.0)
self.timer = QTimer(self)
self.timer.timeout.connect(self.animate)
def __init__(self, *args):
super().__init__(args[0])
print(args[0])
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.lastPos = QPoint()
self.trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.trolltechGreen.setNamedColor('#C239B3')
self.trolltechPurple = QColor.fromCmykF(0.39, 0.39, 0.0, 0.0)
self.trolltechPurple.setNamedColor('#EDCAE3')
def __init__(self, parent=None):
super(GLWidget, self).__init__(parent)
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.lastPos = QPoint()
# 设置QT图形颜色，静态函数fromRgb(), fromHsv(),fromCmyk()可以通过指定特定值返回需要的颜色
# CYMK:青色Cyan、洋红色Magenta、黄色Yellow，黑色Black
self.trolltechGreen = QColor.fromCmykF(0.50, 0.50, 0.1, 0.0)
# 设置界面背景色
self.trolltechPurple = QColor.fromCmykF(0.39, 0.39, 0.39, 0.0)
def set_strategy(self, strategy):
greenium = QColor.fromCmykF(0.7,0,0.9,0)
#greenium.setAlphaF(0.2)
for id_, pos in strategy['strategy']['map']['waypoints'].items():
wp = self._scene.addEllipse(QRectF(pos[0]-10,pos[1]-10,20,20),QPen(), QBrush(greenium))
self._waypoints.append(wp)
for id_, pose in strategy['strategy']['map']['poses'].items():
p = strategy['strategy']['map']['waypoints'][pose[0]]
path = QPainterPath()
cos_ = math.cos(pose[1] * math.pi / 180)
sin_ = math.sin(pose[1] * math.pi / 180)
l = 40
w = 20
path.moveTo(p[0] + l * cos_, p[1] + l * sin_)
path.lineTo(p[0] -l * cos_ + w * sin_, p[1] - l * sin_ - w * cos_)
path.lineTo(p[0] -l * cos_ - w * sin_, p[1] - l * sin_ + w * cos_)
path.closeSubpath()
itm = self._scene.addPath(path, QPen(), QBrush(greenium))
for id_, area in strategy['strategy']['map']['areas'].items():
path = QPainterPath()
v = area['vertices'][0]
path.moveTo(v[0], v[1])
for v in area['vertices'][1:]:
path.lineTo(v[0], v[1])
path.closeSubpath()
itm = self._scene.addPath(path, QPen(), QBrush(greenium))
self._waypoints.append(wp)
def __init__(self, core, parent=None):
super(BirdEyeView, self).__init__(parent)
self.core = core
# widget size
self._width = 700
self._height = 700
self.setMaximumSize(self._width, self._height)
self.setMinimumSize(self._width, self._height)
# draw prediction
self._drawPredict = False
self._drawPredictHypo = False
self._drawPredictObject = False
# world coordinate
self._rulerScale = 5
self._size_x = 100
self._size_y = 100
self._x_center = -10
self._y_center = 0
self.center = False
self._x_center_fix = 0
self._y_center_fix = 0
# background color
self.trolltechPurple = QColor.fromCmykF(0.29, 0.29, 0.0, 0.0)
def makeObject(self):
genList = gl.glGenLists(1)
gl.glNewList(genList, gl.GL_COMPILE)
self.setColor(QColor.fromCmykF(1.0, 0.0, 0.0, 0.0))
gl.glBegin(gl.GL_QUADS)
gl.glNormal3d(0.0, 1.0, 0.0)
gl.glVertex3d(-0.5, 0.5, 0.5)
gl.glVertex3d(0.5, 0.5, 0.5)
gl.glVertex3d(0.5, 0.5, -0.5)
gl.glVertex3d(-0.5, 0.5, -0.5)
gl.glEnd()
gl.glBegin(gl.GL_QUADS)
gl.glNormal3d(0.0, 0.0, 1.0)
gl.glVertex3d(0.5, -0.5, 0.5)
gl.glVertex3d(0.5, 0.5, 0.5)
gl.glVertex3d(-0.5, 0.5, 0.5)
gl.glVertex3d(-0.5, -0.5, 0.5)
gl.glEnd()
gl.glBegin(gl.GL_QUADS)
gl.glNormal3d(1.0, 0.0, 0.0)
gl.glVertex3d(0.5, 0.5, -0.5)
gl.glVertex3d(0.5, 0.5, 0.5)
gl.glVertex3d(0.5, -0.5, 0.5)
gl.glVertex3d(0.5, -0.5, -0.5)
gl.glEnd()
gl.glEndList()
return genList
def __init__(self, parent=None):
super(GLWidget, self).__init__(parent)
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.boomLength = 5
self.xOffset = 0
self.yOffset = 0
self.frame = 0
self.paused = False
self.lastPos = QPoint()
self.trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.trolltechPurple = QColor.fromCmykF(0.39, 0.39, 0.0, 0.0)
def __init__(self, parent=None, width=945, height=355):
super(GLWidget, self).__init__(parent)
self.parent = parent
self.glwidth = width
self.glheight = height
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.lastPos = QPoint()
self.trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.trolltechPurple = QColor.fromCmykF(0.39, 0.39, 0.0, 0.0)
def __init__(self, parent=None):
super(LegendWidget, self).__init__(parent)
# widget size
self._width = 200
self._height = 100
self.setMaximumSize(self._width, self._height)
self.setMinimumSize(self._width, self._height)
self.trolltechPurple = QColor.fromCmykF(0.29, 0.29, 0.0, 0.0)
def __init__(self, parent=None):
super(GLWidget, self).__init__(parent)
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.ratio = 1
self.xTra = 0
self.yTra = 0
self.lastPos = QPoint()
self.loader = loader()
self.loader.load_stl('1.STL')
self.maxsize = self.loader.get_maxsize()
self.trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.trolltechPurple = QColor.fromCmykF(0.39, 0.39, 0.0, 0.0)
def __init__(self, parent=None):
super(GLWidget, self).__init__(parent)
self.xRot = 120
self.yRot = 0
self.zRot = -70
self.lastPos = QPoint()
self.bg_color = QColor.fromCmykF(0.39, 0.39, 0.0, 0.0)
self.coordinates = CoordinateSystem()
def __init__(self, parent=None):
super(PWidgetGL3, self).__init__(parent)
self.object = 0
self.xRot = 500
self.yRot = 500
self.zRot = 0
self.coordLength = 3.0
self.lastPos = QPoint()
self.sensors = []
self.targets = []
self.trolltechBlue = QColor.fromCmykF(1.0, 0.40, 0.0, 0.0)
self.trolltechRed = QColor.fromCmykF(0.0, 1.0, 0.40, 0.0)
self.trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.trolltechBlack = QColor.fromCmykF(0.0, 0.0, 0.0, 1.0)
self.timer = QTimer(self)
self.timer.timeout.connect(self.animate)
def makeObject(self):
trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
NumSectors = 15
x1 = +0.06
y1 = -0.14
x2 = +0.14
y2 = -0.06
x3 = +0.08
y3 = +0.00
x4 = +0.30
y4 = +0.22
self.list_ = GL.glGenLists(1)
GL.glNewList(self.list_, GL.GL_COMPILE)
for i in range(NumSectors):
angle1 = float((i * 2 * math.pi) / NumSectors)
x5 = 0.30 * math.sin(angle1)
y5 = 0.30 * math.cos(angle1)
x6 = 0.20 * math.sin(angle1)
y6 = 0.20 * math.cos(angle1)
angle2 = float(((i + 1) * 2 * math.pi) / NumSectors)
x7 = 0.20 * math.sin(angle2)
y7 = 0.20 * math.cos(angle2)
x8 = 0.30 * math.sin(angle2)
y8 = 0.30 * math.cos(angle2)
self.qglColor(trolltechGreen)
self.quad(GL.GL_QUADS, x5, y5, x6, y6, x7, y7, x8, y8)
self.qglColor(Qt.black)
self.quad(GL.GL_LINE_LOOP, x5, y5, x6, y6, x7, y7, x8, y8)
self.qglColor(trolltechGreen)
self.quad(GL.GL_QUADS, x1, y1, x2, y2, y2, x2, y1, x1)
self.quad(GL.GL_QUADS, x3, y3, x4, y4, y4, x4, y3, x3)
self.qglColor(Qt.black)
self.quad(GL.GL_LINE_LOOP, x1, y1, x2, y2, y2, x2, y1, x1)
self.quad(GL.GL_LINE_LOOP, x3, y3, x4, y4, y4, x4, y3, x3)
GL.glEndList()
def makeObject(self):
trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
NumSectors = 15
x1 = +0.06
y1 = -0.14
x2 = +0.14
y2 = -0.06
x3 = +0.08
y3 = +0.00
x4 = +0.30
y4 = +0.22
self.list_ = GL.glGenLists(1)
GL.glNewList(self.list_, GL.GL_COMPILE)
for i in range(NumSectors):
angle1 = float((i * 2 * math.pi) / NumSectors)
x5 = 0.30 * math.sin(angle1)
y5 = 0.30 * math.cos(angle1)
x6 = 0.20 * math.sin(angle1)
y6 = 0.20 * math.cos(angle1)
angle2 = float(((i + 1) * 2 * math.pi) / NumSectors)
x7 = 0.20 * math.sin(angle2)
y7 = 0.20 * math.cos(angle2)
x8 = 0.30 * math.sin(angle2)
y8 = 0.30 * math.cos(angle2)
self.qglColor(trolltechGreen)
self.quad(GL.GL_QUADS, x5, y5, x6, y6, x7, y7, x8, y8)
self.qglColor(Qt.black)
self.quad(GL.GL_LINE_LOOP, x5, y5, x6, y6, x7, y7, x8, y8)
self.qglColor(trolltechGreen)
self.quad(GL.GL_QUADS, x1, y1, x2, y2, y2, x2, y1, x1)
self.quad(GL.GL_QUADS, x3, y3, x4, y4, y4, x4, y3, x3)
self.qglColor(Qt.black)
self.quad(GL.GL_LINE_LOOP, x1, y1, x2, y2, y2, x2, y1, x1)
self.quad(GL.GL_LINE_LOOP, x3, y3, x4, y4, y4, x4, y3, x3)
GL.glEndList()
def __init__(self, parent=None, cst0=0, csp0=0, csbs0=1.0):
super(QAntennaViewer, self).__init__(parent)
#OpenGL call lists
self.substrate = 0
self.beamPattern = 0
self.axisLines = 0
self.currentSettings = 0
self.xRot = 0
self.zoom = 1.0
self.zRot = 0
self.lastPos = QPoint()
self.xAxisRed = QColor.fromCmykF(0.0, 1.0, 1.0, 0.18)
self.yAxisGreen = QColor.fromCmykF(1.0, 0.0, 1.0, 0.21)
self.zAxisBlue = QColor.fromCmykF(1.0, 1.0, 0.0, .19)
self.csColor = QColor.fromCmykF(0.29, 0.32, 0, 0.71)
self.backgroundPurple = QColor.fromCmykF(0.39, 0.39, 0.0, 0.0)
self.substrateColor = QColor.fromCmykF(0.57, 0, 0.76, 0.77)
self.antennaColor = QColor.fromCmykF(0, 0.17, 0.93, 0.16)
#Drawn antenna factor pattern
self.afPoints = []
self.afNPhi = 0 #number of phi points
self.afNTheta = 0 #number of theta points
self.afBeamScale = 0.5
self.beamTransparancy = 200
self.dirtyBeamPattern = False
self.dirtyCurrentSettings = True
self.dirtyAntennaBox = True
#current setting vector
self.csTheta = cst0
self.csPhi = csp0
self.csBeamScale = csbs0
#draw options
self.drawAxis = True
self.antenna4x1 = True
class GLWidget(CanvasBase):
CAM_LEFT_X = -0.5
CAM_RIGHT_X = 0.5
CAM_BOTTOM_Y = 0.5
CAM_TOP_Y = -0.5
CAM_NEAR_Z = -14.0
CAM_FAR_Z = 14.0
COLOR_BACKGROUND = QColor.fromHsl(160, 0, 255, 255)
COLOR_NORMAL = QColor.fromCmykF(1.0, 0.5, 0.0, 0.0, 1.0)
COLOR_SELECT = QColor.fromCmykF(0.0, 1.0, 0.9, 0.0, 1.0)
COLOR_NORMAL_DISABLED = QColor.fromCmykF(1.0, 0.5, 0.0, 0.0, 0.25)
COLOR_SELECT_DISABLED = QColor.fromCmykF(0.0, 1.0, 0.9, 0.0, 0.25)
COLOR_ENTRY_ARROW = QColor.fromRgbF(0.0, 0.0, 1.0, 1.0)
COLOR_EXIT_ARROW = QColor.fromRgbF(0.0, 1.0, 0.0, 1.0)
COLOR_ROUTE = QColor.fromRgbF(0.5, 0.0, 0.0, 1.0)
COLOR_STMOVE = QColor.fromRgbF(0.5, 0.0, 0.25, 1.0)
COLOR_BREAK = QColor.fromRgbF(1.0, 0.0, 1.0, 0.7)
COLOR_LEFT = QColor.fromHsl(134, 240, 130, 255)
COLOR_RIGHT = QColor.fromHsl(186, 240, 130, 255)
def __init__(self, parent=None):
super(GLWidget, self).__init__(parent)
self.shapes = Shapes([])
self.orientation = 0
self.wpZero = 0
self.routearrows = []
self.expprv = None
self.isPanning = False
self.isRotating = False
self.isMultiSelect = False
self._lastPos = QPoint()
self.posX = 0.0
self.posY = 0.0
self.posZ = 0.0
self.rotX = 0.0
self.rotY = 0.0
self.rotZ = 0.0
self.scale = 1.0
self.scaleCorr = 1.0
self.showPathDirections = False
self.showDisabledPaths = False
self.topLeft = Point()
self.bottomRight = Point()
self.tol = 0
def tr(self, string_to_translate):
"""
Translate a string using the QCoreApplication translation framework
@param string_to_translate: a unicode string
@return: the translated unicode string if it was possible to translate
"""
return text_type(
QCoreApplication.translate('GLWidget', string_to_translate))
def resetAll(self):
# the wpzero is currently generated "last"
if self.wpZero > 0:
GL.glDeleteLists(self.orientation + 1,
self.wpZero - self.orientation)
self.shapes = Shapes([])
self.wpZero = 0
self.delete_opt_paths()
self.posX = 0.0
self.posY = 0.0
self.posZ = 0.0
self.rotX = 0.0
self.rotY = 0.0
self.rotZ = 0.0
self.scale = 1.0
self.topLeft = Point()
self.bottomRight = Point()
self.update()
def delete_opt_paths(self):
if len(self.routearrows) > 0:
GL.glDeleteLists(self.routearrows[0][2], len(self.routearrows))
self.routearrows = []
def addexproutest(self):
self.expprv = Point3D(
g.config.vars.Plane_Coordinates['axis1_start_end'],
g.config.vars.Plane_Coordinates['axis2_start_end'], 0)
def addexproute(self, exp_order, layer_nr):
"""
This function initialises the Arrows of the export route order and its numbers.
"""
for shape_nr in range(len(exp_order)):
shape = self.shapes[exp_order[shape_nr]]
st = self.expprv
en, self.expprv = shape.get_start_end_points_physical()
en = en.to3D(shape.axis3_start_mill_depth)
self.expprv = self.expprv.to3D(shape.axis3_mill_depth)
self.routearrows.append([st, en, 0])
# TODO self.routetext.append(RouteText(text=("%s,%s" % (layer_nr, shape_nr+1)), startp=en))
def addexprouteen(self):
st = self.expprv
en = Point3D(g.config.vars.Plane_Coordinates['axis1_start_end'],
g.config.vars.Plane_Coordinates['axis2_start_end'], 0)
self.routearrows.append([st, en, 0])
for route in self.routearrows:
route[2] = self.makeRouteArrowHead(route[0], route[1])
def contextMenuEvent(self, event):
if not self.isRotating:
clicked, offset, _ = self.getClickedDetails(event)
MyDropDownMenu(self, event.globalPos(), clicked, offset)
def setXRotation(self, angle):
self.rotX = self.normalizeAngle(angle)
def setYRotation(self, angle):
self.rotY = self.normalizeAngle(angle)
def setZRotation(self, angle):
self.rotZ = self.normalizeAngle(angle)
def normalizeAngle(self, angle):
return (angle - 180) % -360 + 180
def mousePressEvent(self, event):
if self.isPanning or self.isRotating:
self.setCursor(Qt.ClosedHandCursor)
elif event.button() == Qt.LeftButton:
clicked, offset, tol = self.getClickedDetails(event)
xyForZ = {}
for shape in self.shapes:
hit = False
z = shape.axis3_start_mill_depth
if z not in xyForZ:
xyForZ[z] = self.determineSelectedPosition(
clicked, z, offset)
hit |= shape.isHit(xyForZ[z], tol)
if not hit:
z = shape.axis3_mill_depth
if z not in xyForZ:
xyForZ[z] = self.determineSelectedPosition(
clicked, z, offset)
hit |= shape.isHit(xyForZ[z], tol)
if self.isMultiSelect and shape.selected:
hit = not hit
if hit != shape.selected:
g.window.TreeHandler.updateShapeSelection(shape, hit)
shape.selected = hit
self.update()
self._lastPos = event.pos()
def getClickedDetails(self, event):
min_side = min(self.frameSize().width(), self.frameSize().height())
clicked = Point(
(event.pos().x() - self.frameSize().width() / 2),
(event.pos().y() -
self.frameSize().height() / 2)) / min_side / self.scale
offset = Point3D(-self.posX, -self.posY, -self.posZ) / self.scale
tol = 4 * self.scaleCorr / min_side / self.scale
return clicked, offset, tol
def determineSelectedPosition(self, clicked, forZ, offset):
angleX = -radians(self.rotX)
angleY = -radians(self.rotY)
zv = forZ - offset.z
clickedZ = ((zv + clicked.x * sin(angleY)) / cos(angleY) -
clicked.y * sin(angleX)) / cos(angleX)
sx, sy, sz = self.deRotate(clicked.x, clicked.y, clickedZ)
return Point(sx + offset.x, -sy - offset.y) #, sz + offset.z
def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton or event.button() == Qt.RightButton:
if self.isPanning:
self.setCursor(Qt.OpenHandCursor)
elif self.isRotating:
self.setCursor(Qt.PointingHandCursor)
def mouseMoveEvent(self, event):
dx = event.pos().x() - self._lastPos.x()
dy = event.pos().y() - self._lastPos.y()
if self.isRotating:
if event.buttons() == Qt.LeftButton:
self.setXRotation(self.rotX - dy / 2)
self.setYRotation(self.rotY + dx / 2)
elif event.buttons() == Qt.RightButton:
self.setXRotation(self.rotX - dy / 2)
self.setZRotation(self.rotZ + dx / 2)
elif self.isPanning:
if event.buttons() == Qt.LeftButton:
min_side = min(self.frameSize().width(),
self.frameSize().height())
dx, dy, dz = self.deRotate(dx, dy, 0)
self.posX += dx / min_side
self.posY += dy / min_side
self.posZ += dz / min_side
self._lastPos = event.pos()
self.update()
def wheelEvent(self, event):
min_side = min(self.frameSize().width(), self.frameSize().height())
x = (event.pos().x() - self.frameSize().width() / 2) / min_side
y = (event.pos().y() - self.frameSize().height() / 2) / min_side
s = 1.001**event.angleDelta().y()
x, y, z = self.deRotate(x, y, 0)
self.posX = (self.posX - x) * s + x
self.posY = (self.posY - y) * s + y
self.posZ = (self.posZ - z) * s + z
self.scale *= s
self.update()
def rotate(self, x, y, z):
angleZ = radians(self.rotZ)
x, y, z = x * cos(angleZ) - y * sin(angleZ), x * sin(angleZ) + y * cos(
angleZ), z
angleY = radians(self.rotY)
x, y, z = x * cos(angleY) + z * sin(angleY), y, -x * sin(
angleY) + z * cos(angleY)
angleX = radians(self.rotX)
return x, y * cos(angleX) - z * sin(angleX), y * sin(angleX) + z * cos(
angleX)
def deRotate(self, x, y, z):
angleX = -radians(self.rotX)
x, y, z = x, y * cos(angleX) - z * sin(angleX), y * sin(
angleX) + z * cos(angleX)
angleY = -radians(self.rotY)
x, y, z = x * cos(angleY) + z * sin(angleY), y, -x * sin(
angleY) + z * cos(angleY)
angleZ = -radians(self.rotZ)
return x * cos(angleZ) - y * sin(angleZ), x * sin(angleZ) + y * cos(
angleZ), z
def getRotationVectors(self, orgRefVector, toRefVector):
"""
Generate a rotation matrix such that toRefVector = matrix * orgRefVector
@param orgRefVector: A 3D unit vector
@param toRefVector: A 3D unit vector
@return: 3 vectors such that matrix = [vx; vy; vz]
"""
# based on:
# http://math.stackexchange.com/questions/180418/calculate-rotation-matrix-to-align-vector-a-to-vector-b-in-3d
if orgRefVector == toRefVector:
return Point3D(1, 0, 0), Point3D(0, 1, 0), Point3D(0, 0, 1)
v = orgRefVector.cross_product(toRefVector)
mn = (1 - orgRefVector * toRefVector) / v.length_squared()
vx = Point3D(
1, -v.z,
v.y) + mn * Point3D(-v.y**2 - v.z**2, v.x * v.y, v.x * v.z)
vy = Point3D(
v.z, 1,
-v.x) + mn * Point3D(v.x * v.y, -v.x**2 - v.z**2, v.y * v.z)
vz = Point3D(-v.y, v.x,
1) + mn * Point3D(v.x * v.z, v.y * v.z, -v.x**2 - v.y**2)
return vx, vy, vz
def initializeGL(self):
logger.debug(
self.tr("Using OpenGL version: %s") %
GL.glGetString(GL.GL_VERSION).decode("utf-8"))
self.setClearColor(GLWidget.COLOR_BACKGROUND)
GL.glEnable(GL.GL_MULTISAMPLE)
GL.glEnable(GL.GL_POLYGON_SMOOTH)
GL.glHint(GL.GL_POLYGON_SMOOTH_HINT, GL.GL_NICEST)
# GL.glPolygonMode(GL.GL_FRONT_AND_BACK, GL.GL_LINE)
GL.glShadeModel(GL.GL_SMOOTH)
GL.glEnable(GL.GL_DEPTH_TEST)
GL.glEnable(GL.GL_CULL_FACE)
# GL.glEnable(GL.GL_LIGHTING)
# GL.glEnable(GL.GL_LIGHT0)
GL.glEnable(GL.GL_BLEND)
GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA)
# GL.glLightfv(GL.GL_LIGHT0, GL.GL_POSITION, (0.5, 5.0, 7.0, 1.0))
# GL.glEnable(GL.GL_NORMALIZE)
self.drawOrientationArrows()
def paintGL(self):
# The last transformation you specify takes place first.
GL.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT)
GL.glLoadIdentity()
GL.glRotatef(self.rotX, 1.0, 0.0, 0.0)
GL.glRotatef(self.rotY, 0.0, 1.0, 0.0)
GL.glRotatef(self.rotZ, 0.0, 0.0, 1.0)
GL.glTranslatef(self.posX, self.posY, self.posZ)
GL.glScalef(self.scale, self.scale, self.scale)
for shape in self.shapes.selected_iter():
if not shape.disabled:
self.setColor(GLWidget.COLOR_STMOVE)
GL.glCallList(shape.drawStMove)
self.setColor(GLWidget.COLOR_SELECT)
GL.glCallList(shape.drawObject)
elif self.showDisabledPaths:
self.setColor(GLWidget.COLOR_SELECT_DISABLED)
GL.glCallList(shape.drawObject)
for shape in self.shapes.not_selected_iter():
if not shape.disabled:
if shape.parentLayer.isBreakLayer():
self.setColor(GLWidget.COLOR_BREAK)
elif shape.cut_cor == 41:
self.setColor(GLWidget.COLOR_LEFT)
elif shape.cut_cor == 42:
self.setColor(GLWidget.COLOR_RIGHT)
else:
self.setColor(GLWidget.COLOR_NORMAL)
GL.glCallList(shape.drawObject)
if self.showPathDirections:
self.setColor(GLWidget.COLOR_STMOVE)
GL.glCallList(shape.drawStMove)
elif self.showDisabledPaths:
self.setColor(GLWidget.COLOR_NORMAL_DISABLED)
GL.glCallList(shape.drawObject)
# optimization route arrows
self.setColor(GLWidget.COLOR_ROUTE)
GL.glBegin(GL.GL_LINES)
for route in self.routearrows:
start = route[0]
end = route[1]
GL.glVertex3f(start.x, -start.y, start.z)
GL.glVertex3f(end.x, -end.y, end.z)
GL.glEnd()
GL.glScalef(self.scaleCorr / self.scale, self.scaleCorr / self.scale,
self.scaleCorr / self.scale)
scaleArrow = self.scale / self.scaleCorr
for route in self.routearrows:
end = scaleArrow * route[1]
GL.glTranslatef(end.x, -end.y, end.z)
GL.glCallList(route[2])
GL.glTranslatef(-end.x, end.y, -end.z)
# direction arrows
for shape in self.shapes:
if shape.selected and (not shape.disabled or self.showDisabledPaths) or\
self.showPathDirections and not shape.disabled:
start, end = shape.get_start_end_points_physical()
start = scaleArrow * start.to3D(shape.axis3_start_mill_depth)
end = scaleArrow * end.to3D(shape.axis3_mill_depth)
GL.glTranslatef(start.x, -start.y, start.z)
GL.glCallList(shape.drawArrowsDirection[0])
GL.glTranslatef(-start.x, start.y, -start.z)
GL.glTranslatef(end.x, -end.y, end.z)
GL.glCallList(shape.drawArrowsDirection[1])
GL.glTranslatef(-end.x, end.y, -end.z)
if self.wpZero > 0:
GL.glCallList(self.wpZero)
GL.glTranslatef(-self.posX / self.scaleCorr,
-self.posY / self.scaleCorr,
-self.posZ / self.scaleCorr)
GL.glCallList(self.orientation)
def resizeGL(self, width, height):
GL.glViewport(0, 0, width, height)
side = min(width, height)
GL.glMatrixMode(GL.GL_PROJECTION)
GL.glLoadIdentity()
if width >= height:
scale_x = width / height
GL.glOrtho(GLWidget.CAM_LEFT_X * scale_x,
GLWidget.CAM_RIGHT_X * scale_x, GLWidget.CAM_BOTTOM_Y,
GLWidget.CAM_TOP_Y, GLWidget.CAM_NEAR_Z,
GLWidget.CAM_FAR_Z)
else:
scale_y = height / width
GL.glOrtho(GLWidget.CAM_LEFT_X, GLWidget.CAM_RIGHT_X,
GLWidget.CAM_BOTTOM_Y * scale_y,
GLWidget.CAM_TOP_Y * scale_y, GLWidget.CAM_NEAR_Z,
GLWidget.CAM_FAR_Z)
self.scaleCorr = 400 / side
GL.glMatrixMode(GL.GL_MODELVIEW)
def setClearColor(self, c):
GL.glClearColor(c.redF(), c.greenF(), c.blueF(), c.alphaF())
def setColor(self, c):
self.setColorRGBA(c.redF(), c.greenF(), c.blueF(), c.alphaF())
def setColorRGBA(self, r, g, b, a):
# GL.glMaterialfv(GL.GL_FRONT, GL.GL_DIFFUSE, (r, g, b, a))
GL.glColor4f(r, g, b, a)
def plotAll(self, shapes):
for shape in shapes:
self.paint_shape(shape)
self.shapes.append(shape)
self.drawWpZero()
def repaint_shape(self, shape):
GL.glDeleteLists(shape.drawObject, 4)
self.paint_shape(shape)
def paint_shape(self, shape):
shape.drawObject = self.makeShape(shape) # 1 object
shape.stmove = StMove(shape)
shape.drawStMove = self.makeStMove(shape.stmove) # 1 object
shape.drawArrowsDirection = self.makeDirArrows(shape) # 2 objects
def makeShape(self, shape):
genList = GL.glGenLists(1)
GL.glNewList(genList, GL.GL_COMPILE)
GL.glBegin(GL.GL_LINES)
shape.make_path(self.drawHorLine, self.drawVerLine)
GL.glEnd()
GL.glEndList()
self.topLeft.detTopLeft(shape.topLeft)
self.bottomRight.detBottomRight(shape.bottomRight)
return genList
def makeStMove(self, stmove):
genList = GL.glGenLists(1)
GL.glNewList(genList, GL.GL_COMPILE)
GL.glBegin(GL.GL_LINES)
stmove.make_path(self.drawHorLine, self.drawVerLine)
GL.glEnd()
GL.glEndList()
return genList
def drawHorLine(self, caller, Ps, Pe):
GL.glVertex3f(Ps.x, -Ps.y, caller.axis3_start_mill_depth)
GL.glVertex3f(Pe.x, -Pe.y, caller.axis3_start_mill_depth)
GL.glVertex3f(Ps.x, -Ps.y, caller.axis3_mill_depth)
GL.glVertex3f(Pe.x, -Pe.y, caller.axis3_mill_depth)
def drawVerLine(self, caller, Ps):
GL.glVertex3f(Ps.x, -Ps.y, caller.axis3_start_mill_depth)
GL.glVertex3f(Ps.x, -Ps.y, caller.axis3_mill_depth)
def drawOrientationArrows(self):
rCone = 0.01
rCylinder = 0.004
zTop = 0.05
zMiddle = 0.02
zBottom = -0.03
segments = 20
arrow = GL.glGenLists(1)
GL.glNewList(arrow, GL.GL_COMPILE)
self.drawCone(Point(), rCone, zTop, zMiddle, segments)
self.drawSolidCircle(Point(), rCone, zMiddle, segments)
self.drawCylinder(Point(), rCylinder, zMiddle, zBottom, segments)
self.drawSolidCircle(Point(), rCylinder, zBottom, segments)
GL.glEndList()
self.orientation = GL.glGenLists(1)
GL.glNewList(self.orientation, GL.GL_COMPILE)
self.setColorRGBA(0.0, 0.0, 1.0, 0.5)
GL.glCallList(arrow)
GL.glRotatef(90, 0, 1, 0)
self.setColorRGBA(1.0, 0.0, 0.0, 0.5)
GL.glCallList(arrow)
GL.glRotatef(90, 1, 0, 0)
self.setColorRGBA(0.0, 1.0, 0.0, 0.5)
GL.glCallList(arrow)
GL.glEndList()
def drawWpZero(self):
r = 0.02
segments = 20 # must be a multiple of 4
self.wpZero = GL.glGenLists(1)
GL.glNewList(self.wpZero, GL.GL_COMPILE)
self.setColorRGBA(0.2, 0.2, 0.2, 0.7)
self.drawSphere(r, segments, segments // 4, segments, segments // 4)
GL.glBegin(GL.GL_TRIANGLE_FAN)
GL.glVertex3f(0, 0, 0)
for i in range(segments // 4 + 1):
ang = -i * 2 * pi / segments
xy2 = Point().get_arc_point(ang, r)
# GL.glNormal3f(0, -1, 0)
GL.glVertex3f(xy2.x, 0, xy2.y)
for i in range(segments // 4 + 1):
ang = -i * 2 * pi / segments
xy2 = Point().get_arc_point(ang, r)
# GL.glNormal3f(-1, 0, 0)
GL.glVertex3f(0, -xy2.y, -xy2.x)
for i in range(segments // 4 + 1):
ang = -i * 2 * pi / segments
xy2 = Point().get_arc_point(ang, r)
# GL.glNormal3f(0, 0, 1)
GL.glVertex3f(-xy2.y, xy2.x, 0)
GL.glEnd()
self.setColorRGBA(0.6, 0.6, 0.6, 0.5)
self.drawSphere(r * 1.25, segments, segments, segments, segments)
GL.glEndList()
def drawSphere(self, r, lats, mlats, longs, mlongs):
lats //= 2
# based on http://www.cburch.com/cs/490/sched/feb8/index.html
for i in range(mlats):
lat0 = pi * (-0.5 + i / lats)
z0 = r * sin(lat0)
zr0 = r * cos(lat0)
lat1 = pi * (-0.5 + (i + 1) / lats)
z1 = r * sin(lat1)
zr1 = r * cos(lat1)
GL.glBegin(GL.GL_QUAD_STRIP)
for j in range(mlongs + 1):
lng = 2 * pi * j / longs
x = cos(lng)
y = sin(lng)
GL.glNormal3f(x * zr0, y * zr0, z0)
GL.glVertex3f(x * zr0, y * zr0, z0)
GL.glNormal3f(x * zr1, y * zr1, z1)
GL.glVertex3f(x * zr1, y * zr1, z1)
GL.glEnd()
def drawSolidCircle(self, origin, r, z, segments):
GL.glBegin(GL.GL_TRIANGLE_FAN)
# GL.glNormal3f(0, 0, -1)
GL.glVertex3f(origin.x, -origin.y, z)
for i in range(segments + 1):
ang = -i * 2 * pi / segments
xy2 = origin.get_arc_point(ang, r)
GL.glVertex3f(xy2.x, -xy2.y, z)
GL.glEnd()
def drawCone(self, origin, r, zTop, zBottom, segments):
GL.glBegin(GL.GL_TRIANGLE_FAN)
GL.glVertex3f(origin.x, -origin.y, zTop)
for i in range(segments + 1):
ang = i * 2 * pi / segments
xy2 = origin.get_arc_point(ang, r)
# GL.glNormal3f(xy2.x, -xy2.y, zBottom)
GL.glVertex3f(xy2.x, -xy2.y, zBottom)
GL.glEnd()
def drawCylinder(self, origin, r, zTop, zBottom, segments):
GL.glBegin(GL.GL_QUAD_STRIP)
for i in range(segments + 1):
ang = i * 2 * pi / segments
xy = origin.get_arc_point(ang, r)
# GL.glNormal3f(xy.x, -xy.y, 0)
GL.glVertex3f(xy.x, -xy.y, zTop)
GL.glVertex3f(xy.x, -xy.y, zBottom)
GL.glEnd()
def makeDirArrows(self, shape):
(start, start_dir), (end,
end_dir) = shape.get_start_end_points_physical(
None, False)
startArrow = GL.glGenLists(1)
GL.glNewList(startArrow, GL.GL_COMPILE)
self.setColor(GLWidget.COLOR_ENTRY_ARROW)
self.drawDirArrow(Point3D(), start_dir.to3D(), True)
GL.glEndList()
endArrow = GL.glGenLists(1)
GL.glNewList(endArrow, GL.GL_COMPILE)
self.setColor(GLWidget.COLOR_EXIT_ARROW)
self.drawDirArrow(Point3D(), end_dir.to3D(), False)
GL.glEndList()
return startArrow, endArrow
def drawDirArrow(self, origin, direction, startError):
offset = 0.0 if startError else 0.05
zMiddle = -0.02 + offset
zBottom = -0.05 + offset
rx, ry, rz = self.getRotationVectors(Point3D(0, 0, 1), direction)
self.drawArrowHead(origin, rx, ry, rz, offset)
GL.glBegin(GL.GL_LINES)
zeroMiddle = Point3D(0, 0, zMiddle)
GL.glVertex3f(zeroMiddle * rx + origin.x, -zeroMiddle * ry - origin.y,
zeroMiddle * rz + origin.z)
zeroBottom = Point3D(0, 0, zBottom)
GL.glVertex3f(zeroBottom * rx + origin.x, -zeroBottom * ry - origin.y,
zeroBottom * rz + origin.z)
GL.glEnd()
def makeRouteArrowHead(self, start, end):
if end == start:
direction = Point3D(0, 0, 1)
else:
direction = (end - start).unit_vector()
rx, ry, rz = self.getRotationVectors(Point3D(0, 0, 1), direction)
head = GL.glGenLists(1)
GL.glNewList(head, GL.GL_COMPILE)
self.drawArrowHead(Point3D(), rx, ry, rz, 0)
GL.glEndList()
return head
def drawArrowHead(self, origin, rx, ry, rz, offset):
r = 0.01
segments = 10
zTop = 0 + offset
zBottom = -0.02 + offset
GL.glBegin(GL.GL_TRIANGLE_FAN)
zeroTop = Point3D(0, 0, zTop)
GL.glVertex3f(zeroTop * rx + origin.x, -zeroTop * ry - origin.y,
zeroTop * rz + origin.z)
for i in range(segments + 1):
ang = i * 2 * pi / segments
xy2 = Point().get_arc_point(ang, r).to3D(zBottom)
GL.glVertex3f(xy2 * rx + origin.x, -xy2 * ry - origin.y,
xy2 * rz + origin.z)
GL.glEnd()
GL.glBegin(GL.GL_TRIANGLE_FAN)
zeroBottom = Point3D(0, 0, zBottom)
GL.glVertex3f(zeroBottom * rx + origin.x, -zeroBottom * ry - origin.y,
zeroBottom * rz + origin.z)
for i in range(segments + 1):
ang = -i * 2 * pi / segments
xy2 = Point().get_arc_point(ang, r).to3D(zBottom)
GL.glVertex3f(xy2 * rx + origin.x, -xy2 * ry - origin.y,
xy2 * rz + origin.z)
GL.glEnd()
def setShowPathDirections(self, flag):
self.showPathDirections = flag
def setShowDisabledPaths(self, flag=True):
self.showDisabledPaths = flag
def autoscale(self):
# TODO currently only works correctly when object is not rotated
if self.frameSize().width() >= self.frameSize().height():
aspect_scale_x = self.frameSize().width() / self.frameSize(
).height()
aspect_scale_y = 1
else:
aspect_scale_x = 1
aspect_scale_y = self.frameSize().height() / self.frameSize(
).width()
scaleX = (GLWidget.CAM_RIGHT_X - GLWidget.CAM_LEFT_X
) * aspect_scale_x / (self.bottomRight.x - self.topLeft.x)
scaleY = (GLWidget.CAM_BOTTOM_Y - GLWidget.CAM_TOP_Y
) * aspect_scale_y / (self.topLeft.y - self.bottomRight.y)
self.scale = min(scaleX, scaleY) * 0.95
self.posX = ((GLWidget.CAM_LEFT_X + GLWidget.CAM_RIGHT_X) * 0.95 *
aspect_scale_x -
(self.topLeft.x + self.bottomRight.x) * self.scale) / 2
self.posY = -((GLWidget.CAM_TOP_Y + GLWidget.CAM_BOTTOM_Y) * 0.95 *
aspect_scale_y -
(self.topLeft.y + self.bottomRight.y) * self.scale) / 2
self.posZ = 0
self.update()
def topView(self):
self.rotX = 0
self.rotY = 0
self.rotZ = 0
self.update()
def isometricView(self):
self.rotX = -22
self.rotY = -22
self.rotZ = 0
self.update()
class Block:
trolltechGreen = QColor.fromCmykF(0.40, 0.0, 1.0, 1.0, 1.0)
trolltechGreenTrsp = QColor.fromCmykF(0.40, 0.0, 1.0, 0.5, 0.0)
trolltechPurple = QColor.fromCmykF(0.39, 0.39, 0.0, 1.0, 0.0)
Black = QColor.fromCmykF(1.0, 1.0, 1.0, 1.0, 1.0)
def __init__(self):
self.x0 = 0.0
self.y0 = 0.0
self.z0 = 0.0
self.show_grid = True
self.ID = 1
self.r_pick = (1 & 0x000000FF) >> 0
self.g_pick = (1 & 0x0000FF00) >> 0
self.b_pick = (1 & 0x00FF0000) >> 0
self.vertices = ((self.x0 + 1, self.y0,
self.z0), (self.x0 + 1, self.y0 + 1,
self.z0), (self.x0, self.y0 + 1, self.z0),
(self.x0, self.y0, self.z0), (self.x0 + 1, self.y0,
self.z0 + 1),
(self.x0 + 1, self.y0 + 1,
self.z0 + 1), (self.x0, self.y0, self.z0 + 1),
(self.x0, self.y0 + 1, self.z0 + 1))
self.edges = ((0, 1), (0, 3), (0, 4), (2, 1), (2, 3), (2, 7), (6, 3),
(6, 4), (6, 7), (5, 1), (5, 4), (5, 7))
self.surfaces = ((0, 1, 2, 3), (3, 2, 7, 6), (6, 7, 5, 4),
(4, 5, 1, 0), (1, 5, 7, 2), (4, 0, 3, 6))
self.isActive = False
self.isSelected = False
self.color = self.trolltechGreen
def __init__(self, x, y, z, ID):
self.x0 = x
self.y0 = y
self.z0 = z
self.show_grid = True
self.ID = ID
self.r_pick = (self.ID & 0x000000FF) >> 0
self.g_pick = (self.ID & 0x0000FF00) >> 8
self.b_pick = (self.ID & 0x00FF0000) >> 16
self.pick_color = QColor.fromRgbF(self.r_pick / 255.0,
self.g_pick / 255.0,
self.b_pick / 255.0, 1.0)
self.vertices = ((self.x0 + 1, self.y0,
self.z0), (self.x0 + 1, self.y0 + 1,
self.z0), (self.x0, self.y0 + 1, self.z0),
(self.x0, self.y0, self.z0), (self.x0 + 1, self.y0,
self.z0 + 1),
(self.x0 + 1, self.y0 + 1,
self.z0 + 1), (self.x0, self.y0, self.z0 + 1),
(self.x0, self.y0 + 1, self.z0 + 1))
self.edges = ((0, 1), (0, 3), (0, 4), (2, 1), (2, 3), (2, 7), (6, 3),
(6, 4), (6, 7), (5, 1), (5, 4), (5, 7))
self.surfaces = ((0, 1, 2, 3), (3, 2, 7, 6), (6, 7, 5, 4),
(4, 5, 1, 0), (1, 5, 7, 2), (4, 0, 3, 6))
self.isActive = False
self.isSelected = False
self.color = self.trolltechGreen
def paint(self):
gl.glBegin(gl.GL_LINES)
self.setColor(self.trolltechPurple)
if self.show_grid or self.isActive:
for edge in self.edges:
for vertex in edge:
gl.glVertex3fv(self.vertices[vertex])
gl.glEnd()
if self.isActive:
gl.glBegin(gl.GL_QUADS)
self.setColor(self.color)
for surface in self.surfaces:
for vertex in surface:
gl.glVertex3fv(self.vertices[vertex])
gl.glEnd()
if self.isSelected:
gl.glBegin(gl.GL_QUADS)
self.setColor(self.trolltechGreenTrsp)
for surface in self.surfaces:
for vertex in surface:
gl.glVertex3fv(self.vertices[vertex])
gl.glEnd()
def select(self):
self.isSelected = not self.isSelected
def activate(self):
self.isActive = not self.isActive
def paintForPick(self):
gl.glBegin(gl.GL_QUADS)
self.setColor(self.pick_color)
for surface in self.surfaces:
for vertex in surface:
gl.glVertex3fv(self.vertices[vertex])
gl.glEnd()
def setColor(self, c):
gl.glColor4f(c.redF(), c.greenF(), c.blueF(), c.alphaF())
def __init__(self, parent=None):
super(Lcnc_3dGraphics, self).__init__(parent)
glnav.GlNavBase.__init__(self)
def C(s):
a = self.colors[s + "_alpha"]
s = self.colors[s]
return [int(x * 255) for x in s + (a, )]
# requires linuxcnc running before laoding this widget
inifile = os.environ.get('INI_FILE_NAME', '/dev/null')
self.inifile = linuxcnc.ini(inifile)
self.logger = linuxcnc.positionlogger(linuxcnc.stat(),
C('backplotjog'),
C('backplottraverse'),
C('backplotfeed'),
C('backplotarc'),
C('backplottoolchange'),
C('backplotprobing'),
self.get_geometry())
# start tracking linuxcnc position so we can plot it
thread.start_new_thread(self.logger.start, (.01, ))
glcanon.GlCanonDraw.__init__(self, linuxcnc.stat(), self.logger)
# set defaults
self.current_view = 'p'
self.fingerprint = ()
self.select_primed = None
self.lat = 0
self.minlat = -90
self.maxlat = 90
self._current_file = None
self.highlight_line = None
self.program_alpha = False
self.use_joints_mode = False
self.use_commanded = True
self.show_limits = True
self.show_extents_option = True
self.gcode_properties = None
self.show_live_plot = True
self.show_velocity = True
self.metric_units = True
self.show_program = True
self.show_rapids = True
self.use_relative = True
self.show_tool = True
self.show_dtg = True
self.grid_size = 0.0
temp = self.inifile.find("DISPLAY", "LATHE")
self.lathe_option = bool(temp == "1" or temp == "True"
or temp == "true")
self.foam_option = bool(self.inifile.find("DISPLAY", "FOAM"))
self.show_offsets = False
self.show_overlay = False
self.enable_dro = False
self.use_default_controls = True
self.mouse_btn_mode = 0
self.use_gradient_background = False
self.a_axis_wrapped = self.inifile.find("AXIS_A", "WRAPPED_ROTARY")
self.b_axis_wrapped = self.inifile.find("AXIS_B", "WRAPPED_ROTARY")
self.c_axis_wrapped = self.inifile.find("AXIS_C", "WRAPPED_ROTARY")
live_axis_count = 0
for i, j in enumerate("XYZABCUVW"):
if self.stat.axis_mask & (1 << i) == 0: continue
live_axis_count += 1
self.num_joints = int(
self.inifile.find("KINS", "JOINTS") or live_axis_count)
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
# add a 100ms timer to poll linuxcnc stats
self.timer = QTimer()
self.timer.timeout.connect(self.poll)
self.timer.start(100)
self.Green = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
def __init__(self, parent=None):
super(Lcnc_3dGraphics, self).__init__(parent)
glnav.GlNavBase.__init__(self)
def C(s):
a = self.colors[s + "_alpha"]
s = self.colors[s]
return [int(x * 255) for x in s + (a, )]
# requires linuxcnc running before laoding this widget
inifile = os.environ.get('INI_FILE_NAME', '/dev/null')
# if status is not available then we are probably
# displaying in designer so fake it
stat = linuxcnc.stat()
try:
stat.poll()
except:
LOG.warning(
'linuxcnc staus failed, Assuming linuxcnc is not running so using fake status for a XYZ machine'
)
stat = fakeStatus()
self.inifile = linuxcnc.ini(inifile)
self.logger = linuxcnc.positionlogger(linuxcnc.stat(),
C('backplotjog'),
C('backplottraverse'),
C('backplotfeed'),
C('backplotarc'),
C('backplottoolchange'),
C('backplotprobing'),
self.get_geometry())
# start tracking linuxcnc position so we can plot it
_thread.start_new_thread(self.logger.start, (.01, ))
glcanon.GlCanonDraw.__init__(self, stat, self.logger)
# set defaults
self.current_view = 'p'
self.fingerprint = ()
self.select_primed = None
self.lat = 0
self.minlat = -90
self.maxlat = 90
self._current_file = None
self.highlight_line = None
self.program_alpha = False
self.use_joints_mode = False
self.use_commanded = True
self.show_limits = True
self.show_extents_option = True
self.gcode_properties = None
self.show_live_plot = True
self.show_velocity = True
self.metric_units = True
self.show_program = True
self.show_rapids = True
self.use_relative = True
self.show_tool = True
self.show_lathe_radius = False
self.show_dtg = True
self.grid_size = 0.0
temp = self.inifile.find("DISPLAY", "LATHE")
self.lathe_option = bool(temp == "1" or temp == "True"
or temp == "true")
self.foam_option = bool(self.inifile.find("DISPLAY", "FOAM"))
self.show_offsets = False
self.show_overlay = False
self.enable_dro = False
self.use_default_controls = True
self.mouse_btn_mode = 0
self.cancel_rotate = False
self.use_gradient_background = False
self.gradient_color1 = (0.0, 0.0, 1)
self.gradient_color2 = (0.0, 0.0, 0.0)
self.a_axis_wrapped = self.inifile.find("AXIS_A", "WRAPPED_ROTARY")
self.b_axis_wrapped = self.inifile.find("AXIS_B", "WRAPPED_ROTARY")
self.c_axis_wrapped = self.inifile.find("AXIS_C", "WRAPPED_ROTARY")
live_axis_count = 0
for i, j in enumerate("XYZABCUVW"):
if self.stat.axis_mask & (1 << i) == 0: continue
live_axis_count += 1
self.num_joints = int(
self.inifile.find("KINS", "JOINTS") or live_axis_count)
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.Green = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.inhibit_selection = True
self.dro_in = "% 9.4f"
self.dro_mm = "% 9.3f"
self.dro_deg = "% 9.2f"
self.dro_vel = " Vel:% 9.2F"
self.addTimer()
def __init__(self, parent=None):
super(Lcnc_3dGraphics, self).__init__(parent)
glnav.GlNavBase.__init__(self)
def C(s):
a = self.colors[s + "_alpha"]
s = self.colors[s]
return [int(x * 255) for x in s + (a, )]
# requires linuxcnc running before loading this widget
inifile = os.environ.get('INI_FILE_NAME', '/dev/null')
# if status is not available then we are probably
# displaying in designer so fake it
stat = linuxcnc.stat()
try:
stat.poll()
except:
LOG.warning(
'linuxcnc status failed, Assuming linuxcnc is not running so using fake status for a XYZ machine'
)
stat = fakeStatus()
self.inifile = linuxcnc.ini(inifile)
self.foam_option = bool(self.inifile.find("DISPLAY", "FOAM"))
try:
trajcoordinates = self.inifile.find("TRAJ",
"COORDINATES").lower().replace(
" ", "")
except:
trajcoordinates = "unknown"
#raise SystemExit("Missing [TRAJ]COORDINATES")
kinsmodule = self.inifile.find("KINS", "KINEMATICS")
self.logger = linuxcnc.positionlogger(linuxcnc.stat(),
C('backplotjog'),
C('backplottraverse'),
C('backplotfeed'),
C('backplotarc'),
C('backplottoolchange'),
C('backplotprobing'),
self.get_geometry(),
self.foam_option)
# start tracking linuxcnc position so we can plot it
_thread.start_new_thread(self.logger.start, (.01, ))
glcanon.GlCanonDraw.__init__(self, stat, self.logger)
glcanon.GlCanonDraw.init_glcanondraw(self,
trajcoordinates=trajcoordinates,
kinsmodule=kinsmodule)
# set defaults
self.display_loaded = False
self.current_view = 'p'
self.fingerprint = ()
self.select_primed = None
self.lat = 0
self.minlat = -90
self.maxlat = 90
self._current_file = None
self.highlight_line = None
self.program_alpha = False
self.use_joints_mode = True
self.use_commanded = True
self.show_limits = True
self.show_extents_option = True
self.gcode_properties = None
self.show_live_plot = True
self.show_velocity = True
self.metric_units = True
self.show_program = True
self.show_rapids = True
self.use_relative = True
self.show_tool = True
self.show_lathe_radius = False
self.show_dtg = True
self.grid_size = 0.0
temp = self.inifile.find("DISPLAY", "LATHE")
self.lathe_option = bool(temp == "1" or temp == "True"
or temp == "true")
self.show_offsets = False
self.show_overlay = False
self.enable_dro = False
self.use_default_controls = True
self.mouse_btn_mode = 0
self.cancel_rotate = False
self.use_gradient_background = False
self.gradient_color1 = (0.0, 0.0, 1)
self.gradient_color2 = (0.0, 0.0, 0.0)
self.a_axis_wrapped = self.inifile.find("AXIS_A", "WRAPPED_ROTARY")
self.b_axis_wrapped = self.inifile.find("AXIS_B", "WRAPPED_ROTARY")
self.c_axis_wrapped = self.inifile.find("AXIS_C", "WRAPPED_ROTARY")
live_axis_count = 0
for i, j in enumerate("XYZABCUVW"):
if self.stat.axis_mask & (1 << i) == 0: continue
live_axis_count += 1
self.num_joints = int(
self.inifile.find("KINS", "JOINTS") or live_axis_count)
# initialize variables for user view
self.presetViewSettings(v=None, z=0, x=0, y=0, lat=None, lon=None)
# allow anyone else to preset user view with better settings
self._presetFlag = False
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.Green = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
self.inhibit_selection = True
self.dro_in = "% 9.4f"
self.dro_mm = "% 9.3f"
self.dro_deg = "% 9.2f"
self.dro_vel = " Vel:% 9.2F"
self._font = 'monospace bold 16'
self.addTimer()
self._buttonList = [Qt.LeftButton, Qt.MiddleButton, Qt.RightButton]
self._invertWheelZoom = False
def __init__(self, parent=None):
super(QBackPlot, self).__init__(parent)
glnav.GlNavBase.__init__(self)
def C(s):
a = self.colors[s + "_alpha"]
s = self.colors[s]
return [int(x * 255) for x in s + (a, )]
# requires linuxcnc running before laoding this widget
inifile = os.environ.get('INI_FILE_NAME', '/dev/null')
self.inifile = linuxcnc.ini(inifile)
self.logger = linuxcnc.positionlogger(linuxcnc.stat(),
C('backplotjog'),
C('backplottraverse'),
C('backplotfeed'),
C('backplotarc'),
C('backplottoolchange'),
C('backplotprobing'),
self.get_geometry())
# start tracking linuxcnc position so we can plot it
thread.start_new_thread(self.logger.start, (.01, ))
glcanon.GlCanonDraw.__init__(self, linuxcnc.stat(), self.logger)
self.canon = None
# set defaults
self.current_view = 'p'
self.fingerprint = ()
self.select_primed = None
self.lat = 0
self.minlat = -90
self.maxlat = 90
self.current_file = None
self.program_length = 0
self.highlight_line = None
self.program_alpha = False
self.use_joints_mode = False
self.use_commanded = True
self.show_limits = True
self.show_extents_option = True
self.show_live_plot = True
self.show_velocity = True
self.metric_units = True
self.show_program = True
self.show_rapids = True
self.use_relative = True
self.show_tool = True
self.show_dtg = True
self.grid_size = 0.0
self.is_lathe = self.inifile.find("DISPLAY",
"LATHE") in ['1', 'True', 'true']
self.random = int(
self.inifile.find("EMCIO", "RANDOM_TOOLCHANGER") or 0)
temp = self.inifile.find("RS274NGC",
"PARAMETER_FILE") or "linuxcnc.var"
self.parameter_file = os.path.join(os.environ['CONFIG_DIR'], temp)
self.foam_option = bool(self.inifile.find("DISPLAY", "FOAM"))
self.show_offsets = False
self.show_overlay = False
self.enable_dro = False
self.use_default_controls = True
self.mouse_btn_mode = 0
self.a_axis_wrapped = self.inifile.find("AXIS_A", "WRAPPED_ROTARY")
self.b_axis_wrapped = self.inifile.find("AXIS_B", "WRAPPED_ROTARY")
self.c_axis_wrapped = self.inifile.find("AXIS_C", "WRAPPED_ROTARY")
live_axis_count = 0
for i, j in enumerate("XYZABCUVW"):
if self.stat.axis_mask & (1 << i) == 0: continue
live_axis_count += 1
self.num_joints = int(
self.inifile.find("KINS", "JOINTS") or live_axis_count)
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
self.Green = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
def __init__(self, parent=None):
super(Lcnc_3dGraphics, self).__init__(parent)
glnav.GlNavBase.__init__(self)
def C(s):
a = self.colors[s + "_alpha"]
s = self.colors[s]
return [int(x * 255) for x in s + (a,)]
# requires linuxcnc running before laoding this widget
inifile = os.environ.get('INI_FILE_NAME', '/dev/null')
self.inifile = linuxcnc.ini(inifile)
self.logger = linuxcnc.positionlogger(linuxcnc.stat(),
C('backplotjog'),
C('backplottraverse'),
C('backplotfeed'),
C('backplotarc'),
C('backplottoolchange'),
C('backplotprobing'),
self.get_geometry()
)
# start tracking linuxcnc position so we can plot it
thread.start_new_thread(self.logger.start, (.01,))
glcanon.GlCanonDraw.__init__(self, linuxcnc.stat(), self.logger)
# set defaults
self.current_view = 'p'
self.fingerprint = ()
self.select_primed = None
self.lat = 0
self.minlat = -90
self.maxlat = 90
self._current_file = None
self.highlight_line = None
self.program_alpha = False
self.use_joints_mode = False
self.use_commanded = True
self.show_limits = True
self.show_extents_option = True
self.gcode_properties = None
self.show_live_plot = True
self.show_velocity = True
self.metric_units = True
self.show_program = True
self.show_rapids = True
self.use_relative = True
self.show_tool = True
self.show_dtg = True
self.grid_size = 0.0
temp = self.inifile.find("DISPLAY", "LATHE")
self.lathe_option = bool(temp == "1" or temp == "True" or temp == "true" )
self.foam_option = bool(self.inifile.find("DISPLAY", "FOAM"))
self.show_offsets = False
self.show_overlay = False
self.enable_dro = False
self.use_default_controls = True
self.mouse_btn_mode = 0
self.use_gradient_background = False
self.a_axis_wrapped = self.inifile.find("AXIS_A", "WRAPPED_ROTARY")
self.b_axis_wrapped = self.inifile.find("AXIS_B", "WRAPPED_ROTARY")
self.c_axis_wrapped = self.inifile.find("AXIS_C", "WRAPPED_ROTARY")
live_axis_count = 0
for i,j in enumerate("XYZABCUVW"):
if self.stat.axis_mask & (1<<i) == 0: continue
live_axis_count += 1
self.num_joints = int(self.inifile.find("KINS", "JOINTS") or live_axis_count)
self.object = 0
self.xRot = 0
self.yRot = 0
self.zRot = 0
# add a 100ms timer to poll linuxcnc stats
self.timer = QTimer()
self.timer.timeout.connect(self.poll)
self.timer.start(100)
self.Green = QColor.fromCmykF(0.40, 0.0, 1.0, 0.0)
def __init__(self, parent = None, ihm_type='pc'):
super(TableViewWidget, self).__init__(parent)
if ihm_type=='pc':
#self.setFixedSize(900,600)
self.setFixedSize(960,660)
elif ihm_type=='pc-mini':
#self.setFixedSize(600,400)
self.setFixedSize(640,440)
else:
#self.setFixedSize(225,150)
self.setFixedSize(240,165)
#self.setSceneRect(QRectF(0,-1500,2000,3000))
self.setSceneRect(QRectF(-100,-1600,2200,3200))
self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self._robots = {}
self._waypoints = []
redium = QColor.fromCmykF(0,1,1,0.1)
greenium = QColor.fromCmykF(0.7,0,0.9,0)
blueium = QColor.fromCmykF(0.9,0.4,0,0)
goldenium = QColor('white')
yellow = QColor.fromCmykF(0,0.25,1,0)
purple = QColor.fromCmykF(0.5,0.9,0,0.05)
background = QColor(40,40,40)
darker = QColor(20,20,20)
# big_robot_poly = QPolygonF([
# QPointF(-135,-151),
# QPointF(60,-151),
# QPointF(170,-91),
# QPointF(170,-45),
# QPointF(111,-40),
# QPointF(111,40),
# QPointF(170,45),
# QPointF(170,91),
# QPointF(60,151),
# QPointF(-135,151)
# ])
little_robot_poly = QPolygonF([
QPointF( 50, 0),
QPointF( 100, 85),
QPointF( 65, 115),
QPointF( -65, 115),
QPointF(-100, 85),
QPointF(-100, -85),
QPointF( -65,-115),
QPointF( 65,-115),
QPointF( 100, -85)
])
#self._scene = QGraphicsScene(QRectF(0,-1500,2000,3000))
self._scene = QGraphicsScene(QRectF(-100,-1600,2200,3200))
# self._big_robot = self._scene.addPolygon(big_robot_poly, QPen(), QBrush(QColor('red')))
# self._big_robot.setZValue(1)
#self._robots['little'] = Robot(self._scene)
self._little_robot = self._scene.addPolygon(little_robot_poly, QPen(), QBrush(QColor('red')))
self._little_robot.setZValue(1)
#self._friend_robot = self._scene.addEllipse(-100, -100, 200, 200, QPen(QBrush(QColor('black')),4), QBrush(QColor('green')))
self._friend_robot = self._scene.addEllipse(-100, -100, TableViewWidget.g_detect_size, TableViewWidget.g_detect_size, QPen(QBrush(QColor('black')),4), QBrush(QColor('white')))
self._friend_robot.setZValue(1)
self._friend_robot.setPos(-1 * 1000, -1 * 1000)
if os.name == 'nt':
self._friend_robot_text = self._scene.addText("0123456", QFont("Calibri",80));
else:
self._friend_robot_text = self._scene.addText("0123456", QFont("System",40));
self._friend_robot_text.setPos(-1 * 1000 - 60, -1 * 1000 - 40)
self._friend_robot_text.setRotation(-90)
self._friend_robot_text.setTransform(QTransform(1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 1.0))
self._friend_robot_text.setZValue(1)
#self._adv1_robot = self._scene.addEllipse(-100, -100, 200, 200, QPen(QBrush(QColor('black')),4), QBrush(QColor('white')))
self._adv1_robot = self._scene.addEllipse(-100, -100, TableViewWidget.g_detect_size, TableViewWidget.g_detect_size, QPen(QBrush(QColor('black')),4), QBrush(QColor('white')))
self._adv1_robot.setZValue(1)
self._adv1_robot.setPos(-1 * 1000, -1 * 1000)
if os.name == 'nt':
self._adv1_robot_text = self._scene.addText("0", QFont("Calibri",80));
else:
self._adv1_robot_text = self._scene.addText("0", QFont("System",40));
self._adv1_robot_text.setPos(-1 * 1000 - 60, -1 * 1000 - 40)
self._adv1_robot_text.setRotation(-90)
self._adv1_robot_text.setTransform(QTransform(1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 1.0))
self._adv1_robot_text.setZValue(1)
#self._adv2_robot = self._scene.addEllipse(-100, -100, 200, 200, QPen(QBrush(QColor('black')),4), QBrush(QColor('blue')))
self._adv2_robot = self._scene.addEllipse(-100, -100, TableViewWidget.g_detect_size, TableViewWidget.g_detect_size, QPen(QBrush(QColor('black')),4), QBrush(QColor('white')))
self._adv2_robot.setZValue(1)
self._adv2_robot.setPos(-1 * 1000, -1 * 1000)
if os.name == 'nt':
self._adv2_robot_text = self._scene.addText("0", QFont("Calibri",80));
else:
self._adv2_robot_text = self._scene.addText("0", QFont("System",40));
self._adv2_robot_text.setPos(-1 * 1000 - 60, -1 * 1000 - 40)
self._adv2_robot_text.setRotation(-90)
self._adv2_robot_text.setTransform(QTransform(1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 1.0))
self._adv2_robot_text.setZValue(1)
self.setScene(self._scene)
self.rotate(90)
if ihm_type=='pc':
self.scale(0.3, -0.3)
elif ihm_type=='pc-mini':
self.scale(0.2, -0.2)
else:
self.scale(0.075, -0.075)
#self._scene.addRect(QRectF(0,-1500,2000,3000),QPen(), QBrush(background))
f=open("widgets/table_2020_600x400.png","rb")
my_buff=f.read()
test_img_pixmap2 = QPixmap()
test_img_pixmap2.loadFromData(my_buff)
#self.setPixmap(test_img_pixmap2)
self._bg_img = QGraphicsPixmapItem(test_img_pixmap2)
self._bg_img.setTransform(QTransform(1.0, 0.0, 0.0, 0.0, -1.0, 0.0, 0.0, 0.0, 0.2))
self._bg_img.setRotation(-90)
self._bg_img.setPos(0, -1500)
self._scene.addItem(self._bg_img);
# Scenario 2020
#Port principal "bleu"
self._scene.addRect(QRectF(500,-1120,570,20),QPen(), QBrush(blueium))
self._scene.addRect(QRectF(500,-1500,30,400),QPen(), QBrush(greenium))
self._scene.addRect(QRectF(1070,-1500,30,400),QPen(), QBrush(redium))
#Port secondaire "bleu"
self._scene.addRect(QRectF(1700,150,20,300),QPen(), QBrush(blueium))
self._scene.addRect(QRectF(1700,150,300,100),QPen(), QBrush(greenium))
self._scene.addRect(QRectF(1700,350,300,100),QPen(), QBrush(redium))
#Bouees cote "bleu"
self._scene.addEllipse(QRectF(1200-35,-1200-35,70,70),QPen(), QBrush(greenium))
self._scene.addEllipse(QRectF(1080-35,-1050-35,70,70),QPen(), QBrush(redium))
self._scene.addEllipse(QRectF(510-35,-1050-35,70,70),QPen(), QBrush(greenium))
self._scene.addEllipse(QRectF(400-35,-1200-35,70,70),QPen(), QBrush(redium))
self._scene.addEllipse(QRectF(100-35,-830-35,70,70),QPen(), QBrush(redium))
self._scene.addEllipse(QRectF(400-35,-550-35,70,70),QPen(), QBrush(greenium))
self._scene.addEllipse(QRectF(800-35,-400-35,70,70),QPen(), QBrush(redium))
self._scene.addEllipse(QRectF(1200-35,-230-35,70,70),QPen(), QBrush(greenium))
self._scene.addEllipse(QRectF(1650-35,-435-35,70,70),QPen(), QBrush(greenium))
self._scene.addEllipse(QRectF(1650-35,-165-35,70,70),QPen(), QBrush(redium))
self._scene.addEllipse(QRectF(1955-35,-495-35,70,70),QPen(), QBrush(redium))
self._scene.addEllipse(QRectF(1955-35,-105-35,70,70),QPen(), QBrush(greenium))
#Port principal "jaune"
self._scene.addRect(QRectF(500,1100,570,20),QPen(), QBrush(yellow))
self._scene.addRect(QRectF(500,1100,30,400),QPen(), QBrush(redium))
self._scene.addRect(QRectF(1070,1100,30,400),QPen(), QBrush(greenium))
#Port secondaire "jaune"
self._scene.addRect(QRectF(1700,-450,20,300),QPen(), QBrush(yellow))
self._scene.addRect(QRectF(1700,-450,300,100),QPen(), QBrush(greenium))
self._scene.addRect(QRectF(1700,-250,300,100),QPen(), QBrush(redium))
#Bouees cote "jaune"
self._scene.addEllipse(QRectF(1200-35,1200-35,70,70),QPen(), QBrush(redium))
self._scene.addEllipse(QRectF(1080-35,1050-35,70,70),QPen(), QBrush(greenium))
self._scene.addEllipse(QRectF(510-35,1050-35,70,70),QPen(), QBrush(redium))
self._scene.addEllipse(QRectF(400-35,1200-35,70,70),QPen(), QBrush(greenium))
self._scene.addEllipse(QRectF(100-35,830-35,70,70),QPen(), QBrush(greenium))
self._scene.addEllipse(QRectF(400-35,550-35,70,70),QPen(), QBrush(redium))
self._scene.addEllipse(QRectF(800-35,400-35,70,70),QPen(), QBrush(greenium))
self._scene.addEllipse(QRectF(1200-35,230-35,70,70),QPen(), QBrush(redium))
self._scene.addEllipse(QRectF(1650-35,435-35,70,70),QPen(), QBrush(redium))
self._scene.addEllipse(QRectF(1650-35,165-35,70,70),QPen(), QBrush(greenium))
self._scene.addEllipse(QRectF(1955-35,495-35,70,70),QPen(), QBrush(greenium))
self._scene.addEllipse(QRectF(1955-35,105-35,70,70),QPen(), QBrush(redium))
#dbg_plt_sz = 3
#self._scene.addEllipse(1000 - dbg_plt_sz, 0 - dbg_plt_sz, 2*dbg_plt_sz, 2*dbg_plt_sz, QPen(QBrush(QColor('white')),4), QBrush(QColor('white')))
self._points = []
#self.setSceneRect(QRectF(0,-150,200,300))
self._traj_segm_l = []
self._debug_edit_mode = False
self._debug_edit_point_l = []
# self._big_robot_x = 0
# self._big_robot_y = 0
self._little_robot_x = 0
self._little_robot_y = 0
self.last_plot_ts = 0
self.plot_graph_l = []
self._plot_items = []
TableViewWidget.g_table_view = self