summaryrefslogtreecommitdiffstats
path: root/binfilter/bf_sch/source/core/sch_globfunc.cxx
diff options
context:
space:
mode:
Diffstat (limited to 'binfilter/bf_sch/source/core/sch_globfunc.cxx')
-rw-r--r--binfilter/bf_sch/source/core/sch_globfunc.cxx244
1 files changed, 0 insertions, 244 deletions
diff --git a/binfilter/bf_sch/source/core/sch_globfunc.cxx b/binfilter/bf_sch/source/core/sch_globfunc.cxx
index 2b35e9c9b..019e5769a 100644
--- a/binfilter/bf_sch/source/core/sch_globfunc.cxx
+++ b/binfilter/bf_sch/source/core/sch_globfunc.cxx
@@ -129,250 +129,6 @@ namespace binfilter {
/*N*/ return (SchObjGroup *) SetObjectAttr (new SchObjGroup, nID, bProtect, bResize, 0);
/*N*/ }
-
-/*************************************************************************
-|*
-|* Berechne kub. Spline
-|*
-\************************************************************************/
-
-/*N*/ void CubicSpline (XPolygon &pKnownPoints,
-/*N*/ int n,
-/*N*/ int splineSize,
-/*N*/ XPolygon &pSplines)
-/*N*/ {
-/*N*/ double *h = new double [n + 1];
-/*N*/ double *m = new double [n + 1];
-/*N*/ double *q = new double [n + 1];
-/*N*/ double *u = new double [n + 1];
-/*N*/
-/*N*/ for (int k = 1;
-/*N*/ k <= n;
-/*N*/ k ++)
-/*N*/ h [k] = pKnownPoints [k].X () - pKnownPoints [k - 1].X ();
-/*N*/
-/*N*/ double p;
-/*N*/ double lambda = 0.0;
-/*N*/ double d = 0.0;
-/*N*/ double mue;
-/*N*/
-/*N*/ q [0] = -lambda / 2.0;
-/*N*/ u [0] = d / 2.0;
-/*N*/
-/*N*/ int j;
-/*N*/ for (j = 1;
-/*N*/ j <= n;
-/*N*/ j ++)
-/*N*/ {
-/*N*/ mue = (j < n)
-/*N*/ ? h[j] / (h [j] + h [j + 1])
-/*N*/ : 0.0;
-/*N*/ p = mue * q [j - 1] + 2.0;
-/*N*/ lambda = 1.0 - mue;
-/*N*/ q [j] = -lambda / p;
-/*N*/ d = (j < n)
-/*N*/ ? 6.0 * ((pKnownPoints [j + 1].Y () - pKnownPoints [j].Y ()) / h [j + 1] -
-/*N*/ (pKnownPoints [j].Y () - pKnownPoints [j - 1].Y ()) / h [j]) / (h [j] + h [j + 1])
-/*N*/ : 0.0;
-/*N*/ u [j] = (d - mue * u [j - 1]) / p;
-/*N*/ }
-/*N*/
-/*N*/ m [n] = u [n];
-/*N*/
-/*N*/ for (j = n - 1;
-/*N*/ j >= 0;
-/*N*/ j --)
-/*N*/ m [j] = q [j] * m [j + 1] + u [j];
-/*N*/
-/*N*/ for (j = 0;
-/*N*/ j < n;
-/*N*/ j ++)
-/*N*/ {
-/*N*/ double xStep = (pKnownPoints [j + 1].X () - pKnownPoints [j].X ()) / splineSize;
-/*N*/ double x = pKnownPoints [j].X ();
-/*N*/
-/*N*/ double alpha = pKnownPoints [j].Y ();
-/*N*/ double gamma = m [j] / 2;
-/*N*/ double beta = (pKnownPoints [j + 1].Y () - pKnownPoints [j].Y ()) / h [j + 1] -
-/*N*/ ((2 * m [j] + m [j + 1]) * h [j + 1]) / 6;
-/*N*/ double delta = (m [j + 1] - m [j]) / (6 * h [j + 1]);
-/*N*/
-/*N*/ for (int i = 0;
-/*N*/ i < splineSize;
-/*N*/ i ++)
-/*N*/ {
-/*N*/ double xdiff = (x - pKnownPoints [j].X ());
-/*N*/ int index = j * splineSize + i;
-/*N*/
-/*N*/ pSplines [(short) index].Y () = long(alpha + xdiff * (beta + xdiff * (gamma + xdiff * delta)));
-/*N*/ pSplines [(short) index].X () = long(x);
-/*N*/ x += xStep;
-/*N*/ }
-/*N*/ }
-/*N*/
-/*N*/ pSplines [n * splineSize].Y () = pKnownPoints [n].Y ();
-/*N*/ pSplines [n * splineSize].X () = pKnownPoints [n].X ();
-/*N*/
-/*N*/ delete[] h;
-/*N*/ delete[] m;
-/*N*/ delete[] q;
-/*N*/ delete[] u;
-/*N*/ }
-
-/*************************************************************************
-|*
-|* Bestimme Knotenvektor fuer B-Spline
-|*
-\************************************************************************/
-
-/*N*/ void TVector (int n,
-/*N*/ int k,
-/*N*/ double *t)
-/*N*/ {
-/*N*/ for (int i = 0;
-/*N*/ i <= n + k;
-/*N*/ i ++)
-/*N*/ {
-/*N*/ if (i < k) t [i] = 0;
-/*N*/ else if (i <= n) t [i] = i - k + 1;
-/*N*/ else t [i] = n - k + 2;
-/*N*/ }
-/*N*/ }
-
-/*************************************************************************
-|*
-|* Berechne linken Knotenvektor
-|*
-\************************************************************************/
-
-/*N*/ double TLeft (double x,
-/*N*/ int i,
-/*N*/ int k,
-/*N*/ double *t)
-/*N*/ {
-/*N*/ double deltaT = t [i + k - 1] - t [i];
-/*N*/
-/*N*/ return (deltaT == 0.0)
-/*N*/ ? 0.0
-/*N*/ : (x - t [i]) / deltaT;
-/*N*/ }
-
-/*************************************************************************
-|*
-|* Berechne rechten Knotenvektor
-|*
-\************************************************************************/
-
-/*N*/ double TRight (double x,
-/*N*/ int i,
-/*N*/ int k,
-/*N*/ double *t)
-/*N*/ {
-/*N*/ double deltaT = t [i + k] - t [i + 1];
-/*N*/
-/*N*/ return (deltaT == 0.0)
-/*N*/ ? 0.0
-/*N*/ : (t [i + k] - x) / deltaT;
-/*N*/ }
-
-/*************************************************************************
-|*
-|* Berechne Gewichtungsvektor
-|*
-\************************************************************************/
-
-/*N*/ void BVector (double x,
-/*N*/ int n,
-/*N*/ int k,
-/*N*/ double *b,
-/*N*/ double *t)
-/*N*/ {
-/*N*/ for (int i = 0;
-/*N*/ i <= n + k;
-/*N*/ i ++)
-/*N*/ b [i] = 0;
-/*N*/
-/*N*/ int i0 = (int) floor (x) + k - 1;
-/*N*/ b [i0] = 1;
-/*N*/
-/*N*/ for (int j = 2;
-/*N*/ j <= k;
-/*N*/ j ++)
-/*N*/ for (int i = 0;
-/*N*/ i <= i0;
-/*N*/ i ++)
-/*N*/ b [i] = TLeft (x, i, j, t) * b [i] + TRight (x, i, j, t) * b [i + 1];
-/*N*/ }
-
-/*************************************************************************
-|*
-|* Berechne einzelnen Punkt
-|*
-\************************************************************************/
-
-/*N*/ void BSPoint (int n,
-/*N*/ Point &p1,
-/*N*/ Point &p2,
-/*N*/ XPolygon &pKnownPoints,
-/*N*/ double *b)
-/*N*/ {
-/*N*/ for (int i = 0;
-/*N*/ i <= n;
-/*N*/ i ++)
-/*N*/ {
-/*N*/ p1.Y () = long(p1.Y () + b [i] * pKnownPoints [i].Y ());
-/*N*/ p2.Y () = long(p2.Y () + b [n - i] * pKnownPoints [i].Y ());
-/*N*/ }
-/*N*/ }
-
-/*************************************************************************
-|*
-|* Berechne B-Spline
-|*
-\************************************************************************/
-
-/*N*/ void approxMesh (int splineSize,
-/*N*/ XPolygon &pSplines,
-/*N*/ XPolygon &pKnownPoints,
-/*N*/ int n,
-/*N*/ int k)
-/*N*/ {
-/*N*/ int pCount = splineSize * n;
-/*N*/ double *b = new double [n + k + 1];
-/*N*/ double *t = new double [n + k + 2];
-/*N*/ double xStep = ((double) n - (double) k + 2.0) / (double) pCount;
-/*N*/ double dStep = ((double) pKnownPoints [n].X () - (double) pKnownPoints [0].X ()) / (double) pCount;
-/*N*/ double dXUp = pKnownPoints [0].X ();
-/*N*/ double dXDown = pKnownPoints [n].X ();
-/*N*/ double x = 0.0;
-/*N*/ int nEnd = pCount / 2 + 1;
-/*N*/
-/*N*/ TVector (n, k, t);
-/*N*/
-/*N*/ for (int j = 0;
-/*N*/ j <= nEnd;
-/*N*/ j ++)
-/*N*/ {
-/*N*/ Point aPoint1;
-/*N*/ Point aPoint2;
-/*N*/
-/*N*/ BVector (x, n, k, b, t);
-/*N*/ BSPoint (n, aPoint1, aPoint2, pKnownPoints, b);
-/*N*/
-/*N*/ pSplines [j].X () = (int)(floor(dXUp)+0.5);
-/*N*/ pSplines [j].Y () = aPoint1.Y ();
-/*N*/ pSplines [pCount - j].X () = (int)(floor(dXDown)+0.5);
-/*N*/ pSplines [pCount - j].Y () = aPoint2.Y ();
-/*N*/
-/*N*/ x += xStep;
-/*N*/ dXUp += dStep;
-/*N*/ dXDown -= dStep;
-/*N*/ }
-/*N*/
-/*N*/ delete[] t;
-/*N*/ delete[] b;
-/*N*/ }
-
/*************************************************************************
|*
|* Passe untere Grenze an den Wertebereich an
generated by cgit (git 2.34.1) at 2024-05-04 06:03:41 +0000