bool CharcoalFilter::convolveImage(const unsigned int order, const double* kernel)
{
long kernelWidth = order;
if ((kernelWidth % 2) == 0)
{
qCWarning(DIGIKAM_DIMG_LOG) << "Kernel width must be an odd number!";
return false;
}
long i;
double normalize = 0.0;
QScopedArrayPointer<double> normal_kernel(new double[kernelWidth * kernelWidth]);
if (!normal_kernel)
{
qCWarning(DIGIKAM_DIMG_LOG) << "Unable to allocate memory!";
return false;
}
for (i = 0; i < (kernelWidth * kernelWidth); ++i)
{
normalize += kernel[i];
}
if (fabs(normalize) <= Epsilon)
{
normalize = 1.0;
}
normalize = 1.0 / normalize;
for (i = 0; i < (kernelWidth * kernelWidth); ++i)
{
normal_kernel[i] = normalize * kernel[i];
}
// --------------------------------------------------------
QList<int> vals = multithreadedSteps(m_orgImage.height());
QList <QFuture<void> > tasks;
for (int j = 0 ; runningFlag() && (j < vals.count()-1) ; ++j)
{
tasks.append(QtConcurrent::run(this,
&CharcoalFilter::convolveImageMultithreaded,
vals[j],
vals[j+1],
normal_kernel.data(),
kernelWidth
));
}
foreach(QFuture<void> t, tasks)
t.waitForFinished();
return true;
}
bool SharpenFilter::convolveImage(const unsigned int order, const double* const kernel)
{
uint y;
int progress;
long i;
double normalize = 0.0;
Args prm;
prm.kernelWidth = order;
prm.halfKernelWidth = prm.kernelWidth / 2;;
if ((prm.kernelWidth % 2) == 0)
{
qCWarning(DIGIKAM_DIMG_LOG) << "Kernel width must be an odd number!";
return false;
}
QScopedArrayPointer<double> normal_kernel(new double[prm.kernelWidth * prm.kernelWidth]);
if (normal_kernel.isNull())
{
qCWarning(DIGIKAM_DIMG_LOG) << "Unable to allocate memory!";
return false;
}
for (i = 0 ; i < (prm.kernelWidth * prm.kernelWidth) ; ++i)
{
normalize += kernel[i];
}
if (fabs(normalize) <= Epsilon)
{
normalize = 1.0;
}
normalize = 1.0 / normalize;
for (i = 0 ; i < (prm.kernelWidth * prm.kernelWidth) ; ++i)
{
normal_kernel[i] = normalize * kernel[i];
}
prm.normal_kernel = normal_kernel.data();
QList<int> vals = multithreadedSteps(m_destImage.width());
for (y = 0 ; runningFlag() && (y < m_destImage.height()) ; ++y)
{
QList <QFuture<void> > tasks;
for (int j = 0 ; runningFlag() && (j < vals.count()-1) ; ++j)
{
prm.start = vals[j];
prm.stop = vals[j+1];
prm.y = y;
tasks.append(QtConcurrent::run(this,
&SharpenFilter::convolveImageMultithreaded,
prm
));
}
foreach(QFuture<void> t, tasks)
t.waitForFinished();
progress = (int)(((double)y * 100.0) / m_destImage.height());
if (progress % 5 == 0)
{
postProgress(progress);
}
}
return true;
}
/**
* Determine the conditional modes and the conditional variance of the
* fixed effects given the data and the current random effects.
* Create a Metropolis-Hasting proposal step from the multivariate
* normal density, determine the acceptance probability and, if the
* step is to be accepted, overwrite the contents of fixed with the
* new contents.
*
* @param GS a GlmerStruct
* @param b list of random effects
* @param fixed current value of the fixed effects
*
* @return updated value of the fixed effects
*/
static double *
internal_glmer_fixef_update(GlmerStruct GS, SEXP b,
double fixed[])
{
SEXP dmu_deta, var;
int i, ione = 1, it, j, lwork = -1;
double *ans = Calloc(GS->p, double), /* proposal point */
*md = Calloc(GS->p, double), /* conditional modes */
*w = Calloc(GS->n, double), *work,
*wtd = Calloc(GS->n * GS->p, double),
*z = Calloc(GS->n, double),
crit, devr, one = 1, tmp, zero = 0;
if (!isNewList(b) || LENGTH(b) != GS->nf)
error(_("%s must be a %s of length %d"), "b", "list", GS->nf);
for (i = 0; i < GS->nf; i++) {
SEXP bi = VECTOR_ELT(b, i);
if (!isReal(bi) || !isMatrix(bi))
error(_("b[[%d]] must be a numeric matrix"), i);
}
AZERO(z, GS->n); /* -Wall */
Memcpy(md, fixed, GS->p);
/* calculate optimal size of work array */
F77_CALL(dgels)("N", &(GS->n), &(GS->p), &ione, wtd, &(GS->n),
z, &(GS->n), &tmp, &lwork, &j);
if (j) /* shouldn't happen */
error(_("%s returned error code %d"), "dgels", j);
lwork = (int) tmp;
work = Calloc(lwork, double);
AZERO(GS->off, GS->n); /* fitted values from random effects */
/* fitted_ranef(GET_SLOT(GS->mer, lme4_flistSym), GS->unwtd, b, */
/* INTEGER(GET_SLOT(GS->mer, lme4_ncSym)), GS->off); */
for (i = 0; i < GS->n; i++)
(GS->etaold)[i] = ((GS->off)[i] += (GS->offset)[i]);
for (it = 0, crit = GS->tol + 1;
it < GS->maxiter && crit > GS->tol; it++) {
/* fitted values from current beta */
F77_CALL(dgemv)("N", &(GS->n), &(GS->p), &one,
GS->X, &(GS->n), md,
&ione, &zero, REAL(GS->eta), &ione);
/* add in random effects and offset */
vecIncrement(REAL(GS->eta), (GS->off), GS->n);
/* check for convergence */
crit = conv_crit(GS->etaold, REAL(GS->eta), GS->n);
/* obtain mu, dmu_deta, var */
eval_check_store(GS->linkinv, GS->rho, GS->mu);
dmu_deta = PROTECT(eval_check(GS->mu_eta, GS->rho,
REALSXP, GS->n));
var = PROTECT(eval_check(GS->var, GS->rho, REALSXP, GS->n));
/* calculate weights and working residual */
for (i = 0; i < GS->n; i++) {
w[i] = GS->wts[i] * REAL(dmu_deta)[i]/sqrt(REAL(var)[i]);
z[i] = w[i] * (REAL(GS->eta)[i] - (GS->off)[i] +
((GS->y)[i] - REAL(GS->mu)[i]) /
REAL(dmu_deta)[i]);
}
UNPROTECT(2);
/* weighted copy of the model matrix */
for (j = 0; j < GS->p; j++)
for (i = 0; i < GS->n; i++)
wtd[i + j * GS->n] = GS->X[i + j * GS->n] * w[i];
/* weighted least squares solution */
F77_CALL(dgels)("N", &(GS->n), &(GS->p), &ione, wtd, &(GS->n),
z, &(GS->n), work, &lwork, &j);
if (j) error(_("%s returned error code %d"), "dgels", j);
Memcpy(md, z, GS->p);
}
/* wtd contains the Cholesky factor of
* the precision matrix */
devr = normal_kernel(GS->p, md, wtd, GS->n, fixed);
devr -= fixed_effects_deviance(GS, fixed);
for (i = 0; i < GS->p; i++) {
double var = norm_rand();
ans[i] = var;
devr -= var * var;
}
F77_CALL(dtrsv)("U", "N", "N", &(GS->p), wtd, &(GS->n), ans, &ione);
for (i = 0; i < GS->p; i++) ans[i] += md[i];
devr += fixed_effects_deviance(GS, ans);
crit = exp(-0.5 * devr); /* acceptance probability */
tmp = unif_rand();
if (asLogical(internal_getElement(GS->cv, "msVerbose"))) {
Rprintf("%5.3f: ", crit);
for (j = 0; j < GS->p; j++) Rprintf("%#10g ", ans[j]);
Rprintf("\n");
}
if (tmp < crit) Memcpy(fixed, ans, GS->p);
Free(ans); Free(md); Free(w);
Free(work); Free(wtd); Free(z);
return fixed;
}