Merge commit '4773cc1128f60e83ba5721fe1ad3497b15078361'

1 files changed, 1086 insertions, 0 deletions

diff --git a/tkblt/generic/tkbltGrElemLineSpline.C b/tkblt/generic/tkbltGrElemLineSpline.C
new file mode 100644
index 0000000..9224d53
--- /dev/null
+++ b/tkblt/generic/tkbltGrElemLineSpline.C
@@ -0,0 +1,1086 @@
+/*
+ * Smithsonian Astrophysical Observatory, Cambridge, MA, USA
+ * This code has been modified under the terms listed below and is made
+ * available under the same terms.
+ */
+
+/*
+ *	Copyright 2009 George A Howlett.
+ *
+ *	Permission is hereby granted, free of charge, to any person obtaining
+ *	a copy of this software and associated documentation files (the
+ *	"Software"), to deal in the Software without restriction, including
+ *	without limitation the rights to use, copy, modify, merge, publish,
+ *	distribute, sublicense, and/or sell copies of the Software, and to
+ *	permit persons to whom the Software is furnished to do so, subject to
+ *	the following conditions:
+ *
+ *	The above copyright notice and this permission notice shall be
+ *	included in all copies or substantial portions of the Software.
+ *
+ *	THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ *	EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ *	MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ *	NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ *	LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ *	OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ *	WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ *
+ */
+
+#include <float.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <cmath>
+
+#include "tkbltGrElemLine.h"
+
+using namespace Blt;
+
+typedef double TriDiagonalMatrix[3];
+typedef struct {
+  double b, c, d;
+} Cubic2D;
+
+typedef struct {
+  double b, c, d, e, f;
+} Quint2D;
+
+// Quadratic spline parameters
+#define E1	param[0]
+#define E2	param[1]
+#define V1	param[2]
+#define V2	param[3]
+#define W1	param[4]
+#define W2	param[5]
+#define Z1	param[6]
+#define Z2	param[7]
+#define Y1	param[8]
+#define Y2	param[9]
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * Search --
+ *
+ *	Conducts a binary search for a value.  This routine is called
+ *	only if key is between x(0) and x(len - 1).
+ *
+ * Results:
+ *	Returns the index of the largest value in xtab for which
+ *	x[i] < key.
+ *
+ *---------------------------------------------------------------------------
+ */
+static int Search(Point2d points[], int nPoints, double key, int *foundPtr)
+{
+  int low = 0;
+  int high = nPoints - 1;
+
+  while (high >= low) {
+    int mid = (high + low) / 2;
+    if (key > points[mid].x)
+      low = mid + 1;
+    else if (key < points[mid].x)
+      high = mid - 1;
+    else {
+      *foundPtr = 1;
+      return mid;
+    }
+  }
+  *foundPtr = 0;
+  return low;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * QuadChoose --
+ *
+ *	Determines the case needed for the computation of the parame-
+ *	ters of the quadratic spline.
+ *
+ * Results:
+ * 	Returns a case number (1-4) which controls how the parameters
+ * 	of the quadratic spline are evaluated.
+ *
+ *---------------------------------------------------------------------------
+ */
+static int QuadChoose(Point2d* p, Point2d* q, double m1, double m2, 
+		      double epsilon)
+{
+  // Calculate the slope of the line joining P and Q
+  double slope = (q->y - p->y) / (q->x - p->x);
+
+  if (slope != 0.0) {
+    double prod1 = slope * m1;
+    double prod2 = slope * m2;
+
+    // Find the absolute values of the slopes slope, m1, and m2
+    double mref = fabs(slope);
+    double mref1 = fabs(m1);
+    double mref2 = fabs(m2);
+
+    // If the relative deviation of m1 or m2 from slope is less than
+    // epsilon, then choose case 2 or case 3.
+    double relerr = epsilon * mref;
+    if ((fabs(slope - m1) > relerr) && (fabs(slope - m2) > relerr) &&
+	(prod1 >= 0.0) && (prod2 >= 0.0)) {
+      double prod = (mref - mref1) * (mref - mref2);
+      if (prod < 0.0) {
+	// l1, the line through (x1,y1) with slope m1, and l2,
+	// the line through (x2,y2) with slope m2, intersect
+	// at a point whose abscissa is between x1 and x2.
+	// The abscissa becomes a knot of the spline.
+	return 1;
+      }
+      if (mref1 > (mref * 2.0)) {
+	if (mref2 <= ((2.0 - epsilon) * mref))
+	  return 3;
+      }
+      else if (mref2 <= (mref * 2.0)) {
+	// Both l1 and l2 cross the line through
+	// (x1+x2)/2.0,y1 and (x1+x2)/2.0,y2, which is the
+	// midline of the rectangle formed by P and Q or both
+	// m1 and m2 have signs different than the sign of
+	// slope, or one of m1 and m2 has opposite sign from
+	// slope and l1 and l2 intersect to the left of x1 or
+	// to the right of x2.  The point (x1+x2)/2. is a knot
+	// of the spline.
+	return 2;
+      }
+      else if (mref1 <= ((2.0 - epsilon) * mref)) {
+	// In cases 3 and 4, sign(m1)=sign(m2)=sign(slope).
+	// Either l1 or l2 crosses the midline, but not both.
+	// Choose case 4 if mref1 is greater than
+	// (2.-epsilon)*mref; otherwise, choose case 3.
+	return 3;
+      }
+      // If neither l1 nor l2 crosses the midline, the spline
+      // requires two knots between x1 and x2.
+      return 4;
+    }
+    else {
+      // The sign of at least one of the slopes m1 or m2 does not
+      // agree with the sign of *slope*.
+      if ((prod1 < 0.0) && (prod2 < 0.0)) {
+	return 2;
+      }
+      else if (prod1 < 0.0) {
+	if (mref2 > ((epsilon + 1.0) * mref))
+	  return 1;
+	else
+	  return 2;
+      }
+      else if (mref1 > ((epsilon + 1.0) * mref))
+	return 1;
+      else
+	return 2;
+    }
+  }
+  else if ((m1 * m2) >= 0.0)
+    return 2;
+  else
+    return 1;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *	Computes the knots and other parameters of the spline on the
+ *	interval PQ.
+ * On input--
+ *	P and Q are the coordinates of the points of interpolation.
+ *	m1 is the slope at P.
+ *	m2 is the slope at Q.
+ *	ncase controls the number and location of the knots.
+ * On output--
+ *
+ *	(v1,v2),(w1,w2),(z1,z2), and (e1,e2) are the coordinates of
+ *	the knots and other parameters of the spline on P.
+ *	(e1,e2) and Q are used only if ncase=4.
+ *---------------------------------------------------------------------------
+ */
+static void QuadCases(Point2d* p, Point2d* q, double m1, double m2, 
+		      double param[], int which)
+{
+  if ((which == 3) || (which == 4)) {
+    double c1 = p->x + (q->y - p->y) / m1;
+    double d1 = q->x + (p->y - q->y) / m2;
+    double h1 = c1 * 2.0 - p->x;
+    double j1 = d1 * 2.0 - q->x;
+    double mbar1 = (q->y - p->y) / (h1 - p->x);
+    double mbar2 = (p->y - q->y) / (j1 - q->x);
+
+    if (which == 4) {
+      // Case 4
+      Y1 = (p->x + c1) / 2.0;
+      V1 = (p->x + Y1) / 2.0;
+      V2 = m1 * (V1 - p->x) + p->y;
+      Z1 = (d1 + q->x) / 2.0;
+      W1 = (q->x + Z1) / 2.0;
+      W2 = m2 * (W1 - q->x) + q->y;
+      double mbar3 = (W2 - V2) / (W1 - V1);
+      Y2 = mbar3 * (Y1 - V1) + V2;
+      Z2 = mbar3 * (Z1 - V1) + V2;
+      E1 = (Y1 + Z1) / 2.0;
+      E2 = mbar3 * (E1 - V1) + V2;
+    }
+    else {
+      // Case 3
+      double k1 = (p->y - q->y + q->x * mbar2 - p->x * mbar1) / (mbar2 - mbar1);
+      if (fabs(m1) > fabs(m2)) {
+	Z1 = (k1 + p->x) / 2.0;
+      } else {
+	Z1 = (k1 + q->x) / 2.0;
+      }
+      V1 = (p->x + Z1) / 2.0;
+      V2 = p->y + m1 * (V1 - p->x);
+      W1 = (q->x + Z1) / 2.0;
+      W2 = q->y + m2 * (W1 - q->x);
+      Z2 = V2 + (W2 - V2) / (W1 - V1) * (Z1 - V1);
+    }
+  }
+  else if (which == 2) {
+    // Case 2
+    Z1 = (p->x + q->x) / 2.0;
+    V1 = (p->x + Z1) / 2.0;
+    V2 = p->y + m1 * (V1 - p->x);
+    W1 = (Z1 + q->x) / 2.0;
+    W2 = q->y + m2 * (W1 - q->x);
+    Z2 = (V2 + W2) / 2.0;
+  }
+  else {
+    // Case 1
+    Z1 = (p->y - q->y + m2 * q->x - m1 * p->x) / (m2 - m1);
+    double ztwo = p->y + m1 * (Z1 - p->x);
+    V1 = (p->x + Z1) / 2.0;
+    V2 = (p->y + ztwo) / 2.0;
+    W1 = (Z1 + q->x) / 2.0;
+    W2 = (ztwo + q->y) / 2.0;
+    Z2 = V2 + (W2 - V2) / (W1 - V1) * (Z1 - V1);
+  }
+}
+
+static int QuadSelect(Point2d* p, Point2d* q, double m1, double m2, 
+		      double epsilon, double param[])
+{
+  int ncase = QuadChoose(p, q, m1, m2, epsilon);
+  QuadCases(p, q, m1, m2, param, ncase);
+  return ncase;
+}
+
+static double QuadGetImage(double p1, double p2, double p3, double x1, 
+			   double x2, double x3)
+{
+  double A = x1 - x2;
+  double B = x2 - x3;
+  double C = x1 - x3;
+
+  double y = (p1 * (A * A) + p2 * 2.0 * B * A + p3 * (B * B)) / (C * C);
+  return y;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *	Finds the image of a point in x.
+ *	On input
+ *	x	Contains the value at which the spline is evaluated.
+ *	leftX, leftY
+ *		Coordinates of the left-hand data point used in the
+ *		evaluation of x values.
+ *	rightX, rightY
+ *		Coordinates of the right-hand data point used in the
+ *		evaluation of x values.
+ *	Z1, Z2, Y1, Y2, E2, W2, V2
+ *		Parameters of the spline.
+ *	ncase	Controls the evaluation of the spline by indicating
+ *		whether one or two knots were placed in the interval
+ *		(xtabs,xtabs1).
+ *---------------------------------------------------------------------------
+ */
+static void QuadSpline(Point2d* intp, Point2d* left, Point2d* right,
+		       double param[], int ncase)
+
+{
+  double y;
+
+  if (ncase == 4) {
+    // Case 4:  More than one knot was placed in the interval.
+    // Determine the location of data point relative to the 1st knot.
+    if (Y1 > intp->x)
+      y = QuadGetImage(left->y, V2, Y2, Y1, intp->x, left->x);
+    else if (Y1 < intp->x) {
+      // Determine the location of the data point relative to the 2nd knot.
+      if (Z1 > intp->x)
+	y = QuadGetImage(Y2, E2, Z2, Z1, intp->x, Y1);
+      else if (Z1 < intp->x)
+	y = QuadGetImage(Z2, W2, right->y, right->x, intp->x, Z1);
+      else
+	y = Z2;
+    }
+    else
+      y = Y2;
+  }
+  else {
+    // Cases 1, 2, or 3:
+    // Determine the location of the data point relative to the knot.
+    if (Z1 < intp->x)
+      y = QuadGetImage(Z2, W2, right->y, right->x, intp->x, Z1);
+    else if (Z1 > intp->x)
+      y = QuadGetImage(left->y, V2, Z2, Z1, intp->x, left->x);
+    else
+      y = Z2;
+  }
+
+  intp->y = y;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ * 	Calculates the derivative at each of the data points.  The
+ * 	slopes computed will insure that an osculatory quadratic
+ * 	spline will have one additional knot between two adjacent
+ * 	points of interpolation.  Convexity and monotonicity are
+ * 	preserved wherever these conditions are compatible with the
+ * 	data.
+ *---------------------------------------------------------------------------
+ */
+static void QuadSlopes(Point2d *points, double *m, int nPoints)
+{
+  double m1s =0;
+  double m2s =0;
+  double m1 =0;
+  double m2 =0;
+  int i, n, l;
+  for (l = 0, i = 1, n = 2; i < (nPoints - 1); l++, i++, n++) {
+    // Calculate the slopes of the two lines joining three
+    // consecutive data points.
+    double ydif1 = points[i].y - points[l].y;
+    double ydif2 = points[n].y - points[i].y;
+    m1 = ydif1 / (points[i].x - points[l].x);
+    m2 = ydif2 / (points[n].x - points[i].x);
+    if (i == 1) {
+      // Save slopes of starting point
+      m1s = m1;
+      m2s = m2;
+    }
+    // If one of the preceding slopes is zero or if they have opposite
+    // sign, assign the value zero to the derivative at the middle point.
+    if ((m1 == 0.0) || (m2 == 0.0) || ((m1 * m2) <= 0.0))
+      m[i] = 0.0;
+    else if (fabs(m1) > fabs(m2)) {
+      // Calculate the slope by extending the line with slope m1.
+      double xbar = ydif2 / m1 + points[i].x;
+      double xhat = (xbar + points[n].x) / 2.0;
+      m[i] = ydif2 / (xhat - points[i].x);
+    }
+    else {
+      // Calculate the slope by extending the line with slope m2.
+      double xbar = -ydif1 / m2 + points[i].x;
+      double xhat = (points[l].x + xbar) / 2.0;
+      m[i] = ydif1 / (points[i].x - xhat);
+    }
+  }
+
+  // Calculate the slope at the last point, x(n).
+  i = nPoints - 2;
+  n = nPoints - 1;
+  if ((m1 * m2) < 0.0)
+    m[n] = m2 * 2.0;
+  else {
+    double xmid = (points[i].x + points[n].x) / 2.0;
+    double yxmid = m[i] * (xmid - points[i].x) + points[i].y;
+    m[n] = (points[n].y - yxmid) / (points[n].x - xmid);
+    if ((m[n] * m2) < 0.0)
+      m[n] = 0.0;
+  }
+
+  // Calculate the slope at the first point, x(0).
+  if ((m1s * m2s) < 0.0)
+    m[0] = m1s * 2.0;
+  else {
+    double xmid = (points[0].x + points[1].x) / 2.0;
+    double yxmid = m[1] * (xmid - points[1].x) + points[1].y;
+    m[0] = (yxmid - points[0].y) / (xmid - points[0].x);
+    if ((m[0] * m1s) < 0.0)
+      m[0] = 0.0;
+  }
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ * QuadEval --
+ *
+ * 	QuadEval controls the evaluation of an osculatory quadratic
+ * 	spline.  The user may provide his own slopes at the points of
+ * 	interpolation or use the subroutine 'QuadSlopes' to calculate
+ * 	slopes which are consistent with the shape of the data.
+ *
+ * ON INPUT--
+ *   	intpPts	must be a nondecreasing vector of points at which the
+ *		spline will be evaluated.
+ *   	origPts	contains the abscissas of the data points to be
+ *		interpolated. xtab must be increasing.
+ *   	y	contains the ordinates of the data points to be
+ *		interpolated.
+ *   	m 	contains the slope of the spline at each point of
+ *		interpolation.
+ *   	nPoints	number of data points (dimension of xtab and y).
+ *   	numEval is the number of points of evaluation (dimension of
+ *		xval and yval).
+ *   	epsilon 	is a relative error tolerance used in subroutine
+ *		'QuadChoose' to distinguish the situation m(i) or
+ *		m(i+1) is relatively close to the slope or twice
+ *		the slope of the linear segment between xtab(i) and
+ *		xtab(i+1).  If this situation occurs, roundoff may
+ *		cause a change in convexity or monotonicity of the
+ *   		resulting spline and a change in the case number
+ *		provided by 'QuadChoose'.  If epsilon is not equal to zero,
+ *		then epsilon should be greater than or equal to machine
+ *		epsilon.
+ * ON OUTPUT--
+ * 	yval 	contains the images of the points in xval.
+ *   	err 	is one of the following error codes:
+ *      	0 - QuadEval ran normally.
+ *      	1 - xval(i) is less than xtab(1) for at least one
+ *		    i or xval(i) is greater than xtab(num) for at
+ *		    least one i. QuadEval will extrapolate to provide
+ *		    function values for these abscissas.
+ *      	2 - xval(i+1) < xval(i) for some i.
+ *
+ *
+ *  QuadEval calls the following subroutines or functions:
+ *      Search
+ *      QuadCases
+ *      QuadChoose
+ *      QuadSpline
+ *---------------------------------------------------------------------------
+ */
+static int QuadEval(Point2d origPts[], int nOrigPts, Point2d intpPts[],
+		    int nIntpPts, double *m, double epsilon)
+{
+  double param[10];
+
+  // Initialize indices and set error result
+  int error = 0;
+  int l = nOrigPts - 1;
+  int p = l - 1;
+  int ncase = 1;
+
+  // Determine if abscissas of new vector are non-decreasing.
+  for (int jj=1; jj<nIntpPts; jj++) {
+    if (intpPts[jj].x < intpPts[jj - 1].x)
+      return 2;
+  }
+  // Determine if any of the points in xval are LESS than the
+  // abscissa of the first data point.
+  int start;
+  for (start = 0; start < nIntpPts; start++) {
+    if (intpPts[start].x >= origPts[0].x)
+      break;
+  }
+  // Determine if any of the points in xval are GREATER than the
+  // abscissa of the l data point.
+  int end;
+  for (end = nIntpPts - 1; end >= 0; end--) {
+    if (intpPts[end].x <= origPts[l].x)
+      break;
+  }
+
+  if (start > 0) {
+    // Set error value to indicate that extrapolation has occurred
+    error = 1;
+
+    // Calculate the images of points of evaluation whose abscissas
+    // are less than the abscissa of the first data point.
+    ncase = QuadSelect(origPts, origPts + 1, m[0], m[1], epsilon, param);
+    for (int jj=0; jj<(start - 1); jj++)
+      QuadSpline(intpPts + jj, origPts, origPts + 1, param, ncase);
+    if (nIntpPts == 1)
+      return error;
+  }
+  int ii;
+  int nn;
+  if ((nIntpPts == 1) && (end != (nIntpPts - 1)))
+    goto noExtrapolation;
+    
+  // Search locates the interval in which the first in-range
+  // point of evaluation lies.
+  int found;
+  ii = Search(origPts, nOrigPts, intpPts[start].x, &found);
+    
+  nn = ii + 1;
+  if (nn >= nOrigPts) {
+    nn = nOrigPts - 1;
+    ii = nOrigPts - 2;
+  }
+  /*
+   * If the first in-range point of evaluation is equal to one
+   * of the data points, assign the appropriate value from y.
+   * Continue until a point of evaluation is found which is not
+   * equal to a data point.
+   */
+  if (found) {
+    do {
+      intpPts[start].y = origPts[ii].y;
+      start++;
+      if (start >= nIntpPts) {
+	return error;
+      }
+    } while (intpPts[start - 1].x == intpPts[start].x);
+	
+    for (;;) {
+      if (intpPts[start].x < origPts[nn].x) {
+	break;	/* Break out of for-loop */
+      }
+      if (intpPts[start].x == origPts[nn].x) {
+	do {
+	  intpPts[start].y = origPts[nn].y;
+	  start++;
+	  if (start >= nIntpPts) {
+	    return error;
+	  }
+	} while (intpPts[start].x == intpPts[start - 1].x);
+      }
+      ii++;
+      nn++;
+    }
+  }
+  /*
+   * Calculate the images of all the points which lie within
+   * range of the data.
+   */
+  if ((ii > 0) || (error != 1))
+    ncase = QuadSelect(origPts+ii, origPts+nn, m[ii], m[nn], epsilon, param);
+
+  for (int jj=start; jj<=end; jj++) {
+    // If xx(j) - x(n) is negative, do not recalculate
+    // the parameters for this section of the spline since
+    // they are already known.
+    if (intpPts[jj].x == origPts[nn].x) {
+      intpPts[jj].y = origPts[nn].y;
+      continue;
+    }
+    else if (intpPts[jj].x > origPts[nn].x) {
+      double delta;
+	    
+      // Determine that the routine is in the correct part of the spline
+      do {
+	ii++;
+	nn++;
+	delta = intpPts[jj].x - origPts[nn].x;
+      } while (delta > 0.0);
+	    
+      if (delta < 0.0)
+	ncase = QuadSelect(origPts+ii, origPts+nn, m[ii], m[nn], 
+			   epsilon, param);
+      else if (delta == 0.0) {
+	intpPts[jj].y = origPts[nn].y;
+	continue;
+      }
+    }
+    QuadSpline(intpPts+jj, origPts+ii, origPts+nn, param, ncase);
+  }
+    
+  if (end == (nIntpPts - 1))
+    return error;
+
+  if ((nn == l) && (intpPts[end].x != origPts[l].x))
+    goto noExtrapolation;
+
+  // Set error value to indicate that extrapolation has occurred
+  error = 1;
+  ncase = QuadSelect(origPts + p, origPts + l, m[p], m[l], epsilon, param);
+
+ noExtrapolation:
+  // Calculate the images of the points of evaluation whose
+  // abscissas are greater than the abscissa of the last data point.
+  for (int jj=(end + 1); jj<nIntpPts; jj++)
+    QuadSpline(intpPts + jj, origPts + p, origPts + l, param, ncase);
+
+  return error;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ *
+ *		  Shape preserving quadratic splines
+ *		   by D.F.Mcallister & J.A.Roulier
+ *		    Coded by S.L.Dodd & M.Roulier
+ *			 N.C.State University
+ *
+ *---------------------------------------------------------------------------
+ */
+/*
+ * Driver routine for quadratic spline package
+ * On input--
+ *   X,Y    Contain n-long arrays of data (x is increasing)
+ *   XM     Contains m-long array of x values (increasing)
+ *   eps    Relative error tolerance
+ *   n      Number of input data points
+ *   m      Number of output data points
+ * On output--
+ *   work   Contains the value of the first derivative at each data point
+ *   ym     Contains the interpolated spline value at each data point
+ */
+int LineElement::quadraticSpline(Point2d *origPts, int nOrigPts, 
+				 Point2d *intpPts, int nIntpPts)
+{
+  double* work = new double[nOrigPts];
+  double epsilon = 0.0;
+  /* allocate space for vectors used in calculation */
+  QuadSlopes(origPts, work, nOrigPts);
+  int result = QuadEval(origPts, nOrigPts, intpPts, nIntpPts, work, epsilon);
+  delete [] work;
+  if (result > 1) {
+    return 0;
+  }
+  return 1;
+}
+
+/*
+ *---------------------------------------------------------------------------
+ * Reference:
+ *	Numerical Analysis, R. Burden, J. Faires and A. Reynolds.
+ *	Prindle, Weber & Schmidt 1981 pp 112
+ *---------------------------------------------------------------------------
+ */
+int LineElement::naturalSpline(Point2d *origPts, int nOrigPts, 
+			       Point2d *intpPts, int nIntpPts)
+{
+  Point2d *ip, *iend;
+  double x, dy, alpha;
+  int isKnot;
+  int i, j, n;
+
+  double* dx = new double[nOrigPts];
+  /* Calculate vector of differences */
+  for (i = 0, j = 1; j < nOrigPts; i++, j++) {
+    dx[i] = origPts[j].x - origPts[i].x;
+    if (dx[i] < 0.0) {
+      return 0;
+    }
+  }
+  n = nOrigPts - 1;		/* Number of intervals. */
+  TriDiagonalMatrix* A = new TriDiagonalMatrix[nOrigPts];
+  if (!A) {
+    delete [] dx;
+    return 0;
+  }
+  /* Vectors to solve the tridiagonal matrix */
+  A[0][0] = A[n][0] = 1.0;
+  A[0][1] = A[n][1] = 0.0;
+  A[0][2] = A[n][2] = 0.0;
+
+  /* Calculate the intermediate results */
+  for (i = 0, j = 1; j < n; j++, i++) {
+    alpha = 3.0 * ((origPts[j + 1].y / dx[j]) - (origPts[j].y / dx[i]) - 
+		   (origPts[j].y / dx[j]) + (origPts[i].y / dx[i]));
+    A[j][0] = 2 * (dx[j] + dx[i]) - dx[i] * A[i][1];
+    A[j][1] = dx[j] / A[j][0];
+    A[j][2] = (alpha - dx[i] * A[i][2]) / A[j][0];
+  }
+
+  Cubic2D* eq = new Cubic2D[nOrigPts];
+  if (!eq) {
+    delete [] A;
+    delete [] dx;
+    return 0;
+  }
+  eq[0].c = eq[n].c = 0.0;
+  for (j = n, i = n - 1; i >= 0; i--, j--) {
+    eq[i].c = A[i][2] - A[i][1] * eq[j].c;
+    dy = origPts[i+1].y - origPts[i].y;
+    eq[i].b = (dy) / dx[i] - dx[i] * (eq[j].c + 2.0 * eq[i].c) / 3.0;
+    eq[i].d = (eq[j].c - eq[i].c) / (3.0 * dx[i]);
+  }
+  delete [] A;
+  delete [] dx;
+
+  /* Now calculate the new values */
+  for (ip = intpPts, iend = ip + nIntpPts; ip < iend; ip++) {
+    ip->y = 0.0;
+    x = ip->x;
+
+    /* Is it outside the interval? */
+    if ((x < origPts[0].x) || (x > origPts[n].x)) {
+      continue;
+    }
+    /* Search for the interval containing x in the point array */
+    i = Search(origPts, nOrigPts, x, &isKnot);
+    if (isKnot) {
+      ip->y = origPts[i].y;
+    } else {
+      i--;
+      x -= origPts[i].x;
+      ip->y = origPts[i].y + x * (eq[i].b + x * (eq[i].c + x * eq[i].d));
+    }
+  }
+  delete [] eq;
+  return 1;
+}
+
+typedef struct {
+  double t;			/* Arc length of interval. */
+  double x;			/* 2nd derivative of X with respect to T */
+  double y;			/* 2nd derivative of Y with respect to T */
+} CubicSpline;
+
+/*
+ * The following two procedures solve the special linear system which arise
+ * in cubic spline interpolation. If x is assumed cyclic ( x[i]=x[n+i] ) the
+ * equations can be written as (i=0,1,...,n-1):
+ *     m[i][0] * x[i-1] + m[i][1] * x[i] + m[i][2] * x[i+1] = b[i] .
+ * In matrix notation one gets A * x = b, where the matrix A is tridiagonal
+ * with additional elements in the upper right and lower left position:
+ *   A[i][0] = A_{i,i-1}  for i=1,2,...,n-1    and    m[0][0] = A_{0,n-1} ,
+ *   A[i][1] = A_{i, i }  for i=0,1,...,n-1
+ *   A[i][2] = A_{i,i+1}  for i=0,1,...,n-2    and    m[n-1][2] = A_{n-1,0}.
+ * A should be symmetric (A[i+1][0] == A[i][2]) and positive definite.
+ * The size of the system is given in n (n>=1).
+ *
+ * In the first procedure the Cholesky decomposition A = C^T * D * C
+ * (C is upper triangle with unit diagonal, D is diagonal) is calculated.
+ * Return TRUE if decomposition exist.
+ */
+static int SolveCubic1(TriDiagonalMatrix A[], int n)
+{
+  int i;
+  double m_ij, m_n, m_nn, d;
+
+  if (n < 1) {
+    return 0;		/* Dimension should be at least 1 */
+  }
+  d = A[0][1];		/* D_{0,0} = A_{0,0} */
+  if (d <= 0.0) {
+    return 0;		/* A (or D) should be positive definite */
+  }
+  m_n = A[0][0];		/*  A_{0,n-1}  */
+  m_nn = A[n - 1][1];		/* A_{n-1,n-1} */
+  for (i = 0; i < n - 2; i++) {
+    m_ij = A[i][2];		/*  A_{i,1}  */
+    A[i][2] = m_ij / d;	/* C_{i,i+1} */
+    A[i][0] = m_n / d;	/* C_{i,n-1} */
+    m_nn -= A[i][0] * m_n;	/* to get C_{n-1,n-1} */
+    m_n = -A[i][2] * m_n;	/* to get C_{i+1,n-1} */
+    d = A[i + 1][1] - A[i][2] * m_ij;	/* D_{i+1,i+1} */
+    if (d <= 0.0) {
+      return 0;	/* Elements of D should be positive */
+    }
+    A[i + 1][1] = d;
+  }
+  if (n >= 2) {		/* Complete last column */
+    m_n += A[n - 2][2];	/* add A_{n-2,n-1} */
+    A[n - 2][0] = m_n / d;	/* C_{n-2,n-1} */
+    A[n - 1][1] = d = m_nn - A[n - 2][0] * m_n;	/* D_{n-1,n-1} */
+    if (d <= 0.0) {
+      return 0;
+    }
+  }
+  return 1;
+}
+
+/*
+ * The second procedure solves the linear system, with the Cholesky
+ * decomposition calculated above (in m[][]) and the right side b given
+ * in x[]. The solution x overwrites the right side in x[].
+ */
+static void SolveCubic2(TriDiagonalMatrix A[], CubicSpline spline[], 
+			int nIntervals)
+{
+  int n = nIntervals - 2;
+  int m = nIntervals - 1;
+
+  // Division by transpose of C : b = C^{-T} * b 
+  double x = spline[m].x;
+  double y = spline[m].y;
+  for (int ii=0; ii<n; ii++) {
+    spline[ii + 1].x -= A[ii][2] * spline[ii].x; /* C_{i,i+1} * x(i) */
+    spline[ii + 1].y -= A[ii][2] * spline[ii].y; /* C_{i,i+1} * x(i) */
+    x -= A[ii][0] * spline[ii].x;	/* C_{i,n-1} * x(i) */
+    y -= A[ii][0] * spline[ii].y; /* C_{i,n-1} * x(i) */
+  }
+  if (n >= 0) {
+    // C_{n-2,n-1} * x_{n-1}
+    spline[m].x = x - A[n][0] * spline[n].x; 
+    spline[m].y = y - A[n][0] * spline[n].y; 
+  }
+  // Division by D: b = D^{-1} * b 
+  for (int ii=0; ii<nIntervals; ii++) {
+    spline[ii].x /= A[ii][1];
+    spline[ii].y /= A[ii][1];
+  }
+
+  // Division by C: b = C^{-1} * b
+  x = spline[m].x;
+  y = spline[m].y;
+  if (n >= 0) {
+    // C_{n-2,n-1} * x_{n-1}
+    spline[n].x -= A[n][0] * x;	
+    spline[n].y -= A[n][0] * y;	
+  }
+  for (int ii=(n - 1); ii>=0; ii--) {
+    // C_{i,i+1} * x_{i+1} + C_{i,n-1} * x_{n-1}
+    spline[ii].x -= A[ii][2] * spline[ii + 1].x + A[ii][0] * x;
+    spline[ii].y -= A[ii][2] * spline[ii + 1].y + A[ii][0] * y;
+  }
+}
+
+/*
+ * Find second derivatives (x''(t_i),y''(t_i)) of cubic spline interpolation
+ * through list of points (x_i,y_i). The parameter t is calculated as the
+ * length of the linear stroke. The number of points must be at least 3.
+ * Note: For CLOSED_CONTOURs the first and last point must be equal.
+ */
+static CubicSpline* CubicSlopes(Point2d points[], int nPoints,
+				int isClosed, double unitX, double unitY)
+{
+  CubicSpline *s1, *s2;
+  int n, i;
+  double norm, dx, dy;
+    
+  CubicSpline* spline = new CubicSpline[nPoints];
+  if (!spline)
+    return NULL;
+
+  TriDiagonalMatrix *A = new TriDiagonalMatrix[nPoints];
+  if (!A) {
+    delete [] spline;
+    return NULL;
+  }
+  /*
+   * Calculate first differences in (dxdt2[i], y[i]) and interval lengths
+   * in dist[i]:
+   */
+  s1 = spline;
+  for (i = 0; i < nPoints - 1; i++) {
+    s1->x = points[i+1].x - points[i].x;
+    s1->y = points[i+1].y - points[i].y;
+
+    /*
+     * The Norm of a linear stroke is calculated in "normal coordinates"
+     * and used as interval length:
+     */
+    dx = s1->x / unitX;
+    dy = s1->y / unitY;
+    s1->t = sqrt(dx * dx + dy * dy);
+
+    s1->x /= s1->t;	/* first difference, with unit norm: */
+    s1->y /= s1->t;	/*   || (dxdt2[i], y[i]) || = 1      */
+    s1++;
+  }
+
+  /*
+   * Setup linear System:  Ax = b
+   */
+  n = nPoints - 2;		/* Without first and last point */
+  if (isClosed) {
+    /* First and last points must be equal for CLOSED_CONTOURs */
+    spline[nPoints - 1].t = spline[0].t;
+    spline[nPoints - 1].x = spline[0].x;
+    spline[nPoints - 1].y = spline[0].y;
+    n++;			/* Add last point (= first point) */
+  }
+  s1 = spline, s2 = s1 + 1;
+  for (i = 0; i < n; i++) {
+    /* Matrix A, mainly tridiagonal with cyclic second index 
+       ("j = j+n mod n") 
+    */
+    A[i][0] = s1->t;	/* Off-diagonal element A_{i,i-1} */
+    A[i][1] = 2.0 * (s1->t + s2->t);	/* A_{i,i} */
+    A[i][2] = s2->t;	/* Off-diagonal element A_{i,i+1} */
+
+    /* Right side b_x and b_y */
+    s1->x = (s2->x - s1->x) * 6.0;
+    s1->y = (s2->y - s1->y) * 6.0;
+
+    /* 
+     * If the linear stroke shows a cusp of more than 90 degree,
+     * the right side is reduced to avoid oscillations in the
+     * spline: 
+     */
+    /*
+     * The Norm of a linear stroke is calculated in "normal coordinates"
+     * and used as interval length:
+     */
+    dx = s1->x / unitX;
+    dy = s1->y / unitY;
+    norm = sqrt(dx * dx + dy * dy) / 8.5;
+    if (norm > 1.0) {
+      /* The first derivative will not be continuous */
+      s1->x /= norm;
+      s1->y /= norm;
+    }
+    s1++, s2++;
+  }
+
+  if (!isClosed) {
+    /* Third derivative is set to zero at both ends */
+    A[0][1] += A[0][0];	/* A_{0,0}     */
+    A[0][0] = 0.0;		/* A_{0,n-1}   */
+    A[n-1][1] += A[n-1][2]; /* A_{n-1,n-1} */
+    A[n-1][2] = 0.0;	/* A_{n-1,0}   */
+  }
+  /* Solve linear systems for dxdt2[] and y[] */
+
+  if (SolveCubic1(A, n)) {	/* Cholesky decomposition */
+    SolveCubic2(A, spline, n); /* A * dxdt2 = b_x */
+  }
+  else {			/* Should not happen, but who knows ... */
+    delete [] A;
+    delete [] spline;
+    return NULL;
+  }
+  /* Shift all second derivatives one place right and update the ends. */
+  s2 = spline + n, s1 = s2 - 1;
+  for (/* empty */; s2 > spline; s2--, s1--) {
+    s2->x = s1->x;
+    s2->y = s1->y;
+  }
+  if (isClosed) {
+    spline[0].x = spline[n].x;
+    spline[0].y = spline[n].y;
+  } else {
+    /* Third derivative is 0.0 for the first and last interval. */
+    spline[0].x = spline[1].x; 
+    spline[0].y = spline[1].y; 
+    spline[n + 1].x = spline[n].x;
+    spline[n + 1].y = spline[n].y;
+  }
+  delete [] A;
+  return spline;
+}
+
+// Calculate interpolated values of the spline function (defined via p_cntr
+// and the second derivatives dxdt2[] and dydt2[]). The number of tabulated
+// values is n. On an equidistant grid n_intpol values are calculated.
+static int CubicEval(Point2d *origPts, int nOrigPts, Point2d *intpPts, 
+		     int nIntpPts, CubicSpline *spline)
+{
+  double t, tSkip;
+  Point2d q;
+  int count;
+
+  /* Sum the lengths of all the segments (intervals). */
+  double tMax = 0.0;
+  for (int ii=0; ii<nOrigPts - 1; ii++)
+    tMax += spline[ii].t;
+
+  /* Need a better way of doing this... */
+
+  /* The distance between interpolated points */
+  tSkip = (1. - 1e-7) * tMax / (nIntpPts - 1);
+    
+  t = 0.0;			/* Spline parameter value. */
+  q = origPts[0];
+  count = 0;
+
+  intpPts[count++] = q;	/* First point. */
+  t += tSkip;
+    
+  for (int ii=0, jj=1; jj<nOrigPts; ii++, jj++) {
+    // Interval length
+    double d = spline[ii].t;
+    Point2d p = q;
+    q = origPts[ii+1];
+    double hx = (q.x - p.x) / d;
+    double hy = (q.y - p.y) / d;
+    double dx0 = (spline[jj].x + 2 * spline[ii].x) / 6.0;
+    double dy0 = (spline[jj].y + 2 * spline[ii].y) / 6.0;
+    double dx01 = (spline[jj].x - spline[ii].x) / (6.0 * d);
+    double dy01 = (spline[jj].y - spline[ii].y) / (6.0 * d);
+    while (t <= spline[ii].t) { /* t in current interval ? */
+      p.x += t * (hx + (t - d) * (dx0 + t * dx01));
+      p.y += t * (hy + (t - d) * (dy0 + t * dy01));
+      intpPts[count++] = p;
+      t += tSkip;
+    }
+
+    // Parameter t relative to start of next interval 
+    t -= spline[ii].t;
+  }
+
+  return count;
+}
+
+int LineElement::naturalParametricSpline(Point2d *origPts, int nOrigPts, 
+					 Region2d *extsPtr, int isClosed,
+					 Point2d *intpPts, int nIntpPts)
+{
+  // Generate a cubic spline curve through the points (x_i,y_i) which are
+  // stored in the linked list p_cntr.
+  // The spline is defined as a 2d-function s(t) = (x(t),y(t)), where the
+  // parameter t is the length of the linear stroke.
+
+  if (nOrigPts < 3)
+    return 0;
+
+  if (isClosed) {
+    origPts[nOrigPts].x = origPts[0].x;
+    origPts[nOrigPts].y = origPts[0].y;
+    nOrigPts++;
+  }
+
+  // Width and height of the grid is used at unit length (2d-norm)
+  double unitX = extsPtr->right - extsPtr->left;
+  double unitY = extsPtr->bottom - extsPtr->top;
+  if (unitX < FLT_EPSILON)
+    unitX = FLT_EPSILON;
+  if (unitY < FLT_EPSILON)
+    unitY = FLT_EPSILON;
+
+  /* Calculate parameters for cubic spline: 
+   *		t     = arc length of interval.
+   *		dxdt2 = second derivatives of x with respect to t, 
+   *		dydt2 = second derivatives of y with respect to t, 
+   */
+  CubicSpline* spline = CubicSlopes(origPts, nOrigPts, isClosed, unitX, unitY);
+  if (spline == NULL)
+    return 0;
+
+  int result= CubicEval(origPts, nOrigPts, intpPts, nIntpPts, spline);
+
+  delete [] spline;
+  return result;
+}
+
+static void CatromCoeffs(Point2d* p, Point2d* a, Point2d* b, 
+			 Point2d* c, Point2d* d)
+{
+  a->x = -p[0].x + 3.0 * p[1].x - 3.0 * p[2].x + p[3].x;
+  b->x = 2.0 * p[0].x - 5.0 * p[1].x + 4.0 * p[2].x - p[3].x;
+  c->x = -p[0].x + p[2].x;
+  d->x = 2.0 * p[1].x;
+  a->y = -p[0].y + 3.0 * p[1].y - 3.0 * p[2].y + p[3].y;
+  b->y = 2.0 * p[0].y - 5.0 * p[1].y + 4.0 * p[2].y - p[3].y;
+  c->y = -p[0].y + p[2].y;
+  d->y = 2.0 * p[1].y;
+}
+
+int LineElement::catromParametricSpline(Point2d* points, int nPoints, 
+					Point2d* intpPts, int nIntpPts)
+{
+  // The spline is computed in screen coordinates instead of data points so
+  // that we can select the abscissas of the interpolated points from each
+  // pixel horizontally across the plotting area.
+
+  Point2d* origPts = new Point2d[nPoints + 4];
+  memcpy(origPts + 1, points, sizeof(Point2d) * nPoints);
+
+  origPts[0] = origPts[1];
+  origPts[nPoints + 2] = origPts[nPoints + 1] = origPts[nPoints];
+
+  for (int ii=0; ii<nIntpPts; ii++) {
+    int interval = (int)intpPts[ii].x;
+    double t = intpPts[ii].y;
+    Point2d a, b, c, d;
+    CatromCoeffs(origPts + interval, &a, &b, &c, &d);
+    intpPts[ii].x = (d.x + t * (c.x + t * (b.x + t * a.x))) / 2.0;
+    intpPts[ii].y = (d.y + t * (c.y + t * (b.y + t * a.y))) / 2.0;
+  }
+
+  delete [] origPts;
+  return 1;
+}