[chiplotle-discuss] Path command

[francesco fantoni]

Hello Victor, I have another suggestion for chiplotle:
I've made a new compound command that takes advantage of the same
functions used for Bezier command, I've called it Path. It basically
traces a path passing through a list of given points, this are not
bezier control points, they are directly ON the path.
The funny thing is that the command has a parameter called 'curvature',
going from 0.0 to 1.0 with 1.0 as default value.
curvature = 0 means a straight line passing through all the points
curvature = 1 gives a nice bezier curve, passing through the points but
following a smooth, fluid path.
Intermediate values give a more flat bezier.
The form of the command is: Path(list_of_points, curvature=1.0)
I attach examples of plotted paths showing curvature values of 0.00, 0.5
and 1.0.

best,
francesco
-------------- next part --------------
A non-text attachment was scrubbed...
Name: path_example_2.jpg
Type: image/jpeg
Size: 11533 bytes
Desc: not available
Url : http://music.columbia.edu/pipermail/chiplotle-discuss/attachments/20100313/e17d46d5/attachment-0002.jpg 
-------------- next part --------------
A non-text attachment was scrubbed...
Name: path_example_1.jpg
Type: image/jpeg
Size: 10145 bytes
Desc: not available
Url : http://music.columbia.edu/pipermail/chiplotle-discuss/attachments/20100313/e17d46d5/attachment-0003.jpg 
-------------- next part --------------
from chiplotle.hpgl.compound.compound import _CompoundHPGL
from chiplotle.hpgl.commands import PU, PD, PA
from chiplotle.hpgl.scalable import Scalable
from chiplotle.utils.geometry import *
from chiplotle.tools.mathtools import bezier_interpolation


class Path(_CompoundHPGL):
	'''draws a path given a list of waypoints'''
	def __init__(self, points, xy=None, curvature=1.0):
		self.points = Scalable(points)
		## points_to_compute determines the number of points calculated for each step of the curve
		self.points_to_compute = 50
		self.curvature = max(0, min(1, curvature))
		xy = xy or (0, 0)
		_CompoundHPGL.__init__(self, xy) 


	@property
	def _subcommands(self):
		result = _CompoundHPGL._subcommands.fget(self)
		if self.curvature == 0:
			## Zero curvature means straight lines.
			plot_points = self.points
			result.append(PU( ))
			result.append(PA(self.xyabsolute + plot_points[0]))
			result.append(PD( ))
			for point_tuple in plot_points[1:]:
				position = self.xyabsolute + point_tuple
				result.append(PA(position))
			result.append(PU( ))
		else:
			curvature = 4 + (1.0-self.curvature)*40
			dx = {0: 0, len(self.points)-1: 0}
			dy = {0: 0, len(self.points)-1: 0}
			bi = {1: -0.25}
			ax = {1: (self.points[2][0]-self.points[0][0]-dx[0]) / 4}
			ay = {1: (self.points[2][1]-self.points[0][1]-dy[0]) / 4}

			for i in range(2, len(self.points)-1):
				bi[i] = -1 / (curvature + bi[i-1])
				ax[i] = -(self.points[i+1][0]-self.points[i-1][0]-ax[i-1]) * bi[i]
				ay[i] = -(self.points[i+1][1]-self.points[i-1][1]-ay[i-1]) * bi[i]

			r = range(1, len(self.points)-1)
			r.reverse()
			for i in r:
				dx[i] = ax[i] + dx[i+1] * bi[i]
				dy[i] = ay[i] + dy[i+1] * bi[i]

			result.append(PU( ))
			result.append(PA(self.xyabsolute + self.points[0]))
			result.append(PD( ))
			for i in range(len(self.points)-1):
				control_points=[(self.points[i][0],
								self.points[i][1]),
								(self.points[i][0]+dx[i],
								self.points[i][1]+dy[i]),
								(self.points[i+1][0] - dx[i+1],
								self.points[i+1][1] - dy[i+1]),
								(self.points[i+1][0],
								self.points[i+1][1])]
				plot_points = bezier_interpolation(
								control_points, 
								self.points_to_compute)
				for point_tuple in plot_points:
					position = self.xyabsolute + point_tuple
					result.append(PA(position))
			result.append(PU( ))
		return result