static cairo_status_t
twin_scaled_font_init (cairo_scaled_font_t *scaled_font,
cairo_t *cr,
cairo_font_extents_t *metrics)
{
metrics->ascent = FY (50);
metrics->descent = FY (14);
return CAIRO_STATUS_SUCCESS;
}
Vector3<Real> ImplicitSurface<Real>::GetGradient (const Vector3<Real>& rkP)
const
{
Real fFX = FX(rkP);
Real fFY = FY(rkP);
Real fFZ = FZ(rkP);
return Vector3<Real>(fFX,fFY,fFZ);
}
Vector3<Real> ImplicitSurface<Real>::GetGradient (const Vector3<Real>& pos)
const
{
Real fx = FX(pos);
Real fy = FY(pos);
Real fz = FZ(pos);
return Vector3<Real>(fx, fy, fz);
}
bool ImplicitSurface<Real>::ComputePrincipalCurvatureInfo (
const Vector3<Real>& rkP, Real& rfCurv0, Real& rfCurv1,
Vector3<Real>& rkDir0, Vector3<Real>& rkDir1)
{
// Principal curvatures and directions for implicitly defined surfaces
// F(x,y,z) = 0.
//
// DF = (Fx,Fy,Fz), L = Length(DF)
//
// D^2 F = +- -+
// | Fxx Fxy Fxz |
// | Fxy Fyy Fyz |
// | Fxz Fyz Fzz |
// +- -+
//
// adj(D^2 F) = +- -+
// | Fyy*Fzz-Fyz*Fyz Fyz*Fxz-Fxy*Fzz Fxy*Fyz-Fxz*Fyy |
// | Fyz*Fxz-Fxy*Fzz Fxx*Fzz-Fxz*Fxz Fxy*Fxz-Fxx*Fyz |
// | Fxy*Fyz-Fxz*Fyy Fxy*Fxz-Fxx*Fyz Fxx*Fyy-Fxy*Fxy |
// +- -+
//
// Gaussian curvature = [DF^t adj(D^2 F) DF]/L^4
//
// Mean curvature = 0.5*[trace(D^2 F)/L - (DF^t D^2 F DF)/L^3]
// first derivatives
Real fFX = FX(rkP);
Real fFY = FY(rkP);
Real fFZ = FZ(rkP);
Real fL = Math<Real>::Sqrt(fFX*fFX + fFY*fFY + fFZ*fFZ);
if (fL <= Math<Real>::ZERO_TOLERANCE)
{
return false;
}
Real fFXFX = fFX*fFX;
Real fFXFY = fFX*fFY;
Real fFXFZ = fFX*fFZ;
Real fFYFY = fFY*fFY;
Real fFYFZ = fFY*fFZ;
Real fFZFZ = fFZ*fFZ;
Real fInvL = ((Real)1.0)/fL;
Real fInvL2 = fInvL*fInvL;
Real fInvL3 = fInvL*fInvL2;
Real fInvL4 = fInvL2*fInvL2;
// second derivatives
Real fFXX = FXX(rkP);
Real fFXY = FXY(rkP);
Real fFXZ = FXZ(rkP);
Real fFYY = FYY(rkP);
Real fFYZ = FYZ(rkP);
Real fFZZ = FZZ(rkP);
// mean curvature
Real fMCurv = ((Real)0.5)*fInvL3*(fFXX*(fFYFY+fFZFZ) + fFYY*(fFXFX+fFZFZ)
+ fFZZ*(fFXFX+fFYFY)
- ((Real)2.0)*(fFXY*fFXFY+fFXZ*fFXFZ+fFYZ*fFYFZ));
// Gaussian curvature
Real fGCurv = fInvL4*(fFXFX*(fFYY*fFZZ-fFYZ*fFYZ)
+ fFYFY*(fFXX*fFZZ-fFXZ*fFXZ) + fFZFZ*(fFXX*fFYY-fFXY*fFXY)
+ ((Real)2.0)*(fFXFY*(fFXZ*fFYZ-fFXY*fFZZ)
+ fFXFZ*(fFXY*fFYZ-fFXZ*fFYY)
+ fFYFZ*(fFXY*fFXZ-fFXX*fFYZ)));
// solve for principal curvatures
Real fDiscr = Math<Real>::Sqrt(Math<Real>::FAbs(fMCurv*fMCurv-fGCurv));
rfCurv0 = fMCurv - fDiscr;
rfCurv1 = fMCurv + fDiscr;
Real fM00 = ((-(Real)1.0 + fFXFX*fInvL2)*fFXX)*fInvL + (fFXFY*fFXY)*fInvL3
+ (fFXFZ*fFXZ)*fInvL3;
Real fM01 = ((-(Real)1.0 + fFXFX*fInvL2)*fFXY)*fInvL + (fFXFY*fFYY)*fInvL3
+ (fFXFZ*fFYZ)*fInvL3;
Real fM02 = ((-(Real)1.0 + fFXFX*fInvL2)*fFXZ)*fInvL + (fFXFY*fFYZ)*fInvL3
+ (fFXFZ*fFZZ)*fInvL3;
Real fM10 = (fFXFY*fFXX)*fInvL3 + ((-(Real)1.0 + fFYFY*fInvL2)*fFXY)*fInvL
+ (fFYFZ*fFXZ)*fInvL3;
Real fM11 = (fFXFY*fFXY)*fInvL3 + ((-(Real)1.0 + fFYFY*fInvL2)*fFYY)*fInvL
+ (fFYFZ*fFYZ)*fInvL3;
Real fM12 = (fFXFY*fFXZ)*fInvL3 + ((-(Real)1.0 + fFYFY*fInvL2)*fFYZ)*fInvL
+ (fFYFZ*fFZZ)*fInvL3;
Real fM20 = (fFXFZ*fFXX)*fInvL3 + (fFYFZ*fFXY)*fInvL3 + ((-(Real)1.0
+ fFZFZ*fInvL2)*fFXZ)*fInvL;
Real fM21 = (fFXFZ*fFXY)*fInvL3 + (fFYFZ*fFYY)*fInvL3 + ((-(Real)1.0
+ fFZFZ*fInvL2)*fFYZ)*fInvL;
Real fM22 = (fFXFZ*fFXZ)*fInvL3 + (fFYFZ*fFYZ)*fInvL3 + ((-(Real)1.0
+ fFZFZ*fInvL2)*fFZZ)*fInvL;
// solve for principal directions
Real fTmp1 = fM00 + rfCurv0;
Real fTmp2 = fM11 + rfCurv0;
Real fTmp3 = fM22 + rfCurv0;
Vector3<Real> akU[3];
Real afLength[3];
akU[0].X() = fM01*fM12-fM02*fTmp2;
akU[0].Y() = fM02*fM10-fM12*fTmp1;
akU[0].Z() = fTmp1*fTmp2-fM01*fM10;
afLength[0] = akU[0].Length();
akU[1].X() = fM01*fTmp3-fM02*fM21;
akU[1].Y() = fM02*fM20-fTmp1*fTmp3;
akU[1].Z() = fTmp1*fM21-fM01*fM20;
afLength[1] = akU[1].Length();
akU[2].X() = fTmp2*fTmp3-fM12*fM21;
akU[2].Y() = fM12*fM20-fM10*fTmp3;
akU[2].Z() = fM10*fM21-fM20*fTmp2;
afLength[2] = akU[2].Length();
int iMaxIndex = 0;
Real fMax = afLength[0];
if (afLength[1] > fMax)
{
iMaxIndex = 1;
fMax = afLength[1];
}
if (afLength[2] > fMax)
{
iMaxIndex = 2;
}
Real fInvLength = ((Real)1.0)/afLength[iMaxIndex];
akU[iMaxIndex] *= fInvLength;
rkDir1 = akU[iMaxIndex];
rkDir0 = rkDir1.UnitCross(Vector3<Real>(fFX,fFY,fFZ));
return true;
}
bool ImplicitSurface<Real>::ComputePrincipalCurvatureInfo (
const Vector3<Real>& pos, Real& curv0, Real& curv1, Vector3<Real>& dir0,
Vector3<Real>& dir1)
{
// Principal curvatures and directions for implicitly defined surfaces
// F(x,y,z) = 0.
//
// DF = (Fx,Fy,Fz), L = Length(DF)
//
// D^2 F = +- -+
// | Fxx Fxy Fxz |
// | Fxy Fyy Fyz |
// | Fxz Fyz Fzz |
// +- -+
//
// adj(D^2 F) = +- -+
// | Fyy*Fzz-Fyz*Fyz Fyz*Fxz-Fxy*Fzz Fxy*Fyz-Fxz*Fyy |
// | Fyz*Fxz-Fxy*Fzz Fxx*Fzz-Fxz*Fxz Fxy*Fxz-Fxx*Fyz |
// | Fxy*Fyz-Fxz*Fyy Fxy*Fxz-Fxx*Fyz Fxx*Fyy-Fxy*Fxy |
// +- -+
//
// Gaussian curvature = [DF^t adj(D^2 F) DF]/L^4
//
// Mean curvature = 0.5*[trace(D^2 F)/L - (DF^t D^2 F DF)/L^3]
// first derivatives
Real fx = FX(pos);
Real fy = FY(pos);
Real fz = FZ(pos);
Real fLength = Math<Real>::Sqrt(fx*fx + fy*fy + fz*fz);
if (fLength <= Math<Real>::ZERO_TOLERANCE)
{
return false;
}
Real fxfx = fx*fx;
Real fxfy = fx*fy;
Real fxfz = fx*fz;
Real fyfy = fy*fy;
Real fyfz = fy*fz;
Real fzfz = fz*fz;
Real invLength = ((Real)1)/fLength;
Real invLength2 = invLength*invLength;
Real invLength3 = invLength*invLength2;
Real invLength4 = invLength2*invLength2;
// second derivatives
Real fxx = FXX(pos);
Real fxy = FXY(pos);
Real fxz = FXZ(pos);
Real fyy = FYY(pos);
Real fyz = FYZ(pos);
Real fzz = FZZ(pos);
// mean curvature
Real meanCurv = ((Real)0.5)*invLength3*(fxx*(fyfy + fzfz) +
fyy*(fxfx + fzfz) + fzz*(fxfx + fyfy) - ((Real)2)*(fxy*fxfy + fxz*fxfz +
fyz*fyfz));
// Gaussian curvature
Real gaussCurv = invLength4*(fxfx*(fyy*fzz - fyz*fyz)
+ fyfy*(fxx*fzz - fxz*fxz) + fzfz*(fxx*fyy - fxy*fxy)
+ ((Real)2)*(fxfy*(fxz*fyz - fxy*fzz) + fxfz*(fxy*fyz - fxz*fyy)
+ fyfz*(fxy*fxz - fxx*fyz)));
// solve for principal curvatures
Real discr = Math<Real>::Sqrt(Math<Real>::FAbs(meanCurv*meanCurv-gaussCurv));
curv0 = meanCurv - discr;
curv1 = meanCurv + discr;
Real m00 = ((-(Real)1 + fxfx*invLength2)*fxx)*invLength +
(fxfy*fxy)*invLength3 + (fxfz*fxz)*invLength3;
Real m01 = ((-(Real)1 + fxfx*invLength2)*fxy)*invLength +
(fxfy*fyy)*invLength3 + (fxfz*fyz)*invLength3;
Real m02 = ((-(Real)1 + fxfx*invLength2)*fxz)*invLength +
(fxfy*fyz)*invLength3 + (fxfz*fzz)*invLength3;
Real m10 = (fxfy*fxx)*invLength3 +
((-(Real)1 + fyfy*invLength2)*fxy)*invLength + (fyfz*fxz)*invLength3;
Real m11 = (fxfy*fxy)*invLength3 +
((-(Real)1 + fyfy*invLength2)*fyy)*invLength + (fyfz*fyz)*invLength3;
Real m12 = (fxfy*fxz)*invLength3 +
((-(Real)1 + fyfy*invLength2)*fyz)*invLength + (fyfz*fzz)*invLength3;
Real m20 = (fxfz*fxx)*invLength3 + (fyfz*fxy)*invLength3 +
((-(Real)1 + fzfz*invLength2)*fxz)*invLength;
Real m21 = (fxfz*fxy)*invLength3 + (fyfz*fyy)*invLength3 +
((-(Real)1 + fzfz*invLength2)*fyz)*invLength;
Real m22 = (fxfz*fxz)*invLength3 + (fyfz*fyz)*invLength3 +
((-(Real)1 + fzfz*invLength2)*fzz)*invLength;
// solve for principal directions
Real tmp1 = m00 + curv0;
Real tmp2 = m11 + curv0;
Real tmp3 = m22 + curv0;
Vector3<Real> U[3];
Real lengths[3];
U[0].X() = m01*m12-m02*tmp2;
U[0].Y() = m02*m10-m12*tmp1;
U[0].Z() = tmp1*tmp2-m01*m10;
lengths[0] = U[0].Length();
U[1].X() = m01*tmp3-m02*m21;
U[1].Y() = m02*m20-tmp1*tmp3;
U[1].Z() = tmp1*m21-m01*m20;
lengths[1] = U[1].Length();
U[2].X() = tmp2*tmp3-m12*m21;
U[2].Y() = m12*m20-m10*tmp3;
U[2].Z() = m10*m21-m20*tmp2;
lengths[2] = U[2].Length();
int maxIndex = 0;
Real maxValue = lengths[0];
if (lengths[1] > maxValue)
{
maxIndex = 1;
maxValue = lengths[1];
}
if (lengths[2] > maxValue)
{
maxIndex = 2;
}
invLength = ((Real)1)/lengths[maxIndex];
U[maxIndex] *= invLength;
dir1 = U[maxIndex];
dir0 = dir1.UnitCross(Vector3<Real>(fx, fy, fz));
return true;
}
// [[Rcpp::export]]
Rcpp::List fitData(Rcpp::DataFrame ds) {
const size_t ncoeffs = NCOEFFS;
const size_t nbreak = NBREAK;
const size_t n = N;
size_t i, j;
Rcpp::DataFrame D(ds); // construct the data.frame object
RcppGSL::vector<double> y = D["y"]; // access columns by name,
RcppGSL::vector<double> x = D["x"]; // assigning to GSL vectors
RcppGSL::vector<double> w = D["w"];
gsl_bspline_workspace *bw;
gsl_vector *B;
gsl_vector *c;
gsl_matrix *X, *cov;
gsl_multifit_linear_workspace *mw;
double chisq, Rsq, dof, tss;
bw = gsl_bspline_alloc(4, nbreak); // allocate a cubic bspline workspace (k = 4)
B = gsl_vector_alloc(ncoeffs);
X = gsl_matrix_alloc(n, ncoeffs);
c = gsl_vector_alloc(ncoeffs);
cov = gsl_matrix_alloc(ncoeffs, ncoeffs);
mw = gsl_multifit_linear_alloc(n, ncoeffs);
gsl_bspline_knots_uniform(0.0, 15.0, bw); // use uniform breakpoints on [0, 15]
for (i = 0; i < n; ++i) { // construct the fit matrix X
double xi = gsl_vector_get(x, i);
gsl_bspline_eval(xi, B, bw); // compute B_j(xi) for all j
for (j = 0; j < ncoeffs; ++j) { // fill in row i of X
double Bj = gsl_vector_get(B, j);
gsl_matrix_set(X, i, j, Bj);
}
}
gsl_multifit_wlinear(X, w, y, c, cov, &chisq, mw); // do the fit
dof = n - ncoeffs;
tss = gsl_stats_wtss(w->data, 1, y->data, 1, y->size);
Rsq = 1.0 - chisq / tss;
Rcpp::NumericVector FX(151), FY(151); // output the smoothed curve
double xi, yi, yerr;
for (xi = 0.0, i=0; xi < 15.0; xi += 0.1, i++) {
gsl_bspline_eval(xi, B, bw);
gsl_multifit_linear_est(B, c, cov, &yi, &yerr);
FX[i] = xi;
FY[i] = yi;
}
Rcpp::List res =
Rcpp::List::create(Rcpp::Named("X")=FX,
Rcpp::Named("Y")=FY,
Rcpp::Named("chisqdof")=Rcpp::wrap(chisq/dof),
Rcpp::Named("rsq")=Rcpp::wrap(Rsq));
gsl_bspline_free(bw);
gsl_vector_free(B);
gsl_matrix_free(X);
gsl_vector_free(c);
gsl_matrix_free(cov);
gsl_multifit_linear_free(mw);
y.free();
x.free();
w.free();
return(res);
}
void AdvectionManager::advance(double dt, const TimeLevelIndex<2> &newTimeIdx,
const VelocityField &velocity) {
TimeLevelIndex<2> oldTimeIdx = newTimeIdx-1;
TimeLevelIndex<2> halfTimeIdx = newTimeIdx-0.5;
const double eps = 1.0e-80;
const double R = domain->getRadius();
for (int s = 0; s < Q.size(); ++s) {
ScalarField &q = *Q[s];
double dQ;
int J;
//#define ONLY_LAX_WENDROFF
//#define ONLY_UPWIND
#ifndef ONLY_UPWIND
// ---------------------------------------------------------------------
// Lax-Wendroff pass
for (int j = 1; j < mesh->getNumGrid(1, FULL)-1; ++j) {
for (int i = 0; i < mesh->getNumGrid(0, HALF); ++i) {
double f1 = dt/(R*dlon[i]);
double f2 = f1/cosLatFull[j];
double u = velocity(0)(halfTimeIdx, i, j);
double q1 = q(oldTimeIdx, i, j);
double q2 = q(oldTimeIdx, i+1, j);
FX(i, j) = 0.5*f1*(u*(q2+q1)-u*u*f2*(q2-q1));
}
}
FX.applyBndCond();
for (int j = 0; j < mesh->getNumGrid(1, HALF); ++j) {
for (int i = 0; i < mesh->getNumGrid(0, FULL); ++i) {
double f1 = dt/(R*dlat[j]);
double f2 = f1/cosLatHalf[j];
double v = velocity(1)(halfTimeIdx, i, j)*cosLatHalf[j];
double q1 = q(oldTimeIdx, i, j );
double q2 = q(oldTimeIdx, i, j+1);
FY(i, j) = 0.5*f1*(v*(q2+q1)-v*v*f2*(q2-q1));
}
}
FY.applyBndCond();
#endif
#if (!defined ONLY_LAX_WENDROFF && !defined ONLY_UPWIND)
// ---------------------------------------------------------------------
// calculate intermediate Qstar
for (int j = 1; j < mesh->getNumGrid(1, FULL)-1; ++j) {
for (int i = 0; i < mesh->getNumGrid(0, FULL); ++i) {
double fx1 = dt/(R*dlon[i]*cosLatFull[i]); // TODO: Should we support irregular lon grids?
double fx2 = dt/(R*dlon[i]*cosLatFull[i]);
double fy1 = dt/(R*dlat[j-1]*cosLatHalf[j-1]);
double fy2 = dt/(R*dlat[j ]*cosLatHalf[j ]);
double u1 = velocity(0)(halfTimeIdx, i-1, j);
double u2 = velocity(0)(halfTimeIdx, i, j);
double v1 = velocity(1)(halfTimeIdx, i, j-1);
double v2 = velocity(1)(halfTimeIdx, i, j );
double tmp1 = fabs(u1*fx1)*(1-fabs(u1*fx1));
double tmp2 = fabs(u2*fx2)*(1-fabs(u2*fx2));
double tmp3 = fabs(v1*fy1)*(1-fabs(v1*fy1));
double tmp4 = fabs(v2*fy2)*(1-fabs(v2*fy2));
double gamma = fmax(fmax(tmp1, tmp2), fmax(tmp3, tmp4));
B(i, j) = 2/(2-2*gamma);
}
}
for (int j = 1; j < mesh->getNumGrid(1, FULL)-1; ++j) {
for (int i = 0; i < mesh->getNumGrid(0, FULL); ++i) {
Qstar(i, j) = q(oldTimeIdx, i, j)-B(i, j)/cosLatFull[j]*
(FX(i, j)-FX(i-1, j)+FY(i, j)-FY(i, j-1));
}
}
// handle poles
// south pole
dQ = 0; J = 0;
for (int i = 0; i < mesh->getNumGrid(0, FULL); ++i) {
dQ += B(i, J+1)*FY(i, J);
}
dQ *= 4.0/mesh->getNumGrid(0, FULL)/cosLatHalf[J];
for (int i = 0; i < mesh->getNumGrid(0, FULL); ++i) {
Qstar(i, J) = q(oldTimeIdx, i, J)-dQ;
}
// north pole
dQ = 0; J = mesh->getNumGrid(1, FULL)-1;
for (int i = 0; i < mesh->getNumGrid(0, FULL); ++i) {
dQ += B(i, J-1)*FY(i, J-1);
}
dQ *= 4.0/mesh->getNumGrid(0, FULL)/cosLatHalf[J-1];
for (int i = 0; i < mesh->getNumGrid(0, FULL); ++i) {
Qstar(i, J) = q(oldTimeIdx, i, J)+dQ;
}
// ---------------------------------------------------------------------
// shape-preserving rule (A <= 0 is good)
for (int j = 0; j < mesh->getNumGrid(1, FULL); ++j) {
for (int i = 0; i < mesh->getNumGrid(0, FULL); ++i) {
double Qmin = 1.0e+15;
double Qmax = -1.0e+15;
if (j == 0) {
Qmin = fmin(fmin(q(oldTimeIdx, i, j), q(oldTimeIdx, i, j+1)), Qmin);
Qmax = fmax(fmax(q(oldTimeIdx, i, j), q(oldTimeIdx, i, j+1)), Qmax);
} else if (j == mesh->getNumGrid(1, FULL)-1) {
Qmin = fmin(fmin(q(oldTimeIdx, i, j), q(oldTimeIdx, i, j-1)), Qmin);
Qmax = fmax(fmax(q(oldTimeIdx, i, j), q(oldTimeIdx, i, j-1)), Qmax);
} else {
Qmin = fmin(fmin(fmin(q(oldTimeIdx, i-1, j), q(oldTimeIdx, i+1, j)),
fmin(q(oldTimeIdx, i, j-1), q(oldTimeIdx, i, j+1))),
fmin(q(oldTimeIdx, i, j), Qmin));
Qmax = fmax(fmax(fmax(q(oldTimeIdx, i-1, j), q(oldTimeIdx, i+1, j)),
fmax(q(oldTimeIdx, i, j-1), q(oldTimeIdx, i, j+1))),
fmax(q(oldTimeIdx, i, j), Qmax));
}
A(i, j) = (Qstar(i, j)-Qmax)*(Qstar(i, j)-Qmin);
}
}
A.applyBndCond();
#endif
#ifndef ONLY_LAX_WENDROFF
// ---------------------------------------------------------------------
// upwind pass
for (int j = 1; j < mesh->getNumGrid(1, FULL)-1; ++j) {
for (int i = 0; i < mesh->getNumGrid(0, HALF); ++i) {
#ifndef ONLY_UPWIND
double tmp1 = (fabs(A(i, j))+A(i, j))/(fabs(A(i, j))+eps);
double tmp2 = (fabs(A(i+1, j))+A(i+1, j))/(fabs(A(i+1, j))+eps);
double tmp3 = (fabs(A(i+1, j))+A(i+1, j))*(fabs(A(i, j))+A(i, j));
double tmp4 = fabs(A(i, j))*fabs(A(i+1, j))+eps;
double cxstar = 0.5*(tmp1+tmp2)-0.25*tmp3/tmp4;
#else
double cxstar = 1;
#endif
double f = dt/(R*dlon[i]);
double u = velocity(0)(halfTimeIdx, i, j);
double q1 = q(oldTimeIdx, i, j);
double q2 = q(oldTimeIdx, i+1, j);
double cx = cxstar+(1-cxstar)*fabs(u*f/cosLatFull[j]);
FX(i, j) = 0.5*f*(u*(q2+q1)-fabs(cx*u)*(q2-q1));
}
}
FX.applyBndCond();
for (int j = 0; j < mesh->getNumGrid(1, HALF); ++j) {
for (int i = 0; i < mesh->getNumGrid(0, FULL); ++i) {
#ifndef ONLY_UPWIND
double tmp1 = (fabs(A(i, j ))+A(i, j ))/(fabs(A(i, j ))+eps);
double tmp2 = (fabs(A(i, j+1))+A(i, j+1))/(fabs(A(i, j+1))+eps);
double tmp3 = (fabs(A(i, j+1))+A(i, j+1))*(fabs(A(i, j))+A(i, j));
double tmp4 = fabs(A(i, j))*fabs(A(i, j+1))+eps;
double cystar = 0.5*(tmp1+tmp2)-0.25*tmp3/tmp4;
#else
double cystar = 1;
#endif
double f = dt/(R*dlat[j]);
double v = velocity(1)(halfTimeIdx, i, j)*cosLatHalf[j];
double q1 = q(oldTimeIdx, i, j );
double q2 = q(oldTimeIdx, i, j+1);
double cy = cystar+(1-cystar)*fabs(v*f/cosLatHalf[j]);
FY(i, j) = 0.5*f*(v*(q2+q1)-fabs(cy*v)*(q2-q1));
}
}
FY.applyBndCond();
#endif
// ---------------------------------------------------------------------
// calculate final Q
for (int j = 1; j < mesh->getNumGrid(1, FULL)-1; ++j) {
for (int i = 0; i < mesh->getNumGrid(0, FULL); ++i) {
q(newTimeIdx, i, j) = q(oldTimeIdx, i, j)-
(FX(i, j)-FX(i-1, j)+FY(i, j)-FY(i, j-1))/cosLatFull[j];
}
}
// handle poles
// south pole
dQ = 0; J = 0;
for (int i = 0; i < mesh->getNumGrid(0, FULL); ++i) {
dQ += FY(i, J);
}
dQ *= 4.0/mesh->getNumGrid(0, FULL)/cosLatHalf[J];
for (int i = 0; i < mesh->getNumGrid(0, FULL); ++i) {
q(newTimeIdx, i, J) = q(oldTimeIdx, i, J)-dQ;
}
// north pole
dQ = 0; J = mesh->getNumGrid(1, FULL)-1;
for (int i = 0; i < mesh->getNumGrid(0, FULL); ++i) {
dQ += FY(i, J-1);
}
dQ *= 4.0/mesh->getNumGrid(0, FULL)/cosLatHalf[J-1];
for (int i = 0; i < mesh->getNumGrid(0, FULL); ++i) {
q(newTimeIdx, i, J) = q(oldTimeIdx, i, J)+dQ;
}
q.applyBndCond(newTimeIdx);
}
diagnose(newTimeIdx);
}
static cairo_status_t
twin_scaled_font_render_glyph (cairo_scaled_font_t *scaled_font,
unsigned long glyph,
cairo_t *cr,
cairo_text_extents_t *metrics)
{
double x1, y1, x2, y2, x3, y3;
const int8_t *b = _cairo_twin_outlines +
_cairo_twin_charmap[glyph >= ARRAY_LENGTH (_cairo_twin_charmap) ? 0 : glyph];
const int8_t *g = twin_glyph_draw(b);
struct {
cairo_bool_t snap;
int snap_x;
int snap_y;
int n_snap_x;
int n_snap_y;
} info = {FALSE};
cairo_set_line_width (cr, 0.06);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
for (;;) {
switch (*g++) {
case 'M':
cairo_close_path (cr);
/* fall through */
case 'm':
x1 = FX(*g++);
y1 = FY(*g++);
if (info.snap)
{
x1 = SNAPX (x1);
y1 = SNAPY (y1);
}
cairo_move_to (cr, x1, y1);
continue;
case 'L':
cairo_close_path (cr);
/* fall through */
case 'l':
x1 = FX(*g++);
y1 = FY(*g++);
if (info.snap)
{
x1 = SNAPX (x1);
y1 = SNAPY (y1);
}
cairo_line_to (cr, x1, y1);
continue;
case 'C':
cairo_close_path (cr);
/* fall through */
case 'c':
x1 = FX(*g++);
y1 = FY(*g++);
x2 = FX(*g++);
y2 = FY(*g++);
x3 = FX(*g++);
y3 = FY(*g++);
if (info.snap)
{
x1 = SNAPX (x1);
y1 = SNAPY (y1);
x2 = SNAPX (x2);
y2 = SNAPY (y2);
x3 = SNAPX (x3);
y3 = SNAPY (y3);
}
cairo_curve_to (cr, x1, y1, x2, y2, x3, y3);
continue;
case 'E':
cairo_close_path (cr);
/* fall through */
case 'e':
cairo_stroke (cr);
break;
case 'X':
/* filler */
continue;
}
break;
}
metrics->x_advance = FX(twin_glyph_right(b)) + cairo_get_line_width (cr);
metrics->x_advance += cairo_get_line_width (cr)/* XXX 2*x.margin */;
if (info.snap)
metrics->x_advance = SNAPI (SNAPX (metrics->x_advance));
return CAIRO_STATUS_SUCCESS;
}
static void flowgrad(float *y, float *flow, int w, int h)
{
float (*gradient)[w][4] = (void*)y;
getsample_operator p = getsample_1;
#define FX(i,j) p(flow,w,h,2,(i),(j),0)
#define FY(i,j) p(flow,w,h,2,(i),(j),1)
for (int j = 0; j < h; j++)
for (int i = 0; i < w; i++) {
// sobel
float ux = -FX(i-1,j-1)-2*FX(i-1,j)-FX(i-1,j+1)
+FX(i+1,j-1)+2*FX(i+1,j)+FX(i+1,j+1);
float uy = -FX(i-1,j-1)-2*FX(i,j-1)-FX(i+1,j-1)
+FX(i-1,j+1)+2*FX(i,j+1)+FX(i+1,j+1);
float vx = -FY(i-1,j-1)-2*FY(i-1,j)-FY(i-1,j+1)
+FY(i+1,j-1)+2*FY(i+1,j)+FY(i+1,j+1);
float vy = -FY(i-1,j-1)-2*FY(i,j-1)-FY(i+1,j-1)
+FY(i-1,j+1)+2*FY(i,j+1)+FY(i+1,j+1);
gradient[j][i][0] = ux;
gradient[j][i][1] = uy;
gradient[j][i][2] = vx;
gradient[j][i][3] = vy;
}
#undef FX
#undef FY
}
