I needed some spline with tension tcl code. I hacked Keith Vetter's Cubic Splines GUI and added some tension algorithms. The reference where each algorithm came from is listed in the code.Enjoy!BAJ You can run this code via Jacl/Swank/Java Web Start at http://www.onemoonscientific.com/swank/tensionspline.jnlp
# the next line restarts using wish \
exec wish "$0" "$@" -visual truecolor
## Cubic Tension Splines: TensionSpline.tcl
###############################################################################################
## Greg Blair 2003-09-29 ##
## I took Keith Vetters Cubic Spline code and added TC and TCB tension, cardinal, ##
## Catmull Rom splines as well as linear and cosine interpolation ##
## using C code I found at: ##
## ##
## http://astronomy.swin.edu.au/~pbourke/analysis/interpolation/ and ##
## http://www.cubic.org/~submissive/sourcerer/hermite.htm ##
## ##
## I hand converted the c code to TCL, and extended Keith's test GUI for the new curve types ##
## ##
## I have include the comments from the websites as documentation to the methods implemented ##
###############################################################################################
##Keith Vetter 2003-03-07 - one feature often noted as missing from tk the ability of the canvas to do cubic splines.
##Here is a routine PolyLine::CubicSpline that takes a list of (x,y) values of control points and returns a
## list points on the cubic spline curve that's suitable to be used by: canvas create line [PolyLine::CubicSplint $xy] ...
##+##########################################################################
#
# CubicSpline -- routines to generate the coordinates of a cubic spline
# given a list of control points. Also included is demo/test harness
# by Keith Vetter
#
# Revisions:
# KPV Mar 07, 2003 - initial revision
#
namespace eval Cubic {}
namespace eval PolyLine {}
##+##########################################################################
#
# CubicSpline - returns the x,y coordinates of the cubic spline using
# xy control points.
# xy => {{x0 y0} {x1 y1} .... {xn yn}}
#
# XY points MUST BE SORTED by increasing x
#
proc PolyLine::CubicSpline {xy {PRECISION 10}} {
set np [expr {[llength $xy] / 2}]
if {$np <= 1} return
set idx 0
foreach {x y} $xy {
set X($idx) $x
set Y($idx) $y
incr idx
}
for {set i 1; set last $X(0)} {$i < $np} {set last $X($i); incr i} {
set h($i) [expr {double($X($i) - $last)}]
if {$h($i) == 0} return
if {$h($i) < 0} return ;# ERROR not sorted
}
if {$np > 2} {
for {set i 1} {$i < $np-1} {incr i} {
set i2 [expr {$i + 1}]
set i0 [expr {$i - 1}]
set diag($i) [expr {($h($i) + $h($i2))/3.0}]
set sup($i) [expr {$h($i2) / 6.0}]
set sub($i) [expr {$h($i) / 6.0}]
set a($i) [expr {($Y($i2) - $Y($i))/$h($i2) -
($Y($i) - $Y($i0)) / $h($i)}]
}
PolyLine::SolveTridiag sub diag sup a [expr {$np - 2}]
}
set a(0) [set a([expr {$np - 1}]) 0]
# Now generate the point list
set xy [list $X(0) $Y(0)]
for {set i 1} {$i < $np} {incr i} {
set i0 [expr {$i - 1}]
for {set j 1} {$j <= $PRECISION} {incr j} {
set t1 [expr {($h($i) * $j) / $PRECISION}]
set t2 [expr {$h($i) - $t1}]
set y [expr {((-$a($i0)/6 * ($t2 + $h($i)) * $t1 +
$Y($i0))* $t2 + (-$a($i)/6 *
($t1+$h($i)) * $t2 + $Y($i)) * $t1)/$h($i)}]
set t [expr {$X($i0) + $t1}]
lappend xy $t $y
}
}
return $xy
}
##+##########################################################################
# SolveTriDiag -- solves the linear system for tridiagoal NxN matrix A
# using Gaussian elimination (no pivoting). Since A is sparse, we pass
# in three diagonals:
# sub(i) => a(i,i-1) diag(i) => a(i,i) sup(i) => a(i,i+1)
#
# Result is returned in b[1:n]
#
proc PolyLine::SolveTridiag {N_sub N_diag N_sup N_b n} {
upvar 1 $N_sub sub
upvar 1 $N_diag diag
upvar 1 $N_sup sup
upvar 1 $N_b b
# Factorization and forward substitution
for {set i 2} {$i <= $n} {incr i} {
set i0 [expr {$i - 1}]
set sub($i) [expr {$sub($i) / $diag($i0)}]
set diag($i) [expr {$diag($i) - $sub($i) * $sup($i0)}]
set b($i) [expr {$b($i) - $sub($i) * $b($i0)}]
}
set b($n) [expr {$b($n) / $diag($n)}]
for {set i [expr {$n - 1}]} {$i >= 1} {incr i -1} {
set i2 [expr {$i + 1}]
set b($i) [expr {($b($i) - $sup($i) * $b($i2)) / $diag($i)}]
}
}
#########################################################################
## from: http://astronomy.swin.edu.au/~pbourke/analysis/interpolation/ ##
#########################################################################
## Discussed here are a number of interpolation methods, this is by no
## means an exhaustive list but the methods shown tend to be those in
## common use in computer graphics. The main attributes is that they
## are easy to compute and are stable. Interpolation as used here is
## different to "smoothing", the techniques discussed here have the
## characteristic that the estimated curve passes through all the
## given points. The idea is that the points are in some sense correct
## and lie on an underlying but unknown curve, the problem is to be
## able to estimate the values of the curve at any position between
## the known points.
## Linear interpolation is the simplest method of getting values at
## positions in between the data points. The points are simply joined
## by straight line segments. Each segment (bounded by two data points)
## can be interpolated independently. The parameter mu defines where
## to estimate the value on the interpolated line, it is 0 at the
## first point and 1 and the second point. For interpolated values
## between the two points mu ranges between 0 and 1. Values of mu
## outside this range result in extrapolation. This convention is
## followed for all the subsequent methods below. As with subsequent
## more interesting methods, a snippet of plain C code will server
## to describe the mathematics.
proc LinearInterpolate {y1 y2 mu} {
# http://astronomy.swin.edu.au/~pbourke/analysis/interpolation/
## return [expr {$y1*(1-$mu)+$y2*$mu}] ;# 2 multiplies 1 add, 1 subtract
return [expr {$y1+$mu*($y2-$y1)}] ;# 1 multiply 1 add, 1 subtract
}
## Linear interpolation results in discontinuities at each point.
## Often a smoother interpolating function is desirable, perhaps
## the simplest is cosine interpolation. A suitable orientated
## piece of a cosine function serves to provide a smooth transition
## between adjacent segments.
proc CosineInterpolate {y1 y2 mu} {
# http://astronomy.swin.edu.au/~pbourke/analysis/interpolation/
## Paul Burke, on his website does mentions:
## By a cute trick the cosine interpolation reverts to linear
## if applied independently to each coordinate.
## must linear interpolate in x coord, cosine interp in y coord
set mu2 [expr {(1.-cos(3.14159265358979323846*$mu))/2.}]
## return [expr {$y1*(1.-$mu2)+$y2*$mu2}]
return [expr {$y1+$mu2*($y2-$y1)}]
}
## Cubic interpolation is the simplest method that offers true
## continuity between the segments. As such it requires more
## than just the two endpoints of the segment but also the two
## points on either side of them. So the function requires 4
## points in all labeled y0, y1, y2, and y3, in the code below.
## mu still behaves the same way for interpolating between
## the segment y1 to y2. This does raise issues for how to
## interpolate between the first and last segments. In the
## examples here I just haven't bothered. A common solution
## is the dream up two extra points at the start and end of
## the sequence, the new points are created so that they
## have a slope equal to the slope of the start or end segment.
proc CubicInterpolate {y0 y1 y2 y3 mu} {
# http://astronomy.swin.edu.au/~pbourke/analysis/interpolation/
set mu2 [expr {$mu*$mu}]
set a0 [expr {$y3 - $y2 - $y0 + $y1}]
set a1 [expr {$y0 - $y1 - $a0}]
set a2 [expr {$y2 - $y0}]
set a3 $y1
return [expr {$a0*$mu*$mu2+$a1*$mu2+$a2*$mu+$a3}]
}
## Hermite interpolation like cubic requires 4 points so that
## it can achieve a higher degree of continuity. In addition
## it has nice tension and biasing controls. Tension can be
## used to tighten up the curvature at the known points. The
## bias is used to twist the curve about the known points.
## The examples shown here have the default tension and
## bias values of 0, it will be left as an exercise for
## the reader to explore different tension and bias values.
##
## Tension: 1 is high, 0 normal, -1 is low
## Bias: 0 is even,
## positive is towards first segment,
## negative towards the other
proc HermiteInterpolate {y0 y1 y2 y3 mu tension bias} {
# http://astronomy.swin.edu.au/~pbourke/analysis/interpolation/
## GB this is a Kochanek-Bartels Spline
## (also called TCB-Splines, for tension,continuity,bias)
## GB with continuity c set to zero
## GB note variables m0,m1 are the slopes at y1,y2
set mu2 [expr {$mu * $mu}]
set mu3 [expr {$mu2 * $mu}]
set m0 [expr {($y1-$y0)*(1+$bias)*(1-$tension)/2 +
($y2-$y1)*(1-$bias)*(1-$tension)/2}]
set m1 [expr {($y2-$y1)*(1+$bias)*(1-$tension)/2 +
($y3-$y2)*(1-$bias)*(1-$tension)/2}]
set a0 [expr { 2*$mu3 - 3*$mu2 + 1}]
set a1 [expr { $mu3 - 2*$mu2 + $mu}]
set a2 [expr { $mu3 - $mu2}]
set a3 [expr {-2*$mu3 + 3*$mu2}]
return [expr {$a0*$y1+$a1*$m0+$a2*$m1+$a3*$y2}]
}
## While you may think the above cases were 2 dimensional,
## they are just 1 dimensional interpolation (the horizontal
## axis is linear). In most cases the interpolation can be
## extended into higher dimensions simply by applying it to
## each of the x,y,z coordinates independently. This is
## shown on the right for 3 dimensions for all but the
## cosine interpolation. By a cute trick the cosine
## interpolation reverts to linear if applied independently
## to each coordinate.
proc HermiteSpline {P1 P2 T1 T2 s} {
# http://www.cubic.org/~submissive/sourcerer/hermite.htm
# Vector S: The interpolation-point and it's powers up to 3:
# Vector C: The parameters of our hermite curve:
# Matrix h: The matrix form of the 4 hermite polynomials:
# S = | s^3 s^2 s 1 | | 2 -2 1 1 | | P1 |
# h = | -3 3 -2 -1 | C = | P2 |
# | 0 0 1 0 | | T1 |
# | 1 0 0 0 | | T2 |
# To calculate a point on the curve you build the Vector S,
# multiply it with the matrix h and then multiply with C.
# P = S * h * C
if {[info exist HermiteCache($s,h1)]} {
set h1 $HermiteCache($s,h1)
set h2 $HermiteCache($s,h2)
set h3 $HermiteCache($s,h3)
set h4 $HermiteCache($s,h4)
} else {
set s2 [expr {$s*$s}]
set s3 [expr {$s*$s2}]
set h1 [expr { 2.*$s3 - 3.*$s2 + 1.}]
set h2 [expr {-2.*$s3 + 3.*$s2}]
set h3 [expr { $s3 - 2.*$s2+$s}]
set h4 [expr { $s3 - $s2}]
set HermiteCache($s,h1) $h1
set HermiteCache($s,h2) $h2
set HermiteCache($s,h3) $h3
set HermiteCache($s,h4) $h4
}
return [expr {$h1*$P1 + $h2 *$P2 + $h3* $T1 + $h4*$T2}]
}
proc CardinalSpline {P0 P1 P2 P3 a s} {
# http://www.cubic.org/~submissive/sourcerer/hermite.htm
# Cardinal splines are just a subset of the hermite curves.
# They don't need the tangent points because they will be calculated from
# the control points. We'll lose some of the flexibility of the hermite
# curves, but as a tradeoff the curves will be much easier to use.
# The formula for the tangents for cardinal splines is:
# T = a * ( P - P )
# i i+1 i-1
# a is a constant which affects the tightness of the curve
# (a should be between 0 and 1, but this is not a must)
set T1 [expr {$a*($P2-$P0)}]
set T2 [expr {$a*($P3-$P1)}]
return [HermiteSpline $P1 $P2 $T1 $T2 $s]
}
proc CatmullRomSpline {P0 P1 P2 P3 s} {
# http://www.cubic.org/~submissive/sourcerer/hermite.htm
# The Catmull-Rom spline is again just a subset of the cardinal splines.
# You only have to define a as 0.5, and you can draw and interpolate
# Catmull-Rom splines.
#
# T = 0.5 * ( P - P )
# i i+1 i-1
return [CardinalSpline $P0 $P1 $P2 $P3 0.5 $s]
}
proc Lerp {a b mu} {
# -------------------------------------------------
# http://www.cubic.org/~submissive/sourcerer/bezier.htm
# simple linear interpolation between two points
# -------------------------------------------------
set ax [lindex $a 0]
set ay [lindex $a 1]
set bx [lindex $b 0]
set by [lindex $b 1]
return [list [expr {$ax + ($bx-$ax)*$mu}] [expr {$ay + ($by-$ay)*$mu}] ]
}
proc BezierSpline {a b c d mu} {
# --------------------------------------------------------
# http://www.cubic.org/~submissive/sourcerer/bezier.htm
# evaluate a point on a bezier-curve. mu goes from 0 to 1.0
# --------------------------------------------------------
set ab [Lerp $a $b $mu]
set bc [Lerp $b $c $mu]
set cd [Lerp $c $d $mu]
set abbc [Lerp $ab $bc $mu]
set bccd [Lerp $bc $cd $mu]
return [Lerp $abbc $bccd $mu]
}
proc HornerBezier {degree xc yc t} {
upvar 1 $xc xcoeff
upvar 1 $yc ycoeff
# -------------------------------------------------------------------------
# Greg Blair, algorithm derived from:
# hornbez(degree, coeff, t)
# Curves and Surface for Computer Aided Geometric Design, A Practical Guide
# Farin, Gerald, Academic Press, 2nd Edition, 1990, page 48
# -------------------------------------------------------------------------
## uses Horner's scheme to compute one coordinate
## value of a Bezier curve. Has to be called
## for each coordinate (x,y, and/or z) of a control polygon.
## Input: degree: degree of curve.
## coeff: array with coefficients of curve.
## t: parameter value.
## Output: coordinate value.
set t1 [expr {1.0 - $t}]
set fact 1.0
set n_choose_i 1
set x [expr {$xcoeff(0)*$t1}]
set y [expr {$ycoeff(0)*$t1}]
for {set i 1} {$i < $degree} {incr i} {
set fact [expr {$fact*$t}]
set n_choose_i [expr {$n_choose_i*($degree-$i+1)/$i}] ;# always int!
set x [expr {$x + $fact*$n_choose_i*$xcoeff($i)*$t1}]
set y [expr {$y + $fact*$n_choose_i*$ycoeff($i)*$t1}]
}
set x [expr {$x + $fact*$t*$xcoeff($degree)}]
set y [expr {$y + $fact*$t*$ycoeff($degree)}]
return [list $x $y]
}
proc TCBSpline {P0 P1 P2 P3 s t c b} {
# http://www.cubic.org/~submissive/sourcerer/hermite.htm
##################################################################
## note by Greg Blair: ##
## ##
## TCB splines due to Doris Kochanek, a UofWaterloo MSc student ##
## ##
## These TCB spline equations can also be found on page 433 of ##
## Splines for use in Computer Graphics & Geometric Modelling ##
## Bartels, Beatty, Barsky, Morgan Kaufman, 1987 ##
##################################################################
# The Kochanek-Bartels Splines
# (also called TCB-Splines, for tension,continuity,bias)
# Now we're going down to the guts of curve interpolation:
# The kb-splines (mostly known from Autodesk's 3d-Studio Max and Newtek's Lightwave)
# are nothing more than hermite curves and a handfull of formulas to calculate the tangents.
# These curves have been introduced by D. Kochanek and R. Bartels in 1984 to
# give animators more control over keyframe animation.
# They introduced three control-values for each keyframe point:
# Tension: How sharply does the curve bend?
# Continuity: How rapid is the change in speed and direction?
# Bias: What is the direction of the curve as it passes through the keypoint?
# I won't try to derive the tangent-formulas here. I think just giving you something you can use
# is a better idea. (if you're interested you can ask me. I can write it down and send it to you
# via email.)
# The "incoming" Tangent equation:
# (1-t)*(1-c)*(1+b)
# TS = ----------------- * ( P - P )
# i 2 i i-1
# (1-t)*(1+c)*(1-b)
# + ----------------- * ( P - P )
# 2 i+1 i
# The "outgoing" Tangent equation:
# (1-t)*(1+c)*(1+b)
# TD = ----------------- * ( P - P )
# i 2 i i-1
# (1-t)*(1-c)*(1-b)
# + ----------------- * ( P - P )
# 2 i+1 i
# When you want to interpolate the curve you should use this vector:
# | P(i) |
# C = | P(i+1) |
# | TD(i) |
# | TS(i+1) |
# You might notice that you always need the previous and next point
# if you want to calculate the curve. This might be a problem when you try
# to calculate keyframe data from Lightwave or 3D-Studio. I don't
# know exactly how these programs handle the cases of the first and last point, but
# there are enough sources available on the internet. Just search around
# a little bit. (Newtek has a good developer section. You can download
# the origignal Lightwave motion code on their web-site).
set TD1 [expr {(1.-$t)*(1.-$c)*(1.+$b)/2*($P1 - $P0)
+ (1.-$t)*(1.+$c)*(1.-$b)/2*($P2 - $P1)}]
set TS2 [expr {(1.-$t)*(1.+$c)*(1.+$b)/2*($P2 - $P1)
+ (1.-$t)*(1.-$c)*(1.-$b)/2*($P3 - $P2)}]
return [HermiteSpline $P1 $P2 $TD1 $TS2 $s]
}
proc KeyFrameTCBSpline {P0 P1 P2 P3 s t c b N0 N1 N2} {
# http://www.cubic.org/~submissive/sourcerer/hermite.htm
# Speed Control
# If you write yourself keyframe-interpolation code and put it into a program
# you'll notice one problem:
# Unless you have your keyframes in fixed intervals you will have a sudden change
# of speed and direction whenever you pass a keyframe-point.
# This can be avoided if you take the number of key-positions (frames) between two keyframes into account:
# N is the number of frames (seconds, whatever) between two keypoints.
# 2 * N
# i-1
# TD = TD * --------------- adjustment of outgoing tangent
# i i N + N
# i-1 i
# 2 * N
# i
# TS = TS * --------------- adjustment of incomming tangent
# i i N + N
# i-1 i
set TD1 [expr {(1.-$t)*(1.-$c)*(1.+$b)/2*($P1 - $P0)
+ (1.-$t)*(1.+$c)*(1.-$b)/2*($P2 - $P1)}]
set TS2 [expr {(1.-$t)*(1.+$c)*(1.+$b)/2*($P2 - $P1)
+ (1.-$t)*(1.-$c)*(1.-$b)/2*($P3 - $P2)}]
set D [expr {$N0 + $N1}]
if {$D} {
set TD1 [expr {$TD1 * 2.*$N0/$D}]
}
set D [expr {$N1+$N2}]
if {$D} {
set TS2 [expr {$TS2 * 2.*$N2/$D}]
}
return [HermiteSpline $P1 $P2 $TD1 $TS2 $s]
}
proc PolyLine::Linear {xy {PRECISION 10}} {
set np [expr {[llength $xy] / 2}]
if {$np <= 1} return
set idx 0
foreach {x y} $xy {
set X($idx) $x
set Y($idx) $y
incr idx
}
# Now generate the point list
set xy [list $X(0) $Y(0)]
for {set i 1} {$i < $np} {incr i} {
set i0 [expr {$i - 1}]
for {set j 0} {$j <= $PRECISION} {incr j} {
set mu [expr {double($j) / double($PRECISION)}]
set x [LinearInterpolate $X($i0) $X($i) $mu]
set y [LinearInterpolate $Y($i0) $Y($i) $mu]
lappend xy $x $y
}
}
return $xy
}
proc PolyLine::Cosine {xy {PRECISION 10}} {
set np [expr {[llength $xy] / 2}]
if {$np <= 1} return
set idx 0
foreach {x y} $xy {
set X($idx) $x
set Y($idx) $y
incr idx
}
# Now generate the point list
set xy [list $X(0) $Y(0)]
for {set i 1} {$i < $np} {incr i} {
set i0 [expr {$i - 1}]
for {set j 0} {$j <= $PRECISION} {incr j} {
set mu [expr {double($j) / double($PRECISION)}]
## Paul Burke, on the website does mention:
## By a cute trick the cosine interpolation reverts to linear
## if applied independently to each coordinate.
## Now
set x [CosineInterpolate $X($i0) $X($i) $mu]
## does generate linear interpolation
## linear interpolation on x and cosine interpolation on y
set x [LinearInterpolate $X($i0) $X($i) $mu]
set y [CosineInterpolate $Y($i0) $Y($i) $mu]
lappend xy $x $y
}
}
return $xy
}
proc PolyLine::CatmullRom {xy {PRECISION 10}} {
set np [expr {[llength $xy] / 2}]
if {$np <= 1} return
set idx 0
foreach {x y} $xy {
set X($idx) $x
set Y($idx) $y
incr idx
if {$idx == 1} {
set X($idx) $x
set Y($idx) $y
incr idx
}
}
## duplicate last point
set X($idx) $x
set Y($idx) $y
incr idx
# Now generate the point list
set xy [list $X(0) $Y(0)]
for {set i 1} {$i < $np} {incr i} {
set i0 [expr {$i - 1}]
set i2 [expr {$i + 1}]
set i3 [expr {$i + 2}]
for {set j 0} {$j <= $PRECISION} {incr j} {
set mu [expr {double($j) / double($PRECISION)}]
set x [CatmullRomSpline $X($i0) $X($i) $X($i2) $X($i3) $mu]
set y [CatmullRomSpline $Y($i0) $Y($i) $Y($i2) $Y($i3) $mu]
lappend xy $x $y
}
}
return $xy
}
proc PolyLine::Bezier {xy {PRECISION 10}} {
set np [expr {[llength $xy] / 2}]
if {$np < 4} return
set idx 0
foreach {x y} $xy {
set X($idx) $x
set Y($idx) $y
incr idx
}
set xy {}
set idx 0
while {[expr {$idx+4}] <= $np} {
set a [list $X($idx) $Y($idx)]; incr idx
set b [list $X($idx) $Y($idx)]; incr idx
set c [list $X($idx) $Y($idx)]; incr idx
set d [list $X($idx) $Y($idx)];# incr idx ;# use last pt as 1st pt of next segment
for {set j 0} {$j <= $PRECISION} {incr j} {
set mu [expr {double($j) / double($PRECISION)}]
set pt [BezierSpline $a $b $c $d $mu]
lappend xy [lindex $pt 0] [lindex $pt 1]
}
}
return $xy
}
proc PolyLine::FDBezier {xy {PRECISION 10}} { ;# forward differencing Bezier calc.
## http://www.niksula.cs.hut.fi/~hkankaan/Homepages/bezierfast.html
## Calculating bezier curves is quite processor intensive task, but
## this algorithm will make calculating at least 10 times faster.
## Especially with bezier surfaces of bezier spaces, you will need the speed.
## All polynomial functions can be calculated via forward differencing.
## The key idea is to start at some point of the function, move forwards
## at constant step and use Taylor series to calculate the next value.
## Further reading
## The algo I presented here may not be the best one, but it works fine
## for most 3d applications. If you need more, read these:
## Adaptive forward differencing for rendering curves and surfaces;
## Sheue-Ling Lien, Michael Shantz and Vaughan Pratt;
## Proceedings of the 14th annual conference on Computer graphics, 1987, Pages 111 - 118
## Rendering trimmed NURBS with adaptive forward differencing;
## M. Shantz and Sheue-Ling Chang;
## Proceedings of the 15th annual conference on Computer graphics, 1988, Pages 189 - 198
## Rendering cubic curves and surfaces with integer adaptive forward differencing;
## S.-L. Chang and M. S. R. Rocchetti;
## Conference proceedings on Computer graphics, 1989, Pages 157 - 166
set np [expr {[llength $xy] / 2}]
if {$np < 4} return
set idx 0
foreach {x y} $xy {
set X($idx) $x
set Y($idx) $y
incr idx
}
set t [expr {1.0 / double($PRECISION)}]
set temp [expr { $t * $t}]
set idx 0
set xy {}
while {[expr {$idx+4}] <= $np} { ;# segment loop
set X0 $X($idx)
set Y0 $Y($idx); incr idx
set X1 $X($idx)
set Y1 $Y($idx); incr idx
set X2 $X($idx)
set Y2 $Y($idx); incr idx
set X3 $X($idx)
set Y3 $Y($idx);# re-use last pt for 1st pt of next segment
set xf $X0
set yf $Y0
set xfd [expr { 3 * ($X1 - $X0) * $t}]
set yfd [expr { 3 * ($Y1 - $Y0) * $t}]
set xfdd_per_2 [expr { 3 * ($X0 - 2 * $X1 + $X2) * $temp}]
set yfdd_per_2 [expr { 3 * ($Y0 - 2 * $Y1 + $Y2) * $temp}]
set xfddd_per_2 [expr { 3 * (3 * ($X1 - $X2) + $X3 - $X0) * $temp * $t}]
set yfddd_per_2 [expr { 3 * (3 * ($Y1 - $Y2) + $Y3 - $Y0) * $temp * $t}]
set xfddd [expr { $xfddd_per_2 + $xfddd_per_2}]
set yfddd [expr { $yfddd_per_2 + $yfddd_per_2}]
set xfdd [expr { $xfdd_per_2 + $xfdd_per_2}]
set yfdd [expr { $yfdd_per_2 + $yfdd_per_2}]
set xfddd_per_6 [expr { $xfddd_per_2 * (1.0 / 3)}]
set yfddd_per_6 [expr { $yfddd_per_2 * (1.0 / 3)}]
for {set j $PRECISION} {$j} {incr j -1} { ;# pt in segment loop
lappend xy $xf $yf
set xf [expr { $xf + $xfd + $xfdd_per_2 + $xfddd_per_6}]
set yf [expr { $yf + $yfd + $yfdd_per_2 + $yfddd_per_6}]
set xfd [expr { $xfd + $xfdd + $xfddd_per_2}]
set yfd [expr { $yfd + $yfdd + $yfddd_per_2}]
set xfdd [expr { $xfdd + $xfddd}]
set yfdd [expr { $yfdd + $yfddd}]
set xfdd_per_2 [expr { $xfdd_per_2 + $xfddd_per_2}]
set yfdd_per_2 [expr { $yfdd_per_2 + $yfddd_per_2}]
}
}
lappend xy $X3 $Y3
return $xy
}
proc PolyLine::HornBezier {xy {PRECISION 10}} {
set np [expr {[llength $xy] / 2}]
if {$np < 3} return
set idx 0
foreach {x y} $xy {
set X($idx) $x
set Y($idx) $y
incr idx
}
set degree [expr { $np -1 }]
# Now generate the point list
# 1st knot
set xy [list $X(0) $Y(0)]
# interpolate for intermediate points
for {set j 1} {$j < $PRECISION} {incr j} {
set t [expr {double($j) / double($PRECISION)}]
set pt [HornerBezier $degree X Y $t]
lappend xy [lindex $pt 0] [lindex $pt 1]
}
# 2nd knot
lappend xy $X($degree) $Y($degree)
return $xy
}
proc PolyLine::Cardinal {xy a {PRECISION 10}} {
set np [expr {[llength $xy] / 2}]
if {$np <= 1} return
set idx 0
foreach {x y} $xy {
set X($idx) $x
set Y($idx) $y
incr idx
if {$idx == 1} {
set X($idx) $x
set Y($idx) $y
incr idx
}
}
## duplicate last point
set X($idx) $x
set Y($idx) $y
incr idx
# Now generate the point list
set xy [list $X(0) $Y(0)]
for {set i 1} {$i < $np} {incr i} {
set i0 [expr {$i - 1}]
set i2 [expr {$i + 1}]
set i3 [expr {$i + 2}]
for {set j 0} {$j <= $PRECISION} {incr j} {
set mu [expr {double($j) / double($PRECISION)}]
set x [CardinalSpline $X($i0) $X($i) $X($i2) $X($i3) $a $mu]
set y [CardinalSpline $Y($i0) $Y($i) $Y($i2) $Y($i3) $a $mu]
lappend xy $x $y
}
}
return $xy
}
proc PolyLine::Cubic {xy {PRECISION 10}} {
set np [expr {[llength $xy] / 2}]
if {$np <= 1} return
set idx 0
foreach {x y} $xy {
set X($idx) $x
set Y($idx) $y
incr idx
if {$idx == 1} {
set X($idx) $x
set Y($idx) $y
incr idx
}
}
## duplicate last point
set X($idx) $x
set Y($idx) $y
incr idx
# Now generate the point list
set xy [list $X(0) $Y(0)]
for {set i 1} {$i < $np} {incr i} {
set i0 [expr {$i - 1}]
set i2 [expr {$i + 1}]
set i3 [expr {$i + 2}]
for {set j 0} {$j <= $PRECISION} {incr j} {
set mu [expr {double($j) / double($PRECISION)}]
set x [CubicInterpolate $X($i0) $X($i) $X($i2) $X($i3) $mu]
set y [CubicInterpolate $Y($i0) $Y($i) $Y($i2) $Y($i3) $mu]
lappend xy $x $y
}
}
return $xy
}
proc PolyLine::Hermite {xy tension bias {PRECISION 10}} {
set np [expr {[llength $xy] / 2}]
if {$np <= 1} return
set idx 0
foreach {x y} $xy {
set X($idx) $x
set Y($idx) $y
incr idx
if {$idx == 1} {
set X($idx) $x
set Y($idx) $y
incr idx
}
}
## duplicate last point
set X($idx) $x
set Y($idx) $y
incr idx
# Now generate the point list
set xy [list $X(0) $Y(0)]
for {set i 1} {$i < $np} {incr i} {
set i0 [expr {$i - 1}]
set i2 [expr {$i + 1}]
set i3 [expr {$i + 2}]
for {set j 0} {$j <= $PRECISION} {incr j} {
set mu [expr {double($j) / double($PRECISION)}]
set x [HermiteInterpolate $X($i0) $X($i) $X($i2) $X($i3) $mu $tension $bias]
set y [HermiteInterpolate $Y($i0) $Y($i) $Y($i2) $Y($i3) $mu $tension $bias]
lappend xy $x $y
}
}
return $xy
}
proc PolyLine::TCB {xy tension continuity bias {PRECISION 10}} {
set np [expr {[llength $xy] / 2}]
if {$np <= 1} return
set idx 0
foreach {x y} $xy {
set X($idx) $x
set Y($idx) $y
incr idx
if {$idx == 1} {
set X($idx) $x
set Y($idx) $y
incr idx
}
}
## duplicate last point
set X($idx) $x
set Y($idx) $y
incr idx
# Now generate the point list
set xy [list $X(0) $Y(0)]
for {set i 1} {$i < $np} {incr i} {
set i0 [expr {$i - 1}]
set i2 [expr {$i + 1}]
set i3 [expr {$i + 2}]
for {set j 0} {$j <= $PRECISION} {incr j} {
set mu [expr {double($j) / double($PRECISION)}]
set x [TCBSpline $X($i0) $X($i) $X($i2) $X($i3) $mu $tension $continuity $bias]
set y [TCBSpline $Y($i0) $Y($i) $Y($i2) $Y($i3) $mu $tension $continuity $bias]
lappend xy $x $y
}
}
return $xy
}
proc PolyLine::KeyFrameTCB {xy tension continuity bias {PRECISION 10}} {
set np [expr {[llength $xy] / 2}]
if {$np <= 1} return
set idx 0
foreach {x y} $xy {
set X($idx) $x
set Y($idx) $y
incr idx
if {$idx == 1} { ;## duplicate 1st pt
set X($idx) $x
set Y($idx) $y
incr idx
}
}
## duplicate last point
set X($idx) $x
set Y($idx) $y
incr idx
# Now generate the point list
set xy [list $X(0) $Y(0)]
for {set i 1} {$i < $np} {incr i} {
set i0 [expr {$i - 1}]
set i2 [expr {$i + 1}]
set i3 [expr {$i + 2}]
set X0 $X($i0)
set X1 $X($i)
set X2 $X($i2)
set X3 $X($i3)
set Y0 $Y($i0)
set Y1 $Y($i)
set Y2 $Y($i2)
set Y3 $Y($i3)
set N0 [expr {$X1 - $X0}]
set N1 [expr {$X2 - $X1}]
set N2 [expr {$X3 - $X3}]
for {set j 0} {$j <= $PRECISION} {incr j} {
set mu [expr {double($j) / double($PRECISION)}]
set x [KeyFrameTCBSpline $X0 $X1 $X2 $X3 $mu $tension $continuity $bias $N0 $N1 $N2]
set y [KeyFrameTCBSpline $Y0 $Y1 $Y2 $Y3 $mu $tension $continuity $bias $N0 $N1 $N2]
lappend xy $x $y
}
}
return $xy
} if {[file tail [info script]] == [file tail $argv0]} { ##Now to demonstrate and test the code you can use the following:
################################################################
################################################################
#
# Test harness and demo code
#
package require Tk
set S(title) "Cubic Splines with Tension"
set S(r) 5 ;# Control point size
set S(w) 5 ;# Line width
set S(precision) 10
set INITPOINTS {-200 0 -80 -125 30 100 200 0}
proc Reset {} {
global S
set S(tension) 0
set S(continuity) 0
set S(bias) 0
set S(a) 0.5
DrawCurve
}
proc BrushedMetal {c width height} {
## from wiki http://wiki.tcl.tk/9776
return
## for {set row 0} {$row < $height} {incr row 1} {
## set line_color [expr {45000+int(1000000*rand())%3000}]
## $c create line 0 $row $width $row -width 1
## -fill [format "#%04x%04x%04x"
## $line_color $line_color $line_color]
## }
}
proc DoDisplay {} {
global S INITPOINTS
wm title . $S(title)
pack [frame .ctrl -relief ridge -bd 2 -padx 5 -pady 5] \
-side right -fill both -ipady 5
pack [frame .screen -bd 2 -relief raised] -side top -fill both -expand 1
canvas .c -relief raised -borderwidth 0 -height 500 -width 500
BrushedMetal .c 500 500
pack .c -in .screen -side top -fill both -expand 1
bind all <Alt-c> {catch {console show}}
bind .c <Configure> {ReCenter %W %h %w}
.c bind p <B1-Motion> [list MouseMove %x %y]
bind all <Escape> {exit}
DoCtrlFrame
AddCtrlPoint $INITPOINTS
update
}
proc DoCtrlFrame {} {
frame .buttons
pack [button .buttons.add -text "Add Pt" -command AddCtrlPoint] -side left
pack [button .buttons.dele -text "Del Pt" -command DeleteCtrlPoint] -side left
pack [button .buttons.clear -text "Clear Pts" -command ClearCtrlPoint] -side left
set font {Helvetica 14 bold}
scale .prec -width 10 -orient h -variable S(precision) -font $font \
-label Precision: -relief ridge -from 1 -to 40 -command DrawCurve
scale .bias -width 10 -orient h -variable S(bias) -font $font \
-label "B - Bias:" -relief ridge -from -1. -to 1. -resolution 0.01 -command DrawCurve
scale .tens -width 10 -orient h -variable S(tension) -font $font \
-label "T - Tension:" -relief ridge -from -1. -to 1. -resolution 0.01 -command DrawCurve
scale .cont -width 10 -orient h -variable S(continuity) -font $font \
-label "C - Continuity:" -relief ridge -from -1. -to 1. -resolution 0.01 -command DrawCurve
scale .a -width 10 -orient h -variable S(a) -font $font \
-label "Cardinal Spline - A:" -relief ridge -from 0. -to 1. -resolution 0.01 -command DrawCurve
button .reset -text Reset -command {Reset}
labelframe .rb -text "INTERPOLATOR" -relief ridge -bd 2
set rbList {} ;# radio button list
lappend rbList {line "Linear"}
lappend rbList {cosi "Cosine"}
lappend rbList {cubp "Cubic Polynomial"}
lappend rbList {cubs "Cubic Spline - Keith Vetter"}
lappend rbList {catm "CatmullRom Spline"}
lappend rbList {card "Cardinal Spline (A)"}
lappend rbList {tbsp "TB Spline"}
lappend rbList {tcbs "TCB Spline"}
lappend rbList {bezi "Piecewise Bezier Spline"}
lappend rbList {fbez "Fwd Dif Piecewise Bezier Spline"}
lappend rbList {hbez "Horner Bezier Spline"}
## KeyFrame splines are drawing a linear line, not a spline for 1st segment
## I guess our assumption that we can test these splines by assuming
## the number of frames between key frames is the difference in X coordinates
## is not adequate.
## remove from GUI:
## lappend rbList {kfs "Key Frame TCB Spline"}
set i 1
foreach entry $rbList {
set key [lindex $entry 0]
set text [lindex $entry 1]
pack [frame .rb.l$i]
radiobutton .rb.l$i.$key -variable S(type) -value $key -font $font \
-width 30 -text $text -command DrawCurve -anchor w
pack .rb.l$i.$key -side top -pady 2 -anchor w -fill x
incr i
}
pack [button .buttons.about -text About -command About] -side left
pack [button .buttons.exit -text Exit -command exit] -side left
set row 1
grid .buttons -in .ctrl -row $row -sticky ew ; incr row
#grid .add -in .ctrl -row $row -sticky ew
#grid .dele -in .ctrl -row $row -sticky ew
#grid .clear -in .ctrl -row $row -sticky ew ; incr row
grid .prec -in .ctrl -row $row -sticky ew ; incr row
grid .tens -in .ctrl -row $row -sticky ew ; incr row
grid .cont -in .ctrl -row $row -sticky ew ; incr row
grid .bias -in .ctrl -row $row -sticky ew ; incr row
grid .a -in .ctrl -row $row -sticky ew ; incr row
grid .reset -in .ctrl -row $row -sticky ew ; incr row
grid .rb -in .ctrl -row $row -sticky ew ; incr row
#grid .about -in .ctrl -row $row -sticky ew ; incr row
#grid .exit -in .ctrl -row $row -sticky ew ; incr row
}
proc ReCenter {W h w} { ;# Called by configure event
foreach h2 [expr {$h / 2}] w2 [expr {$w / 2}] break
$W config -scrollregion [list -$w2 -$h2 $w2 $h2]
BrushedMetal $W [expr {2 * $w2}] [expr {2 * $h2}]
}
proc MakeBox {x y r} {
return [list [expr {$x-$r}] [expr {$y-$r}] [expr {$x+$r}] [expr {$y+$r}]]
}
proc MouseMove {X Y} {
regexp {p([0-9]+)} [.c itemcget current -tag] => who
set X [.c canvasx $X] ; set Y [.c canvasy $Y]
foreach x $::P($who,x) y $::P($who,y) break
foreach ::P($who,x) $X ::P($who,y) $Y break
.c move p$who [expr {$X - $x}] [expr {$Y - $y}]
DrawCurve
}
proc AddCtrlPoint {{xy {}}} {
global P S
set np [llength [array names P *x]]
if {$xy == {}} {
set w [expr {[winfo width .c] - 50}]
set xy [list [expr {$w * rand() - $w/2}] [expr {50 * rand() - 25}]]
}
foreach {x y} $xy {
set P($np,x) $x
set P($np,y) $y
.c create oval [MakeBox $x $y $S(r)] -tag [list p p$np] -fill yellow
incr np
}
DrawCurve
}
proc DeleteCtrlPoint {} {
global P
set np [llength [array names P *x]]
if {$np == 0} return
incr np -1
# Always delete the rightmost control point
# swap RIGHTMOST and NP then delete NP
set rightmost [lindex [lindex [SortPoints] end] end]
.c delete p$rightmost
.c itemconfig p$np -tag [list p p$rightmost]
set P($rightmost,x) $P($np,x)
set P($rightmost,y) $P($np,y)
unset P($np,x)
unset P($np,y)
DrawCurve
}
proc ClearCtrlPoint {} {
global P
.c delete p
catch {unset P}
DrawCurve
}
proc SortPoints {} {
global P
set np [llength [array names P *x]]
set xy {}
for {set i 0} {$i < $np} {incr i} {
lappend xy [list $P($i,x) $P($i,y) $i]
}
set xy2 [lsort -real -index 0 $xy]
return $xy2
}
proc DrawCurve {args} {
global S
set xy {}
foreach pt [SortPoints] { ;# Flatten point list
foreach {x y} $pt break
lappend xy $x $y
}
switch $::S(type) {
"line" { set xy [PolyLine::Linear $xy $::S(precision)] }
"cosi" { set xy [PolyLine::Cosine $xy $::S(precision)] }
"cubp" { set xy [PolyLine::Cubic $xy $::S(precision)] }
"cubs" { set xy [PolyLine::CubicSpline $xy $::S(precision)] }
"catm" { set xy [PolyLine::CatmullRom $xy $::S(precision)] }
"bezi" { set xy [PolyLine::Bezier $xy $::S(precision)] }
"fbez" { set xy [PolyLine::FDBezier $xy $::S(precision)] }
"hbez" { set xy [PolyLine::HornBezier $xy $::S(precision)] }
"tbsp" { set xy [PolyLine::Hermite $xy $::S(tension) $::S(bias) $::S(precision)] }
"tcbs" { set xy [PolyLine::TCB $xy $::S(tension) $::S(continuity) $::S(bias) $::S(precision)] }
"card" { set xy [PolyLine::Cardinal $xy $::S(a) $::S(precision)] }
"kfs" { set xy [PolyLine::KeyFrameTCB $xy $::S(tension) $::S(continuity) $::S(bias) $::S(precision)] }
}
.c delete cubic
if {$xy == {}} return
.c create line $xy -tag cubic -width $::S(w)
.c lower cubic
}
proc About {} {
set msg "Tension Splines
by Greg Blair September 2003
[email protected]
GUI derived from
Cubic Splines
by Keith Vetter, March 2003"
tk_messageBox -title About -message $msg
}
################################################################
################################################################
DoDisplay
set S(type) line
Reset
DrawCurve
##In the above code, the part of [PolyLine::CubicSpline] that comes after Now generate
##the point list does such a conversion, but it is rather crude. Approximation with
##polygons is not bad as such (indeed, it is what Postscript does internally when it
##flattens paths), but in general one would want the number of line segments to be
##adjusted to the actual curve, so that the "precision" really would give a bound on
##the approximation error. I don't know how one would achieve this effectively, but
##there are probably good algorithms in the literature.
}uniquename 2013aug18Since images at 'external sites' (such as www3.sympatico.ca above) tend to go dead, here is a screenshot image 'locally stored' on the disk drives of the server of this wiki. This image was created from the code above, but to fit the GUI on a netbook screen (max of 600 pixels high), the size 14 font was changed to 7 --- and a '-pady 0' parameter was added to 'button' and 'radiobutton' definitions. Also the '-width' (height) of the 'scale' widgets was reduced to 6 pixels.
