static void calc_coefficients(AVFilterContext *ctx)
{
ColorMatrixContext *color = ctx->priv;
double rgb_coeffd[4][3][3];
double yuv_convertd[16][3][3];
int v = 0;
int i, j, k;
for (i = 0; i < 4; i++)
inverse3x3(rgb_coeffd[i], yuv_coeff[i]);
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
solve_coefficients(yuv_convertd[v], rgb_coeffd[i], yuv_coeff[j]);
for (k = 0; k < 3; k++) {
color->yuv_convert[v][k][0] = NS(yuv_convertd[v][k][0]);
color->yuv_convert[v][k][1] = NS(yuv_convertd[v][k][1]);
color->yuv_convert[v][k][2] = NS(yuv_convertd[v][k][2]);
}
if (color->yuv_convert[v][0][0] != 65536 || color->yuv_convert[v][1][0] != 0 ||
color->yuv_convert[v][2][0] != 0) {
av_log(ctx, AV_LOG_ERROR, "error calculating conversion coefficients\n");
}
v++;
}
}
}
std::vector<contr_t> slater_fit(double zeta, int am, int nf, bool verbose, int method) {
sto_params_t par;
par.zeta=zeta;
par.l=am;
par.Nf=nf;
par.method=method;
int maxiter=1000;
// Degrees of freedom
int dof;
if(par.method==0 && nf>=2)
dof=2;
else
// Full optimization
par.method=2;
if(par.method==1 && nf>=4)
dof=4;
else
// Full optimization
par.method=2;
// Full optimization
if(par.method==2)
dof=par.Nf;
gsl_multimin_function_fdf minfunc;
minfunc.n=dof;
minfunc.f=eval_difference;
minfunc.df=eval_difference_df;
minfunc.fdf=eval_difference_fdf;
minfunc.params=(void *) ∥
gsl_multimin_fdfminimizer *min;
// Allocate minimizer
// min=gsl_multimin_fdfminimizer_alloc(gsl_multimin_fdfminimizer_vector_bfgs2,dof);
min=gsl_multimin_fdfminimizer_alloc(gsl_multimin_fdfminimizer_conjugate_pr,dof);
gsl_vector *x;
x=gsl_vector_alloc(dof);
// Initialize vector
gsl_vector_set_all(x,0.0);
// Set starting point
switch(par.method) {
case(2):
// Legendre - same as for even tempered
case(1):
// Well tempered - same initialization as for even-tempered
case(0):
// Even tempered, set alpha=1.0 and beta=2.0
gsl_vector_set(x,0,1.0);
if(dof>1)
gsl_vector_set(x,1,2.0);
break;
/*
case(2):
// Free minimization, set exponents to i
for(int i=0;i<nf;i++)
gsl_vector_set(x,i,i);
break;
*/
default:
ERROR_INFO();
throw std::runtime_error("Unknown Slater fitting method.\n");
}
// Set minimizer
gsl_multimin_fdfminimizer_set(min, &minfunc, x, 0.01, 1e-4);
// Iterate
int iter=0;
int iterdelta=0;
int status;
double cost=0;
if(verbose) printf("Iteration\tDelta\n");
do {
iter++;
iterdelta++;
// Simplex
status = gsl_multimin_fdfminimizer_iterate(min);
if (status) {
// printf("Encountered GSL error \"%s\"\n",gsl_strerror(status));
break;
}
// Are we converged?
status = gsl_multimin_test_gradient (min->gradient, 1e-12);
if (verbose && status == GSL_SUCCESS)
{
printf ("converged to minimum at\n");
}
if(min->f!=cost) {
if(verbose) printf("%i\t%e\t%e\t%e\n",iter,min->f,min->f-cost,gsl_blas_dnrm2(min->gradient));
cost=min->f;
iterdelta=0;
}
} while (status == GSL_CONTINUE && iterdelta < maxiter);
// Get best exponents and coefficients
std::vector<double> optexp=get_exps(min->x,&par);
arma::vec optc=solve_coefficients(optexp,par.zeta,par.l);
// Free memory
gsl_vector_free(x);
gsl_multimin_fdfminimizer_free(min);
// Return
std::vector<contr_t> ret(nf);
for(int i=0;i<nf;i++) {
ret[i].z=optexp[i];
ret[i].c=optc[i];
}
return ret;
}
