The MASM Forum

the following is part of an article from codeproject.com
the original article uses <sub> and <sup> bulletin board codes
the codeproject website changed the way they handle these bbc's
so, now, they don't display correctly   :P
i wanted to be able to understand the math, so i put it here to read it
i also separated lines where he has multiple equations on a line

this is the full article by Oleg V. Polikarpotchkin and Peter Lee:
http://www.codeproject.com/Articles/31859/Draw-a-Smooth-Curve-through-a-Set-of-2D-Points-wit (http://www.codeproject.com/Articles/31859/Draw-a-Smooth-Curve-through-a-Set-of-2D-Points-wit)

A Bezier curve on a single interval is expressed as:

B(t)=(1-t)³P₀+3(1-t)²tP₁+3(1-t)t²P₂+t³P₃ (1)

where t is in [0,1], and

    P0 – first knot point
    P1 – first control point (close to P0)
    P2 – second control point (close to P3)
    P3 – second knot point

The first derivative of (1) is:

B'(t)=-3(1-t)²P₀+3(3t²–4t+1)P₁+3(2t–3t²)P₂+3t²P₃

The second derivative of (1) is:

B''(t)=6(1 - t)P₀+3(6t-4)P₁+3(2–6t)P₂+6tP₃

Single Segment

If we have just two knot points, our "smooth" Bezier curve should be a straight line, i.e. in (1) the coefficients in the members with the power 2 and 3 should be zero. It's easy to deduce that its control points should be calculated as:

3P₁ = 2P₀ + P₃
P₂ = 2P₁ – P₀

Multiple Segments

This is the case where we have more than two points. One more time: to make a sequence of individual Bezier curves to be a spline, we should calculate Bezier control points so that the spline curve has two continuous derivatives at knot points.

Considering a set of piecewise Bezier curves with n+1 points and n subintervals, the (i-1)-th curve should connect to the i-th one. Now we will denote the points as follows:

    Pi – ith knot point (i=1,..,n)
    P1i – first control point close to Pi
    P2i – second control point close to Pi

At the ith subinterval, the Bezier curve will be:

B_i(t)=(1-t)³P_i-1+3(1-t)²tP1_i+3(1-t)t²P2_i+t³P_i; (i=1,..,n)

The first derivative at the ith subinterval is:

B'_i(t)=-3(1-t)²P_i-1+3(3t²-4t+1)P1_i+3(2t-3t²)P2_i+3t²P_i; (i=1,..,n)

The first derivative continuity condition B'i-1(1)=B'i(0) gives:

P1_i+P2_i-1 = 2P_i-1; (i=2,..,n) (2)

The second derivative at the ith subinterval is:

B''_i(t)=6(1-t)P_i-1+6(3t-2)P1_i+6(1-3t)P2_i+6tP_i; (i=1,..,n)

The second derivative continuity condition B''i-1(1)=B''i(0) gives:

P1_i-1+2P1_i=P2_i+2P2_i-1; (i=2,..,n) (3)

Then, as always with splines, we'll add two more conditions at the ends of the total interval. These will be the "natural conditions" B''1(0) = 0 and B''n(1) = 0.

2P1₁-P2₁ = P₀ (4)
2P2_n-P1_n = P_n (5)

Now, we have 2n conditions (2-5) for n control points P1 and n control points P2. Excluding P2, we'll have n equations for n control points P1:

2P1₁ + P1₂ = P₀ + 2P₁
P1₁ + 4P1₂ + P1₃ = 4P₁ + 2P₂ ....
P1_i-1 + 4P1_i + P1_i+1 = 4P_i-1 + 2P_i (6) ....
P1_n-2 + 4P1_n-1 + P1_n = 4P_n-2 + 2P_n-1
2P1_n-1 + 7P1_n = 8P_n-1 + P_n

System (6) is the tridiagonal one with the diagonal dominance, hence we can solve it by simple variable elimination without any tricks.

When P1 is found, P2 could be calculated from (2) and (5).

Hi Dave,

yes, Bezier splines are very interesting and powerful. They are often used by automobile or aircraft designers.

Gunther

i just wanna make some lines from data points - lol

If you need help I can post a qbasic example.... ;)

that would be very helpful, Alfonso   :t
i have a hard time with C   :P

here is a test bed program
i use 2 arrays with 36 points each, and switch between them
that demonstrates draw/undraw

for now, the 2 control points are just filled in by a "dummy" proc named SynthesizeBezierControlPoints

i am trying to do something like Oleg and Peter, except i am trying to do it with extended integer math   :P

i am having a hard time understanding part of this code
the first part, i think i understand
i don't expect anyone to translate it to asm
but, if you could give a simple description of what is going on, that would be great   :biggrin:
// Calculate first Bezier control points
// Right hand side vector
double[] rhs = new double[n];

// Set right hand side X values
for (int i = 1; i < n - 1; ++i)
rhs[i] = 4 * knots[i].X + 2 * knots[i + 1].X;
rhs[0] = knots[0].X + 2 * knots[1].X;
rhs[n - 1] = (8 * knots[n - 1].X + knots[n].X) / 2.0;
// Get first control points X-values
double[] x = GetFirstControlPoints(rhs);

// Set right hand side Y values
for (int i = 1; i < n - 1; ++i)
rhs[i] = 4 * knots[i].Y + 2 * knots[i + 1].Y;
rhs[0] = knots[0].Y + 2 * knots[1].Y;
rhs[n - 1] = (8 * knots[n - 1].Y + knots[n].Y) / 2.0;
// Get first control points Y-values
double[] y = GetFirstControlPoints(rhs);

// Fill output arrays.
firstControlPoints = new Point[n];
secondControlPoints = new Point[n];
for (int i = 0; i < n; ++i)
{
// First control point
firstControlPoints[i] = new Point(x[i], y[i]);
// Second control point
if (i < n - 1)
secondControlPoints[i] = new Point(2 * knots[i + 1].X - x[i + 1], 2 * knots[i + 1].Y - y[i + 1]);
else
secondControlPoints[i] = new Point((knots[n].X + x[n - 1]) / 2, (knots[n].Y + y[n - 1]) / 2);
}
}

/// <summary>
/// Solves a tridiagonal system for one of coordinates (x or y) of first Bezier control points.
/// </summary>
/// <param name="rhs">Right hand side vector.</param>
/// <returns>Solution vector.</returns>
private static double[] GetFirstControlPoints(double[] rhs)
{
int n = rhs.Length;
double[] x = new double[n]; // Solution vector.
double[] tmp = new double[n]; // Temp workspace.

double b = 2.0;
x[0] = rhs[0] / b;
for (int i = 1; i < n; i++) // Decomposition and forward substitution.
{
tmp[i] = 1 / b;
b = (i < n - 1 ? 4.0 : 3.5) - tmp[i];
x[i] = (rhs[i] - x[i - 1]) / b;
}

for (int i = 1; i < n; i++)
x[n - i - 1] -= tmp[n - i] * x[n - i]; // Backsubstitution.

return x;
}
}
}
the part that is really throwing me is this part
b = (i < n - 1 ? 4.0 : 3.5) - tmp[i];
x[i] = (rhs[i] - x[i - 1]) / b;
}

for (int i = 1; i < n; i++)
x[n - i - 1] -= tmp[n - i] * x[n - i]; // Backsubstitution.
the "b = (i < n - 1 ? 4.0 : 3.5) - tmp[ i ];" line is tossing me for a loop - lol
i kind of get the rest, i think

b = (i < n - 1 ? 4.0 : 3.5) - tmp[i]

ok - let me see if i got this right

    .if i < n-1
        b=4.0 - tmp[i]
    .else
        b=3.5 - tmp[i]
    .endif

or, do i have it backwards ?

yup that's right...  :t
(condition) ? true-clause : false-clause
and by the way the code is in C#...

the first part of code is set up the array in order to calculate the points.. the '[]' is indicating an array..
it goes like this
(NameOfArray)[index]
where the index is zero based..

hope this helps...

thanks Dubby
i think i have it figured, now   :P

Here it is the example in quick basic... though if you have started already with c, maybe it were better for you to keep on going with that... Anyway, I hope that helps :)

thanks, Alfonso   :t

Hi,

   Hey, thanks for starting this.  Maybe a bit advanced, but I looked
at my copy of "Numerical Recipes", and implemented something
simpler.  So, now I have a curve fit / interpolation program to play
with.  Maybe I'll work up to a Bezier interpolation.

   I did write a Bezier curve for a paint type program a long time ago.
Only took three or four tries to get it to look okay.  Never got the
optimization part though.  Nice that computers don't mind using brute
force.

Cheers,

Steve N.

hi Steve

yah - there are 2 different approaches
1) calculate "de Boor" control points if you want to use the PolyBezier API
2) calculate all the points

i am trying method 1, simply because that's where i started - lol
i think method 2 might be better, overall
i will get there, eventually

well, it's trying to work - lol
at least it doesn't crash   :biggrin:

(http://img203.imageshack.us/img203/4310/bezier1.png)

Hi Dave,

Quote from: dedndave on June 02, 2013, 08:02:13 AM
well, it's trying to work - lol
at least it doesn't crash   :biggrin:

you're in the right direction.

Gunther

a little better   :P

(http://img4.imageshack.us/img4/598/bezier2.png)

success   :biggrin:

let me do some clean-up, then i'll post a program with source   :t

(http://img259.imageshack.us/img259/7104/bezier3.png)

the FPU code probably isn't as efficient as it could be
for example, i may have a couple FWAIT's in there that could be eliminated   :P
but, the function works fairly well
it could be updated for SSE, too

updated the documentation for the routine

by the way, i did a re-design on the original algorithm   :biggrin:

         // Set right hand side X values
         for (int i = 1; i < n - 1; ++i)
            rhs = 4 * knots.X + 2 * knots[i + 1].X;
         rhs[0] = knots[0].X + 2 * knots[1].X;
         rhs[n - 1] = (8 * knots[n - 1].X + knots[n].X) / 2.0;
         // Get first control points X-values
         double[] x = GetFirstControlPoints(rhs);

         // Set right hand side Y values
         for (int i = 1; i < n - 1; ++i)
            rhs = 4 * knots.Y + 2 * knots[i + 1].Y;
         rhs[0] = knots[0].Y + 2 * knots[1].Y;
         rhs[n - 1] = (8 * knots[n - 1].Y + knots[n].Y) / 2.0;
         // Get first control points Y-values
         double[] y = GetFirstControlPoints(rhs);

the part in red was incorporated into the GetFirstControlPoints function
i also added stack-probe code for the local arrays

i updated the documentation for the routine....

a minimum of 3 knot points is required   :P

Hi Dave,

you've made a very encouraging progress. Looks nice.  :t

Gunther

thanks Gunther   :t

Cool routine  8)

thanks, Marinus   :biggrin:

i'll probably update it, after i've had some time to optimize it a little bit

Impressive :t

Real cute, Dave :t

By the way, why this combi instead of fstp st?
        ffree   st(0)
        fincstp

Quote from: dedndave on June 03, 2013, 02:31:19 AM
the FPU code probably isn't as efficient as it could be
for example, i may have a couple FWAIT's in there that could be eliminated   :P

FWAIT makes sure that unmasked FP exceptions are handled, but due FINIT all expectations are masked and thus there is no need to use this instruction.

good work Dave :t
edit:should be fun to see what happens if you feed landscaperenderer in this thread:
http://masm32.com/board/index.php?topic=1890.75
with many of your curves

thanks, Tedd, Jochen, qWord, and DayDreamer   :t

i was just reviewing my use of FWAIT
it seems to work with all of them removed - lol
although, there may be one or two that are prudent
for example, i change the value of a pointer while the FPU is writing to that location
with FPU code, the CPU and FPU execute different streams, so to speak
i don't want the cart to get in front of the horse   :P
i may be able to rearrange some instructions to eliminate all of them

back in the 80's, i was fairly used to writing code for the 8087
it was a very different animal than modern FPU implementations
and - that was a while ago - my memory isn't what it used to be

Quote from: jj2007 on June 04, 2013, 01:11:38 AM
By the way, why this combi instead of fstp st?
        ffree   st(0)
        fincstp

thanks Jochen - i guess i had forgotten that little trick - i am rusty

Quote from: qWord on June 04, 2013, 01:40:01 AM
FWAIT makes sure that unmasked FP exceptions are handled, but due FINIT all expectations are masked and thus there is no need to use this instruction.

i thought the idea was to cause the CPU to wait until the FPU finishes the current instruction
as for FINIT - i put that in there as a matter of habit (i could just set precision control  :P )
but, i would like the routine to work without it, also

Quote from: daydreamer2 on June 04, 2013, 01:57:51 AM
edit:should be fun to see what happens if you feed landscaperenderer in this thread:
http://masm32.com/board/index.php?topic=1890.75
with many of your curves

yes - one of the goals is to pick colors, rather than X,Y points, by using a bezier (or similar) interpolation
but, the PolyBezier function doesn't suit that case

i will probably also add support for a bezier with 2 points and validate the number of points param
once i get this one cleaned up, i will do one for closed curves,
then move on to generating points without using PolyBezier

Quote from: dedndave on June 04, 2013, 02:04:12 AMfor example, i change the value of a pointer while the FPU is writing to that location
with FPU code, the CPU and FPU execute different streams

the streams are synchronized as needed - otherwise there would be clear statements in Intel's and AMD's documentation (you might read them in this context). Unless not supporting antiques like the 286/386, you can safely remove all WAITs (assuming masked exceptions).

ok, thanks qWord   :t

i was under the impression it was required when accessing things like the control word
of course - my code does not do that - but i was wondering if that were still true

ok - i see that Raymond uses FWAIT, as a precautionary measure

i know - i should RTFM
but, i have spent the last 3 days reading about bezier splines - lol
my eyes are getting very old   :(

Per the Intel manual:

Quote
The FNSTSW AX form of the instruction is used primarily in conditional branching...

When the FNSTSW AX instruction is executed, the AX register is updated before the processor executes any further instructions. The status stored in the AX register is thus guaranteed to be from the completion of the prior FPU instruction.

But there is no such statement for the instruction form where the destination is a memory location and no such statement for FSTCW/FNSTCW, where the destination must be a memory location.

I've seen that there are some unnecessary DIVs in the function GetFirstControlPoints(). As an example, the following modification use scalar SSE2 instructions to do the same and needs only one division.
GetFirstControlPoints PROC uKnotQty:UINT,lpKnotArray:LPVOID,lpResArray:LPVOID

;subroutine for deBoorBezierSpline

;EBX = size of X, Y, Rhs, or Tmp array in bytes
;only EBX and EBP are preserved

;-----------------------------------------

_lpResArray   TEXTEQU <dword ptr [ebp+20]>  ;pointer to Res (result) array
_lpKnotArray  TEXTEQU <dword ptr [ebp+16]>  ;pointer to Knot array
_uKnotQty     TEXTEQU <dword ptr [ebp+12]>  ;knot point qty
;                                [ebp+8]    ;RETurn address
;                                [ebp+4]    ;saved EBX contents
;                                [ebp]      ;saved EBP contents

;-----------------------------------------

        push    ebx
        push    ebp
        mov     ebp,esp
        mov     eax,_lpKnotArray
        mov     edx,_uKnotQty
        and     esp,-8
        lea     edi,[eax+2*ebx]
        sub     edx,2             ;EDX = control pair qty - 1
        add     edi,ebx           ;EDI = pointer to last knot point element
        lea     esi,[esp-8]       ;ESI = pointer to last Rhs element
        sub     esp,ebx
        lea     ecx,[edi-24]      ;ECX = pointer to second-to-last knot point element

;Rhs#[n!-1!]=(8!*Knot![n!-1!].X+Knot![n!].X)/2.0#

        mov     eax,[ecx]
        shl     eax,3
        add     eax,[edi]
       
        movsd xmm6,r8_1_0 ; xmm6 = 1.0
        movsd xmm7,r8_r2_0 ; xmm7 = 1/b = 0.5
       
        cvtsi2sd xmm1,eax
mulsd xmm1,xmm7
        movsd real8 ptr [esi],xmm1
       
        sub     ecx,24
        sub     edi,24
        add     edx,-1

        lea     esi,[esi-8]
        jz      gfcps1

;for(i!=1!;i!<n!-1!;++i!)
;    Rhs#[i!]=4!*Knot![i!].X+2!*Knot![i!+1!].X

gfcps0: mov     eax,[ecx]
        shl     eax,1
        add     eax,[edi]
        shl     eax,1
       
        cvtsi2sd xmm0,eax
        movsd real8 ptr [esi],xmm0
       
        sub     ecx,24
        sub     edi,24
        add     edx,-1

        lea     esi,[esi-8]
        jnz     gfcps0

;Rhs#[0!]=Knot![0!].X+2!*Knot![1!].X

gfcps1: mov     eax,[edi]
        shl     eax,1
        add     eax,[ecx]
       
        cvtsi2sd xmm0,eax
        movsd real8 ptr [esi],xmm0

;EBX = X/Y/Rhs/Tmp array bytes
;EDX = 0
;ESI = pointer to Rhs array

        mov     ecx,_uKnotQty
        sub     esp,ebx
        add     ecx,-1            ;ECX = de Boor control pair qty
        mov     edi,_lpResArray   ;EDI = pointer to Res array
        add     ecx,-1            ;ECX = de Boor control pair qty - 1
        mov     ebx,esp           ;EBX = pointer to Tmp array
        mov     edx,ecx           ;EDX = de Boor control pair qty - 1

;double b#=2.0#
;Res#[0!]=Rhs#[0!]/b#

        movsd xmm0,real8 ptr [esi]
        mulsd xmm0,xmm7
        movsd real8 ptr [edi],xmm0

        add     ebx,8
        add     esi,8

; for (int i = 1; i < n; i++) // Decomposition and forward substitution.
; {
; tmp[i] = 1 / b;
; b = (i < n - 1 ? 4.0 : 3.5) - tmp[i];
; x[i] = (rhs[i] - x[i - 1]) / b;
; }

gfcps2: movsd real8 ptr [ebx],xmm7

cmp     edx,1
        jnz     gfcps3

        movsd xmm0,r8_3_5
        jmp short gfcps4

gfcps3: movsd xmm0,r8_4_0

gfcps4: movsd xmm4,real8 ptr [esi]
subsd xmm0,xmm7
movapd xmm7,xmm6
subsd xmm4,real8 ptr [edi]
divsd xmm7,xmm0
add     edi,8
mulsd xmm4,xmm7
        movsd real8 ptr [edi],xmm4
        add     ebx,8
        add     esi,8
        add     edx,-1
        jnz     gfcps2

;EBX = pointer to end of Tmp array
;ECX = de Boor control pair qty - 1
;EDI = pointer to last element of Res array

        sub     edi,8
        sub     ebx,8       

; for (int i = 1; i < n; i++)
; x[n - i - 1] -= tmp[n - i] * x[n - i]; // Backsubstitution.

gfcps5:
movsd xmm0,real8 ptr [edi]
movsd xmm1,real8 ptr [edi+8]
mulsd xmm1,real8 ptr [ebx]
subsd xmm0,xmm1
movsd real8 ptr [edi],xmm0

        sub     ebx,8
        sub     edi,8
        add     ecx,-1
        jnz     gfcps5

        leave
        pop     ebx
        ret     12

GetFirstControlPoints ENDP

i think the whole thing could be done with SSE, rather than FPU
but, that's for someone who knows SSE   :redface:
i may have to learn it, sooner than later - lol

Quote from: dedndave on June 04, 2013, 08:22:01 AMbut, that's for someone who knows SSE   :redface:
i may have to learn it, sooner than later - lol

common... at least the scalar stuff is extreme simple. The basic instructions:

type identifier (type ID):
    ss = scalar single = REAL4 = low DWORD of corresponding XMM register
    sd = scalar double = REAL8 = low QWORD of corresponding XMM register
    For the conversion instructions:
    si = scalar integer = SDWORD = GPR or memory location

instructions:
    mov<type ID> {xmmReg, memory location}, {memory location, xmmReg}  ; for mem -> reg: zero extension
    e.g.:
        movsd xmm0,REAl8 ptr [eax] ; move scalar double from [eax] to xmm0. the upper 8 bytes are zero.

arithmetic:
    add/sub/mul/div/sqrt<type ID> xmmReg, {xmmReg,memory location}
    e.g.:
        sqrtss xmm0,REAL4 ptr [eax]  ; single precision: xmm0 = sqrt(REAL4 ptr [eax])
        sqrtsd xmm0,xmm1               ; double precision: xmm0 = sqrt(xmm1)

conversion:
    cvt<type ID src>2<type ID dest> {xmmReg, memory location, 32bit GRP}, {32bit GPR or integer memory location, memory location, xmmReg}
    e.g.:
        cvtsi2ss xmm0,eax     ; eax -> REAl4 in xmm0
        cvtsd2si eax,xmm0     ; REAL8 in xmm0 -> eax
        cvtss2sd xmm0,xmm0 ; convert scalar single to scalar double in xmm0

compare:
    comi<type ID> xmmReg, {xmmReg,memory location}
    set the flags as comparing unsigned values (ja/jb,...)

The above instruction does not need alignment of operands.

thanks for the simple tutorial, qWord   :t

is that SSE, SSE2 ?

Quote from: dedndave on June 04, 2013, 10:21:30 AM
thanks for the simple tutorial, qWord   :t

is that SSE, SSE2 ?

both.
The double precision stuff has been introduced with SSE2.

Quote from: dedndave on June 04, 2013, 10:21:30 AM
thanks for the simple tutorial, qWord   :t

well done indeed :t

Hi qWord,

thank you for the good re-fresher.  :t It's always a good idea to read your posts very attentive.

Gunther

i think there is a better way to create the de Boor control points
if you look at the images above, you will see that the Bezier curve exceeds the data minima and maxima

this can be overcome by setting the first derivative term to 0 for knot points where
both adjacent knot points are either above or below the center knot point

let me play with it   :P

Hey,

Just caught up on this thread now. Is there a reason you're using this particular type of spline in favour of other alternatives?
For splines that pass through all of it's control points (IE: data points) I normally use a Catmull Rom spline and granted I only cursed over the pages but it seems to me the basis functions and implementation are a lot simpler.

John

hi John
yah - i looked at the Catmull ROM splines, as well
they suffer the same issue - the curve exceeds the data minima and maxima

also - there is simpler math to do a point-by point Bezier spline
at least, it seems easier than using PolyBezier - lol

Catmull ROM looks like it would be nice in a graphics program,
where you want to let the user create an odd-shaped curve
as you said - the curve passes through all the points

still, i like to have options
i would like to find a way to create de Boor control points so the minima and maxima are not exceeded
if for no other reason, a learning process   :P

well - the first problem pops right out there - lol

the routine doesn't know we are ploting a mathematical function
it simply sees a series of points and solves for the control points, in the order they are listed
when it finds a control point, it looks at the previously solved point for "direction"

for example, i can rotate the point data and get a reasonable curve

(http://img856.imageshack.us/img856/9130/bezier4.png)

the routine doesn't know whether the terms minima and maxima apply to the x axis or the y axis
furthermore, it doesn't know that i am using constant uni-directional steps in one axis

Ahh.. got you. So you need a curve that passes through the points but takes min(n) and max(n) and makes sure that those are basically the peak/dip of the curve and only other parts of the curve may extend past the data-point.

yah - the math used doesn't account for that
i am looking into it - it is not as simple as i thought it should be - lol

Hi,

   Linear interpolation will not overshoot.  Higher order interpolation
pretty much has to overshoot unless your data is rather constrained
to begin with.  Clamping of some sort will be needed.  Or weird
constraints on the control points (which kinda obviate the use of the
higher order).

Regards,

Steve N.

what about take cosine as interpolation?
cosine outputs between 1.0 and -1.0 so its easy to scale up and you only use first half of curve so lenght is pi

good thinking - something along that line

i was thinking of identifying the minima and maxima, then doing the curve in sections   :P
i just have to figure out how to get the endpoints of each section to have 0 slope

there's probably a much more efficient way
i have to look at the math in the original post

Quote from: dedndave on June 05, 2013, 03:41:51 AM
good thinking - something along that line

i was thinking of identifying the minima and maxima, then doing the curve in sections   :P
i just have to figure out how to get the endpoints of each section to have 0 slope

there's probably a much more efficient way
i have to look at the math in the original post

why dont try loop thru SSE MAXSS AND MINSS instruction
and save result of where you are in the curve everytime maximum gets bigger than previous max and minimum gets smaller than previous min

Quote from: dedndave on June 05, 2013, 03:41:51 AM
i just have to figure out how to get the endpoints of each section to have 0 slope

Hi,

   Well, as you are using Bezier curves, all you need to do is have the
line from the last control point to the last data point have a slope of
zero.  So, after all the calculations, when you determine that you are
at the end of a section, set the control point's Y value to equal the Y
value of the data point.  That sounds a bit crude, but it will get you
a zero slope.

Cheers,

Steve N.

yah - a minima or maxima can be found by comparing each Y value with the adjacent Y values'

i tried that method, Steve - it didn't work the way i think it should have - lol
i am going to take another look at it - my code may have missed something

Hi Dave,

Quote from: dedndave on June 05, 2013, 07:09:10 AM
i tried that method, Steve - it didn't work the way i think it should have - lol

   I just looked at some curves in my draw program.  And they
seemed to work okay(ish).  Do you have the values for the four
points?

Quote
i am going to take another look at it - my code may have missed something

   Okay, good luck.

Regards,

Steve N.

i have the routine cleaned up
i added support for 2-point lines
and it validates the knot quantity parameter
i did not add the SSE divide that qWord suggested
reason is - if you are using the SSE registers for something else - this routine only uses FPU registers
next week, when i have more time, i will take qWord's advice and try an SSE version   :P

i also added some "knobs" to play with...
FILE_RANDOM   EQU 1          ;non-zero for file data points, zero for random data points
DATA_POINTS   EQU 0          ;non-zero to draw data points
CONTROL_LINES EQU 0          ;non-zero to draw control lines
FLAT_MINMAX   EQU 0          ;non-zero to flatten minima/maxima control lines

TIMER_ELAPSE  EQU 60         ;interval time in mS

the biggest change there is, i added some "real-world" file data   :biggrin:
you can look at Input.jpg to see what the same data looks like in image form

 :P

(http://img856.imageshack.us/img856/8238/o3yz.jpg)

Very nice overview.  :t
But where's the 3D representation?  :biggrin:

lol
that is down the road a bit
had to get the basics running, first

i want to use file mapping to access the data
that will require a lot of work
not that file mapping is that hard - but a lot of the current code will have to be updated

Dave, stay away from the patients with +348 mmHg, they are dangerous. Those in the blue area are on Ducky's table (http://en.wikipedia.org/wiki/David_McCallum#NCIS), I suppose?

well - the program autoranges the pressures
that way, all the colors are used, no matter what the pressure range

however, it's funny you mention that
earlier versions limited the pressure to -20 and +250 mmHg
i did that because i was concerned about rejecting bad data packets

the doctor had a patient that was exceeding +250, so he couldn't see all the data
the limits are now set to -999.9 and +999.9 mmHg   :P

when you start out, the pressures are at 0 and +1
so, a "Ducky" patient would be solid dark blue, i think - lol
kinda like a BSOD, but without the white text   :biggrin: