[chiplotle-discuss] bezier curves
vga2102 at columbia.edu
Fri Mar 12 17:23:13 EST 2010
I've made a few changes to your code and I've added it to the repository. SVN update and test it. I hope I didn't break it.
I added scaling and transposition capability, and a variable to let the user set the number of interpolation points. I also moved the computation of the bezier interpolation function to a `mathtools` folder, as well as the `pascal_row` function.
I think a next improvement would be to calculate the slope of the curve at each point and remove those points for which the slope is smaller than a given threshold. This would eliminate the drawing of points that fall on a quasi-straight line, making the drawing faster.
On Fri, Mar 12, 2010 at 02:15:01PM -0500, Victor Adan wrote:
> hello Francesco,
> This is fantastic!! We have been thinking about implementing something like this, and now you have done it!
> I'll take a careful look at the code and add it to the repository.
> On Fri, Mar 12, 2010 at 11:18:36AM +0100, francesco fantoni wrote:
> > As in HPGL/1 there are no bezier curves as far as I know, I was thinking
> > about a chiplote compound command in order to aproximate a bezier.
> > I've written a first implementation, and it seems to work.
> > the compound command is 'Bezier(list)', where list is a list of tuples.
> > Each tuple contains the absolute coordinates of bezier curve's control
> > points.
> > I'm using PA commands to plot the sequence of aproximated points
> > calculated by the routine, probably circle arcs could be used in a more
> > sophisticated way, but I think it's way too complex for me.
> > I include an image of my test, showing some variations of a curve with
> > some control point in common, and some 20 curves drawn with random
> > control points.
> > Maybe it's interesting.
> > (obviously bezier.py goes in chiplotle-trunk/chiplotle/hpgl/compound/)
> > best regards,
> > francesco
> > 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 *
> > class Bezier(_CompoundHPGL):
> > '''Bezier curve aproximation'''
> > def __init__(self, control_points):
> > self.control_points = control_points
> > xy = self.control_points
> > _CompoundHPGL.__init__(self, xy)
> > def pascal_row(n):
> > # This returns the nth row of Pascal's Triangle
> > result=
> > x,numerator=1,n
> > for denominator in range(1,n//2+1):
> > # print(numerator,denominator,x)
> > x*=numerator
> > x/=denominator
> > result.append(x)
> > numerator-=1
> > if n&1==0:
> > # n is even
> > result.extend(reversed(result[:-1]))
> > else:
> > result.extend(reversed(result))
> > return result
> > self.n=len(self.control_points)
> > self.combinations=pascal_row(self.n-1)
> > # This uses the generalized formula for bezier curves
> > # http://en.wikipedia.org/wiki/B%C3%A9zier_curve#Generalization
> > self.plot_points=
> > ts=[t/100.0 for t in range(101)]
> > for t in ts:
> > tpowers=(t**i for i in range(self.n))
> > upowers=reversed([(1-t)**i for i in range(self.n)])
> > coefs=[c*a*b for c,a,b in zip(self.combinations,tpowers,upowers)]
> > self.plot_points.append(tuple(sum([coef*p for coef,p in zip(coefs,ps)]) for ps in zip(*self.control_points)))
> > self.plot_points_int=
> > for point in self.plot_points:
> > self.plot_points_int.append((int(point),int(point)))
> > @property
> > def _subcommands(self):
> > result = _CompoundHPGL._subcommands.fget(self)
> > result.append( PU( ) )
> > result.append( PA(self.plot_points_int) )
> > result.append( PD() )
> > for point_tuple in self.plot_points_int:
> > result.append( PA(point_tuple) )
> > result.append( PU() )
> > return result
> > _______________________________________________
> > chiplotle-discuss mailing list
> > chiplotle-discuss at music.columbia.edu
> > http://music.columbia.edu/mailman/listinfo/chiplotle-discuss
> chiplotle-discuss mailing list
> chiplotle-discuss at music.columbia.edu
More information about the chiplotle-discuss