/** @brief Overloading the test fixture set up. */ virtual void SetUp() { // Call the parent set up. TestFunctionDataSetting::SetUp(); // Set the hyperparameters. logHyp.cov(0) = log(ell); logHyp.cov(1) = log(sigma_f); logHyp.lik(0) = log(sigma_n); // Some constants N = trainingData.N(); pInvSqrtD = invSqrtD(logHyp.lik, trainingData); pL1 = choleskyFactor(logHyp.cov, logHyp.lik, trainingData); pL2 = choleskyFactor(logHyp.cov, trainingData, pInvSqrtD); pY_M = y_m(logHyp.mean, trainingData); pAlpha1 = alpha(pInvSqrtD, pL1, pY_M); pAlpha2 = alpha(logHyp.lik, pL1, pY_M); pQ1 = q(pInvSqrtD, pL1, pAlpha1); pQ2 = q(logHyp.lik, pL1, pAlpha2); dnlZWRTLikHyp1 = dnlZWRTLikHyp(logHyp.lik, trainingData, pQ1); dnlZWRTLikHyp2 = dnlZWRTLikHyp(logHyp.lik, pQ2); }
BSplineFit<T>::BSplineFit( int iDimension, int iSampleQuantity, const T* afSampleData, int iDegree, int iControlQuantity ) : m_kBasis( iControlQuantity, iDegree ) { if( iControlQuantity <= iDegree + 1 ) iControlQuantity = iDegree + 2; if( iControlQuantity > iSampleQuantity ) iControlQuantity = iSampleQuantity; iDegree = constrain( iDegree, 1, iControlQuantity - 1 ); assert(iDimension >= 1); assert(1 <= iDegree && iDegree < iControlQuantity); assert(iControlQuantity <= iSampleQuantity); m_iDimension = iDimension; m_iSampleQuantity = iSampleQuantity; m_afSampleData = afSampleData; m_iDegree = iDegree; m_iControlQuantity = iControlQuantity; m_afControlData = new T[m_iDimension*iControlQuantity]; // Fit the data points with a B-spline curve using a least-squares error // metric. The problem is of the form A^T*A*X = A^T*B. BSplineFitBasisd kDBasis(m_iControlQuantity,m_iDegree); double dTMultiplier = 1.0/(double)(m_iSampleQuantity - 1); double dT; int i0, i1, i2, iMin, iMax, j; // Construct the matrix A (depends only on the output basis function). BandedMatrixd* pkAMat = new BandedMatrixd( m_iControlQuantity, m_iDegree+1, m_iDegree + 1 ); for (i0 = 0; i0 < m_iControlQuantity; i0++) { for ( i1 = 0; i1 < i0; i1++ ) { (*pkAMat)(i0,i1) = (*pkAMat)(i1,i0); } int i1Max = i0 + m_iDegree; if (i1Max >= m_iControlQuantity) { i1Max = m_iControlQuantity - 1; } for (i1 = i0; i1 <= i1Max; i1++) { double dValue = 0.0; for (i2 = 0; i2 < m_iSampleQuantity; i2++) { dT = dTMultiplier*(double)i2; kDBasis.compute(dT,iMin,iMax); if (iMin <= i0 && i0 <= iMax && iMin <= i1 && i1 <= iMax) { double dB0 = kDBasis.getValue(i0 - iMin); double dB1 = kDBasis.getValue(i1 - iMin); dValue += dB0*dB1; } } (*pkAMat)(i0,i1) = dValue; } } // Construct the matrix B. double** aadBMat; aadBMat = new double*[m_iControlQuantity]; aadBMat[0] = new double[m_iControlQuantity*m_iSampleQuantity]; for( int iRow = 1; iRow < m_iControlQuantity; iRow++ ) { aadBMat[iRow] = &aadBMat[0][m_iSampleQuantity*iRow]; } memset( aadBMat[0],0,m_iControlQuantity*m_iSampleQuantity*sizeof(double) ); for (i0 = 0; i0 < m_iControlQuantity; i0++) { for (i1 = 0; i1 < m_iSampleQuantity; i1++) { dT = dTMultiplier*(double)i1; kDBasis.compute(dT,iMin,iMax); if (iMin <= i0 && i0 <= iMax) { aadBMat[i0][i1] = kDBasis.getValue(i0 - iMin); } } } // Construct the control points for the least-squares curve. double* adControlData = new double[m_iDimension*m_iControlQuantity]; memset( adControlData,0,m_iDimension*m_iControlQuantity*sizeof(double) ); double* pdBaseTarget = adControlData; for (i0 = 0; i0 < m_iControlQuantity; i0++) { const T* pfSource = m_afSampleData; double* adTarget = pdBaseTarget; for (i1 = 0; i1 < m_iSampleQuantity; i1++) { double dBValue = aadBMat[i0][i1]; for (j = 0; j < m_iDimension; j++) { adTarget[j] += dBValue*(double)(*pfSource++); } } pdBaseTarget += m_iDimension; } // Solve A^T*A*ControlData = A^T*B*SampleData. bool bSolved = choleskyFactor(*pkAMat); assert(bSolved); bSolved = solveLower(*pkAMat,adControlData); assert(bSolved); bSolved = solveUpper(*pkAMat,adControlData); assert(bSolved); // Set the B-spline control points. T* pfTarget = m_afControlData; const double* pdSource = adControlData; for (i0 = 0; i0 < m_iDimension*m_iControlQuantity; i0++) { *pfTarget++ = (T)(*pdSource++); } // Set the first and last output control points to match the first and // last input samples. This supports the application of fitting keyframe // data with B-spline curves. The user expects that the curve passes // through the first and last positions in order to support matching two // consecutive keyframe sequences. T* pfCEnd0 = m_afControlData; const T* pfSEnd0 = m_afSampleData; T* pfCEnd1 = &m_afControlData[m_iDimension*(m_iControlQuantity-1)]; const T* pfSEnd1 = &m_afSampleData[m_iDimension*(m_iSampleQuantity-1)]; for (j = 0; j < m_iDimension; j++) { *pfCEnd0++ = *pfSEnd0++; *pfCEnd1++ = *pfSEnd1++; } delete [] adControlData; if( aadBMat ) { delete [] aadBMat[0]; delete [] aadBMat; aadBMat = 0; } delete pkAMat; }