def bulge2arc(self, Ps, Pe, bulge): """ bulge2arc() """ c = (1 / bulge - bulge) / 2 #Berechnung des Mittelpunkts (Formel von Mickes!) #Calculation of the center (Micke's formula) O = Point(x=(Ps.x + Pe.x - (Pe.y - Ps.y) * c) / 2, \ y=(Ps.y + Pe.y + (Pe.x - Ps.x) * c) / 2) #Radius = Distance between the centre and Ps r = O.distance(Ps) #Kontrolle ob beide gleich sind (passt ...) #Check if they are equal (fits ...) #r=O.distance(Pe) #Unterscheidung f�r den �ffnungswinkel. #Distinction for the opening angle. ??? if bulge > 0: return ArcGeo(Ps=Ps, Pe=Pe, O=O, r=r) else: arc = ArcGeo(Ps=Pe, Pe=Ps, O=O, r=r) arc.reverse() return arc
def initialize_export_vars(self): """ This function is called to initialize all export variables. This will be done directly before the export starts. """ #Initialization of the General Postprocessor parameters self.feed = 0 self.speed = 0 self.tool_nr = 1 self.comment = "" self.abs_export = self.vars.General["abs_export"] self.Pe = Point(x=g.config.vars.Plane_Coordinates['axis1_start_end'], y=g.config.vars.Plane_Coordinates['axis2_start_end']) self.Ps = Point(x=g.config.vars.Plane_Coordinates['axis1_start_end'], y=g.config.vars.Plane_Coordinates['axis2_start_end']) self.lPe = Point(x=g.config.vars.Plane_Coordinates['axis1_start_end'], y=g.config.vars.Plane_Coordinates['axis2_start_end']) self.IJ = Point(x=0.0, y=0.0) self.O = Point(x=0.0, y=0.0) self.r = 0.0 self.s_ang = 0.0 self.e_ang = 0.0 self.ze = g.config.vars.Depth_Coordinates['axis3_retract'] self.lz = self.ze self.keyvars = {"%feed":'self.iprint(self.feed)', \ "%speed":'self.iprint(self.speed)', \ "%tool_nr":'self.iprint(self.tool_nr)', \ "%nl":'self.nlprint()', \ "%XE":'self.fnprint(self.Pe.x)', \ "%-XE":'self.fnprint(-self.Pe.x)', \ "%XS":'self.fnprint(self.Ps.x)', \ "%-XS":'self.fnprint(-self.Ps.x)', \ "%YE":'self.fnprint(self.Pe.y*fac)', \ "%-YE":'self.fnprint(-self.Pe.y*fac)', \ "%YS":'self.fnprint(self.Ps.y*fac)', \ "%-YS":'self.fnprint(-self.Ps.y*fac)', \ "%ZE":'self.fnprint(self.ze)', \ "%-ZE":'self.fnprint(-self.ze)', \ "%I":'self.fnprint(self.IJ.x)', \ "%-I":'self.fnprint(-self.IJ.x)', \ "%J":'self.fnprint(self.IJ.y*fac)', \ "%-J":'self.fnprint(-self.IJ.y*fac)', \ "%XO":'self.fnprint(self.O.x)', \ "%-XO":'self.fnprint(-self.O.x)', \ "%YO":'self.fnprint(self.O.y*fac)', \ "%-YO":'self.fnprint(-self.O.y*fac)', \ "%R":'self.fnprint(self.r)', \ "%AngS":'self.fnprint(degrees(self.s_ang))', \ "%-AngS":'self.fnprint(degrees(-self.s_ang))', \ "%AngE":'self.fnprint(degrees(self.e_ang))', \ "%-AngE":'self.fnprint(degrees(-self.e_ang))', \ "%comment":'self.sprint(self.comment)'}
def __init__(self, Nr=0, caller=None): self.Typ = 'Ellipse' self.Nr = Nr #Initialisieren der Werte #Initialise the values self.Layer_Nr = 0 self.center = Point(0, 0) #Centre of the geometry self.vector = Point(1, 0) # Vector A = semi-major axis. # a = rotation of the ellipse # http://de.wikipedia.org/wiki/Gro%C3%9Fe_Halbachse self.ratio = 1 #Verh�ltnis der kleinen zur gro�en Halbachse (b/a) #Ratio of the minor to major axis (b/a) #self.AngS = 0 #Startwinkel beim zeichnen eines Ellipsensegments #Starting angle when drawing an ellipse segment #self.AngE = radians(360) #Endwinkel (Winkel im DXF als Radians!) #End angle (angle in radians as DXF!) #Die folgenden Grundwerte werden sp�ter ein mal berechnet #The following limits are calculated later self.length = 0 self.Points = [] self.Points.append(self.center) #Lesen der Geometrie / Read the geometry self.Read(caller) #Zuweisen der Toleranz f�rs Fitting / Assign the tolerance for fitting tol = g.config.fitting_tolerance #Errechnen der Ellipse / Calculate the ellipse self.Ellipse_Grundwerte() self.Ellipse_2_Arcs(tol)
def Read(self, caller): """ This function does read the geometry. @param caller: The instance which is calling the function """ #Assign short name lp = caller.line_pairs e = lp.index_code(0, caller.start + 1) #Assign layer s = lp.index_code(8, caller.start + 1) self.Layer_Nr = caller.Get_Layer_Nr(lp.line_pair[s].value) #X Value sl = lp.index_code(10, s + 1) x0 = float(lp.line_pair[sl].value) #Y Value s = lp.index_code(20, sl + 1) y0 = float(lp.line_pair[s].value) #X Value 2 s = lp.index_code(11, sl + 1) x1 = float(lp.line_pair[s].value) #Y Value 2 s = lp.index_code(21, s + 1) y1 = float(lp.line_pair[s].value) #Searching for an extrusion direction s_nxt_xt = lp.index_code(230, s + 1, e) #If there is a extrusion direction given flip around x-Axis if s_nxt_xt != None: extrusion_dir = float(lp.line_pair[s_nxt_xt].value) logger.debug( self.tr('Found extrusion direction: %s') % extrusion_dir) if extrusion_dir == -1: x0 = -x0 x1 = -x1 Ps = Point(x0, y0) Pe = Point(x1, y1) #Anhängen der LineGeo Klasse für die Geometrie #Annexes to LineGeo class for geometry ??? self.geo.append(LineGeo(Ps=Ps, Pe=Pe)) #Länge entspricht der Länge des Kreises #Length corresponding to the length (circumference?) of the circle self.length = self.geo[-1].length #Neuen Startwert für die nächste Geometrie zurückgeben #New starting value for the next geometry caller.start = s
def makeShapesAndPlot(self, values): """ Plots all data stored in the values parameter to the Canvas @param values: Includes all values loaded from the dxf file """ #Generate the Shapes self.makeShapes(values, p0 = Point(x = self.cont_dx, y = self.cont_dy), pb = Point(x = 0.0, y = 0.0), sca = [self.cont_scale, self.cont_scale, self.cont_scale], rot = self.rotate)
def __init__(self, Nr=None, Name='', parent=None, children=[], p0=Point(), pb=Point(), sca=[1, 1, 1], rot=0.0): self.type = "Entity" self.Nr = Nr self.Name = Name self.children = children self.p0 = p0 self.pb = pb self.sca = sca self.rot = rot self.parent = parent
def calc_O1_O2_k(self, r1, r2, tan_a, teta): """ calc_O1_O2_k() """ #print("r1: %0.3f, r2: %0.3f, tan_a: %0.3f, teta: %0.3f" %(r1,r2,tan_a,teta)) #print("N1: x: %0.3f, y: %0.3f" %(-sin(tan_a), cos(tan_a))) #print("V: x: %0.3f, y: %0.3f" %(-sin(teta+tan_a),cos(teta+tan_a))) O1 = Point(x=self.Ps.x - r1 * sin(tan_a), \ y=self.Ps.y + r1 * cos(tan_a)) k = Point(x=self.Ps.x + r1 * (-sin(tan_a) + sin(teta + tan_a)), \ y=self.Ps.y + r1 * (cos(tan_a) - cos(tan_a + teta))) O2 = Point(x=k.x + r2 * (-sin(teta + tan_a)), \ y=k.y + r2 * (cos(teta + tan_a))) return O1, O2, k
def AnalyseAndOptimize(self): """ This method is called after the shape has been generated before it gets plotted to change all shape direction to a CW shape. """ logger.debug( self.tr("Analysing the shape for CW direction Nr: %s") % self.nr) # Optimization for closed shapes if self.closed: # Start value for the first sum start = self.geos[0].get_start_end_points(0)[0] summe = 0.0 for geo in self.geos: if geo.type == 'LineGeo': ende = geo.get_start_end_points(1)[0] summe += (start.x + ende.x) * (ende.y - start.y) / 2 start = ende elif geo.type == 'ArcGeo': segments = int(abs(degrees(geo.ext)) // 90 + 1) for i in range(segments): ang = geo.s_ang + (i + 1) * geo.ext / segments ende = Point(geo.O.x + cos(ang) * geo.r, geo.O.y + sin(ang) * geo.r) summe += (start.x + ende.x) * (ende.y - start.y) / 2 start = ende if summe > 0.0: self.reverse() logger.debug(self.tr("Had to reverse the shape to be cw"))
def FindNearestStPoint(self, StPoint=Point()): """ Find Nearest Point to given StartPoint. This is used to change the start of closed contours @param StPoint: This is the point for which the nearest point shall be searched. """ if self.closed: logger.debug(self.tr("Clicked Point: %s") % StPoint) start = self.geos[0].get_start_end_points(0, self.parent)[0] min_distance = start.distance(StPoint) logger.debug(self.tr("Old Start Point: %s") % start) min_geo_nr = 0 for geo_nr in range(1, len(self.geos)): start = self.geos[geo_nr].get_start_end_points(0, self.parent)[0] if start.distance(StPoint) < min_distance: min_distance = start.distance(StPoint) min_geo_nr = geo_nr # Overwrite the geometries in changed order. self.geos = self.geos[min_geo_nr:] + self.geos[:min_geo_nr] start = self.geos[0].get_start_end_points(0, self.parent)[0] logger.debug(self.tr("New Start Point: %s") % start)
def __init__( self, text='S', startp=Point(x=0.0, y=0.0), ): """ Initialisation of the class. """ QtGui.QGraphicsItem.__init__(self) self.setFlag(QtGui.QGraphicsItem.ItemIsSelectable, False) self.text = text self.sc = 1.0 self.startp = QtCore.QPointF(startp.x, -startp.y) pencolor = QtGui.QColor(0, 200, 255) self.brush = QtGui.QColor(0, 100, 255) self.pen = QtGui.QPen(pencolor, 1, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin) self.pen.setCosmetic(True) self.path = QtGui.QPainterPath() self.path.addText(QtCore.QPointF(0, 0), QtGui.QFont("Arial", 10 / self.sc), self.text)
def calc_curve(self, n=0, cpts_nr=20): """ Berechnen von eine Anzahl gleichm�ssig verteilter Punkte bis zur n-ten Ableitung """ #Anfangswerte f�r Step und u u = 0 step = float(self.Knots[-1]) / (cpts_nr - 1) Points = [] #Wenn die erste Ableitung oder h�her errechnet wird die ersten #Ableitung in dem tan als Winkel in rad gespeichert tang = [] while u <= self.Knots[-1]: CK = self.bspline_ders_evaluate(n=n, u=u) #Den Punkt in einem Punkt List abspeichern Points.append(Point(x=CK[0][0], y=CK[0][1])) #F�r die erste Ableitung wird den Winkel der tangente errechnet if n >= 1: tang.append(atan2(CK[1][1], CK[1][0])) u += step return Points, tang
def Read(self, caller): """ Read() """ #Assign short name lp = caller.line_pairs e = lp.index_code(0, caller.start + 1) #Assign layer s = lp.index_code(8, caller.start + 1) self.Layer_Nr = caller.Get_Layer_Nr(lp.line_pair[s].value) #X Value s = lp.index_code(10, s + 1) x0 = float(lp.line_pair[s].value) #Y Value s = lp.index_code(20, s + 1) y0 = float(lp.line_pair[s].value) Ps = Point(x0, y0) self.geo.append(HoleGeo(Ps)) #self.geo.append(LineGeo(Ps=Point(0,0), Pe=P)) #Neuen Startwert für die nächste Geometrie zurückgeben #New starting value for the next geometry caller.start = s
def analyse_and_opt(self): """ analyse_and_opt() """ summe = 0 #Richtung in welcher der Anfang liegen soll (unten links) #Direction of the top (lower left) ??? Popt = Point(x= -1e3, y= -1e6) #Calculation of the alignment after Gaussian-Elling #Positive value means CW, negative value indicates CCW #closed polygon for Line in self.geo: summe += (Line.Ps.x * Line.Pe.y - Line.Pe.x * Line.Ps.y) / 2 if summe > 0.0: self.reverse() #Find the smallest starting point from bottom left X (Must be new loop!) #logger.debug(self.geo) min_distance = self.geo[0].Ps.distance(Popt) min_geo_nr = 0 for geo_nr in range(1, len(self.geo)): if (self.geo[geo_nr].Ps.distance(Popt) < min_distance): min_distance = self.geo[geo_nr].Ps.distance(Popt) min_geo_nr = geo_nr #Order contour so the new starting point is at the beginning self.geo = self.geo[min_geo_nr:len(self.geo)] + self.geo[0:min_geo_nr]
def __init__(self, MyGraphicsView, MyGraphicsScene, position): QtGui.QMenu.__init__(self) self.position = MyGraphicsView.mapToGlobal(position) GVPos = MyGraphicsView.mapToScene(position) self.PlotPos = Point(x=GVPos.x(), y=-GVPos.y()) self.MyGraphicsScene = MyGraphicsScene self.MyGraphicsView = MyGraphicsView if len(self.MyGraphicsScene.selectedItems()) == 0: return invertAction = self.addAction(self.tr("Invert Selection")) disableAction = self.addAction(self.tr("Disable Selection")) enableAction = self.addAction(self.tr("Enable Selection")) self.addSeparator() swdirectionAction = self.addAction(self.tr("Switch Direction")) SetNxtStPAction = self.addAction(self.tr("Set Nearest StartPoint")) if g.config.machine_type == 'drag_knife': pass else: self.addSeparator() submenu1 = QtGui.QMenu(self.tr('Cutter Compensation'), self) self.noCompAction = submenu1.addAction( self.tr("G40 No Compensation")) self.noCompAction.setCheckable(True) self.leCompAction = submenu1.addAction( self.tr("G41 Left Compensation")) self.leCompAction.setCheckable(True) self.reCompAction = submenu1.addAction( self.tr("G42 Right Compensation")) self.reCompAction.setCheckable(True) logger.debug( self.tr("The selected shapes have the following direction: %i") % (self.calcMenuDir())) self.checkMenuDir(self.calcMenuDir()) self.addMenu(submenu1) invertAction.triggered.connect(self.invertSelection) disableAction.triggered.connect(self.disableSelection) enableAction.triggered.connect(self.enableSelection) swdirectionAction.triggered.connect(self.switchDirection) SetNxtStPAction.triggered.connect(self.setNearestStP) if g.config.machine_type == 'drag_knife': pass else: self.noCompAction.triggered.connect(self.setNoComp) self.leCompAction.triggered.connect(self.setLeftComp) self.reCompAction.triggered.connect(self.setRightComp) self.exec_(self.position)
def analyse_and_opt(self): """ analyse_and_opt() """ summe = 0 #Richtung in welcher der Anfang liegen soll (unten links) #Direction of the top (lower left) ???? Popt = Point(x=-1e3, y=-1e6) #Calculation of the alignment after Gaussian-Elling #Positive value means CW, negative value indicates CCW #closed polygon for Line in self.geo: summe += (Line.Pa.x * Line.Pe.y - Line.Pe.x * Line.Pa.y) / 2 if summe > 0.0: self.reverse() #Suchen des kleinsten Startpunkts von unten Links X zuerst (Muss neue Schleife sein!) #Find the smallest starting point from bottom left X (Must be new loop!) min_distance = self.geo[0].Pa.distance(Popt) min_geo_nr = 0 for geo_nr in range(1, len(self.geo)): if (self.geo[geo_nr].Pa.distance(Popt) < min_distance): min_distance = self.geo[geo_nr].Pa.distance(Popt) min_geo_nr = geo_nr #Kontur so anordnen das neuer Startpunkt am Anfang liegt #Order Contour so new starting point is at the beginning self.geo = self.geo[min_geo_nr:len(self.geo)] + self.geo[0:min_geo_nr]
def __init__(self, startp=Point(x=0.0, y=0.0), endp=None, length=60.0, angle=50.0, color=QtCore.Qt.red, pencolor=QtCore.Qt.green, dir=0): """ Initialisation of the class. """ self.sc = 1 super(Arrow, self).__init__() self.startp = QtCore.QPointF(startp.x, -startp.y) self.endp = endp self.length = length self.angle = angle self.dir = dir self.allwaysshow = False self.arrowHead = QtGui.QPolygonF() self.setFlag(QtGui.QGraphicsItem.ItemIsSelectable, False) self.myColor = color self.pen = QtGui.QPen(pencolor, 1, QtCore.Qt.SolidLine, QtCore.Qt.RoundCap, QtCore.Qt.RoundJoin) self.arrowSize = 8.0 self.pen.setCosmetic(True)
def contains_point(self, point): """ Method to determine the minimal distance from the point to the shape @param point: a QPointF @return: minimal distance """ min_distance = float(0x7fffffff) ref_point = Point(point.x(), point.y()) t = 0.0 while t < 1.0: per_point = self.path.pointAtPercent(t) spline_point = Point(per_point.x(), per_point.y()) distance = ref_point.distance(spline_point) if distance < min_distance: min_distance = distance t += 0.01 return min_distance
def Ellipse_Point(self, alpha=0):#Point(0,0) """ Ellipse_Point() """ #gro�e Halbachse, kleine Halbachse, rotation der Ellipse (rad), Winkel des Punkts in der Ellipse (rad) #Semi-major axis, minor axis, rotation of the ellipse (rad), the point in the ellipse angle (rad) ??? Ex = self.a * cos(alpha) * cos(self.rotation) - self.b * sin(alpha) * sin(self.rotation) Ey = self.a * cos(alpha) * sin(self.rotation) + self.b * sin(alpha) * cos(self.rotation) return Point(self.center.x + Ex, self.center.y + Ey)
def addexproutest(self): """ This function initialises the Arrows of the export route order and its numbers. @param shapes_st_en_points: The start and end points of the shapes. @param route: The order of the shapes to be plotted. """ x_st = g.config.vars.Plane_Coordinates['axis1_start_end'] y_st = g.config.vars.Plane_Coordinates['axis2_start_end'] self.expprv = Point(x=x_st, y=y_st) self.expcol = QtCore.Qt.darkRed
def addexproute(self, exp_order, layer_nr): """ This function initialises the Arrows of the export route order and its numbers. @param shapes_st_en_points: The start and end points of the shapes. @param route: The order of the shapes to be plotted. """ x_st = g.config.vars.Plane_Coordinates['axis1_start_end'] y_st = g.config.vars.Plane_Coordinates['axis2_start_end'] start = Point(x=x_st, y=y_st) ende = Point(x=x_st, y=y_st) #shapes_st_en_points.append([start,ende]) #Print the optimised route for shape_nr in range(len(exp_order)): st = self.expprv [en, dummy] = self.shapes[exp_order[shape_nr]].get_st_en_points(0) [self.expprv, dummy] = self.shapes[exp_order[shape_nr]].get_st_en_points(1) # st=shapes_st_en_points[route[st_nr]][1] # en=shapes_st_en_points[route[en_nr]][0] self.routearrows.append( Arrow(startp=st, endp=en, color=self.expcol, pencolor=self.expcol)) self.expcol = QtCore.Qt.darkGray self.routetext.append( RouteText(text=("%s,%s" % (layer_nr, shape_nr + 1)), startp=en)) #self.routetext[-1].ItemIgnoresTransformations self.addItem(self.routetext[-1]) self.addItem(self.routearrows[-1])
def Read(self, caller): """ Read() """ #Assign short name lp = caller.line_pairs e = lp.index_code(0, caller.start + 1) #Assign Layer s = lp.index_code(8, caller.start + 1) self.Layer_Nr = caller.Get_Layer_Nr(lp.line_pair[s].value) #Centre X value, Y value s = lp.index_code(10, s + 1) x0 = float(lp.line_pair[s].value) s = lp.index_code(20, s + 1) y0 = float(lp.line_pair[s].value) self.center = Point(x0, y0) #XWert, YWert. Vektor, relativ zum Zentrum, Gro�e Halbachse #X value, Y value. Vector relative to the center, Semi-major axis s = lp.index_code(11, s + 1) x1 = float(lp.line_pair[s].value) s = lp.index_code(21, s + 1) y1 = float(lp.line_pair[s].value) self.vector = Point(x1, y1) #Ratio minor to major axis s = lp.index_code(40, s + 1) self.ratio = float(lp.line_pair[s].value) #Start Winkel - Achtung, ist als rad (0-2pi) im dxf #Start angle - Note in radian (0-2pi) per dxf s = lp.index_code(41, s + 1) self.AngS = float(lp.line_pair[s].value) #End Winkel - Achtung, ist als rad (0-2pi) im dxf #End angle - Note in radian (0-2pi) per dxf s = lp.index_code(42, s + 1) self.AngE = float(lp.line_pair[s].value) #Neuen Startwert f�r die n�chste Geometrie zur�ckgeben #New starting value for the next geometry return caller.start = e
def makeShapesAndPlot(self, values): """ Plots all data stored in the values parameter to the Canvas @param values: Includes all values loaded from the dxf file """ #Generate the Shapes self.makeShapes( values, p0=Point(x=self.cont_dx, y=self.cont_dy), pb=Point(x=0.0, y=0.0), sca=[self.cont_scale, self.cont_scale, self.cont_scale], rot=self.rotate) # Automatic cutter compensation self.automaticCutterCompensation() # Break insertion Breaks(self.LayerContents).process() #Populate the treeViews self.TreeHandler.buildEntitiesTree(self.EntitiesRoot) self.TreeHandler.buildLayerTree(self.LayerContents) #Print the values self.MyGraphicsView.clearScene() self.MyGraphicsScene = MyGraphicsScene() self.MyGraphicsScene.plotAll(self.shapes, self.EntitiesRoot) self.MyGraphicsView.setScene(self.MyGraphicsScene) self.setShow_wp_zero() self.setShow_path_directions() self.setShow_disabled_paths() self.setUpdate_export_route() self.MyGraphicsView.show() self.MyGraphicsView.setFocus() #Autoscale the Canvas self.MyGraphicsView.autoscale()
def bulge2arc(self, Ps, Pe, bulge): """ bulge2arc() """ c = (1 / bulge - bulge) / 2 #Calculate the centre point (Micke's formula!) O = Point(x=(Ps.x + Pe.x - (Pe.y - Ps.y) * c) / 2, \ y=(Ps.y + Pe.y + (Pe.x - Ps.x) * c) / 2) #Radius = Distance between the centre and Ps r = O.distance(Ps) #Check if they are equal (fits ...) #r=O.distance(Pe) #Unterscheidung f�r den �ffnungswinkel. #Distinction for the opening angle. ??? if bulge > 0: return ArcGeo(Ps=Ps, Pe=Pe, O=O, r=r) else: arc = ArcGeo(Ps=Pe, Pe=Ps, O=O, r=r) arc.reverse() return arc
def bulge2arc(self, Pa, Pe, bulge): """ bulge2arc() """ c = (1 / bulge - bulge) / 2 #Calculate the centre point (Micke's formula!) O = Point(x=(Pa.x + Pe.x - (Pe.y - Pa.y) * c) / 2, \ y=(Pa.y + Pe.y + (Pe.x - Pa.x) * c) / 2) #Radius = Distance between the centre and Pa r = O.distance(Pa) #Check if they are equal (fits ...) #r=O.distance(Pe) #Unterscheidung für den Öffnungswinkel. #Distinction for the opening angle. ??? if bulge > 0: return ArcGeo(Pa=Pa, Pe=Pe, O=O, r=r) else: arc = ArcGeo(Pa=Pe, Pe=Pa, O=O, r=r) arc.reverse() return arc
def Read(self, caller): """ Read() """ #Assign short name lp = caller.line_pairs e = lp.index_code(0, caller.start + 1) #Block Name ind = lp.index_code(2, caller.start + 1, e) #print lp.line_pair[ind].value ######################################## self.BlockName = lp.line_pair[ind].value #Assign layer s = lp.index_code(8, caller.start + 1, e) self.Layer_Nr = caller.Get_Layer_Nr(lp.line_pair[s].value) #X Value s = lp.index_code(10, s + 1, e) x0 = float(lp.line_pair[s].value) #Y Value s = lp.index_code(20, s + 1, e) y0 = float(lp.line_pair[s].value) self.Point = Point(x0, y0) #XScale s_temp = lp.index_code(41, s + 1, e) if s_temp != None: self.Scale[0] = float(lp.line_pair[s_temp].value) #YScale s_temp = lp.index_code(42, s + 1, e) if s_temp != None: self.Scale[1] = float(lp.line_pair[s_temp].value) #ZScale s_temp = lp.index_code(43, s + 1, e) if s_temp != None: self.Scale[2] = float(lp.line_pair[s_temp].value) #Rotation s_temp = lp.index_code(50, s + 1, e) if s_temp != None: self.rot = radians(float(lp.line_pair[s_temp].value)) #New starting value for the next geometry caller.start = e
def intersectGeometry(self, lineGeo, breakShape): """ Try to break lineGeo with the given breakShape. Will return the intersection points of lineGeo with breakShape. """ intersections = [] line = QtCore.QLineF(lineGeo.Pa.x, lineGeo.Pa.y, lineGeo.Pe.x, lineGeo.Pe.y) for breakGeo in breakShape.geos: if isinstance(breakGeo, LineGeo): breakLine = QtCore.QLineF(breakGeo.Pa.x, breakGeo.Pa.y, breakGeo.Pe.x, breakGeo.Pe.y) intersection = QtCore.QPointF(5, 5) res = line.intersect(breakLine, intersection) if (res == QtCore.QLineF.BoundedIntersection): intersections.append( Point(intersection.x(), intersection.y())) return intersections
def intersectLineGeometry(self, lineGeo, breakShape): """ Try to break lineGeo with the given breakShape. Will return the intersection points of lineGeo with breakShape. """ # TODO geos should be abs intersections = [] line = QtCore.QLineF(lineGeo.Ps.x, lineGeo.Ps.y, lineGeo.Pe.x, lineGeo.Pe.y) for breakGeo in breakShape.geos: if isinstance(breakGeo, LineGeo): breakLine = QtCore.QLineF(breakGeo.Ps.x, breakGeo.Ps.y, breakGeo.Pe.x, breakGeo.Pe.y) intersection = QtCore.QPointF(0, 0) # values do not matter res = line.intersect(breakLine, intersection) if res == QtCore.QLineF.BoundedIntersection: intersections.append( Point(intersection.x(), intersection.y())) return intersections
def addexprouteen(self): """ This function initialises the Arrows of the export route order and its numbers. @param shapes_st_en_points: The start and end points of the shapes. @param route: The order of the shapes to be plotted. """ x_st = g.config.vars.Plane_Coordinates['axis1_start_end'] y_st = g.config.vars.Plane_Coordinates['axis2_start_end'] st = self.expprv en = Point(x=x_st, y=y_st) self.expcol = QtCore.Qt.darkRed self.routearrows.append( Arrow(startp=st, endp=en, color=self.expcol, pencolor=self.expcol)) self.addItem(self.routearrows[-1])
def add2path(self, papath=None, parent=None, layerContent=None): """ Plots the geometry of self into defined path for hit testing. Refer to http://stackoverflow.com/questions/11734618/check-if-point-exists-in-qpainterpath for description @param papath: The hitpath to add the geometrie @param parent: The parent of the shape """ abs_geo = self.make_abs_geo(parent) segments = int(abs(degrees(abs_geo.ext) // 3) + 1) for i in range(segments + 1): ang = abs_geo.s_ang + i * abs_geo.ext / segments p_cur = Point(abs_geo.O.x + cos(ang) * abs(abs_geo.r), abs_geo.O.y + sin(ang) * abs(abs_geo.r)) if i >= 1: papath.lineTo(p_cur.x, -p_cur.y)
def analyse_and_opt(self): """ analyse_and_opt() """ #Richtung in welcher der Anfang liegen soll (unten links) #Direction of top (lower left) ??? Popt = Point(x= -1e3, y= -1e6) #Suchen des kleinsten Startpunkts von unten Links X zuerst (Muss neue Schleife sein!) #Find the smallest starting point from bottom left X (Must be new loop!) min_distance = self.geo[0].Ps.distance(Popt) min_geo_nr = 0 for geo_nr in range(1, len(self.geo)): if (self.geo[geo_nr].Ps.distance(Popt) < min_distance): min_distance = self.geo[geo_nr].Ps.distance(Popt) min_geo_nr = geo_nr #Kontur so anordnen das neuer Startpunkt am Anfang liegt #Contour so the new starting point is at the start order self.geo = self.geo[min_geo_nr:len(self.geo)] + self.geo[0:min_geo_nr]
def mouseMoveEvent(self, event): """ MouseMoveEvent of the Graphiscview. May also be used for the Statusbar. @purpose: Get the MouseMoveEvent and use it for the Rubberband Selection @param event: Event Parameters passed to function """ if not(self.mppos is None): Point = event.pos() - self.mppos if (Point.manhattanLength() > 3): #print 'the mouse has moved more than 3 pixels since the oldPosition' #print "Mouse Pointer is currently hovering at: ", event.pos() self.rubberBand.show() self.rubberBand.setGeometry(QtCore.QRect(self.mppos, event.pos()).normalized()) scpoint = self.mapToScene(event.pos()) #self.setStatusTip('X: %3.1f; Y: %3.1f' %(scpoint.x(), -scpoint.y())) #works not as supposed to self.setToolTip('X: %3.1f; Y: %3.1f' %(scpoint.x(), -scpoint.y())) super(MyGraphicsView, self).mouseMoveEvent(event)