windows-xp/Source/XPSP1/NT/multimedia/directx/dxg/ref8/hop/bspline.cpp

/*============================================================================
 *
 *  Copyright (C) 1999-2000 Microsoft Corporation.  All Rights Reserved.
 *
 *  File:       bspline.cpp
 *  Content:    Implementation for B-Splines
 *
 ****************************************************************************/

#include "pch.cpp"
#pragma hdrstop

//-----------------------------------------------------------------------------
// RefDev::ProcessBSpline
//-----------------------------------------------------------------------------
HRESULT RefDev::ProcessBSpline( DWORD dwOffW, DWORD dwOffH,
                                DWORD dwWidth, DWORD dwHeight,
                                DWORD dwStride, DWORD order,
                                FLOAT *pPrimSegments )
{
    if(order == 0)
    {
        order = 2;
    }
    else
    {
        ++order;
    }

    int u_range = dwWidth - (order - 1);
    int v_range = dwHeight - (order - 1);

    if(u_range <= 0 || v_range <= 0)
    {
        DPFERR("Insufficient control vertices for current order");
        return DDERR_INVALIDPARAMS;
    }

    RDBSpline bsp(dwWidth, dwHeight, order, order);

    static const unsigned M[4] = {0, 0, 0, 0}, N[4] = {0, 0, 0, 0};

    unsigned u_segs, v_segs, u_start, v_start;

    if(pPrimSegments != 0)
    {
        u_segs = unsigned(double(unsigned(pPrimSegments[0]) + unsigned(pPrimSegments[2])) / 2.0 + 0.5);
        v_segs = unsigned(double(unsigned(pPrimSegments[1]) + unsigned(pPrimSegments[3])) / 2.0 + 0.5);
        if(u_segs == 0)
        {
            u_segs = 1;
        }
        if(v_segs == 0)
        {
            v_segs = 1;
        }
        if(unsigned(pPrimSegments[0]) != unsigned(pPrimSegments[2]) || unsigned(pPrimSegments[1]) != unsigned(pPrimSegments[3]))
        {
            // First, gulp, the irregular outside
            // To make life easier, we don't want to deal with the case when u_segs or v_segs is one
            // This ensures that there is at least one inside point
            if(u_segs == 1)
            {
                u_segs = 2;
            }
            if(v_segs == 1)
            {
                v_segs = 2;
            }
            // Start with top edge
            unsigned segs = unsigned(pPrimSegments[0]);
            unsigned k_outer = 0;
            unsigned k_inner = 1;
            unsigned outer_inc = u_segs - 2;
            unsigned inner_inc = segs;
            unsigned outer = 0;
            unsigned inner = 0;
            double u0, v0, u1, v1, u2, v2;
            while(outer_inc != 0 ? (inner != inner_inc * outer_inc || outer != inner_inc * outer_inc) : (k_outer < segs))
            {
                if(inner < outer)
                {
                    _ASSERT(k_inner < u_segs - 1, "Error in logic");
                    u0 = double(u_range * k_inner) / double(u_segs) + double(order - 1);    
                    v0 = double(v_range) / double(v_segs) + double(order - 1);
                    u1 = double(u_range * k_outer) / double(segs) + double(order - 1);    
                    v1 = double(order - 1);
                    u2 = double(u_range * (k_inner + 1)) / double(u_segs) + double(order - 1);    
                    v2 = v0;
                    ++k_inner;
                    inner += inner_inc;
                }
                else
                {
                    _ASSERT(k_outer < segs, "Error in logic");
                    u0 = double(u_range * k_inner) / double(u_segs) + double(order - 1);    
                    v0 = double(v_range) / double(v_segs) + double(order - 1);
                    u1 = double(u_range * k_outer) / double(segs) + double(order - 1);    
                    v1 = double(order - 1);
                    u2 = double(u_range * (k_outer + 1)) / double(segs) + double(order - 1);    
                    v2 = v1;
                    ++k_outer;
                    outer += outer_inc;
                }
                HRESULT hr = DrawTessTri(bsp, dwOffW, dwOffH, dwStride, M, N, u0, v0, u1, v1, u2, v2,
                                         bsp.TexCoordU(u0), bsp.TexCoordV(v0),
                                         bsp.TexCoordU(u1), bsp.TexCoordV(v1),
                                         bsp.TexCoordU(u2), bsp.TexCoordV(v2),
                                         false, false, false);
                if(FAILED(hr))
                {
                    return hr;
                }
            }
            // bottom edge
            segs = unsigned(pPrimSegments[2]);
            k_outer = segs;
            k_inner = u_segs - 1;
            inner_inc = segs;
            outer = 0;
            inner = 0;
            while(outer_inc != 0 ? (inner != inner_inc * outer_inc || outer != inner_inc * outer_inc) : (k_outer > 0))
            {
                if(inner < outer)
                {
                    _ASSERT(k_inner > 1, "Error in logic");
                    u0 = double(u_range * k_inner) / double(u_segs) + double(order - 1);    
                    v0 = double(v_range * (v_segs - 1)) / double(v_segs) + double(order - 1);
                    u1 = double(u_range * k_outer) / double(segs) + double(order - 1);    
                    v1 = double(v_range + order - 1);
                    u2 = double(u_range * (k_inner - 1)) / double(u_segs) + double(order - 1);    
                    v2 = v0;
                    --k_inner;
                    inner += inner_inc;
                }
                else
                {
                    _ASSERT(k_outer > 0, "Error in logic");
                    u0 = double(u_range * k_inner) / double(u_segs) + double(order - 1);    
                    v0 = double(v_range * (v_segs - 1)) / double(v_segs) + double(order - 1);
                    u1 = double(u_range * k_outer) / double(segs) + double(order - 1);    
                    v1 = double(v_range + order - 1);
                    u2 = double(u_range * (k_outer - 1)) / double(segs) + double(order - 1);    
                    v2 = v1;
                    --k_outer;
                    outer += outer_inc;
                }
                HRESULT hr = DrawTessTri(bsp, dwOffW, dwOffH, dwStride, M, N, u0, v0, u1, v1, u2, v2,
                                         bsp.TexCoordU(u0), bsp.TexCoordV(v0),
                                         bsp.TexCoordU(u1), bsp.TexCoordV(v1),
                                         bsp.TexCoordU(u2), bsp.TexCoordV(v2),
                                         false, false, false);
                if(FAILED(hr))
                {
                    return hr;
                }
            }
            // right edge
            segs = unsigned(pPrimSegments[1]);
            k_outer = 0;
            k_inner = 1;
            outer_inc = v_segs - 2;
            inner_inc = segs;
            outer = 0;
            inner = 0;
            while(outer_inc != 0 ? (inner != inner_inc * outer_inc || outer != inner_inc * outer_inc) : (k_outer < segs))
            {
                if(inner < outer)
                {
                    _ASSERT(k_inner < v_segs - 1, "Error in logic");
                    u0 = double(u_range * (u_segs - 1)) / double(u_segs) + double(order - 1);
                    v0 = double(v_range * k_inner) / double(v_segs) + double(order - 1);
                    u1 = double(u_range + order - 1);
                    v1 = double(v_range * k_outer) / double(segs) + double(order - 1);
                    u2 = u0;
                    v2 = double(v_range * (k_inner + 1)) / double(v_segs) + double(order - 1);    
                    ++k_inner;
                    inner += inner_inc;
                }
                else
                {
                    _ASSERT(k_outer < segs, "Error in logic");
                    u0 = double(u_range * (u_segs - 1)) / double(u_segs) + double(order - 1);
                    v0 = double(v_range * k_inner) / double(v_segs) + double(order - 1);
                    u1 = double(u_range + order - 1);
                    v1 = double(v_range * k_outer) / double(segs) + double(order - 1);
                    u2 = u1;
                    v2 = double(v_range * (k_outer + 1)) / double(segs) + double(order - 1);    
                    ++k_outer;
                    outer += outer_inc;
                }
                HRESULT hr = DrawTessTri(bsp, dwOffW, dwOffH, dwStride, M, N, u0, v0, u1, v1, u2, v2,
                                         bsp.TexCoordU(u0), bsp.TexCoordV(v0),
                                         bsp.TexCoordU(u1), bsp.TexCoordV(v1),
                                         bsp.TexCoordU(u2), bsp.TexCoordV(v2),
                                         false, false, false);
                if(FAILED(hr))
                {
                    return hr;
                }
            }
            // left edge
            segs = unsigned(pPrimSegments[3]);
            k_outer = segs;
            k_inner = v_segs - 1;
            inner_inc = segs;
            outer = 0;
            inner = 0;
            while(outer_inc != 0 ? (inner != inner_inc * outer_inc || outer != inner_inc * outer_inc) : (k_outer > 0))
            {
                if(inner < outer)
                {
                    _ASSERT(k_inner > 1, "Error in logic");
                    u0 = double(u_range) / double(u_segs) + double(order - 1);
                    v0 = double(v_range * k_inner) / double(v_segs) + double(order - 1);
                    u1 = double(order - 1);
                    v1 = double(v_range * k_outer) / double(segs) + double(order - 1);
                    u2 = u0;
                    v2 = double(v_range * (k_inner - 1)) / double(v_segs) + double(order - 1);    
                    --k_inner;
                    inner += inner_inc;
                }
                else
                {
                    _ASSERT(k_outer > 0, "Error in logic");
                    u0 = double(u_range) / double(u_segs) + double(order - 1);
                    v0 = double(v_range * k_inner) / double(v_segs) + double(order - 1);
                    u1 = double(order - 1);
                    v1 = double(v_range * k_outer) / double(segs) + double(order - 1);
                    u2 = u1;
                    v2 = double(v_range * (k_outer - 1)) / double(segs) + double(order - 1);    
                    --k_outer;
                    outer += outer_inc;
                }
                HRESULT hr = DrawTessTri(bsp, dwOffW, dwOffH, dwStride, M, N, u0, v0, u1, v1, u2, v2,
                                         bsp.TexCoordU(u0), bsp.TexCoordV(v0),
                                         bsp.TexCoordU(u1), bsp.TexCoordV(v1),
                                         bsp.TexCoordU(u2), bsp.TexCoordV(v2),
                                         false, false, false);
                if(FAILED(hr))
                {
                    return hr;
                }
            }
            // Now do the regular interior
            u_start = 1;
            v_start = 1;
        }
        else
        {
            // It can be done regularly
            u_start = 0;
            v_start = 0;
        }
    }
    else
    {
        unsigned segs = unsigned(GetRSf()[D3DRS_PATCHSEGMENTS]);
        if(segs == 0)
        {
            segs = 1;
        }
        u_start = 0;
        v_start = 0;
        u_segs = segs;
        v_segs = segs;
    }

    for(unsigned i = v_start; i < v_segs - v_start; ++i)
    {
        double v0 = double(v_range * i) / double(v_segs) + double(order - 1);
        double v1 = double(v_range * (i + 1)) / double(v_segs) + double(order - 1);
        for(unsigned j = u_start; j < u_segs - u_start; ++j)
        {
            double u0 = double(u_range * j) / double(u_segs) + double(order - 1);    
            double u1 = double(u_range * (j + 1)) / double(u_segs) + double(order - 1);    
            HRESULT hr = DrawTessQuad(bsp, dwOffW, dwOffH, dwStride, M, N, u0, v0, u1, v1,
                                      bsp.TexCoordU(u0), bsp.TexCoordV(v0),
                                      bsp.TexCoordU(u1), bsp.TexCoordV(v1),
                                      false);
            if(FAILED(hr))
            {
                return hr;
            }
        }
    }

    return S_OK;
}

//-----------------------------------------------------------------------------
// RDBSpline::Sample
//-----------------------------------------------------------------------------
void RDBSpline::Sample(DWORD dwDataType, double u, double v, const BYTE *pRow, DWORD dwStride, DWORD dwPitch, BYTE *Q) const
{
    double Acc[4] = {0.0, 0.0, 0.0, 0.0};
    unsigned dwElements = 0;
    switch(dwDataType)
    {
        case D3DVSDT_FLOAT4:
            ++dwElements;
        case D3DVSDT_FLOAT3:
            ++dwElements;
        case D3DVSDT_FLOAT2:
            ++dwElements;
        case D3DVSDT_FLOAT1:
            ++dwElements;
            {
                for(unsigned i = 0; i < m_dwHeight; ++i)
                {
                    double N = Basis(i, m_dwOrderV, v);
                    const BYTE *pCol = pRow;
                    for(unsigned j = 0; j < m_dwWidth; ++j)
                    {
                        double NM = N * Basis(j, m_dwOrderU, u);
                        const FLOAT *B = (FLOAT*)pCol;
                        for(unsigned e = 0; e < dwElements; ++e)
                        {
                            Acc[e] += double(B[e]) * NM;
                        }
                        pCol += dwStride;
                    }
                    pRow += dwPitch;
                }
                for(unsigned e = 0; e < dwElements; ++e)
                {
                    ((FLOAT*)Q)[e] = FLOAT(Acc[e]);
                }
            }
            break;
        case D3DVSDT_D3DCOLOR:
        case D3DVSDT_UBYTE4:
            dwElements = 4;
            {
                for(unsigned i = 0; i < m_dwHeight; ++i)
                {
                    double N = Basis(i, m_dwOrderV, v);
                    const BYTE *pCol = pRow;
                    for(unsigned j = 0; j < m_dwWidth; ++j)
                    {
                        double NM = N * Basis(j, m_dwOrderU, u);
                        const BYTE *B = pCol;
                        for(unsigned e = 0; e < 4; ++e)
                        {
                            Acc[e] += double(B[e]) * NM;
                        }
                        pCol += dwStride;
                    }
                    pRow += dwPitch;
                }
                for(unsigned e = 0; e < 4; ++e)
                {
                    int t = int(Acc[e]);
                    Q[e] = BYTE(t < 0 ? 0 : (t > 255 ? 255 : t));
                }
            }
            break;
        case D3DVSDT_SHORT4:
            dwElements += 2;
        case D3DVSDT_SHORT2:
            dwElements += 2;
            {
                for(unsigned i = 0; i < m_dwHeight; ++i)
                {
                    double N = Basis(i, m_dwOrderV, v);
                    const BYTE *pCol = pRow;
                    for(unsigned j = 0; j < m_dwWidth; ++j)
                    {
                        double NM = N * Basis(j, m_dwOrderU, u);
                        const SHORT *B = (SHORT*)pCol;
                        for(unsigned e = 0; e < dwElements; ++e)
                        {
                            Acc[e] += double(B[e]) * NM;
                        }
                        pCol += dwStride;
                    }
                    pRow += dwPitch;
                }
                for(unsigned e = 0; e < dwElements; ++e)
                {
                    ((SHORT*)Q)[e] = SHORT(Acc[e]);
                }
            }
            break;
        default:
            _ASSERT(FALSE, "Ununderstood vertex element data type");
    }
}

//-----------------------------------------------------------------------------
// RDBSpline::SampleNormal
//-----------------------------------------------------------------------------
void RDBSpline::SampleNormal(DWORD dwDataType, double u, double v, const BYTE *pRow, DWORD dwStride, DWORD dwPitch, BYTE *Q) const
{
    double Acc[2][3] = {{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}};
    // Fudge u and v if they are on the boundary. This is because the derivative is discontinuous on the boundary
    // and we really want it to be slightly inside the boundary.
    if(v == double(m_dwHeight))
    {
        v -= v * DBL_EPSILON;
    }
    if(u == double(m_dwWidth))
    {
        u -= u * DBL_EPSILON;
    }
    switch(dwDataType)
    {
        case D3DVSDT_FLOAT4:
        case D3DVSDT_FLOAT3:
            {
                for(unsigned i = 0; i < m_dwHeight; ++i)
                {
                    double N      = Basis(i, m_dwOrderV, v);
                    double NPrime = BasisPrime(i, m_dwOrderV, v);
                    const BYTE *pCol = pRow;
                    for(unsigned j = 0; j < m_dwWidth; ++j)
                    {
                        double NMPrime = N      * BasisPrime(j, m_dwOrderU, u);
                        double NPrimeM = NPrime * Basis(j, m_dwOrderU, u);
                        const FLOAT *B = (FLOAT*)pCol;
                        for(unsigned e = 0; e < 3; ++e)
                        {
                            Acc[0][e] += double(B[e]) * NMPrime;
                            Acc[1][e] += double(B[e]) * NPrimeM;
                        }
                        pCol += dwStride;
                    }
                    pRow += dwPitch;
                }
                ((FLOAT*)Q)[0] = FLOAT(Acc[0][1] * Acc[1][2] - Acc[0][2] * Acc[1][1]);
                ((FLOAT*)Q)[1] = FLOAT(Acc[0][2] * Acc[1][0] - Acc[0][0] * Acc[1][2]);
                ((FLOAT*)Q)[2] = FLOAT(Acc[0][0] * Acc[1][1] - Acc[0][1] * Acc[1][0]);
            }
            break;
        case D3DVSDT_D3DCOLOR:
        case D3DVSDT_UBYTE4:
            {
                for(unsigned i = 0; i < m_dwHeight; ++i)
                {
                    double N      = Basis(i, m_dwOrderV, v);
                    double NPrime = BasisPrime(i, m_dwOrderV, v);
                    const BYTE *pCol = pRow;
                    for(unsigned j = 0; j < m_dwWidth; ++j)
                    {
                        double NMPrime = N      * BasisPrime(j, m_dwOrderU, u);
                        double NPrimeM = NPrime * Basis(j, m_dwOrderU, u);
                        const BYTE *B = pCol;
                        for(unsigned e = 0; e < 3; ++e)
                        {
                            Acc[0][e] += double(B[e]) * NMPrime;
                            Acc[1][e] += double(B[e]) * NPrimeM;
                        }
                        pCol += dwStride;
                    }
                    pRow += dwPitch;
                }
                ((FLOAT*)Q)[0] = FLOAT(Acc[0][1] * Acc[1][2] - Acc[0][2] * Acc[1][1]);
                ((FLOAT*)Q)[1] = FLOAT(Acc[0][2] * Acc[1][0] - Acc[0][0] * Acc[1][2]);
                ((FLOAT*)Q)[2] = FLOAT(Acc[0][0] * Acc[1][1] - Acc[0][1] * Acc[1][0]);
            }
            break;
        case D3DVSDT_SHORT4:
            {
                for(unsigned i = 0; i < m_dwHeight; ++i)
                {
                    double N      = Basis(i, m_dwOrderV, v);
                    double NPrime = BasisPrime(i, m_dwOrderV, v);
                    const BYTE *pCol = pRow;
                    for(unsigned j = 0; j < m_dwWidth; ++j)
                    {
                        double NMPrime = N      * BasisPrime(j, m_dwOrderU, u);
                        double NPrimeM = NPrime * Basis(j, m_dwOrderU, u);
                        const SHORT *B = (SHORT*)pCol;
                        for(unsigned e = 0; e < 3; ++e)
                        {
                            Acc[0][e] += double(B[e]) * NMPrime;
                            Acc[1][e] += double(B[e]) * NPrimeM;
                        }
                        pCol += dwStride;
                    }
                    pRow += dwPitch;
                }
                ((FLOAT*)Q)[0] = FLOAT(Acc[0][1] * Acc[1][2] - Acc[0][2] * Acc[1][1]);
                ((FLOAT*)Q)[1] = FLOAT(Acc[0][2] * Acc[1][0] - Acc[0][0] * Acc[1][2]);
                ((FLOAT*)Q)[2] = FLOAT(Acc[0][0] * Acc[1][1] - Acc[0][1] * Acc[1][0]);
            }
            break;
        case D3DVSDT_SHORT2:
        case D3DVSDT_FLOAT2:
        case D3DVSDT_FLOAT1:
        default:
            _ASSERT(FALSE, "Ununderstood vertex element data type");
    }
}

//-----------------------------------------------------------------------------
// RDBSpline::SampleDegenerateNormal
//-----------------------------------------------------------------------------
void RDBSpline::SampleDegenerateNormal(DWORD dwDataType, const BYTE *pRow, DWORD dwStride, DWORD dwPitch, BYTE *Q) const
{
    double Acc[2][3] = {{0.0, 0.0, 0.0}, {0.0, 0.0, 0.0}};
    switch(dwDataType)
    {
        case D3DVSDT_FLOAT4:
        case D3DVSDT_FLOAT3:
            {
                for(unsigned i = 0; i < m_dwHeight; ++i)
                {
                    double JPrime = BasisPrime(i, m_dwOrderV, 0.0);
                    const FLOAT *B1 = (FLOAT*)pRow;
                    const FLOAT *B2 = (FLOAT*)(pRow + (m_dwWidth - 1) * dwStride);
                    for(unsigned e = 0; e < 3; ++e)
                    {
                        Acc[0][e] += double(B2[e]) * JPrime;
                        Acc[1][e] += double(B1[e]) * JPrime;
                    }
                    pRow += dwPitch;
                }
                ((FLOAT*)Q)[0] = FLOAT(Acc[0][1] * Acc[1][2] - Acc[0][2] * Acc[1][1]);
                ((FLOAT*)Q)[1] = FLOAT(Acc[0][2] * Acc[1][0] - Acc[0][0] * Acc[1][2]);
                ((FLOAT*)Q)[2] = FLOAT(Acc[0][0] * Acc[1][1] - Acc[0][1] * Acc[1][0]);
            }
            break;
        case D3DVSDT_D3DCOLOR:
        case D3DVSDT_UBYTE4:
            {
                for(unsigned i = 0; i < m_dwHeight; ++i)
                {
                    double JPrime = BasisPrime(i, m_dwOrderV, 0.0);
                    const BYTE *B1 = pRow;
                    const BYTE *B2 = pRow + (m_dwWidth - 1) * dwStride;
                    for(unsigned e = 0; e < 3; ++e)
                    {
                        Acc[0][e] += double(B2[e]) * JPrime;
                        Acc[1][e] += double(B1[e]) * JPrime;
                    }
                    pRow += dwPitch;
                }
                ((FLOAT*)Q)[0] = FLOAT(Acc[0][1] * Acc[1][2] - Acc[0][2] * Acc[1][1]);
                ((FLOAT*)Q)[1] = FLOAT(Acc[0][2] * Acc[1][0] - Acc[0][0] * Acc[1][2]);
                ((FLOAT*)Q)[2] = FLOAT(Acc[0][0] * Acc[1][1] - Acc[0][1] * Acc[1][0]);
            }
            break;
        case D3DVSDT_SHORT4:
            {
                for(unsigned i = 0; i < m_dwHeight; ++i)
                {
                    double JPrime = BasisPrime(i, m_dwOrderV, 0.0);
                    const SHORT *B1 = (SHORT*)pRow;
                    const SHORT *B2 = (SHORT*)(pRow + (m_dwWidth - 1) * dwStride);
                    for(unsigned e = 0; e < 3; ++e)
                    {
                        Acc[0][e] += double(B2[e]) * JPrime;
                        Acc[1][e] += double(B1[e]) * JPrime;
                    }
                    pRow += dwPitch;
                }
                ((FLOAT*)Q)[0] = FLOAT(Acc[0][1] * Acc[1][2] - Acc[0][2] * Acc[1][1]);
                ((FLOAT*)Q)[1] = FLOAT(Acc[0][2] * Acc[1][0] - Acc[0][0] * Acc[1][2]);
                ((FLOAT*)Q)[2] = FLOAT(Acc[0][0] * Acc[1][1] - Acc[0][1] * Acc[1][0]);
            }
            break;
        case D3DVSDT_FLOAT2:
        case D3DVSDT_FLOAT1:
        case D3DVSDT_SHORT2:
        default:
            _ASSERT(FALSE, "Ununderstood vertex element data type");
    }
}

//-----------------------------------------------------------------------------
// RDBSpline::Basis
//-----------------------------------------------------------------------------
double RDBSpline::Basis(unsigned i, unsigned k, double s) const
{
    if(k == 1)
    {
        if(Knot(i) <= s && s < Knot(i + 1))
        {
            return 1.0;
        }
        else
        {
            return 0.0;
        }
    }
    else
    {
        _ASSERT(k != 0, "Arithmatic error in RDBSpline::Basis");
        return ((s - Knot(i)) * Basis(i, k - 1, s)) / (Knot(i + k - 1) - Knot(i)) + 
               ((Knot(i + k) - s) * Basis(i + 1, k - 1, s)) / (Knot(i + k) - Knot(i + 1));
    }
}

//-----------------------------------------------------------------------------
// RDBSpline::BasisPrime
//-----------------------------------------------------------------------------
double RDBSpline::BasisPrime(unsigned i, unsigned k, double s) const
{
    if(k == 1)
    {
        return 0.0;
    }
    else
    {
        _ASSERT(k != 0, "Arithmatic error in RDBSpline::BasisPrime");
        return (Basis(i, k - 1, s) + (s - Knot(i)) * BasisPrime(i, k - 1, s)) / (Knot(i + k - 1) - Knot(i)) + 
               ((Knot(i + k) - s) * BasisPrime(i + 1, k - 1, s) - Basis(i + 1, k - 1, s)) / (Knot(i + k) - Knot(i + 1));
    }
}