The Algorithmist

Prince EXO3 Black Review Part 2

algorithmist — Thu, 19 Nov 2009 13:33:04 +0000

My recent two hitting sessions were against a heavy, cold wind. I was quite pleased with how the frame held up against the wind. Here are some pics of the racquet, courtesy of Tom Coyle (Hilton D/FW Lakes). The EXO3 Black is shown by itself and compared right next to the O3 Speedport Black (both with the exact same string job).

EXO3 Black is on the right, Speedport Black on the left (with the blue grommets). I have to keep the pic sizes small for the blog. Contact me if you want the full-size images.

The racquet has the same 16×19 string pattern and head size as the O3 Black.

Here is a side view.

Yes, that’s me – sorry, we were going low-budget on this production

Now, here’s the frame straight on.

And last, the two side-by-side. BTW, the EXO3 Black is shown with the stock grip; the O3 Speedport Black has an overgrip.

Sorry about the left hand over part of both frames, but it was *very* windy when these pics were taken, so it was pretty difficult to keep the two racquets steady for the camera.

Prince EXO3 Black Review Part 1

algorithmist — Mon, 16 Nov 2009 14:12:27 +0000

This is the first in a multi-part review of the Prince EXO3 Black. I’ve hit with this racquet four times with my standard stringbed of Pro Hurricane Tour 17 on the mains and VS Team Gut 17 on the crosses. I previously used an O3 Speedport Black, although have been hitting with the Black Team for many months while recovering from an arm injury. I’m still not back to 100% on the arm/shoulder, so I feel this is a good condition to report on any wear/stress caused by the new frame.

Here are the racquet specs, right off the frame

Head Size: 100 sq. in

Length: 27 in.

String Pattern: 16×19

Unstrung Weight: 10.8 oz

Unstrung Balance: 12.6 in

Swingweight: 295

Power Level: 975

Grip: Prince Resi Pro

Stiffness: 72 (from the internet)

Strung balance appears to be a few points head-light. Although the EXO3 Black clearly feels heavier than the O3 Black Team, the swingweight is such that it’s pretty easy to get the racquet to the ball. I do experience some timing issues and that’s just a matter of me getting used to the frame.

My style is all-court (1hb) and what I never do under any circumstances is stand several feet behind the baseline and trade mondo-topspin groundies with the young whippersnappers. I like to step up, take the ball on the rise, and hammer it back deep and hard. For that, you need a rock-solid frame and the EXO3 Black delivers with flying colors. I can’t describe how much I like the solid feel at impact. I can stand closer to the baseline and take half- or three-quarter swings at deep balls and pound them back with complete confidence. It was a bit hit-and-miss with the prior frame.

Speaking of feel and response, I got a dramatic upgrade on volleys. I never liked being at the net with the Speedport Black Team, despite the excellent maneuverability of the stick. With the EXO3 Black, I can’t wait to get there

Serves are a bit different. I’m taking more of a half-stroke motion, starting with the racquet raised in the air. The EXO3 Black needs a bit more work to generate the same service speed. However, I noticed that I hit my spots with more regularity. I suspect that the previous frame was more susceptible to slight twitches in forearm or wrist motion.

I was quite pleased with the arm-friendliness of the heavier, stiffer frame. As expected, stroke timing is a bit different. When balls are being hammered to you by a pro or a 4.5+ player, tiny fractions of a second really matter. The first two sessions, I noticed some slight soreness in the front of my shoulder near the chest. It faded pretty quickly. By the fourth session, I didn’t notice much at all. With the Speedport Black Team, I had a problem with the head-heavy frame and a responsive stringbed at lower tension. Even sweet-spot impacts at very low racquet speed (like a drop shot) had some perceptible low-frequency vibration (the type a damper does not inhibit). Nothing but solid feel from the EXO3 Black. I should note, however, with this particular hybrid string job at lower tension, I prefer the feel of the frame with the small EXO3 vibration damper that comes with the racquet.

Stock grip feels really good, although I’m not sweating much in the colder weather. For most racquets, I can’t wait to apply an overgrip.

I’ll post another review as soon as I have pics. I don’t own a digital camera, so I have to find someone to take the pics for me. I want to compare the EXO3 Black to the Speedport Black in the same pic.

Going Underground for a While

algorithmist — Mon, 09 Nov 2009 13:08:40 +0000

Just returned from a long business trip. I’ve started a new and pretty intense gig. I’m back to work with the Flex framework for the first time in two years and already doing Google Finance-style data visualizations. I’ll be extremely busy for the next two weeks and then go on vacation for two weeks. I might blog a bit during vacation, but don’t expect much of anything between now and the end of the year.

Thanks.

Degrafa Cardinal Spline

algorithmist — Tue, 20 Oct 2009 12:41:06 +0000

The Degrafa Cardinal spline is now available from the Origin branch. Usage is very similar to the Catmull-Rom spline with the exception of the tension parameter. The Cardinal spline is based on the C-R code base, so it supports closure. The algorithm is the same as the C-R spline, so it is best used for tensions in the [0,1] range. For example,

xmlns:comp=”components.*”
xmlns:degrafa=”com.degrafa.*”
xmlns:paint=”com.degrafa.paint.*”
xmlns:geom=”com.degrafa.geometry.*”
xmlns:splines=”com.degrafa.geometry.splines.*”
layout=”absolute”
width=”600″ height=”500″
pageTitle=”Cardinal Spline”
applicationComplete=”test()” viewSourceURL=”srcview/index.html”>

produces the same fit as the Catmull-Rom spline,

Closure with Zero Tension

Changing the tension to 1 ‘pulls’ the spline to the point where the fit is line-to-line,

Closure with Tension = 1

Tensions in the range -1 to 3 are supported. Negative tension ‘loosens’ the fit. Tensions greater than 1 cause the spline to loop in on itself going into and out of each knot. The effect at initial and terminal knots depends on how the auxiliary control points are chosen (same options as the C-R spline).

Splines are open by default. For example,

produces the following

Loosening the tension in a Cardinal spline

I’m preparing for a long business trip, so posts and Degrafa updates will be sparse over the next several weeks.

Degrafa Bezier X at Y Test Program

algorithmist — Fri, 16 Oct 2009 12:46:21 +0000

There is not much difference from the demo of the Bezier x-at-y method from the previously posted y-at-x demos. Here is the MXML for the test case. Most of the heavy lifting is in the displayXatY() method. Study that and you should have a pretty good understanding of how the Bezier x-at-y method is applied.

If time allows, I’ll try to cook up a demo illustrating how to align sprites along the contour of a Bezier curve, but that will most likely wait until after I return from my upcoming business trip.

xmlns:mx=”http://www.adobe.com/2006/mxml”
xmlns:geom=”components.*”
xmlns=”http://www.degrafa.com/2007″
layout=”absolute”
width=”600″ height=”500″
pageTitle=”Degrafa Advanced Cubic Bezier X at Y”
applicationComplete=”test()” xmlns:degrafa=”http://www.degrafa.com/2007″ viewSourceURL=”srcview/index.html”>

import mx.events.PropertyChangeEvent;
import mx.events.SliderEvent;

import com.degrafa.GraphicPointEX;
import com.degrafa.core.collections.GraphicPointCollection;

private var __yMin:Number;
private var __yMax:Number;

private function test():void
{
// restrict dragging for each point
var bounds:Rectangle = new Rectangle(background.x, background.y, background.width, background.height);
pointA.restrict      = bounds;
pointB.restrict      = bounds;
pointC.restrict      = bounds;
pointD.restrict      = bounds;

// actions when a property is changed on any InteractivePoint
pointA.addEventListener(PropertyChangeEvent.PROPERTY_CHANGE, onPropertyChanged);
pointB.addEventListener(PropertyChangeEvent.PROPERTY_CHANGE, onPropertyChanged);
pointC.addEventListener(PropertyChangeEvent.PROPERTY_CHANGE, onPropertyChanged);
pointD.addEventListener(PropertyChangeEvent.PROPERTY_CHANGE, onPropertyChanged);

// assign the quad. bezier data from script
assignBezierInterpolationPoints();

__mySlider__.alpha = 0.2;
__yMin = __mySlider__.y;
__yMax = __mySlider__.y + __mySlider__.height;
}

private function assignBezierInterpolationPoints():void
{
// property changes trigger redraw
var params:Array = bezier.interpolate( [new Point(pointA.x, pointA.y), new Point(pointB.x, pointB.y),
new Point(pointC.x, pointC.y), new Point(pointD.x, pointD.y)] );
}

private function onPropertyChanged(_e:PropertyChangeEvent):void
{
switch( _e.property )
{
case InteractivePoint.MOUSE_DOWN:
__mySlider__.enabled = false;
__mySlider__.alpha = 0.2;
boundsLayer.graphics.clear();

addEventListener(Event.ENTER_FRAME, onPointMove);
break;

case InteractivePoint.MOUSE_UP:
removeEventListener(Event.ENTER_FRAME, onPointMove);

// enable slider
__mySlider__.enabled = true;
__mySlider__.alpha = 1.0;
__mySlider__.value = 0;
break;
}
}

// redraw control points and bezier curve when an InteractivePoint is moved
private function onPointMove(_e:Event):void
{
assignBezierInterpolationPoints();
}

// display X at Y
private function displayXatY(_e:SliderEvent):void
{
// line does not track the middle of the thumb, but the slider value
var myY:Number = (1-_e.value)*__yMax + _e.value*__yMin – bezierLayer.y;
var values:Array = bezier.xAtY(myY);

__x1__.text = “”;
__x2__.text = “”;
__x3__.text = “”;

var g:Graphics = boundsLayer.graphics;
g.clear();
g.lineStyle(1,0xff0000);
g.moveTo( __mySlider__.x+10, myY + bezierLayer.y);
g.lineTo( background.x , myY + bezierLayer.y);

if( values.length != 0 )
{
var o:Object = values[0];
var myX:Number = o.x;
__x1__.text = “t: ” + o.t + “, x: ” + myX;

g.beginFill(0xff0000);
g.drawCircle(myX, bezierLayer.y + myY, 4);

if( values.length > 1 )
{
o = values[1];
myX = o.x;
__x2__.text = “t: ” + o.t + “, x: ” + myX;

g.beginFill(0xff0000);
g.drawCircle(myX, bezierLayer.y + myY, 4);
}

if( values.length == 3 )
{
o = values[2];
myX = o.x;
__x3__.text = “t: ” + o.t + “, x: ” + myX;

g.beginFill(0xff0000);
g.drawCircle(myX, bezierLayer.y + myY, 4);
}
}
}

]]>

Bezier Y at X Algorithm

algorithmist — Thu, 15 Oct 2009 12:54:46 +0000

A few requests for the algorithm behind the Bezier y-at-x and x-at-y methods have been received. The code is self-contained in the com.degrafa.geometry.AdvancedQuadraticBezier and AdvancedCubicBezier classes. Both classes accept control points in their constructors and use classes from com.degrafa.utilities.math . The latter classes are independent from any internal Degrafa architecture. So, people who maintain their own Bezier class libraries have a path to include the y-at-x and x-at-y capability.

Finding the y-coordinates at a given x or the x-coordinates at a given y is an exercise in root-finding. Suppose the Bezier curve is B(t) which is quadratic or cubic in t. For the cubic Bezier, the vector equation for the curve produces two scalar equations, one for the x-coordinates and one for the y-coordinates, i.e.

B_x(t) = c_0x + c_1xt + c_2xt² + c_3xt³

B_y(t) = c_0y + c_1yt + c_2yt² + c_3yt³

For the y-at-x case, the required y-coordinates are found at the t-parameters corresponding to the intersection of B(t) with the vertical line x = a, or

c_0x + c_1xt + c_2xt² + c_3xt³ – a = 0

The problem reduces to one of finding roots of a cubic polynomial. This starts by finding one root. Synthetic division is used to factor out the single root leaving a quadratic polynomial. The two possible roots of that polynomial are found with the venerable quadratic formula. Only roots in [0,1] are valid solutions to the y-at-x problem. The roots (values of t) are used to compute the y-coordinates using the equation for B_y(t). With a quadratic Bezier, roots are found directly with the quadratic formula.

The x-at-y problem is similar in that the required x-coordinates are the intersection of B(t) with the horizontal line y = a. There is one degenerate case where the Bezier curve is a segment of a horizontal or vertical line and the single parameter describing the line is the input value. For example, a cubic Bezier curve is the line x = a and the y-coordinates for x = a are desired. Theoretically, there are an infinite number. The Degrafa code does not currently handle this case. Some argue that no values should be returned while otheres argue that perhaps t = 0, t = 1/2 and t = 1 should be returned.

Given the rarity of this case actually occurring, the argument is postponed in lieu of more important developments. Tomorrow, I’ll post some code from the demos.

New Degrafa Bezier Methods

algorithmist — Wed, 14 Oct 2009 12:49:42 +0000

I have received a couple requests for x-at-y methods in the advanced quadratic and cubic Bezier classes to complement the existing y-at-x methods. Fortunately, the algorithm is the same, just a different set of coefficients, so it was an easy addition.

The x-at-y problem is typically used to distribute sprites left-to-right and top-to-bottom along the contour of a Bezier curve. The y-coordinate of the first sprite is fixed. The horizontal location is determined by the x-coordinate of the Bezier curve corresponding to the specified y-coordinate (plus some offset). Sprites are ’stacked’ along the contour of the curve by incrementing the y-coordinate based on the height of the previous sprite plus some offset, then repeating the algorithm.

The following diagrams illustrate the quadratic and cubic cases.

Quadratic Bezier x-at-y

Cubic Bezier x-at-y

These methods are in the AdvancedQuadraticBezier and AdvancedCubicBezier classes. Update SVN and enjoy.

Cardinal Splines Part 5

algorithmist — Thu, 08 Oct 2009 12:50:11 +0000

Continuing from part 4 of this series, we are looking at tension values outside the range of zero to one. When T is negative, then s = (1-T)/2 increases from 1/2 and grows without limit as T becomes larger negative. So, what happens for large values of s?

Using the same four knots and the same equation from part 4 of this series, P(0.5) serves as an approximate representation of the midpoint of the curve from P₂ to P₃. The curve is not naturally arc-length parameterized, so P(0.5) is a convenient point on the curve ‘away’ from both endpoints.

The expectation is that as s increases, the curve tends to follow the tangents more closely. Now,

P(0.5) = s/8[(P₃ - P₁) + (P₂ - P₄)] + 0.5(P₂ + P₃)

The second term is the midpoint between P₂ and P₃. If P^t(t) denotes the tangent, the above equation becomes

P(0.5) = s/8[P^t(0) - P^t(1)] + 0.5(P₂ + P₃)

The first term is the difference between the two tangents, multiplied by a constant term that grows without bound. The endpoint of this vector is added to the midpoint between P₂ and P₃. That means that P(0.5) is pushed arbitrarily far away from the fixed point 0.5(P₂ + P₃) as s increases without bound.

The following diagram shows what happens when s = 1 (corresponding to T = -1). The red curve is the Degrafa Catmull-Rom spline (s = 1/2) and the blue curve is the Cardinal spline with s = 1. Note the tendency for the curve to stay closer to the tangents at each join. Point reflection is used to compute the auxiliary points at the beginning and end (i.e. before P₁ and after P₄).

Cardinal Spline s = 1

A cubic curve only has so much flexibility in terms of inflection. Driving T too far negative (and thus s too far away from 1/2) can cause strange behavior as shown in the case where s = 2, below.

Cardinal Spline s = 2

Exact behavior varies depending on how the auxiliary points are chosen.

The case where T > 1 drives s negative. This reverses the role of in- and out-tangents. This causes the spline to loop around itself at each join. Look at the comments from part 4 for a link to a good demo of this case.

These extreme cases serve as poor interpolants, but can be used to draw cool-looking curves. So, there is some justification for allowing tension values outside the typical [0,1] range.

Cardinal Splines Part 4

algorithmist — Tue, 06 Oct 2009 13:03:35 +0000

Continuing from part 3 of this series, a formal tension parameter, T = 1-2s, was introduced. All we noted about tension was that T=0 corresponds to s = 1/2. At s=1/2, the Cardinal spline takes on the form of the more familiar Catmull-Rom spline. The Catmull-Rom spline may, however, be derived independently from the notion of Cardinal splines as the blending of two parabolas [1]. The zero-tension Cardinal Spline happens to conforms to a well-known C-1 continuous spline.

What happens as the tension parameter is moved away from zero? Can it reasonably be both positive and negative? To better understand the effect of the tension parameter on the spline, the Cardinal-spline basis matrix is

[ -s  2-s  s-2   s ]
[ 2s  s-3  3-2s -s ]
[ -s   0    s    0 ]
[  0   1    0    0 ]

Given four arbitrary knots,

[P₁, P₂, P₃, P₄]

the following vector equation applies for an aribrary point P(t) on the curve from P₂ to P₃

P(t) = s(-t³ + 2t² – t)P₁ + s(-t³ + t²)P₂ + (2t³ – 3t² + 1)P₂ + s(t³ – 2t² + t)P₃ + (-2t³ + 3t²)P₃ + s(t³ – t²)P₄

We have already looked at T = 0, so consider T = 1, corresponding to s = 0. The equation for P(t) reduces to

(2t³ – 3t² + 1)P₂ + (-2t³ + 3t²)P₃, which can be simplified to

(3t² – 2t³)(P₃ – P₂) + P₂. If u = 3t² – 2t³, then

P(t) = (1-u)P₂ + uP₃, which is the parametric equation of a line from P₂ to P₃.

While u does vary from 0 to 1, the primary curve parameter is t. At t varies from 0 to 1, u is approximately sigmoid but very close to linear throughout its range. So, we can say that as T approaches 1, the spline approaches a straight-line interpolation between knots.

The following screenshot shows a four-knot example with a black line connecting the knots and the spline drawn in blue with T=1. The Degrafa Catmull-Rom spline is drawn in red, which corresponds to the Cardinal spline with zero tension. This allows a comparison of the range of fits available in the tension range from zero to one.

Tension Ranges in a Cardinal Spline

The natural tension range is from zero to one. Values outside this range are possible, although rarely practical. These factors are discussed in the next section of this series.

References:

[1] Salomon, D. “Computer Graphics and Geometric Modeling”, Springer Verlag, NY, 1999.

Cardinal Splines Part 3

algorithmist — Thu, 01 Oct 2009 12:35:00 +0000

Continuing from part 2 of this series, the tension in a Cardinal spline is controlled by the s-parameter. Given a four-tuple of control points or knots,

[P_a, P_b, P_c, P_d]

cubic Hermite interpolation is applied with start-tangent s(P_c – P_a) and end-tangent s(P_d – P_b) .

Theoretically, s could vary from zero to positive infinity. A very long tangent vector, indicated by a large s-value causes the curve to follow the tangent very closely in and out of the join point. A very small tangent vector, indicated by a small s-value, causes the curve to approach and leave the join point more like a straight line.

Intuitively, this is the opposite of how we expect tension to behave. Larger tension should ‘pull’ the curve closer to a straight-line interpolation of the knots, with exactly straight lines as a limiting case. This gives rise to the convention of a formal tension parameter, T, that is inversely related to s.

The typical convention is to define s = (1-T)/2 or T = 1 – 2s. Note that the zero-tension case corresponds to s = 1/2 or a relatively ‘loose’ movement into and out of each join. This special case corresponds to the Catmull-Rom spline. For this reason, the C-R spline is sometimes called the zero-tension or neutral Cardinal spline.

The tension parameter will be discussed in more detail in subsequent posts in this series. Tangent vectors are arbitrary at the initial and terminal knots, just as with the Catmull-Rom spline. Fortunately, there are several methods for automatically assigning these tangents. The C-R spline in Degrafa implements two methods; point duplication and point reflection. Line segment reflection can be added as a third option. It is also possible to allow designers to set these tangents interactively.

Local control via knot placement, tension control, and adjustment of initial/terminal tangent vectors provides artists with a variety of methods to design specific curves using Cardinal splines.