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 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.AngS = float(lp.line_pair[s].value)
#End Winkel - Achtung, ist als rad (0-2pi) im 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
caller.start = e
def plot_cut_cor(self, Canvas=None, length=20):
start, start_ang = self.get_st_en_points(0)
#BaseEntitie erstellen um auf oberster Ebene zu Fräsen
BaseEntitie = EntitieContentClass(Nr=-1,
Name='BaseEntitie',
parent=None,
children=[],
p0=PointClass(x=0.0, y=0.0),
pb=PointClass(x=0.0, y=0.0),
sca=[1, 1, 1],
rot=0.0)
x_ca, y_ca = Canvas.get_can_coordinates(start.x, start.y)
if self.cut_cor == 41:
start_ang = start_ang + 90
else:
start_ang = start_ang - 90
dx = cos(radians(start_ang)) * length
dy = sin(radians(start_ang)) * length
hdl = Line(Canvas.canvas,
x_ca,
-y_ca,
x_ca + dx,
-y_ca - dy,
fill='SteelBlue3',
arrow='last')
return hdl
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 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 bulge2arc(self,Pa,Pe,bulge):
c=(1/bulge-bulge)/2
#Berechnung des Mittelpunkts (Formel von Mickes!
O=PointClass(x=(Pa.x+Pe.x-(Pe.y-Pa.y)*c)/2,\
y=(Pa.y+Pe.y+(Pe.x-Pa.x)*c)/2)
#Abstand zwischen dem Mittelpunkt und PA ist der Radius
r=O.distance(Pa)
#Kontrolle ob beide gleich sind (passt ...)
#r=O.distance(Pe)
#Unterscheidung für den Öffnungswinkel.
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 bulge2arc(self, Pa, Pe, bulge):
c = (1 / bulge - bulge) / 2
#Berechnung des Mittelpunkts (Formel von Mickes!
O=PointClass(x=(Pa.x+Pe.x-(Pe.y-Pa.y)*c)/2,\
y=(Pa.y+Pe.y+(Pe.x-Pa.x)*c)/2)
#Abstand zwischen dem Mittelpunkt und PA ist der Radius
r = O.distance(Pa)
#Kontrolle ob beide gleich sind (passt ...)
#r=O.distance(Pe)
#Unterscheidung für den Öffnungswinkel.
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 __init__(self,
type="Entitie",
Nr=None,
Name='',
parent=None,
children=[],
p0=PointClass(x=0.0, y=0.0),
pb=PointClass(x=0.0, y=0.0),
sca=[1, 1, 1],
rot=0.0):
self.type = type
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 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)
#Berechnen der Start und Endwerte des Kreises ohne Überschneidung
s_ang = -3 * pi / 4
m_ang = s_ang - pi
e_ang = -3 * pi / 4
#Berechnen der Start und Endwerte des Arcs
Pa = PointClass(x=cos(s_ang) * r, y=sin(s_ang) * r) + O
Pm = PointClass(x=cos(m_ang) * r, y=sin(m_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=Pm, O=O, r=r, s_ang=s_ang, e_ang=m_ang, dir=-1))
self.geo.append(
ArcGeo(Pa=Pm, Pe=Pe, O=O, r=r, s_ang=m_ang, e_ang=e_ang, dir=-1))
#Länge entspricht der Länge des Kreises
self.length = self.geo[-1].length + self.geo[-2].length
#Neuen Startwert für die nächste Geometrie zurückgeben
caller.start = s
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 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))
self.make_start_moves(config)
#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
#BaseEntitie erstellen um auf oberster Ebene zu Fräsen
BaseEntitie = EntitieContentClass(Nr=-1,
Name='BaseEntitie',
parent=None,
children=[],
p0=P0,
pb=PointClass(x=0.0, y=0.0),
sca=sca,
rot=0.0)
hdls += self.st_move[1].plot2can(CanvasClass.canvas,
BaseEntitie,
tag=self.nr,
col='SteelBlue3')
hdls += self.st_move[2].plot2can(CanvasClass.canvas,
BaseEntitie,
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)
#Block Name
ind = lp.index_code(2, caller.start + 1, e)
#print lp.line_pair[ind].value ####################################################################
self.BlockName = 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)
#Rotation
s_temp = lp.index_code(50, s + 1, e)
if s_temp != None:
self.rot = radians(float(lp.line_pair[s_temp].value))
#Neuen Startwert für die nächste Geometrie zurückgeben
caller.start = e
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 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_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
#Polyline flag
s_temp = lp.index_code(70, s + 1, e)
if s_temp == None:
PolyLineFlag = 0
else:
PolyLineFlag = int(lp.line_pair[s_temp].value)
s = s_temp
#print("PolylineFlag: %i" %PolyLineFlag)
while 1: #and not(s==None):
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)
#Bulge
bulge = 0
e_vertex = lp.index_both(0, "VERTEX", s + 1, e)
if e_vertex == None:
e_vertex = e
s_temp = lp.index_code(42, s + 1, e_vertex)
#print('stemp: %s, e: %s, next 10: %s' %(s_temp,e,lp.index_both(0,"VERTEX",s+1,e)))
if s_temp != None:
bulge = float(lp.line_pair[s_temp].value)
s = s_temp
#Vertex flag (bit-coded); default is 0; 1 = Closed; 128 = Plinegen
s_temp = lp.index_code(70, s + 1, e_vertex)
if s_temp == None:
VertexFlag = 0
else:
VertexFlag = int(lp.line_pair[s_temp].value)
s = s_temp
#print("Vertex Flag: %i" %PolyLineFlag)
#Zuweisen der Geometrien für die Polyline
if (VertexFlag != 16):
if type(Pa) != type(None):
if next_bulge == 0:
self.geo.append(LineGeo(Pa=Pa, Pe=Pe))
else:
#self.geo.append(LineGeo(Pa=Pa,Pe=Pe))
#print bulge
self.geo.append(self.bulge2arc(Pa, Pe, next_bulge))
#Länge drauf rechnen wenns eine Geometrie ist
self.length += self.geo[-1].length
#Der Bulge wird immer für den und den nächsten Punkt angegeben
next_bulge = bulge
Pa = Pe
#Es ist eine geschlossene Polyline
if PolyLineFlag == 1:
#print("sollten Übereinstimmen: %s, %s" %(Pa,Pe))
if next_bulge == 0:
self.geo.append(LineGeo(Pa=Pa, Pe=self.geo[0].Pa))
else:
self.geo.append(self.bulge2arc(Pa, self.geo[0].Pa, next_bulge))
#Länge drauf rechnen wenns eine Geometrie ist
self.length += self.geo[-1].length
#Neuen Startwert für die nächste Geometrie zurückgeben
caller.start = e
def Write_GCode(self, config, postpro):
#Erneutes erstellen der Einlaufgeometrien
self.make_start_moves(config)
#Werkzeugdurchmesser in Radius umrechnen
tool_rad = config.tool_dia.get() / 2
#BaseEntitie erstellen um auf oberster Ebene zu Fräsen
BaseEntitie = EntitieContentClass(Nr=-1,
Name='BaseEntitie',
parent=None,
children=[],
p0=PointClass(x=0.0, y=0.0),
pb=PointClass(x=0.0, y=0.0),
sca=[1, 1, 1],
rot=0.0)
depth = config.axis3_mill_depth.get()
max_slice = config.axis3_slice_depth.get()
#Wenn Output Format DXF dann nur einmal Fräsen
if postpro.output_type == 'dxf':
depth = max_slice
#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(parent=BaseEntitie, postpro=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:
#Errechnen des Startpunkts ohne Werkzeug Kompensation
#und einschalten der Kompensation
start, start_ang = self.get_st_en_points(0)
postpro.set_cut_cor(self.cut_cor, start)
self.st_move[1].Write_GCode(parent=BaseEntitie, postpro=postpro)
self.st_move[2].Write_GCode(parent=BaseEntitie, postpro=postpro)
#Schreiben der Geometrien für den ersten Schnitt
for geo in self.geos:
geo.Write_GCode(self.parent, postpro)
#Ausschalten der Fräsradiuskorrektur
if (not (self.cut_cor == 40)) & (postpro.cancel_cc_for_depth == 1):
ende, en_angle = self.get_st_en_points(1)
if self.cut_cor == 41:
pos_cut_out = ende.get_arc_point(en_angle - 90, tool_rad)
elif self.cut_cor == 42:
pos_cut_out = ende.get_arc_point(en_angle + 90, tool_rad)
postpro.deactivate_cut_cor(pos_cut_out)
#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 einschalten.
if ((not (self.cut_cor == 40)) &
(self.closed == 0)) or (postpro.cancel_cc_for_depth == 1):
#Errechnen des Startpunkts ohne Werkzeug Kompensation
#und einschalten der Kompensation
postpro.set_cut_cor(self.cut_cor, start)
for geo_nr in range(len(self.geos)):
self.geos[geo_nr].Write_GCode(self.parent, postpro)
#Errechnen des Konturwerte mit Fräsradiuskorrektur und ohne
ende, en_angle = self.get_st_en_points(1)
if self.cut_cor == 41:
pos_cut_out = ende.get_arc_point(en_angle - 90, tool_rad)
elif self.cut_cor == 42:
pos_cut_out = ende.get_arc_point(en_angle + 90, tool_rad)
#Ausschalten der Fräsradiuskorrektur falls benötigt
if (not (self.cut_cor == 40)) & (postpro.cancel_cc_for_depth == 1):
postpro.deactivate_cut_cor(pos_cut_out)
#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())
#Falls Fräsradius Korrektur noch nicht ausgeschaltet ist ausschalten.
if (not (self.cut_cor == 40)) & (not (postpro.cancel_cc_for_depth)):
#Errechnen des Konturwerte mit Fräsradiuskorrektur und ohne
ende, en_angle = self.get_st_en_points(1)
postpro.deactivate_cut_cor(ende)
return 1
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
st = lp.index_code(73, s + 1)
nCPts = int(lp.line_pair[s].value)
s = st
#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
s = st
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
#Lesen der Kontrollpunkte
s = st
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))
if len(self.Weights) == 0:
for nr in range(len(self.CPoints)):
self.Weights.append(1)
caller.start = e
def get_all_vars(self,pp_file_nr):
self.parser.read(os.path.join(self.folder,self.postprocessor_files[pp_file_nr]))
#try:
self.output_type=self.parser.get('General', 'output_type')
self.abs_export=int(self.parser.get('General', 'abs_export'))
self.cancel_cc_for_depth=int(self.parser.get('General', 'cancel_cc_for_depth'))
self.export_ccw_arcs_only=int(self.parser.get('General', 'export_ccw_arcs_only'))
self.max_arc_radius=int(self.parser.get('General','max_arc_radius'))
self.gcode_be=self.parser.get('General', 'code_begin')
self.gcode_en=self.parser.get('General', 'code_end')
self.pre_dec=int(self.parser.get('Number format','pre_decimals'))
self.post_dec=int(self.parser.get('Number format','post_decimals'))
self.dec_sep=self.parser.get('Number format','decimal_seperator')
self.pre_dec_z_pad=int(self.parser.get('Number format','pre_decimal_zero_padding'))
self.post_dec_z_pad=int(self.parser.get('Number format','post_decimal_zero_padding'))
self.signed_val=int(self.parser.get('Number format','signed_values'))
self.use_line_nrs=int(self.parser.get('Line numbers','use_line_nrs'))
self.line_nrs_begin=int(self.parser.get('Line numbers','line_nrs_begin'))
self.line_nrs_step=int(self.parser.get('Line numbers','line_nrs_step'))
self.tool_ch_str=self.parser.get('Program','tool_change')
self.feed_ch_str=self.parser.get('Program','feed_change')
self.rap_pos_plane_str=self.parser.get('Program','rap_pos_plane')
self.rap_pos_depth_str=self.parser.get('Program','rap_pos_depth')
self.lin_mov_plane_str=self.parser.get('Program','lin_mov_plane')
self.lin_mov_depth_str=self.parser.get('Program','lin_mov_depth')
self.arc_int_cw=self.parser.get('Program','arc_int_cw')
self.arc_int_ccw=self.parser.get('Program','arc_int_ccw')
self.cut_comp_off_str=self.parser.get('Program','cutter_comp_off')
self.cut_comp_left_str=self.parser.get('Program','cutter_comp_left')
self.cut_comp_right_str=self.parser.get('Program','cutter_comp_right')
self.feed=0
self.Pe=PointClass( x=self.config.axis1_st_en.get(),
y=self.config.axis2_st_en.get())
self.Pa=PointClass(x=self.config.axis1_st_en.get(),
y=self.config.axis2_st_en.get())
self.lPe=PointClass( x=self.config.axis1_st_en.get(),
y=self.config.axis2_st_en.get())
self.IJ=PointClass( x=0.0,y=0.0)
self.O=PointClass( x=0.0,y=0.0)
self.r=0.0
self.a_ang=0.0
self.e_ang=0.0
self.ze=self.config.axis3_retract.get()
self.lz=self.ze
self.vars={"%feed":'self.iprint(self.feed)',\
"%nl":'self.nlprint()',\
"%XE":'self.fnprint(self.Pe.x)',\
"%-XE":'self.fnprint(-self.Pe.x)',\
"%XA":'self.fnprint(self.Pa.x)',\
"%-XA":'self.fnprint(-self.Pa.x)',\
"%YE":'self.fnprint(self.Pe.y)',\
"%-YE":'self.fnprint(-self.Pe.y)',\
"%YA":'self.fnprint(self.Pa.y)',\
"%-YA":'self.fnprint(-self.Pa.y)',\
"%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)',\
"%-J":'self.fnprint(-self.IJ.y)',\
"%XO":'self.fnprint(self.O.x)',\
"%-XO":'self.fnprint(-self.O.x)',\
"%YO":'self.fnprint(self.O.y)',\
"%-YO":'self.fnprint(-self.O.y)',\
"%R":'self.fnprint(self.r)',\
"%AngA":'self.fnprint(degrees(self.a_ang))',\
"%-AngA":'self.fnprint(degrees(-self.a_ang))',\
"%AngE":'self.fnprint(degrees(self.e_ang))',\
"%-AngE":'self.fnprint(degrees(-self.e_ang))'}
def HPt_2_Pt(self, HPt):
return PointClass(x=HPt[0] / HPt[-1], y=HPt[1] / HPt[-1])
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)
#print LWPLClosed
s = lp.index_code(10, s + 1, e)
while 1:
#XWert
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)
Pe = PointClass(x=x, y=y)
#Bulge
bulge = 0
s_nxt_x = lp.index_code(10, s + 1, e)
e_nxt_b = s_nxt_x
#Wenn am Ende dann Suche bis zum Ende
if e_nxt_b == None:
e_nxt_b = e
s_bulge = lp.index_code(42, s + 1, e_nxt_b)
#print('stemp: %s, e: %s, next 10: %s' %(s_temp,e,lp.index_code(10,s+1,e)))
if s_bulge != None:
bulge = float(lp.line_pair[s_bulge].value)
s_nxt_x = s_nxt_x
#Übernehmen des nächsten X Wert als Startwert
s = s_nxt_x
#Zuweisen der Geometrien für die Polyline
if not (type(Pa) == type(None)):
if next_bulge == 0:
self.geo.append(LineGeo(Pa=Pa, Pe=Pe))
else:
#self.geo.append(LineGeo(Pa=Pa,Pe=Pe))
#print bulge
self.geo.append(self.bulge2arc(Pa, Pe, next_bulge))
#Länge drauf rechnen wenns eine Geometrie ist
self.length += self.geo[-1].length
#Der Bulge wird immer für den und den nächsten Punkt angegeben
next_bulge = bulge
Pa = Pe
if (LWPLClosed == 1) or (LWPLClosed == 129):
#print("sollten Übereinstimmen: %s, %s" %(Pa,Pe))
if next_bulge:
self.geo.append(self.bulge2arc(Pa, self.geo[0].Pa, next_bulge))
else:
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