relative angle added

arc started
move added

Author: cnc-club

bezier-console.py

@@ -22,14 +22,14 @@
 #		all values are relative if the case is lover to use absolute coordinates use upper case.
 ################################################################################
 
-from csp import CSP
+from csp import CSP, CSPsubpath
 from points import P
 from math import *
 import inkex
 import re
 import sys
 import traceback
-
+from biarc import Arc, Line
 
 def warn(s) :
 	if bezier_console.options.silent : return
@@ -102,6 +102,42 @@ def draw_line(self,x,y,a,l) :
 		p1 = self.get_line_xy(x,y,a,l)
 		self.path.join( CSP([[[self.p,self.p,self.p],[p1,p1,p1]]]) )
 
+
+	def move_to(self,x,y,a,l) :
+		p1 = self.get_line_xy(x,y,a,l)
+		self.path.items.append(CSPSubpath([[p1,p1,p1]])) 
+
+	def arc_on_two_points_and_slope(self,st,end,slope) :
+		# find the center 
+		m = (end - st)/2
+		n = slope.ccw()
+		# get the intersection of lines throught st and m normal to slope and st-end line
+		l1 = Line(st,st+n)
+		l2 = Line(st+m,st+m+m.ccw())
+		p = l1.intersect(l2,True) 
+		if len(p)!=1 : 
+			warn((p,l1,l2,slope))
+			error("Bad parameters for arc on two points. Command: %s"%self.command)
+		c = p[0]
+		a = (st-c).cross(slope)
+		return Arc(st,end,c,a)		 
+		
+		
+	def get_arc_param(self,x,y,a,r,i,j,l) :
+		st = self.p
+
+		if a==None and r==None and i==None and j==None and l==None :
+			# using two points and slope.
+			if x==None and y==None : error("To few parametersfor arc. Command: %s"%self.command) 
+			end = P(x if x!=None else self.p.x, y if y!=None else self.p.y)
+			return self.arc_on_two_points_and_slope(self.p,end,self.slope)
+
+					
+	def draw_arc(self,x,y,a,r,i,j,l) :
+		st = self.p
+		arc = self.get_arc_param(x,y,a,r,i,j,l)
+		warn(arc)
+		self.path.join(arc.to_csp())
 
 	def parse_command(self, a) :
 		if a.strip() == "" : return
@@ -115,10 +151,15 @@ def parse_command(self, a) :
 				t = self.last_command 
 			# parse the parameters 
 			x,y,a,l,r,i,j = None, None, None, None, None, None, None
+			try:
+				self.slope = self.path.slope(-1,-1,1)
+			except: 
+				self.slope = P(1.,0.)	
 			for p in re.findall("([alxyrijALXYRIJ])\s*(\-?\d*\.?\d*)",params) :
 				#warn(p)				
 				p = list(p)
-				if p[0] in ("a","A") : a = -float(p[1])/180*pi
+				if p[0] == "A" : a = -float(p[1])/180*pi
+				elif p[0] == "a" : a = self.slope.angle() -float(p[1])/180*pi
 				else :	p[1] = float(p[1])*self.options.units
 				if   p[0] == "x" : x = self.p.x + p[1]
 				elif p[0] == "X" : x = p[1]
@@ -128,15 +169,13 @@ def parse_command(self, a) :
 				elif p[0] == "I" : I = p[1]
 				elif p[0] == "j" : j = self.p.y - p[1]
 				elif p[0] == "J" : J = -p[1]
-
-				# TODO add relative angles
+				elif p[0] in ("r","R") : r = -p[1]
 				elif p[0] in ("l","L") : l = p[1]
 
 			# exec command
 			if t in ("l","L") : self.draw_line(x,y,a,l)
-			if t in ("h","H") : self.draw_line(x,self.p.y,None,l)
-			if t in ("v","V") : self.draw_line(self.p.x,y,None,l)
-			if t in ("a","A") : self.draw_line(self.p.x,y,None,l)
+			if t in ("a","A") : self.draw_arc(x,y,a,r,i,j,l)
+			if t in ("m","M") : self.move_to(x,y,a,l)
 			self.last_command = t
 
 	def effect(self) :

biarc.py

@@ -1,13 +1,15 @@
-import points
+from points import P
 from math import *
 import inkex
+from csp import CSP, CSPsubpath
+pi2 = pi*2
 
 ################################################################################
 ###		Biarc classes - Arc, Line and Biarc
 ################################################################################
 class Arc():
 	def __init__(self,st,end,c,a,r=None) :
-		debugger.add_debugger_to_class(self.__class__)
+		#debugger.add_debugger_to_class(self.__class__)
 		# a - arc's angle, it's not defining actual angle before now, but defines direction so it's value does not mather matters only the sign.
 		if st.__class__ == P :  st = st.to_list()
 		if end.__class__ == P : end = end.to_list()
@@ -28,6 +30,27 @@ def __repr__(self) :
 	def copy(self) :
 		return Arc(self.st,self.end,self.c,self.a,self.r)	
 
+	def to_csp(self) :
+		# Taken from cubicsuperpath's ArcToCsp	
+		O = self.c
+		sectors = int(abs(self.a)*2/pi)+1
+		da = self.a/sectors
+		v = 4*tan(da/4)/3
+		angle = (self.st-self.c).angle()
+		cspsubpath = CSPsubpath()
+		for i in range(sectors+1) :
+			c,s = cos(angle)*self.r, sin(angle)*self.r
+			v1=P([O.x+c - (-v)*s,	O.y+s + (-v)*c])
+			pt=P([O.x+c,			O.y+s])
+			v2=P([O.x+c - v*s,		O.y+s + v*c])
+			cspsubpath.points.append([v1,pt,v2])
+			angle += da 
+		cspsubpath.points[0][0] = cspsubpath.points[0][1].copy()
+		cspsubpath.points[-1][2] = cspsubpath.points[-1][1].copy()
+		csp = CSP()	
+		csp.items.append(cspsubpath)
+		return csp 
+		
 	def rebuild(self,st=None,end=None,c=None,a=None,r=None) : 
 		if st==None: st=self.st
 		if end==None: end=self.end
@@ -59,7 +82,7 @@ def bounds(self) :
 		x1,y1, x2,y2 =  ( min(self.st.x,self.end.x),min(self.st.y,self.end.y),
 						  max(self.st.x,self.end.x),max(self.st.y,self.end.y) )
 		# Then check 0,pi/2,pi and 2pi angles. 
-		if self.point_inside_angle(self.c+P(0,self.r)) :
+		if self.point_Gde_angle(self.c+P(0,self.r)) :
 			y2 = max(y2, self.c.y+self.r)
 		if self.point_inside_angle(self.c+P(0,-self.r)) :
 			y1 = min(y1, self.c.y-self.r)
@@ -174,7 +197,7 @@ def point_d2(self, p):
 class Line():
 
 	def __init__(self,st,end):
-		debugger.add_debugger_to_class(self.__class__)
+		#debugger.add_debugger_to_class(self.__class__)
 		if st.__class__ == P :  st = st.to_list()
 		if end.__class__ == P :	end = end.to_list()
 		self.st = P(st)
@@ -233,7 +256,7 @@ def draw(self, group=None, style=None, layer=None, transform=None, num = 0, reve
 			attr["transform"] = transform		
 		inkex.etree.SubElement(	group, inkex.addNS('path','svg'),  attr	)
 
-	def intersect(self,b) :
+	def intersect(self,b, false_intersection = False) :
 		if b.__class__ == Line :
 			if self.l < 10e-8 or b.l < 10e-8 : return []
 			v1 = self.end - self.st
@@ -260,7 +283,7 @@ def intersect(self,b) :
 				t1 = ( v2.x*(self.st.y-b.st.y) - v2.y*(self.st.x-b.st.x) ) / x
 				t2 = ( v1.x*(self.st.y-b.st.y) - v1.y*(self.st.x-b.st.x) ) / x
 
-				if 0<=t1<=1 and 0<=t2<=1 : return [ self.st+v1*t1 ]	
+				if 0<=t1<=1 and 0<=t2<=1 or false_intersection : return [ self.st+v1*t1 ]	
 				else : return []					
 		else: 
 			# taken from http://mathworld.wolfram.com/Circle-LineIntersection.html
@@ -277,10 +300,14 @@ def intersect(self,b) :
 			if descr==0 : return self.check_intersection(b.check_intersection([ P([D*dy/dr+b.c.x,-D*dx/dr+b.c.y]) ]))
 			sign = -1. if dy<0 else 1.
 			descr = sqrt(descr)
-			return self.check_intersection(b.check_intersection([
-						 P( [ (D*dy+sign*dx*descr)/dr+b.c.x, (-D*dx+abs(dy)*descr)/dr+b.c.y ]  ), 
+			points = [
+						 P( [ (D*dy+sign*dx*descr)/dr+b.c.x, (-D*dx+abs(dy)*descr)/dr+b.c.y ] ), 
 						 P( [ (D*dy-sign*dx*descr)/dr+b.c.x, (-D*dx-abs(dy)*descr)/dr+b.c.y ] )
-						]))
+					]
+			if false_intersection :
+				return points
+			else: 
+				return self.check_intersection(b.check_intersection( points ))
 
 
 	def check_intersection(self, points):
@@ -349,7 +376,7 @@ def point_d2(self, p) :
 
 class Biarc:
 	def __init__(self, items=None):
-		debugger.add_debugger_to_class(self.__class__)
+		#debugger.add_debugger_to_class(self.__class__)
 		if items == None :
 			self.items = []
 		else: 	

csp.py

@@ -92,8 +92,6 @@ def from_list(self, csp) :
 		for subpath in csp :
 			self.items.append(CSPsubpath(subpath))	
 
-			
-			
 	def to_list(self) :
 		res = []
 		for subpath in self.items :
@@ -113,10 +111,13 @@ def from_el(self, el) :
 	def to_string(self) : 
 		return cubicsuperpath.formatPath(self.to_list()) 
 
-
 	def length(self) :
 		return sum([subpath.length() for subpath in self.items()])
 
+	def slope(self,i,j,t) :
+		# slope - normalized slope, i.e. l(n)=1
+		return self.items[i].slope(j,t)
+
 	def normal(self,i,j,t) :
 		# normal - normalized normal, i.e. l(n)=1
 		return self.items[i].normal(j,t)