/// <summary>
/// Builds a DCT-interpolated image.
/// </summary>
/// <param name="info">format of the image.</param>
/// <param name="xwaves">number of X waves.</param>
/// <param name="ywaves">number of Y waves.</param>
/// <param name="pval">the values of a set of sampled points.</param>
public DCTInterpolationImage(SySal.Imaging.ImageInfo info, int xwaves, int ywaves, PointValue[] pval)
: base(info, new DCT(info.BitsPerPixel / 8, xwaves, ywaves, info.Width, info.Height, pval))
{
XWaves = xwaves;
YWaves = ywaves;
PointValues = pval;
NumericalTools.AdvancedFitting.LeastSquares lsq = new NumericalTools.AdvancedFitting.LeastSquares();
NumericalTools.Minimization.ITargetFunction dct = (NumericalTools.Minimization.ITargetFunction)Pixels;
double[][] indep = new double[pval.Length][];
double[] dep = new double[pval.Length];
double[] deperr = new double[pval.Length];
int i;
for (i = 0; i < indep.Length; i++)
{
indep[i] = new double[2] {
pval[i].X, pval[i].Y
};
dep[i] = pval[i].Value;
deperr[i] = 1.0;
}
double[] p = lsq.Fit(dct, xwaves * ywaves, indep, dep, deperr, 10);
((DCT)dct).ParamValues = p;
((DCT)dct).MakeCosValues();
((DCT)dct).m_CachedValues = new int[info.Width * info.Height];
System.Threading.Thread[] hcomp_Threads = new System.Threading.Thread[info.Height];
int iiy;
for (iiy = 0; iiy < info.Height; iiy++)
{
hcomp_Threads[iiy] = new System.Threading.Thread(new System.Threading.ParameterizedThreadStart(delegate(object oiiiy)
{
int iiiy = (int)oiiiy;
int iix, ix, iy;
for (iix = 0; iix < info.Width; iix++)
{
double dv = 0.0;
for (ix = 0; ix < XWaves; ix++)
{
for (iy = 0; iy < YWaves; iy++)
{
dv += ((DCT)dct).ParamValues[iy * XWaves + ix] * ((DCT)dct).XCosValues[ix, iix] * ((DCT)dct).YCosValues[iy, iiiy];
}
}
((DCT)dct).m_CachedValues[iiiy * info.Width + iix] = (int)Math.Round(dv);
}
}));
hcomp_Threads[iiy].Start(iiy);
}
for (iiy = 0; iiy < info.Height; iiy++)
{
hcomp_Threads[iiy].Join();
hcomp_Threads[iiy] = null;
}
}
public Chi2H(NumericalTools.Minimization.ITargetFunction d1, NumericalTools.Minimization.ITargetFunction d2, int fitpars, double[][] indep, double[] dep, double[] deperr)
{
m_D1 = d1;
m_D2 = d2;
m_FitPars = fitpars;
m_Indep = indep;
m_Dep = dep;
m_DepErr = deperr;
m_Cases = indep.Length;
if (m_Cases != dep.Length || m_Cases != deperr.Length)
{
throw new Exception("Data size is inconsistent: " + m_Cases + " for indep.var., " + m_Dep.Length + " for dep.var. and " + m_DepErr.Length + " for dep.var.err.");
}
m_Vars = d1.CountParams - m_FitPars;
}
/// <summary>
/// Fits the data to the specified function. The function is meant to have <b>p</b>+<b>v</b> parameters, the first <b>p</b> of which are to be fitted,
/// whereas the remaining <b>v</b> are assumed to be independent variables, whose values are picked from the lists for the independent variables.
/// </summary>
/// <param name="f">the function to be fitted. First derivatives w.r.t. the fit parameters are needed.</param>
/// <param name="fitparameters">the number of parameters to be fitted. They must be the first parameters to be passed to the function.</param>
/// <param name="indep">the list of values for the independent variables.</param>
/// <param name="dep">the list of values for the dependent variable.</param>
/// <param name="deperr">the list of errors for the dependent variable.</param>
/// <param name="maxiterations">maximum number of iterations to find the minimum.</param>
/// <returns>the parameters of the fit.</returns>
public double[] Fit(NumericalTools.Minimization.ITargetFunction f, int fitparameters, double[][] indep, double[] dep, double[] deperr, int maxiterations)
{
m_DegreesOfFreedom = dep.Length - fitparameters;
if (m_DegreesOfFreedom < 0)
{
throw new NumericalTools.Minimization.MinimizationException("Degrees of freedom = " + m_DegreesOfFreedom + ". Aborting.");
}
NumericalTools.Minimization.NewtonMinimizer MA = new NumericalTools.Minimization.NewtonMinimizer();
MA.Logger = m_TW;
Chi2F chi2 = new Chi2F(f, fitparameters, indep, dep, deperr);
MA.FindMinimum(chi2, maxiterations);
m_EstimatedVariance = MA.Value / m_DegreesOfFreedom;
m_BestFit = MA.Point;
Minimization.ITargetFunction[] g = new NumericalTools.Minimization.ITargetFunction[fitparameters];
double[,] hessian = new double[fitparameters, fitparameters];
int i, j;
for (i = 0; i < fitparameters; i++)
{
g[i] = chi2.Derive(i);
for (j = 0; j < fitparameters; j++)
{
hessian[i, j] = g[i].Derive(j).Evaluate(m_BestFit);
}
}
m_CorrelationMatrix = new double[fitparameters, fitparameters];
double[][] c = new Cholesky(hessian, 0.0).Inverse(0.0);
for (i = 0; i < fitparameters; i++)
{
for (j = 0; j < i; j++)
{
m_CorrelationMatrix[j, i] = m_CorrelationMatrix[i, j] = c[i][j] / (Math.Sqrt(c[i][i]) * Math.Sqrt(c[j][j]));
}
m_CorrelationMatrix[i, j] = 1.0;
}
m_StandardErrors = new double[fitparameters];
for (i = 0; i < fitparameters; i++)
{
m_StandardErrors[i] = Math.Sqrt(m_EstimatedVariance * c[i][i]);
}
return(m_BestFit);
}
public Chi2F(NumericalTools.Minimization.ITargetFunction f, int fitpars, double[][] indep, double[] dep, double[] deperr)
{
m_F = f;
m_FitPars = fitpars;
m_Indep = indep;
m_Dep = dep;
m_DepErr = deperr;
m_Cases = indep.Length;
if (m_Cases != dep.Length || m_Cases != deperr.Length)
{
throw new Exception("Data size is inconsistent: " + m_Cases + " for indep.var., " + m_Dep.Length + " for dep.var. and " + m_DepErr.Length + " for dep.var.err.");
}
m_Vars = f.CountParams - m_FitPars;
m_Start = new double[m_FitPars];
int i;
for (i = 0; i < m_FitPars; i++)
{
m_Start[i] = m_F.Start[i];
}
}
/// <summary>
/// Fits the data to the specified function. The function is meant to have <b>p</b>+<b>v</b> parameters, the first <b>p</b> of which are to be fitted,
/// whereas the remaining <b>v</b> are assumed to be independent variables, whose values are picked from the lists for the independent variables.
/// </summary>
/// <param name="f">the function to be fitted. First derivatives w.r.t. the fit parameters are needed.</param>
/// <param name="fitparameters">the number of parameters to be fitted. They must be the first parameters to be passed to the function.</param>
/// <param name="indep">the list of values for the independent variables.</param>
/// <param name="indeperr">the list of errors for the independent variable.</param>
/// <param name="dep">the list of values for the dependent variable.</param>
/// <param name="deperr">the list of errors for the dependent variable.</param>
/// <param name="maxiterations">maximum number of iterations to find the minimum.</param>
/// <returns>the parameters of the fit.</returns>
/// <remarks>The method of effective variance is used to take errors on the independent variables into account. </remarks>
public double[] Fit(NumericalTools.Minimization.ITargetFunction f, int fitparameters, double[][] indep, double[] dep, double [][] indeperr, double[] deperr, int maxiterations)
{
m_DegreesOfFreedom = dep.Length - fitparameters;
if (m_DegreesOfFreedom < 0)
{
throw new NumericalTools.Minimization.MinimizationException("Degrees of freedom = " + m_DegreesOfFreedom + ". Aborting.");
}
NumericalTools.Minimization.NewtonMinimizer MA = new NumericalTools.Minimization.NewtonMinimizer();
MA.Logger = m_TW;
NumericalTools.Minimization.ITargetFunction[] f_d = new NumericalTools.Minimization.ITargetFunction[f.CountParams - fitparameters];
int i, j;
for (i = 0; i < f_d.Length; i++)
{
f_d[i] = f.Derive(i + fitparameters);
}
double [] c_deperr = new double[deperr.Length];
double [] xp = new double[f.CountParams];
double [] xfp = new double[fitparameters];
double dfx;
for (i = 0; i < f_d.Length; i++)
{
xfp[i] = f.Start[i];
}
int maxouteriter = maxiterations;
if (maxouteriter <= 0)
{
maxouteriter = -1;
}
double f0, f1, dxchange;
do
{
if (m_TW != null)
{
m_TW.WriteLine("Starting with derivative guess - remaining iterations: " + maxouteriter);
}
for (i = 0; i < f_d.Length; i++)
{
xp[i] = xfp[i];
}
for (i = 0; i < c_deperr.Length; i++)
{
for (j = 0; j < f_d.Length; j++)
{
xp[j + fitparameters] = indep[i][j];
}
c_deperr[i] = deperr[i] * deperr[i];
for (j = 0; j < f_d.Length; j++)
{
dfx = f_d[j].Evaluate(xp) * indeperr[i][j];
c_deperr[i] += dfx * dfx;
}
c_deperr[i] = Math.Sqrt(c_deperr[i]);
}
Chi2F chi2 = new Chi2F(f, fitparameters, indep, dep, c_deperr);
chi2.SetStart(xfp);
f0 = chi2.Evaluate(xfp);
MA.FindMinimum(chi2, maxiterations);
m_EstimatedVariance = MA.Value / m_DegreesOfFreedom;
m_BestFit = MA.Point;
Minimization.ITargetFunction[] g = new NumericalTools.Minimization.ITargetFunction[fitparameters];
double[,] hessian = new double[fitparameters, fitparameters];
for (i = 0; i < fitparameters; i++)
{
g[i] = chi2.Derive(i);
for (j = 0; j < fitparameters; j++)
{
hessian[i, j] = g[i].Derive(j).Evaluate(m_BestFit);
}
}
m_CorrelationMatrix = new double[fitparameters, fitparameters];
double[][] c = new Cholesky(hessian, 0.0).Inverse(0.0);
for (i = 0; i < fitparameters; i++)
{
for (j = 0; j < i; j++)
{
m_CorrelationMatrix[j, i] = m_CorrelationMatrix[i, j] = c[i][j] / (Math.Sqrt(c[i][i]) * Math.Sqrt(c[j][j]));
}
m_CorrelationMatrix[i, j] = 1.0;
}
m_StandardErrors = new double[fitparameters];
for (i = 0; i < fitparameters; i++)
{
m_StandardErrors[i] = Math.Sqrt(m_EstimatedVariance * c[i][i]);
}
dxchange = 0.0;
for (i = 0; i < f_d.Length; i++)
{
dxchange += (xfp[i] - m_BestFit[i]) * (xfp[i] - m_BestFit[i]);
}
f1 = chi2.Evaluate(m_BestFit);
for (i = 0; i < xfp.Length; i++)
{
xfp[i] = m_BestFit[i];
}
if (m_TW != null)
{
m_TW.WriteLine("End with derivative guess - remaining iterations: " + maxouteriter);
}
if (--maxouteriter < 0)
{
maxouteriter = -1;
}
}while (maxouteriter != 0 && f.StopMinimization(f1, f0, dxchange) == false);
return(m_BestFit);
}
