def Read(self, caller):
#Kürzere Namen zuweisen
lp = caller.line_pairs
#Layer zuweisen
s = lp.index_code(8, caller.start + 1)
self.Layer_Nr = caller.Get_Layer_Nr(lp.line_pair[s].value)
#XWert
s = lp.index_code(10, s + 1)
x0 = float(lp.line_pair[s].value)
#YWert
s = lp.index_code(20, s + 1)
y0 = float(lp.line_pair[s].value)
#XWert2
s = lp.index_code(11, s + 1)
x1 = float(lp.line_pair[s].value)
#YWert2
s = lp.index_code(21, s + 1)
y1 = float(lp.line_pair[s].value)
Pa = PointClass(x0, y0)
Pe = PointClass(x1, y1)
#Anhängen der LineGeo Klasse für die Geometrie
self.geo.append(LineGeo(Pa=Pa, Pe=Pe))
#Länge entspricht der Länge des Kreises
self.length = self.geo[-1].length
#Neuen Startwert für die nächste Geometrie zurückgeben
caller.start = s
def Read(self, caller):
#Kürzere Namen zuweisen
lp = caller.line_pairs
e = lp.index_code(0, caller.start + 1)
#Layer zuweisen
s = lp.index_code(8, caller.start + 1)
self.Layer_Nr = caller.Get_Layer_Nr(lp.line_pair[s].value)
#XWert, YWert Center
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 = PointClass(x0, y0)
#XWert, YWert. Vektor, relativ zum Zentrum, Große Halbachse
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 = PointClass(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
s = lp.index_code(41, s + 1)
self.Start_Ang = float(lp.line_pair[s].value)
#End Winkel - Achtung, ist als rad (0-2pi) im dxf
s = lp.index_code(42, s + 1)
self.End_Ang = float(lp.line_pair[s].value)
#Neuen Startwert für die nächste Geometrie zurückgeben
caller.start = e
def __init__(self, Nr=0, caller=None):
self.Typ = 'Ellipse'
self.Nr = Nr
#Initialisieren der Werte
self.Layer_Nr = 0
self.center = PointClass(0, 0) #Mittelpunkt der Geometrie
self.vector = PointClass(
1, 0) #Vektor A = große Halbachse a, = Drehung der Ellipse
# http://de.wikipedia.org/wiki/Gro%C3%9Fe_Halbachse
self.ratio = 1 #Verhältnis der kleinen zur großen Halbachse (b/a)
self.AngS = 0 #Startwinkel beim zeichnen eines Ellipsensegments
self.AngE = radians(360) #Endwinkel (Winkel im DXF als Radians!)
#Die folgenden Grundwerte werden später ein mal berechnet
self.length = 0
self.Points = []
self.Points.append(self.center)
#Lesen der Geometrie
self.Read(caller)
#Zuweisen der Toleranz fürs Fitting
tol = caller.config.fitting_tolerance.get()
#Errechnen der Ellipse
self.Ellipse_Grundwerte()
self.Ellipse_2_Arcs(tol)
def plot_cut_info(self, CanvasClass, config):
hdls = []
hdls.append(self.plot_start(CanvasClass))
hdls.append(self.plot_end(CanvasClass))
if self.cut_cor > 40:
hdls.append(self.plot_cut_cor(CanvasClass))
#Versatz des Zeichnens durch Position
P0=PointClass(x=-CanvasClass.dx*CanvasClass.scale,\
y=-CanvasClass.dy*CanvasClass.scale-CanvasClass.canvas.winfo_height())
#Korrektur der Skalierung
sca = [CanvasClass.scale] * 3
self.make_start_moves(config)
hdls += self.st_move[1].plot2can(CanvasClass.canvas,
P0,
sca,
tag=self.nr,
col='SteelBlue3')
hdls += self.st_move[2].plot2can(CanvasClass.canvas,
P0,
sca,
tag=self.nr,
col='SteelBlue3')
return hdls
def Read(self, caller):
#Kürzere Namen zuweisen
lp = caller.line_pairs
e = lp.index_code(0, caller.start + 1)
#Layer zuweisen
s = lp.index_code(8, caller.start + 1)
self.Layer_Nr = caller.Get_Layer_Nr(lp.line_pair[s].value)
#Spline Flap zuweisen
s = lp.index_code(70, s + 1)
self.Spline_flag = int(lp.line_pair[s].value)
#Spline Ordnung zuweisen
s = lp.index_code(71, s + 1)
self.degree = int(lp.line_pair[s].value)
#Number of CPts
s = lp.index_code(73, s + 1)
nCPts = int(lp.line_pair[s].value)
#Lesen der Knoten
while 1:
#Knoten Wert
sk = lp.index_code(40, s + 1, e)
if sk == None:
break
self.Knots.append(float(lp.line_pair[sk].value))
s = sk
#Lesen der Gewichtungen
while 1:
#Knoten Gewichtungen
sg = lp.index_code(41, s + 1, e)
if sg == None:
break
self.Weights.append(float(lp.line_pair[sg].value))
s = sg
if len(self.Weights) == 0:
for nr in range(nCPts):
self.Weights.append(1)
#Lesen der Kontrollpunkte
while 1:
#XWert
s = lp.index_code(10, s + 1, e)
#Wenn kein neuer Punkt mehr gefunden wurde abbrechen ...
if s == None:
break
x = float(lp.line_pair[s].value)
#YWert
s = lp.index_code(20, s + 1, e)
y = float(lp.line_pair[s].value)
self.CPoints.append(PointClass(x, y))
caller.start = e
def Read(self, caller):
#Kürzere Namen zuweisen
lp=caller.line_pairs
e=lp.index_both(0,"SEQEND",caller.start+1)+1
#Layer zuweisen
s=lp.index_code(8,caller.start+1)
self.Layer_Nr=caller.Get_Layer_Nr(lp.line_pair[s].value)
#Pa=None für den ersten Punkt
Pa=None
while 1:
s=lp.index_both(0,"VERTEX",s+1,e)
if s==None:
break
#XWert
s=lp.index_code(10,s+1,e)
x=float(lp.line_pair[s].value)
#YWert
s=lp.index_code(20,s+1,e)
y=float(lp.line_pair[s].value)
Pe=PointClass(x=x,y=y)
#Zuweisen der Geometrien für die Polyline
if not(type(Pa)==type(None)):
self.geo.append(LineGeo(Pa=Pa,Pe=Pe))
self.length+=self.geo[-1].length
Pa=Pe
#Neuen Startwert für die nächste Geometrie zurückgeben
caller.start=e
def analyse_and_opt(self):
summe=0
#Richtung in welcher der Anfang liegen soll (unten links)
Popt=PointClass(x=-1e3,y=-1e6)
#Berechnung der Fläch nach Gauß-Elling Positive Wert bedeutet CW
#negativer Wert bedeutet CCW geschlossenes 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!)
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
self.geo=self.geo[min_geo_nr:len(self.geo)]+self.geo[0:min_geo_nr]
def Read(self, caller):
#Kürzere Namen zuweisen
lp = caller.line_pairs
e = lp.index_code(0, caller.start + 1)
#Block Name
ind = lp.index_code(2, caller.start + 1, e)
self.Block = caller.Get_Block_Nr(lp.line_pair[ind].value)
#Layer zuweisen
s = lp.index_code(8, caller.start + 1, e)
self.Layer_Nr = caller.Get_Layer_Nr(lp.line_pair[s].value)
#XWert
s = lp.index_code(10, s + 1, e)
x0 = float(lp.line_pair[s].value)
#YWert
s = lp.index_code(20, s + 1, e)
y0 = float(lp.line_pair[s].value)
self.Point = PointClass(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)
#Neuen Startwert für die nächste Geometrie zurückgeben
caller.start = e
def Ellipse_Point(self, alpha=0): #PointClass(0,0)
#große Halbachse, kleine Halbachse, rotation der Ellipse (rad), Winkel des Punkts in der Ellipse (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 PointClass(self.center.x + Ex, self.center.y + Ey)
def Read(self, caller):
Old_Point = PointClass(0, 0)
#Kürzere Namen zuweisen
lp = caller.line_pairs
e = lp.index_code(0, caller.start + 1)
#Layer zuweisen
s = lp.index_code(8, caller.start + 1)
self.Layer_Nr = caller.Get_Layer_Nr(lp.line_pair[s].value)
#Pa=None für den ersten Punkt
Pa = None
#Number of vertices
s = lp.index_code(90, s + 1, e)
NoOfVert = int(lp.line_pair[s].value)
#Polyline flag (bit-coded); default is 0; 1 = Closed; 128 = Plinegen
s = lp.index_code(70, s + 1, e)
LWPLClosed = int(lp.line_pair[s].value)
for i in range(1, NoOfVert):
#XWert
s = lp.index_code(10, s + 1, e)
x = float(lp.line_pair[s].value)
#YWert
s = lp.index_code(20, s + 1, e)
y = float(lp.line_pair[s].value)
Pe = PointClass(x=x, y=y)
#Zuweisen der Geometrien für die Polyline
if not (type(Pa) == type(None)):
self.geo.append(LineGeo(Pa=Pa, Pe=Pe))
self.length += self.geo[-1].length
Pa = Pe
if (LWPLClosed == 1):
self.geo.append(LineGeo(Pa=Pa, Pe=self.geo[0].Pa))
self.length += self.geo[-1].length
#Neuen Startwert für die nächste Geometrie zurückgeben
caller.start = e
def __init__(self,nr='None',ent_nr='None',ent_cnr='None',closed=0,\
p0=PointClass(x=0,y=0),sca=[],cut_cor=40,length=0.0,geos=[],geos_hdls=[]):
self.nr = nr
self.ent_nr = ent_nr
self.ent_cnr = ent_cnr
self.closed = closed
self.p0 = p0
self.sca = sca
self.cut_cor = 40
self.length = length
self.geos = geos
self.geos_hdls = geos_hdls
def analyse_and_opt(self):
#Richtung in welcher der Anfang liegen soll (unten links)
Popt = PointClass(x=-1e3, y=-1e6)
#Suchen des kleinsten Startpunkts von unten Links X zuerst (Muss neue Schleife sein!)
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
self.geo = self.geo[min_geo_nr:len(self.geo)] + self.geo[0:min_geo_nr]
def Read(self, caller):
#Kürzere Namen zuweisen
lp = caller.line_pairs
#Layer zuweisen
s = lp.index_code(8, caller.start + 1)
self.Layer_Nr = caller.Get_Layer_Nr(lp.line_pair[s].value)
#XWert
s = lp.index_code(10, s + 1)
x0 = float(lp.line_pair[s].value)
#YWert
s = lp.index_code(20, s + 1)
y0 = float(lp.line_pair[s].value)
O = PointClass(x0, y0)
#Radius
s = lp.index_code(40, s + 1)
r = float(lp.line_pair[s].value)
#Start Winkel
s = lp.index_code(50, s + 1)
s_ang = radians(float(lp.line_pair[s].value))
#End Winkel
s = lp.index_code(51, s + 1)
e_ang = radians(float(lp.line_pair[s].value))
#Berechnen der Start und Endwerte des Arcs
Pa = PointClass(x=cos(s_ang) * r, y=sin(s_ang) * r) + O
Pe = PointClass(x=cos(e_ang) * r, y=sin(e_ang) * r) + O
#Anhängen der ArcGeo Klasse für die Geometrie
self.geo.append(
ArcGeo(Pa=Pa, Pe=Pe, O=O, r=r, s_ang=s_ang, e_ang=e_ang, dir=1))
#Länge entspricht der Länge des Kreises
self.length = self.geo[-1].length
#Neuen Startwerd für die nächste Geometrie zurückgeben
caller.start = s
def calc_curve(self, n=0, cpts_nr=20):
#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(PointClass(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 Write_GCode(self, config, postpro):
#Erneutes erstellen der Einlaufgeometrien
self.make_start_moves(config)
depth = config.axis3_mill_depth.get()
max_slice = config.axis3_slice_depth.get()
#Scheibchendicke bei Frästiefe auf Frästiefe begrenzen
if -abs(max_slice) <= depth:
mom_depth = depth
else:
mom_depth = -abs(max_slice)
#Positionieren des Werkzeugs über dem Anfang und Eintauchen
self.st_move[0].Write_GCode([1,1,1],\
PointClass(x=0,y=0),\
postpro)
postpro.rap_pos_z(config.axis3_safe_margin.get())
postpro.chg_feed_rate(config.F_G1_Depth.get())
postpro.lin_pol_z(mom_depth)
postpro.chg_feed_rate(config.F_G1_Plane.get())
#Wenn G41 oder G42 an ist Fräsradiuskorrektur
if self.cut_cor != 40:
postpro.set_cut_cor(self.cut_cor)
self.st_move[1].Write_GCode([1,1,1],\
PointClass(x=0,y=0),\
postpro)
self.st_move[2].Write_GCode([1,1,1],\
PointClass(x=0,y=0),\
postpro)
#Schreiben der Geometrien für den ersten Schnitt
for geo in self.geos:
geo.Write_GCode(self.sca, self.p0, postpro)
#Zählen der Schleifen
snr = 0
#Schleifen für die Anzahl der Schnitte
while mom_depth > depth:
snr += 1
mom_depth = mom_depth - abs(max_slice)
if mom_depth < depth:
mom_depth = depth
#Erneutes Eintauchen
postpro.chg_feed_rate(config.F_G1_Depth.get())
postpro.lin_pol_z(mom_depth)
postpro.chg_feed_rate(config.F_G1_Plane.get())
#Falls es keine geschlossene Kontur ist
if self.closed == 0:
self.reverse()
self.switch_cut_cor()
#Falls cut correction eingeschaltet ist diese umdrehen.
if not (self.cut_cor == 40):
postpro.set_cut_cor(self.cut_cor)
for geo_nr in range(len(self.geos)):
self.geos[geo_nr].Write_GCode(self.sca, self.p0, postpro)
#Anfangswert für Direction wieder herstellen falls nötig
if (snr % 2) > 0:
self.reverse()
self.switch_cut_cor()
#Fertig und Zurückziehen des Werkzeugs
postpro.lin_pol_z(config.axis3_safe_margin.get())
postpro.rap_pos_z(config.axis3_retract.get())
postpro.set_cut_cor(40)
return 1
def HPt_2_Pt(self, HPt):
return PointClass(x=HPt[0] / HPt[-1], y=HPt[1] / HPt[-1])