x_ite 4.0.5 → 4.7.5

package/src/standard/Geospatial/Geodetic.js

@@ -56,11 +56,11 @@ function (Vector3,
 {
 "use strict";
 
-	var
+	const
 		EPS_H = 1e-3,
 		EPS_P = 1e-10,
 		IMAX  = 30;
-		
+
 	function Geodetic (spheroid, latitudeFirst, radians)
 	{
 		this .longitudeFirst = ! latitudeFirst;
@@ -76,12 +76,12 @@ function (Vector3,
 		constructor: Geodetic,
 		convert: function (geodetic, result)
 		{
-			var elevation = geodetic .z;
+			const elevation = geodetic .z;
 
 			if (this .longitudeFirst)
 			{
 				var
-					latitude  = geodetic .y;
+					latitude  = geodetic .y,
 					longitude = geodetic .x;
 			}
 			else
@@ -90,18 +90,18 @@ function (Vector3,
 					latitude  = geodetic .x,
 					longitude = geodetic .y;
 			}
-		
+
 			if (this .degrees)
 			{
 				latitude  *= Math .PI / 180;
 				longitude *= Math .PI / 180;
 			}
-		
+
 			return this .convertRadians (latitude, longitude, elevation, result);
 		},
 		convertRadians: function (latitude, longitude, elevation, result)
 		{
-			var
+			const
 				slat  = Math .sin (latitude),
 				slat2 = Math .pow (slat, 2),
 				clat  = Math .cos (latitude),
@@ -124,7 +124,7 @@ function (Vector3,
 
 			if (this .longitudeFirst)
 			{
-				var tmp = result .x;
+				const tmp = result .x;
 
 				result .x = result .y; // latitude
 				result .y = tmp;       // longitude
@@ -134,40 +134,40 @@ function (Vector3,
 		},
 		applyRadians: function (geocentric, result)
 		{
-			var
+			const
 				x = geocentric .x,
 				y = geocentric .y,
 				z = geocentric .z;
-		
-			var P = Math .sqrt (x * x + y * y);
-		
+
+			const P = Math .sqrt (x * x + y * y);
+
 			// Handle pole case.
 			if (P == 0)
 				return result .set (Math .PI, 0, z - this .c);
 
-			var
+			let
 				latitude  = 0,
 				longitude = Math .atan2 (y, x),
 				elevation = 0;
-		
-			var
+
+			let
 				a    = this .a,
 				N    = a,
 				ecc2 = this .ecc2;
-		
-			for (var i = 0; i < IMAX; ++ i)
+
+			for (let i = 0; i < IMAX; ++ i)
 			{
-				var
+				const
 					h0 = elevation,
 					b0 = latitude;
-		
+
 				latitude = Math .atan (z / P / (1 - ecc2 * N / (N + elevation)));
-		
-				var sin_p = Math .sin (latitude);
-		
+
+				const sin_p = Math .sin (latitude);
+
 				N         = a / Math .sqrt (1 - ecc2 * sin_p * sin_p);
 				elevation = P / Math .cos (latitude) - N;
-		
+
 				if (Math .abs (elevation - h0) < EPS_H && Math .abs (latitude - b0) < EPS_P)
 					break;
 			}
@@ -176,15 +176,15 @@ function (Vector3,
 		},
 		normal: function (geocentric, result)
 		{
-			var geodetic = this .applyRadians (geocentric, result);
+			const geodetic = this .applyRadians (geocentric, result);
 
-			var
+			const
 				latitude  = geodetic .x,
 				longitude = geodetic .y;
 
-			var clat = Math .cos (latitude);
+			const clat = Math .cos (latitude);
 
-			var
+			const
 				nx = Math .cos (longitude) * clat,
 				ny = Math .sin (longitude) * clat,
 				nz = Math .sin (latitude);
@@ -202,61 +202,61 @@ function (Vector3,
 				RANGE    = this .degrees ? 180 : M_PI,
 				RANGE1_2 = RANGE / 2,
 				RANGE2   = RANGE * 2;
-		
+
 			var range = 0;
-		
+
 			if (this .longitudeFirst)
 			{
-				source .x = Algorithm .interval (source .x, -RANGE,    RANGE);	
+				source .x = Algorithm .interval (source .x, -RANGE,    RANGE);
 				source .y = Algorithm .interval (source .y, -RANGE1_2, RANGE1_2);
-		
-				destination .x = Algorithm .interval (destination .x, -RANGE,    RANGE);	
+
+				destination .x = Algorithm .interval (destination .x, -RANGE,    RANGE);
 				destination .y = Algorithm .interval (destination .y, -RANGE1_2, RANGE1_2);
-		
+
 				range = Math .abs (destination .x - source .x);
 			}
 			else
 			{
 				source .x = Algorithm .interval (source .x, -RANGE1_2, RANGE1_2);
 				source .y = Algorithm .interval (source .y, -RANGE,    RANGE);
-		
+
 				destination .x = Algorithm .interval (destination .x, -RANGE1_2, RANGE1_2);
 				destination .y = Algorithm .interval (destination .y, -RANGE,    RANGE);
-		
+
 				range = Math .abs (destination .y - source .y);
 			}
-		
+
 			if (range <= RANGE)
 				return source .lerp (destination, t);
-		
+
 			var step = (RANGE2 - range) * t;
-		
+
 			if (this .longitudeFirst)
 			{
 				var longitude = source .x < destination .x ? source .x - step : source .x + step;
-		
+
 				if (longitude < -RANGE)
 					longitude += RANGE2;
-		
+
 				else if (longitude > RANGE)
 					longitude -= RANGE2;
-		
+
 				return source .set (longitude,
-				                    Algorithm .lerp (source .y, destination .y, t),
-				                    Algorithm .lerp (source .z, destination .z, t));
+				                    source .y + t * (destination .y - source .y),
+				                    source .z + t * (destination .z - source .z));
 			}
 
 			var longitude = source .y < destination .y ? source .y - step : source .y + step;
-	
+
 			if (longitude < -RANGE)
 				longitude += RANGE2;
-	
+
 			else if (longitude > RANGE)
 				longitude -= RANGE2;
-	
-			return source .set (Algorithm .lerp (source .x, destination .x, t),
+
+			return source .set (source .x + t * (destination .x - source .x),
 			                    longitude,
-			                    Algorithm .lerp (source .z, destination .z, t));
+			                    source .z + t * (destination .z - source .z));
 		},
 		source: new Vector3 (0, 0, 0),
 		destination: new Vector3 (0, 0, 0),

package/src/standard/Geospatial/ReferenceEllipsoids.js

@@ -54,7 +54,7 @@ function (Spheroid3)
 {
 "use strict";
 
-	var ReferenceEllipsoids =
+	const ReferenceEllipsoids =
 	{
 		// Earth
 		// X3D Specification

package/src/standard/Geospatial/UniversalTransverseMercator.js

@@ -58,14 +58,14 @@ function (Geodetic,
 {
 "use strict";
 
-	var
+	const
 		N0 = 1.0e7,
 		E0 = 5.0e5,
 		k0 = 0.9996;
 
 	function UniversalTransverseMercator (spheroid, zone, northernHemisphere, northingFirst)
 	{
-		var
+		const
 			a    = spheroid .getSemiMajorAxis (),
 			ecc2 = 1 - Math .pow (spheroid .getSemiMinorAxis () / a, 2),
 			EE   = ecc2 / (1 - ecc2),
@@ -99,11 +99,11 @@ function (Geodetic,
 		convert: function (utm, result)
 		{
 			// https://gist.github.com/duedal/840476
-		
+
 			if (this .eastingFirst)
 			{
 				var
-					northing = utm .y;
+					northing = utm .y,
 					easting  = utm .x;
 			}
 			else
@@ -112,34 +112,34 @@ function (Geodetic,
 					northing = utm .x,
 					easting  = utm .y;
 			}
-		
+
 			// Check for southern hemisphere and remove offset from easting.
-		
-			var S = this .southernHemisphere;
-		
+
+			let S = this .southernHemisphere;
+
 			if (northing < 0)
 			{
 				S        = ! this .southernHemisphere;
 				northing = -northing;
 			}
-		
+
 			if (S)
 				northing -= N0;
-		
+
 			easting -= E0;
-		
+
 			// Begin calculation.
-		
-			var
+
+			const
 				mu   = northing / this .A,
 				phi1 = mu + this .B * Math .sin (2 * mu) + this .C * Math .sin (4 * mu) + this .D * Math .sin (6 * mu);
-		
-			var
+
+			const
 				sinphi1 = Math .pow (Math .sin (phi1), 2),
 				cosphi1 = Math .cos (phi1),
 				tanphi1 = Math .tan (phi1);
-		
-			var
+
+			const
 				N1 = this .a / Math .sqrt (1 - this .ecc2 * sinphi1),
 				T2 = Math .pow (tanphi1, 2),
 				T8 = Math .pow (tanphi1, 8),
@@ -147,67 +147,67 @@ function (Geodetic,
 				C2 = C1 * C1,
 				R1 = this .E / Math .pow (1 - this .ecc2 * sinphi1, 1.5),
 				I  = easting / (N1 * k0);
-		
-			var
+
+			const
 				J = (5 + 3 * T2 + 10 * C1 - 4 * C2 - this .E9) * Math .pow (I, 4) / 24,
 				K = (61 + 90 * T2 + 298 * C1 + 45 * T8 - this .E252 - 3 * C2) * Math .pow (I, 6) / 720,
 				L = (5 - 2 * C1 + 28 * T2 - 3 * C2 + this .E8 + 24 * T8) * Math .pow (I, 5) / 120;
-		
-			var
+
+			const
 				latitude  = phi1 - (N1 * tanphi1 / R1) * (I * I / 2 - J + K),
 				longitude = this .longitude0 + (I - (1 + 2 * T2 + C1) * Math .pow (I, 3) / 6 + L) / cosphi1;
-		
+
 			return this .geodeticConverter .convertRadians (latitude, longitude, utm .z, result);
 		},
 		apply: function (geocentric, result)
 		{
 			// https://gist.github.com/duedal/840476
 
-			var
+			const
 				geodetic  = this .geodeticConverter .applyRadians (geocentric, result),
 				latitude  = geodetic .x,
 				longitude = geodetic .y;
-		
-			var
+
+			const
 				tanlat = Math .tan (latitude),
 				coslat = Math .cos (latitude);
-		
-			var
+
+			const
 				EE = this .EE,
 				N  = this .a / Math .sqrt (1 - this .ecc2 * Math .pow (Math .sin (latitude), 2)),
 				T  = tanlat * tanlat,
 				T6 = T * T * T,
 				C  = EE * coslat * coslat,
 				A  = coslat * (longitude - this .longitude0);
-		
-			var M = this .a * (this .W * latitude
-			                   - this .X * Math .sin (2 * latitude)
-			                   + this .Y * Math .sin (4 * latitude)
-			                   - this .Z * Math .sin (6 * latitude));
-		
-			var easting = k0 * N * (A + (1 - T + C) * Math .pow (A, 3) / 6
-			                        + (5 - 18 * T6 + 72 * C - 58 * EE) * Math .pow (A, 5) / 120)
-			              + E0;
-		
-			var northing = k0 * (M + N * tanlat * (A * A / 2 + (5 - T + 9 * C + 4 * C * C) * Math .pow (A, 4) / 24
+
+			const M = this .a * (this .W * latitude
+			                     - this .X * Math .sin (2 * latitude)
+			                     + this .Y * Math .sin (4 * latitude)
+			                     - this .Z * Math .sin (6 * latitude));
+
+			const easting = k0 * N * (A + (1 - T + C) * Math .pow (A, 3) / 6
+			                          + (5 - 18 * T6 + 72 * C - 58 * EE) * Math .pow (A, 5) / 120)
+			                + E0;
+
+			let northing = k0 * (M + N * tanlat * (A * A / 2 + (5 - T + 9 * C + 4 * C * C) * Math .pow (A, 4) / 24
 			                                       + (61 - 58 * T6 + 600 * C - 330 * EE) * Math .pow (A, 6) / 720));
-		
+
 			if (latitude < 0)
 			{
 				northing += N0;
-				
+
 				if (! this .southernHemisphere)
 					northing = -northing;
 			}
 			else
 			{
 				if (this .southernHemisphere)
-					northing = -northing;		
+					northing = -northing;
 			}
-		
+
 			if (this .eastingFirst)
 				return result .set (easting, northing, geodetic .z);
-		
+
 			return result .set (northing, easting, geodetic .z);
 		},
 		//lerp: Vector3 .lerp,

package/src/standard/Math/Algorithm.js

@@ -47,17 +47,15 @@
  ******************************************************************************/
 
 
-
 define (function ()
 {
 "use strict";
 
-	var Algorithm =
+	function Algorithm () { }
+
+	Algorithm .prototype =
 	{
-		signum: function (value)
-		{
-			return (0 < value) - (value < 0);
-		},
+		constructor: Algorithm,
 		radians: function (value)
 		{
 			return value * (Math .PI / 180);
@@ -70,9 +68,15 @@ define (function ()
 		{
 			return min + Math .random () * (max - min);
 		},
+		fract: function (value)
+		{
+			return value > 0 ? value - Math .floor (value) : value - Math .ceil (value);
+		},
 		clamp: function (value, min, max)
 		{
-			return value < min ? min : (value > max ? max : value);
+			// http://jsperf.com/math-clamp
+			// http://jsperf.com/clamping-methods/2
+			return Math .min (Math .max (value, min), max);
 		},
 		interval: function (value, low, high)
 		{
@@ -90,7 +94,7 @@ define (function ()
 		},
 		slerp: function (source, destination, t)
 		{
-			var cosom = source .dot (destination);
+			let cosom = source .dot (destination);
 
 			if (cosom <= -1)
 				throw new Error ("slerp is not possible: vectors are inverse collinear.");
@@ -103,9 +107,9 @@ define (function ()
 				// Reverse signs so we travel the short way round
 				cosom = -cosom;
 				destination .negate ();
-			}				
+			}
 
-			var
+			const
 				omega = Math .acos (cosom),
 				sinom = Math .sin  (omega),
 
@@ -121,7 +125,7 @@ define (function ()
 		},
 		simpleSlerp: function (source, destination, t)
 		{
-			var cosom = source .dot (destination);
+			const cosom = source .dot (destination);
 
 			if (cosom <= -1)
 				throw new Error ("slerp is not possible: vectors are inverse collinear.");
@@ -129,7 +133,7 @@ define (function ()
 			if (cosom >= 1) // both normal vectors are equal
 				return source;
 
-			var
+			const
 				omega = Math .acos (cosom),
 				sinom = Math .sin  (omega),
 
@@ -151,31 +155,15 @@ define (function ()
 		{
 			///  Returns the next power of two of @a n. If n is a power of two, n is returned.
 
-			-- n;
-
-			for (var k = 1; ! (k & (1 << (4 + 1))); k <<= 1)
-				n |= n >> k;
+			if (this .isPowerOfTwo (n))
+				return n;
 
-			return ++ n;
+			return 1 << 32 - Math .clz32 (n);
 		},
-		/*
-		isInt: function(n)
+		cmp: function (lhs, rhs)
 		{
-			return typeof n === 'number' && 
-			       parseFloat (n) == parseInt (n, 10) && ! isNaN (n);
+			return lhs > rhs ? 1 : lhs < rhs ? -1 : 0;
 		},
-		decimalPlaces: function (n)
-		{
-			var
-				a = Math.abs(n),
-				c = a, count = 1;
-
-			while(! Algorithm .isInt (c) && isFinite (c))
-				c = a * Math .pow (10, count ++);
-	
-			return count-1;
-		},
-		*/
 		less: function (lhs, rhs)
 		{
 			return lhs < rhs;
@@ -188,7 +176,7 @@ define (function ()
 		{
 		   // http://en.cppreference.com/w/cpp/algorithm/lower_bound
 
-			var
+			let
 				index = 0,
 				step  = 0,
 				count = last - first;
@@ -213,7 +201,7 @@ define (function ()
 		{
 		   // http://en.cppreference.com/w/cpp/algorithm/upper_bound
 
-			var
+			let
 				index = 0,
 				step  = 0,
 				count = last - first;
@@ -237,7 +225,7 @@ define (function ()
 		},
 		set_difference: function (lhs, rhs, result)
 		{
-			for (var key in lhs)
+			for (const key in lhs)
 			{
 				if (key in rhs)
 					continue;
@@ -249,9 +237,5 @@ define (function ()
 		},
 	};
 
-	Object .preventExtensions (Algorithm);
-	Object .freeze (Algorithm);
-	Object .seal (Algorithm);
-
-	return Algorithm;
+	return new Algorithm ();
 });

package/src/standard/Math/Algorithms/Bezier.js

@@ -0,0 +1,147 @@
+/* -*- Mode: JavaScript; coding: utf-8; tab-width: 3; indent-tabs-mode: tab; c-basic-offset: 3 -*-
+ *******************************************************************************
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright create3000, Scheffelstraße 31a, Leipzig, Germany 2011.
+ *
+ * All rights reserved. Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * The copyright notice above does not evidence any actual of intended
+ * publication of such source code, and is an unpublished work by create3000.
+ * This material contains CONFIDENTIAL INFORMATION that is the property of
+ * create3000.
+ *
+ * No permission is granted to copy, distribute, or create derivative works from
+ * the contents of this software, in whole or in part, without the prior written
+ * permission of create3000.
+ *
+ * NON-MILITARY USE ONLY
+ *
+ * All create3000 software are effectively free software with a non-military use
+ * restriction. It is free. Well commented source is provided. You may reuse the
+ * source in any way you please with the exception anything that uses it must be
+ * marked to indicate is contains 'non-military use only' components.
+ *
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2015, 2016 Holger Seelig <holger.seelig@yahoo.de>.
+ *
+ * This file is part of the X_ITE Project.
+ *
+ * X_ITE is free software: you can redistribute it and/or modify it under the
+ * terms of the GNU General Public License version 3 only, as published by the
+ * Free Software Foundation.
+ *
+ * X_ITE is distributed in the hope that it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+ * A PARTICULAR PURPOSE. See the GNU General Public License version 3 for more
+ * details (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version 3
+ * along with X_ITE.  If not, see <http://www.gnu.org/licenses/gpl.html> for a
+ * copy of the GPLv3 License.
+ *
+ * For Silvio, Joy and Adi.
+ *
+ ******************************************************************************/
+
+
+define ([
+	"standard/Math/Algorithm",
+],
+function (Algorithm)
+{
+	"use strict";
+
+	const lerp = Algorithm .lerp;
+
+	function Bezier (x0, y0, x1, y1, x2, y2, x3, y3)
+	{
+		this .x0 = x0;
+		this .y0 = y0;
+		this .x1 = x1;
+		this .y1 = y1;
+		this .x2 = x2;
+		this .y2 = y2;
+		this .x3 = x3;
+		this .y3 = y3;
+
+		this .order = arguments .length / 2 - 1;
+	}
+
+	Bezier .prototype =
+	{
+		getLUT: function (dimension)
+		{
+			const
+				x0  = this .x0,
+				y0  = this .y0,
+				x1  = this .x1,
+				y1  = this .y1,
+				x2  = this .x2,
+				y2  = this .y2,
+				x3  = this .x3,
+				y3  = this .y3,
+				lut = [ ];
+
+			switch (this .order)
+			{
+				case 2:
+				{
+					for (let i = 0, d = dimension - 1; i < dimension; ++ i)
+					{
+						lut .push (quadric (x0, y0, x1, y1, x2, y2, i / d));
+					}
+
+					break;
+				}
+				case 3:
+				{
+					for (let i = 0, d = dimension - 1; i < dimension; ++ i)
+					{
+						lut .push (cubic (x0, y0, x1, y1, x2, y2, x3, y3, i / d));
+					}
+
+					break;
+				}
+			}
+
+			return lut;
+		}
+	};
+
+	function quadric (x0, y0, x1, y1, x2, y2, t)
+	{
+		const
+			ax0 = lerp (x0, x1, t),
+			ay0 = lerp (y0, y1, t),
+			ax1 = lerp (x1, x2, t),
+			ay1 = lerp (y1, y2, t),
+			bx0 = lerp (ax0, ax1, t),
+			by0 = lerp (ay0, ay1, t);
+
+		return {x: bx0, y: by0};
+	}
+
+	function cubic (x0, y0, x1, y1, x2, y2, x3, y3, t)
+	{
+		const
+			ax0 = lerp (x0, x1, t),
+			ay0 = lerp (y0, y1, t),
+			ax1 = lerp (x1, x2, t),
+			ay1 = lerp (y1, y2, t),
+			ax2 = lerp (x2, x3, t),
+			ay2 = lerp (y2, y3, t),
+			bx0 = lerp (ax0, ax1, t),
+			by0 = lerp (ay0, ay1, t),
+			bx1 = lerp (ax1, ax2, t),
+			by1 = lerp (ay1, ay2, t),
+			cx0 = lerp (bx0, bx1, t),
+			cy0 = lerp (by0, by1, t);
+
+		return {x: cx0, y: cy0};
+	}
+
+ 	return Bezier;
+});