"{ Package: 'stx:libbasic2' }"

Geometric subclass:#Bezier

	instanceVariableNames:'start end controlPoint1 controlPoint2'

	classVariableNames:'ScaledFlatness'

	poolDictionaries:''

	category:'Graphics-Geometry-Objects'

!

!Bezier class methodsFor:'documentation'!

documentation

"

    Beziers represent parametric cubic curvea.

    [instance variables:]

        start                   <Point>         startPoint of the curve.

        end                     <Point>         endPoint of the curve.

        controlPoint1           <Point>         control point.

        controlPoint2           <Point>         control point.

    [class variables:]

        ScaledFlatness          <Integer>       curves flatness parameter

    [author:]

        unknown (based upon the PD path package)

"

!

examples

"

  bezier:

                                                                        [exBegin]

    |v s|

    v := (View extent:110@110) openAndWait.

    s := Bezier

            start:10@10

            end:100@100

            controlPoint1:50@50

            controlPoint2:10@80.

    v paint:Color red.

    s displayStrokedOn:v.

    v paint:Color black.

    v displayPoint:10@10.

    v displayPoint:100@100.

    v displayPoint:50@50.

    v displayPoint:10@80.

                                                                        [exEnd]

"

! !

!Bezier class methodsFor:'instance creation'!

start:startPoint end:endPoint controlPoint1:controlPoint1 controlPoint2:controlPoint2

    "create & return a new bezier curve"

    ^ self basicNew 

        setStart:startPoint end:endPoint controlPoint1:controlPoint1 controlPoint2:controlPoint2

    "Created: 12.2.1997 / 11:33:19 / cg"

    "Modified: 12.2.1997 / 14:25:59 / cg"

! !

!Bezier class methodsFor:'class initialization'!

initialize

    "initialize class constants"

    ScaledFlatness := (0.5 * Scale) rounded.

    "

     Bezier initialize

    "

    "Modified: 12.2.1997 / 14:26:26 / cg"

! !

!Bezier methodsFor:'accessing'!

controlPoint1

    "return the first controlPoint"

    ^ controlPoint1

    "Modified: 12.2.1997 / 14:27:01 / cg"

!

controlPoint2

    "return the second controlPoint"

    ^ controlPoint2

    "Created: 12.2.1997 / 11:33:18 / cg"

    "Modified: 12.2.1997 / 14:27:12 / cg"

!

end

    "return the endPoint"

    ^ end

    "Created: 12.2.1997 / 11:33:18 / cg"

    "Modified: 12.2.1997 / 14:27:42 / cg"

!

start

    "return the startPoint"

    ^ start

    "Modified: 12.2.1997 / 14:27:32 / cg"

! !

!Bezier methodsFor:'comparing'!

= anObject 

    "return true, if the receiver and the arg represent the same bezier curve"

    self species == anObject species ifTrue:[

        start = anObject start ifTrue:[

            end = anObject end ifTrue:[

                controlPoint1 = anObject controlPoint1 ifTrue:[

                    controlPoint2 = anObject controlPoint2 ifTrue:[

                        ^ true

                    ]

                ]

            ]

        ]

    ].

    ^ false.

    "Modified: 12.2.1997 / 14:29:38 / cg"

!

hash

    "return an integer useful as hashKey;

     redefined, since = is redefined"

    ^ start hash + end hash + controlPoint1 hash + controlPoint2 hash

    "Modified: 12.2.1997 / 14:30:11 / cg"

! !

!Bezier methodsFor:'converting'!

asLine

    "return a line from the startPoint to the endPoint"

    ^ LineSegment from:start to:end

    "Created: 12.2.1997 / 11:33:19 / cg"

    "Modified: 12.2.1997 / 14:31:01 / cg"

!

asPolyline

    "return a polygon which approximates the curve"

    ^ Polygon vertices:(self computePoints)

    "Modified: 12.2.1997 / 14:31:28 / cg"

! !

!Bezier methodsFor:'displaying'!

displayFilledOn: aGraphicsContext

    "report an error: cannot be filled."

    self shouldNotImplement

    "Modified: 12.2.1997 / 14:31:49 / cg"

!

displayStrokedOn: aGraphicsContext

    "display the curve as an outline"

    aGraphicsContext displayPolygon:(self computePoints)

    "Modified: 12.2.1997 / 14:33:09 / cg"

! !

!Bezier methodsFor:'private'!

addPointsFromStartX:p1X y:p1Y control1X:p2X y:p2Y control2X:p3X y:p3Y endX:p4X y:p4Y to:aCollection

    "actual workHorse for point computation"

    |x1 y1 x2 y2 x3 y3 t d dist dx3 dy3

     midX12 midY12 midX23 midY23 x1p y1p xm ym|

%{  /* OPTIONAL */

    /*

     * easy inlining; all math is done in smallIntegers

     */

    if (__bothSmallInteger(p1X, p1Y)

     && __bothSmallInteger(p2X, p2Y)

     && __bothSmallInteger(p3X, p3Y)

     && __bothSmallInteger(p4X, p4Y)

     && __isSmallInteger(@global(ScaledFlatness))

     && __isFloat(@global(InverseScale))

    ) {

        int _x1 = __intVal(p1X);

        int _y1 = __intVal(p1Y);

        int _x2 = __intVal(p2X);

        int _y2 = __intVal(p2Y);

        int _x3 = __intVal(p3X);

        int _y3 = __intVal(p3Y);

        int _p4X = __intVal(p4X);

        int _p4Y = __intVal(p4Y);

        int _flatness = __intVal(@global(ScaledFlatness));

        double _flatnessD = (double)_flatness;

        double _invScaleD = __floatVal(@global(InverseScale));

        for (;;) {

            int _midX12, _midY12, _midX23, _midY23;

            int _x1p, _y1p, _xm, _ym;

            extern double sqrt(), ceil(), floor();

#           define round(x)     (((x) < 0) ? ceil((x) - 0.5) : floor((x) + 0.5))

            if (_p4X == _x1) {

                int _dX1, _dX2;

                _dX1 = _x2 - _x1; if (_dX1 < 0) _dX1 = -_dX1;

                _dX2 = _x3 - _x1; if (_dX2 < 0) _dX2 = -_dX2;

                if ((_dX1 <= _flatness) && (_dX2 <= _flatness)) break;

            } else {

                int _dX3, _dY3, _dX3Abs, _dY3Abs;

                _dX3 = _dX3Abs = (_p4X - _x1); if (_dX3 < 0) _dX3Abs = -_dX3Abs;

                _dY3 = _dY3Abs = (_p4Y - _y1); if (_dY3 < 0) _dY3Abs = -_dY3Abs;

                if (_dX3Abs >= _dY3Abs) {

                    double _slope = (double)_dY3 / (double)_dX3;

                    double _t;

                    int _d, _dist;

                    _t = _slope*_slope + 1.0;

                    _t = sqrt(_t) * _flatnessD;

                    _t = round(_t);

                    _d = _t;

                    _t = _slope * (_x2-_x1);

                    _t = round(_t);

                    _dist = _t;

                    _dist -= (_y2-_y1);

                    if ((_dist >= 0) ? (_dist <= _d) : ((_dist + _d) >= 0)) {

                        _t = _slope * (_x3-_x1);

                        _t = round(_t);

                        _dist = _t;

                        _dist -= (_y3-_y1);

                        if ((_dist >= 0) ? (_dist <= _d) : ((_dist + _d) >= 0)) break;

                    }

                } else {

                    double _slope = (double)_dX3 / (double)_dY3;

                    double _t;

                    int _d, _dist;

                    _t = _slope*_slope + 1.0;

                    _t = sqrt(_t) * _flatnessD;

                    _t = round(_t);

                    _d = _t;

                    _t = _slope * (_y2-_y1);

                    _t = round(_t);

                    _dist = _t;

                    _dist -= (_x2-_x1);

                    if ((_dist >= 0) ? (_dist <= _d) : ((_dist + _d) >= 0)) {

                        _t = _slope * (_y3-_y1);

                        _t = round(_t);

                        _dist = _t;

                        _dist -= (_x3-_x1);

                        if ((_dist >= 0) ? (_dist <= _d) : ((_dist + _d) >= 0)) break;

                    }

                }

            }

#           undef round

            _midX12 = (_x1 + _x2) / 2;  

            _midY12 = (_y1 + _y2) / 2;

            _midX23 = (_x2 + _x3) / 2;  

            _midY23 = (_y2 + _y3) / 2;

            _x3 = (_x3 + _p4X) / 2;  

            _y3 = (_y3 + _p4Y) / 2;

            _x1p = (_midX12 + _midX23) / 2;  

            _y1p = (_midY12 + _midY23) / 2;

            _x2 = (_midX23 + _x3) / 2;  

            _y2 = (_midY23 + _y3) / 2;

            _xm = (_x1p + _x2) / 2;  

            _ym = (_y1p + _y2) / 2;

            {

                static struct inlineCache addPoints = __ILC9(@line);

                (*addPoints.ilc_func)(self, 

                                      @symbol(addPointsFromStartX:y:control1X:y:control2X:y:endX:y:to:), 

                                      nil, 

                                      &addPoints, 

                                      __MKSMALLINT(_x1), __MKSMALLINT(_y1),

                                      __MKSMALLINT(_midX12), __MKSMALLINT(_midY12),

                                      __MKSMALLINT(_x1p), __MKSMALLINT(_y1p),

                                      __MKSMALLINT(_xm), __MKSMALLINT(_ym),

                                      aCollection

                                     );

            }    

            _x1 = _xm;  

            _y1 = _ym;

        }

        {

            static struct inlineCache add = __ILC1(@line);

            OBJ newPoint;

            double d_x, d_y;

            d_x = _p4X * _invScaleD;

            d_y = _p4Y * _invScaleD;

            newPoint = __MKPOINT_DOUBLE( d_x, d_y);

            (*add.ilc_func)(aCollection,

                            @symbol(add:),

                            nil,

                            &add,

                            newPoint

                           );

        }

        RETURN (self);

    }  

%}.

    x1 := p1X.  y1 := p1Y.

    x2 := p2X.  y2 := p2Y.

    x3 := p3X.  y3 := p3Y.

    [

        p4X = x1 ifTrue:[

            "p4X = x1, i.e. dx = 0"

            (x2 - x1) abs <= ScaledFlatness 

	    and: [(x3 - x1) abs <= ScaledFlatness]

        ] ifFalse:[

            dx3 := p4X - x1.

            dy3 := p4Y - y1.

            (dx3 abs >= dy3 abs) ifTrue:[

                t := dy3 asFloat / dx3.

                d := ((1.0 + (t * t)) sqrt * ScaledFlatness) rounded.

                dist := (t * (x2 - x1)) rounded - (y2 - y1).

                (dist >= 0 ifTrue: [dist <= d] ifFalse: [dist + d >= 0]) 

                and:[dist := (t * (x3 - x1)) rounded - (y3 - y1).

                     dist >= 0 ifTrue: [dist <= d] ifFalse: [dist + d >= 0]]

            ] ifFalse:[

                t := dx3 asFloat / dy3.

                d := ((1.0 + (t * t)) sqrt * ScaledFlatness) rounded.

                dist := (t * (y2 - y1)) rounded - (x2 - x1).

                (dist >= 0 ifTrue: [dist <= d] ifFalse: [dist + d >= 0]) 

                and:[dist := (t * (y3 - y1)) rounded - (x3 - x1).

                     dist >= 0 ifTrue: [dist <= d] ifFalse: [dist + d >= 0]]

            ]

        ]

    ] whileFalse:[

        midX12 := (x1 + x2) // 2.  

        midY12 := (y1 + y2) // 2.

        midX23 := (x2 + x3) // 2.  

        midY23 := (y2 + y3) // 2.

        x3 := (x3 + p4X) // 2.  

        y3 := (y3 + p4Y) // 2.

        x1p := (midX12 + midX23) // 2.  

        y1p := (midY12 + midY23) // 2.

        x2 := (midX23 + x3) // 2.  

        y2 := (midY23 + y3) // 2.

        xm := (x1p + x2) // 2.  

        ym := (y1p + y2) // 2.

        self

            addPointsFromStartX:x1 y:y1

                      control1X:midX12 y:midY12

                      control2X:x1p y:y1p

                           endX:xm y:ym

                             to:aCollection.

        x1 := xm.  

        y1 := ym.

    ].

    aCollection add: (p4X asFloat * InverseScale) @ (p4Y asFloat  * InverseScale)

    "Created: 12.2.1997 / 15:05:52 / cg"

    "Modified: 12.2.1997 / 15:10:34 / cg"

!

computeBounds

    "return the reactngle which encloses the curve."

    ^ self class boundingRectangleForPoints:(self computePoints).

    "Modified: 12.2.1997 / 14:33:45 / cg"

!

computePoints

    "compute the points along the bezier - return a collection of points"

    |pointCollection|

    pointCollection := OrderedCollection new.

    pointCollection add:start.

    self 

        addPointsFromStartX: (start x * Scale) rounded

                          y: (start y * Scale) rounded

                  control1X: (controlPoint1 x * Scale) rounded

                          y: (controlPoint1 y * Scale) rounded

                  control2X: (controlPoint2 x * Scale) rounded

                          y: (controlPoint2 y * Scale) rounded

                       endX: (end x * Scale) rounded

                          y: (end y * Scale) rounded

                         to: pointCollection.

    ^ pointCollection

    "Modified: 12.2.1997 / 15:04:07 / cg"

!

setStart:startPoint end:endPoint controlPoint1:cp1 controlPoint2:cp2

    start := startPoint.

    end := endPoint.

    controlPoint1 := cp1.

    controlPoint2 := cp2

    "Modified: 12.2.1997 / 14:48:19 / cg"

! !

!Bezier methodsFor:'testing'!

outlineIntersects:aRectangle

    "return true, if the curve intersects a rectangle"

    ^ self class vertices:(self computePoints) intersectsRectangle:aRectangle

    "Created: 12.2.1997 / 11:33:18 / cg"

    "Modified: 12.2.1997 / 14:50:35 / cg"

! !

!Bezier methodsFor:'transforming'!

scaledBy:scaleFactor 

    "return a copy of the receiver, which is scaled by some amount"

    ^ self species

        start:(start * scaleFactor)

        end:(end * scaleFactor)

        controlPoint1:(controlPoint1 * scaleFactor)

        controlPoint2:(controlPoint2 * scaleFactor)

    "Created: 12.2.1997 / 11:33:18 / cg"

    "Modified: 12.2.1997 / 14:51:34 / cg"

!

translatedBy:translation 

    "return a copy of the receiver, which is translated by some amount"

    ^ self species

            start:(start + translation)

            end:(end + translation)

            controlPoint1:(controlPoint1 + translation)

            controlPoint2:(controlPoint2 + translation)

    "Modified: 12.2.1997 / 14:52:12 / cg"

! !

!Bezier class methodsFor:'documentation'!

version

    ^ '$Header: /cvs/stx/stx/libbasic2/Bezier.st,v 1.5 2003-08-29 17:31:58 cg Exp $'

! !

Bezier initialize!