From 455a49de9c6a43db3a0aae69a28673a627008e5e Mon Sep 17 00:00:00 2001
From: Martin Enzelsberger <S1010454006@students.fh-hagenberg.at>
Date: Fri, 10 Jun 2011 12:13:18 +0200
Subject: [PATCH] GestureRecognizer2D and Test application

---
 .../.classpath                                     |   3 +-
 GestureDetectionApp/GestureRecognition/.project    |  17 ++
 .../.settings/org.eclipse.jdt.core.prefs           |  12 ++
 .../org.eclipse.ltk.core.refactoring.prefs         |   3 +
 .../src/at/mus/recognition/Acceleration.java       |  49 +++++
 .../src/at/mus/recognition/Point.java              |  26 +++
 .../src/at/mus/recognition/Recognizer2D.java       | 214 ++++++++++++++++++++
 .../src/at/mus/recognition/Rectangle.java          |  12 ++
 .../src/at/mus/recognition/Template.java           |  13 ++
 .../src/at/mus/recognition/Templates.java          |  52 +++++
 .../GestureRecognizerTest/.classpath               |   7 +
 GestureDetectionApp/GestureRecognizerTest/.project |  17 ++
 .../.settings/org.eclipse.jdt.core.prefs           |  12 ++
 .../GestureRecognizerTest/src/gui/MainFrame.java   | 220 +++++++++++++++++++++
 .../GestureRecognizerTest/src/gui/PointsPanel.java |  58 ++++++
 .../GestureSensitiveControl/.classpath             |   1 +
 .../GestureSensitiveControl/GestureActivity.java   |   8 +-
 .../GestureSensitiveControl/PositionRecorder.java  |  28 +++
 18 files changed, 749 insertions(+), 3 deletions(-)
 copy GestureDetectionApp/{GestureSensitiveControl => GestureRecognition}/.classpath (50%)
 create mode 100644 GestureDetectionApp/GestureRecognition/.project
 create mode 100644 GestureDetectionApp/GestureRecognition/.settings/org.eclipse.jdt.core.prefs
 create mode 100644 GestureDetectionApp/GestureRecognition/.settings/org.eclipse.ltk.core.refactoring.prefs
 create mode 100644 GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Acceleration.java
 create mode 100644 GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Point.java
 create mode 100644 GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Recognizer2D.java
 create mode 100644 GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Rectangle.java
 create mode 100644 GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Template.java
 create mode 100644 GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Templates.java
 create mode 100644 GestureDetectionApp/GestureRecognizerTest/.classpath
 create mode 100644 GestureDetectionApp/GestureRecognizerTest/.project
 create mode 100644 GestureDetectionApp/GestureRecognizerTest/.settings/org.eclipse.jdt.core.prefs
 create mode 100644 GestureDetectionApp/GestureRecognizerTest/src/gui/MainFrame.java
 create mode 100644 GestureDetectionApp/GestureRecognizerTest/src/gui/PointsPanel.java
 create mode 100644 GestureDetectionApp/GestureSensitiveControl/src/at/mus/GestureSensitiveControl/PositionRecorder.java

diff --git a/GestureDetectionApp/GestureSensitiveControl/.classpath b/GestureDetectionApp/GestureRecognition/.classpath
similarity index 50%
copy from GestureDetectionApp/GestureSensitiveControl/.classpath
copy to GestureDetectionApp/GestureRecognition/.classpath
index 609aa00..18d70f0 100644
--- a/GestureDetectionApp/GestureSensitiveControl/.classpath
+++ b/GestureDetectionApp/GestureRecognition/.classpath
@@ -1,7 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <classpath>
 	<classpathentry kind="src" path="src"/>
-	<classpathentry kind="src" path="gen"/>
-	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/GestureDetectionApp/GestureRecognition/.project b/GestureDetectionApp/GestureRecognition/.project
new file mode 100644
index 0000000..78858f1
--- /dev/null
+++ b/GestureDetectionApp/GestureRecognition/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>GestureRecognition</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/GestureDetectionApp/GestureRecognition/.settings/org.eclipse.jdt.core.prefs b/GestureDetectionApp/GestureRecognition/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..08908ea
--- /dev/null
+++ b/GestureDetectionApp/GestureRecognition/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,12 @@
+#Fri Jun 03 15:05:57 CEST 2011
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6
diff --git a/GestureDetectionApp/GestureRecognition/.settings/org.eclipse.ltk.core.refactoring.prefs b/GestureDetectionApp/GestureRecognition/.settings/org.eclipse.ltk.core.refactoring.prefs
new file mode 100644
index 0000000..4272109
--- /dev/null
+++ b/GestureDetectionApp/GestureRecognition/.settings/org.eclipse.ltk.core.refactoring.prefs
@@ -0,0 +1,3 @@
+#Fri Jun 03 19:22:01 CEST 2011
+eclipse.preferences.version=1
+org.eclipse.ltk.core.refactoring.enable.project.refactoring.history=false
diff --git a/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Acceleration.java b/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Acceleration.java
new file mode 100644
index 0000000..34875e7
--- /dev/null
+++ b/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Acceleration.java
@@ -0,0 +1,49 @@
+package at.mus.recognition;
+
+public class Acceleration {
+	public float x, y, z;
+
+	public Acceleration(float x, float y, float z) {
+		this.x = x;
+		this.y = y;
+		this.z = z;
+	}
+
+	public Acceleration(float[] value) {
+		this(value[0], value[1], value[2]);
+	}
+
+	/**
+	 * Returns distance between 2 vectors
+	 * @param acc
+	 * @return
+	 */
+	public float distance(Acceleration acc) {
+		return (float) Math.sqrt((x - acc.x) * (x - acc.x) + (y - acc.y) * (y - acc.y) + (z - acc.z) * (z - acc.z));
+	}
+	
+	/**
+	 * Returns length of the vector
+	 * @return
+	 */
+	public float length() {
+		return (float)Math.sqrt(x*x + y*y + z*z);
+	}
+	
+	/**
+	 * Returns unit vector
+	 * @return
+	 */
+	public Acceleration unit() {
+		float norm = (float)(1.0  / length());
+		return new Acceleration(norm * x, norm * y, norm * z);
+	}
+	
+	/**
+	 * Returns difference between 2 vectors
+	 * @return
+	 */
+	public Acceleration difference(Acceleration acc) {
+		return new Acceleration(x - acc.x, y - acc.y, z - acc.z);
+	}
+}
diff --git a/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Point.java b/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Point.java
new file mode 100644
index 0000000..d0b34da
--- /dev/null
+++ b/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Point.java
@@ -0,0 +1,26 @@
+package at.mus.recognition;
+
+public class Point {
+	public double x, y;
+
+	public Point() {
+		this.x = 0.0;
+		this.y = 0.0;
+	}
+
+	public Point(double x, double y) {
+		this.x = x;
+		this.y = y;
+	}
+
+	public Point(Point p) {
+		this.x = p.x;
+		this.y = p.y;
+	}
+	
+	public double distance(Point p){
+		double dx = p.x - x;
+		double dy = p.y - y;
+		return Math.sqrt(dx * dx + dy * dy);
+	}
+}
diff --git a/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Recognizer2D.java b/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Recognizer2D.java
new file mode 100644
index 0000000..5e0a95d
--- /dev/null
+++ b/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Recognizer2D.java
@@ -0,0 +1,214 @@
+package at.mus.recognition;
+
+import java.util.*;
+
+public class Recognizer2D {
+	private static final double Phi = 0.5 * (-1.0 + Math.sqrt(5.0)); // Golden Ratio
+	private static final double AngleRange = deg2Rad(45.0);
+	private static final double AnglePrecision = deg2Rad(2.0);
+
+	/* Step 1: Resample */
+
+	public List<Point> resample(List<Point> points, int n) {
+		List<Point> newPoints = new ArrayList<Point>();
+		double I = pathLength(points) / (n - 1);
+		double D = 0.0;
+
+		newPoints.add(points.get(0));
+		for (int i = 1; i < points.size(); i++) {
+			Point pi_1 = points.get(i - 1);
+			Point pi = points.get(i);
+			double d = pi_1.distance(pi);
+			if (D + d >= I) {
+				Point q = new Point(pi_1.x + ((I - D) / d) * (pi.x - pi_1.x),
+						pi_1.y + ((I - D) / d) * (pi.y - pi_1.y));
+				newPoints.add(q);
+				points.add(i, q);
+				D = 0.0;
+			} else
+				D += d;
+		}
+		// somtimes we fall a rounding-error short of adding the last point, so
+		// add it if so
+		if (newPoints.size() == (n - 1)) {
+			Point last = points.get(points.size() - 1);
+			newPoints.add(new Point(last.x, last.y));
+		}
+		return newPoints;
+	}
+
+	private double pathLength(List<Point> points) {
+		double d = 0.0;
+		for (int i = 1; i < points.size(); i++)
+			d += points.get(i - 1).distance(points.get(i));
+		return d;
+	}
+
+	/* Step 2: Rotate */
+
+	public List<Point> rotateToZero(List<Point> points) {
+		Point c = centroid(points);
+		Point p0 = points.get(0);
+		double radians = Math.atan2(c.y - p0.y, c.x - p0.x); // indicative angle
+		return rotateBy(points, c, radians);
+	}
+
+	private List<Point> rotateBy(List<Point> points, Point c, double radians) {
+		double cos = Math.cos(radians);
+		double sin = Math.sin(radians);
+
+		List<Point> newPoints = new ArrayList<Point>();
+		for (Point p : points) {
+			newPoints.add(new Point(
+					(p.x - c.x) * cos - (p.y - c.y) * sin + c.x, (p.x - c.x)
+							* sin + (p.y - c.y) * cos + c.y));
+		}
+		return newPoints;
+	}
+
+	private Point centroid(List<Point> points) {
+		double cx = 0.0, cy = 0.0;
+		for (Point p : points) {
+			cx += p.x;
+			cy += p.y;
+		}
+		cx /= points.size();
+		cy /= points.size();
+		return new Point(cx, cy);
+	}
+
+	/* Step 3: Scale */
+
+	public List<Point> scaleAndTranslateTo(List<Point> points, double size, Point pt) {
+		List<Point> newPoints = new ArrayList<Point>();
+
+		// scale
+		Rectangle rect = boundingBox(points);
+		for (Point p : points) {
+			newPoints.add(new Point(p.x * (size / rect.width), p.y
+					* (size / rect.height)));
+		}
+
+		// translate
+		Point c = centroid(newPoints);
+		for (Point p : newPoints) {
+			p.x = p.x + pt.x - c.x;
+			p.y = p.y + pt.y - c.y;
+		}
+		return newPoints;
+	}
+
+	private Rectangle boundingBox(List<Point> points) {
+		double minX = Double.MAX_VALUE, maxX = Double.MIN_VALUE;
+		double minY = Double.MAX_VALUE, maxY = Double.MIN_VALUE;
+		for (Point p : points) {
+			if (p.x < minX)
+				minX = p.x;
+			if (p.y < minY)
+				minY = p.y;
+			if (p.x > maxX)
+				maxX = p.x;
+			if (p.y > maxY)
+				maxY = p.y;
+		}
+		return new Rectangle(minX, minY, maxX - minX, maxY - minY);
+	}
+
+	/* Step 4: Recognition */
+	
+	/**
+	 * @param rawPoints list of points to recognize
+	 * @param templates pre-defined list of templates
+	 * @param n number of points (resample)
+	 * @param size square size (scaleAndTranslateTo)
+	 * @param origin desired origin (scaleAndTranslateTo)
+	 */
+	public Result recognize(List<Point> rawPoints, List<Template> templates, int n, double size, Point origin) {
+		List<Point> points = scaleAndTranslateTo(rotateToZero(resample(rawPoints, n)), size, origin);
+		
+		Point c = centroid(points);
+		double b = Double.MAX_VALUE, d;
+		Template tpl = null;
+		for (Template t : templates) {
+			d = distanceAtBestAngle(points, t, c, -AngleRange, +AngleRange, AnglePrecision);
+			if (d < b) {
+				b = d; // best (least) distance
+				tpl = t;
+			}
+		}
+		double halfDiagonal = Math.sqrt(size * size * 2) * 0.5;
+		return new Result(tpl, 1.0 - b / halfDiagonal);
+	}
+
+	private double distanceAtBestAngle(List<Point> points, Template t, Point c, double a, double b, double threshold) {
+		double x1 = Phi * a + (1.0 - Phi) * b;
+		double f1 = distanceAtAngle(points, t, c, x1);
+		double x2 = (1.0 - Phi) * a + Phi * b;
+		double f2 = distanceAtAngle(points, t, c, x2);
+
+		while (Math.abs(b - a) > threshold) {
+			if (f1 < f2) {
+				b = x2;
+				x2 = x1;
+				f2 = f1;
+				x1 = Phi * a + (1.0 - Phi) * b;
+				f1 = distanceAtAngle(points, t, c, x1);
+			} else {
+				a = x1;
+				x1 = x2;
+				f1 = f2;
+				x2 = (1.0 - Phi) * a + Phi * b;
+				f2 = distanceAtAngle(points, t, c, x2);
+			}
+		}
+		return Math.min(f1, f2);
+	}
+
+	private double distanceAtAngle(List<Point> points, Template t, Point c,
+			double radians) {
+		List<Point> newPoints = rotateBy(points, c, radians);
+
+		/* path distance */
+		double d = 0.0;
+		for (int i = 0; i < newPoints.size(); i++)
+			d += newPoints.get(i).distance(t.points[i]);
+		return d / newPoints.size();
+	}
+
+	/* help methods */
+	private static double deg2Rad(double d) { 
+		return (d * Math.PI / 180.0); 
+	}
+	
+	/*// not used
+	 private static double rad2Deg(double r) { 
+		return (r * 180.0 / Math.PI); 
+	}*/
+	
+	public static class Result {
+		private Template tpl;
+		private double match;
+
+		public Result(Template tpl, double match) {
+			super();
+			this.tpl = tpl;
+			this.match = match;
+		}
+
+		public Template getTemplate() {
+			return tpl;
+		}
+
+		public void setTemplate(Template tpl) {
+			this.tpl = tpl;
+		}
+
+		public double getMatch() {
+			return match;
+		}
+
+		public void setMatch(double match) {
+			this.match = match;
+		}
+	}
+}
diff --git a/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Rectangle.java b/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Rectangle.java
new file mode 100644
index 0000000..f5aec25
--- /dev/null
+++ b/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Rectangle.java
@@ -0,0 +1,12 @@
+package at.mus.recognition;
+
+public class Rectangle {
+	double x, y, width, height;
+
+	public Rectangle(double x, double y, double width, double height) {
+		this.x = x;
+		this.y = y;
+		this.width = width;
+		this.height = height;
+	}
+}
\ No newline at end of file
diff --git a/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Template.java b/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Template.java
new file mode 100644
index 0000000..97ce8ad
--- /dev/null
+++ b/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Template.java
@@ -0,0 +1,13 @@
+package at.mus.recognition;
+
+public class Template {
+	public String name;
+	public Point[] points;
+	
+	public Template(String name, double[][] points) {
+		this.name = name;
+		this.points = new Point[points.length];
+		for (int i = 0; i < points.length; i++)
+			this.points[i] = new Point(points[i][0], points[i][1]);
+	}
+}
diff --git a/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Templates.java b/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Templates.java
new file mode 100644
index 0000000..d2cd492
--- /dev/null
+++ b/GestureDetectionApp/GestureRecognition/src/at/mus/recognition/Templates.java
@@ -0,0 +1,52 @@
+package at.mus.recognition;
+
+import java.util.*;
+
+public class Templates {
+	public static final List<Template> list;
+	
+	public static double[][] right1 = { { -125.497, -121.851 }, { -120.733, -119.502 }, { -116.03, -116.527 }, { -111.325, -113.57 }, { -106.617, -110.642 }, { -101.905, -107.748 }, { -97.188, -104.897 }, { -92.467, -102.084 }, { -87.737, -99.367 }, { -83.006, -96.651 }, { -78.251, -94.193 }, { -73.474, -91.964 }, { -68.698, -89.736 }, { -63.922, -87.508 }, { -59.145, -85.279 }, { -54.369, -83.051 }, { -49.593, -80.822 }, { -44.854, -78.208 }, { -40.141, -75.32 }, { -35.393, -72.794 }, { -30.617, -70.565 }, { -25.841, -68.337 }, { -21.065, -66.109 }, { -16.288, -63.88 }, { -11.529, -61.489 }, { -6.857, -58.248 }, { -2.098, -55.856 }, { 2.678, -53.628 }, { 4.817, -46.239 }, { 3.874, -34.952 }, { 2.931, -23.665 }, { 1.988, -12.378 }, { 1.045, -1.091 }, { 0.102, 10.197 }, { -0.841, 21.484 }, { -1.784, 32.771 }, { -1.252, 40.265 }, { 3.246, 44.663 }, { 7.754, 49.009 }, { 12.285, 53.22 }, { 16.876, 57.045 }, { 21.461, 60.91 }, { 26.018, 64.964 }, { 30.574, 69.018 }, { 35.13, 73.071 }, { 39.687, 77.125 }, { 44.302, 80.787 }, { 48.924, 84.399 }, { 53.546, 88.01 }, { 58.266, 90.837 }, { 62.986, 93.656 }, { 67.724, 96.297 }, { 72.47, 98.866 }, { 77.215, 101.435 }, { 81.961, 104.004 }, { 86.697, 106.67 }, { 91.43, 109.367 }, { 96.163, 112.063 }, { 100.878, 114.928 }, { 105.59, 117.815 }, { 110.357, 120.146 }, { 115.133, 122.374 }, { 119.91, 124.602 }, { 124.503, 128.149 }};
+	public static double[][] right2 = { { -122.248, -122.468 }, { -115.38, -119.813 }, { -108.511, -117.158 }, { -101.643, -114.503 }, { -94.774, -111.848 }, { -87.974, -109.086 }, { -81.298, -106.127 }, { -74.621, -103.169 }, { -67.901, -100.275 }, { -61.182, -97.381 }, { -54.48, -94.463 }, { -48.118, -91.081 }, { -41.756, -87.7 }, { -35.358, -84.365 }, { -28.8, -81.239 }, { -22.242, -78.112 }, { -15.668, -75.007 }, { -9.033, -71.989 }, { -2.337, -69.065 }, { 4.531, -66.41 }, { 11.4, -63.755 }, { 13.264, -58.803 }, { 11.003, -52.945 }, { 7.918, -47.322 }, { 5.336, -41.528 }, { 3.609, -35.531 }, { 1.113, -29.723 }, { -1.587, -23.965 }, { -4.287, -18.207 }, { -6.987, -12.448 }, { -9.762, -6.716 }, { -13.044, -1.159 }, { -15.573, 4.648 }, { -17.896, 10.512 }, { -21.201, 16.038 }, { -25.188, 21.249 }, { -28.469, 26.806 }, { -29.706, 32.02 }, { -25.515, 37.134 }, { -20.349, 41.637 }, { -14.459, 45.476 }, { -7.916, 48.624 }, { -1.867, 52.36 }, { 4.1, 56.178 }, { 9.579, 60.454 }, { 15.112, 64.675 }, { 21.385, 68.164 }, { 27.657, 71.653 }, { 33.657, 75.431 }, { 39.465, 79.413 }, { 45.294, 83.371 }, { 51.567, 86.86 }, { 57.839, 90.349 }, { 64.148, 93.796 }, { 70.483, 97.21 }, { 76.818, 100.624 }, { 83.102, 104.1 }, { 89.374, 107.589 }, { 95.682, 111.037 }, { 102.056, 114.403 }, { 108.352, 117.862 }, { 114.522, 121.468 }, { 121.011, 124.686 }, { 127.752, 127.532 }};
+	public static double[][] right3 = { { -124.747, -130.126 }, { -119.818, -126.085 }, { -115.05, -121.561 }, { -110.306, -116.974 }, { -105.573, -112.355 }, { -100.773, -107.954 }, { -95.631, -104.665 }, { -90.489, -101.375 }, { -85.346, -98.085 }, { -80.204, -94.795 }, { -75.154, -91.152 }, { -70.108, -87.494 }, { -65.033, -83.958 }, { -59.779, -81.166 }, { -54.524, -78.374 }, { -49.27, -75.582 }, { -44.015, -72.788 }, { -38.766, -69.969 }, { -33.517, -67.15 }, { -28.269, -64.33 }, { -22.997, -61.627 }, { -17.691, -59.101 }, { -12.385, -56.575 }, { -7.079, -54.049 }, { -1.804, -51.366 }, { 3.407, -48.37 }, { 8.622, -45.394 }, { 13.175, -41.368 }, { 12.627, -32.684 }, { 11.06, -24.133 }, { 9.492, -15.582 }, { 7.925, -7.03 }, { 6.357, 1.521 }, { 3.665, 9.201 }, { 0.611, 16.611 }, { -1.43, 24.898 }, { -3.592, 33.105 }, { -4.569, 41.764 }, { -5.235, 50.515 }, { -1.496, 56.316 }, { 3.647, 59.606 }, { 8.95, 62.147 }, { 14.256, 64.673 }, { 19.562, 67.199 }, { 24.868, 69.725 }, { 30.174, 72.251 }, { 35.48, 74.777 }, { 40.757, 77.45 }, { 45.987, 80.361 }, { 51.216, 83.273 }, { 56.49, 85.959 }, { 61.797, 88.485 }, { 67.103, 91.011 }, { 72.409, 93.537 }, { 77.715, 96.063 }, { 83.021, 98.589 }, { 88.327, 101.115 }, { 93.633, 103.641 }, { 98.939, 106.167 }, { 104.16, 109.118 }, { 109.376, 112.09 }, { 114.641, 114.822 }, { 119.947, 117.348 }, { 125.253, 119.874 }};
+	
+	public static double[][] left1 = { { -123.879, 121.153 }, { -118.82, 121.341 }, { -113.765, 120.668 }, { -108.714, 119.85 }, { -103.661, 119.135 }, { -98.601, 118.85 }, { -93.541, 118.56 }, { -88.483, 118.127 }, { -83.425, 117.695 }, { -78.365, 117.552 }, { -73.304, 117.568 }, { -68.243, 117.584 }, { -63.214, 116.272 }, { -58.198, 114.473 }, { -53.181, 112.673 }, { -48.164, 110.874 }, { -43.169, 108.693 }, { -38.184, 106.33 }, { -33.199, 103.967 }, { -28.182, 102.18 }, { -23.159, 100.529 }, { -18.135, 98.879 }, { -13.095, 97.701 }, { -8.048, 96.736 }, { -5.377, 89.983 }, { -4.55, 76.579 }, { -5.317, 63.076 }, { -5.69, 49.426 }, { -5.57, 35.826 }, { -4.823, 22.29 }, { -3.488, 9.107 }, { -3.007, -3.998 }, { -4.492, -17.082 }, { -5.384, -30.551 }, { -5.493, -44.138 }, { -6.088, -57.604 }, { -6.27, -70.976 }, { -4.092, -78.666 }, { 0.893, -81.029 }, { 5.896, -83.023 }, { 10.936, -84.258 }, { 15.96, -85.825 }, { 20.945, -88.188 }, { 25.93, -90.551 }, { 30.914, -92.913 }, { 35.899, -95.276 }, { 40.884, -97.639 }, { 45.9, -99.452 }, { 50.919, -101.2 }, { 55.939, -102.948 }, { 60.958, -104.696 }, { 65.977, -106.444 }, { 70.997, -108.192 }, { 76.016, -109.94 }, { 81.02, -111.972 }, { 86.004, -114.335 }, { 90.989, -116.698 }, { 95.974, -119.06 }, { 100.998, -120.693 }, { 106.026, -122.26 }, { 111.054, -123.816 }, { 116.091, -125.137 }, { 121.128, -126.459 }, { 126.121, -128.659 }};
+	public static double[][] left2 = { { -123.739, 122.556 }, { -117.857, 119.869 }, { -111.973, 117.191 }, { -105.966, 115.389 }, { -100.039, 113.023 }, { -94.117, 110.626 }, { -88.09, 109.021 }, { -82.063, 107.415 }, { -76.046, 105.701 }, { -70.03, 103.987 }, { -64.001, 102.4 }, { -57.961, 100.931 }, { -51.921, 99.461 }, { -45.922, 97.632 }, { -39.961, 95.455 }, { -34.002, 93.269 }, { -28.051, 91.023 }, { -22.101, 88.776 }, { -16.177, 86.351 }, { -10.295, 83.664 }, { -4.412, 80.977 }, { 1.569, 78.977 }, { 7.528, 76.815 }, { 12.074, 72.89 }, { 9.07, 64.473 }, { 7.225, 54.943 }, { 4.47, 46.031 }, { 1.249, 37.523 }, { -1.511, 28.586 }, { -3.944, 19.401 }, { -6.11, 10.035 }, { -8.082, 0.56 }, { -9.72, -9.091 }, { -11.529, -18.655 }, { -13.555, -28.106 }, { -15.358, -37.673 }, { -16.996, -47.324 }, { -18.633, -56.976 }, { -19.068, -66.584 }, { -14.453, -70.034 }, { -8.361, -70.69 }, { -2.396, -72.549 }, { 3.487, -75.236 }, { 9.514, -76.842 }, { 15.541, -78.447 }, { 21.539, -80.322 }, { 27.526, -82.289 }, { 33.513, -84.256 }, { 39.48, -86.374 }, { 45.414, -88.739 }, { 51.348, -91.103 }, { 57.282, -93.467 }, { 63.22, -95.799 }, { 69.161, -98.113 }, { 75.102, -100.428 }, { 81.019, -102.896 }, { 86.902, -105.583 }, { 92.784, -108.271 }, { 98.667, -110.958 }, { 104.549, -113.645 }, { 110.432, -116.332 }, { 116.314, -119.02 }, { 122.197, -121.707 }, { 126.261, -127.444 }};
+	public static double[][] left3 = { { -117.026, 127.898 }, { -110.502, 125.226 }, { -103.803, 123.143 }, { -97.173, 120.787 }, { -90.541, 118.436 }, { -83.881, 116.192 }, { -77.224, 113.934 }, { -70.572, 111.658 }, { -63.926, 109.357 }, { -57.289, 107.023 }, { -50.67, 104.628 }, { -44.115, 102.01 }, { -37.512, 99.587 }, { -30.714, 97.974 }, { -23.915, 96.36 }, { -17.249, 94.195 }, { -10.677, 91.631 }, { -4.211, 88.74 }, { 2.234, 85.784 }, { 6.346, 81.686 }, { 5.596, 73.891 }, { 3.825, 66.207 }, { 1.716, 58.648 }, { -0.778, 51.234 }, { -2.999, 43.706 }, { -5.433, 36.267 }, { -8.016, 28.891 }, { -10.599, 21.515 }, { -13.182, 14.139 }, { -15.606, 6.694 }, { -17.939, -0.79 }, { -20.334, -8.248 }, { -22.916, -15.624 }, { -25.256, -23.093 }, { -27.069, -30.764 }, { -29.107, -38.358 }, { -31.435, -45.839 }, { -33.406, -53.431 }, { -31.309, -58.412 }, { -24.619, -60.535 }, { -17.928, -62.658 }, { -11.268, -64.901 }, { -4.624, -67.207 }, { 2.014, -69.536 }, { 8.647, -71.886 }, { 15.279, -74.237 }, { 21.906, -76.605 }, { 28.494, -79.114 }, { 35.082, -81.623 }, { 41.67, -84.132 }, { 48.258, -86.641 }, { 54.858, -89.106 }, { 61.471, -91.529 }, { 68.083, -93.952 }, { 74.695, -96.375 }, { 81.308, -98.798 }, { 87.861, -101.409 }, { 94.306, -104.366 }, { 100.75, -107.322 }, { 107.195, -110.278 }, { 113.64, -113.234 }, { 120.085, -116.19 }, { 126.529, -119.146 }, { 132.974, -122.102 }};
+	
+	public static double[][] square1 = { { -15.55, -123.905 }, { -23.16, -115.846 }, { -29.635, -107.047 }, { -37.681, -99.252 }, { -44.56, -90.665 }, { -51.831, -82.33 }, { -59.897, -74.552 }, { -68.722, -67.422 }, { -76.851, -59.697 }, { -84.897, -51.902 }, { -92.943, -44.106 }, { -101.762, -36.985 }, { -110.75, -30.01 }, { -118.827, -22.241 }, { -127.71, -15.241 }, { -121.175, -7.509 }, { -113.931, 0.845 }, { -106.209, 8.882 }, { -98.181, 16.691 }, { -90.135, 24.486 }, { -82.056, 32.255 }, { -73.958, 40.01 }, { -65.832, 47.742 }, { -57.937, 55.645 }, { -50.501, 63.884 }, { -43.092, 72.143 }, { -35.487, 80.26 }, { -28.971, 88.986 }, { -22.211, 97.622 }, { -15.116, 106.08 }, { -8.042, 114.513 }, { -1.307, 123.081 }, { 4.932, 126.095 }, { 12.978, 118.299 }, { 20.526, 110.177 }, { 28.083, 102.059 }, { 35.164, 93.592 }, { 43.21, 85.797 }, { 51.256, 78.001 }, { 59.302, 70.206 }, { 67.348, 62.411 }, { 75.394, 54.616 }, { 83.441, 46.821 }, { 90.655, 38.446 }, { 97.755, 29.985 }, { 105.63, 22.07 }, { 112.425, 13.446 }, { 116.927, 3.738 }, { 120.736, -6.187 }, { 122.29, -15.044 }, { 113.52, -22.208 }, { 105.229, -29.78 }, { 96.258, -36.772 }, { 87.286, -43.763 }, { 78.315, -50.754 }, { 70.514, -58.719 }, { 62.505, -66.533 }, { 54.178, -74.101 }, { 45.85, -81.67 }, { 36.967, -88.74 }, { 27.996, -95.732 }, { 19.774, -103.353 }, { 10.943, -110.462 }, { 1.528, -116.358 }};
+	public static double[][] square2 = { { -52.487, -124.821 }, { -56.102, -113.772 }, { -62.071, -103.799 }, { -68.021, -93.822 }, { -74.342, -84.066 }, { -80.276, -74.08 }, { -85.09, -63.543 }, { -89.836, -52.991 }, { -94.062, -42.247 }, { -97.934, -31.425 }, { -102.116, -20.616 }, { -107.958, -10.606 }, { -114.325, -0.879 }, { -120.692, 8.849 }, { -119.991, 17.121 }, { -110.556, 23.824 }, { -101.073, 30.46 }, { -91.701, 37.255 }, { -82.207, 43.881 }, { -72.738, 50.544 }, { -63.113, 56.979 }, { -53.436, 63.321 }, { -43.613, 69.408 }, { -33.989, 75.843 }, { -24.192, 81.975 }, { -14.771, 88.693 }, { -5.147, 95.128 }, { 4.292, 101.819 }, { 13.804, 108.409 }, { 23.758, 113.845 }, { 33.561, 119.791 }, { 42.526, 125.179 }, { 48.008, 114.961 }, { 54.02, 105.031 }, { 60.704, 95.567 }, { 67.071, 85.839 }, { 73.438, 76.112 }, { 79.806, 66.385 }, { 86.173, 56.658 }, { 92.932, 47.253 }, { 99.308, 37.533 }, { 106.063, 28.114 }, { 112.085, 18.203 }, { 117.912, 8.171 }, { 124.279, -1.556 }, { 129.308, -9.97 }, { 118.995, -15.038 }, { 109.148, -21.074 }, { 99.242, -27.026 }, { 89.37, -33.018 }, { 79.284, -38.543 }, { 69.659, -44.978 }, { 60.035, -51.414 }, { 50.41, -57.849 }, { 40.786, -64.284 }, { 31.161, -70.719 }, { 21.537, -77.155 }, { 11.912, -83.59 }, { 2.288, -90.025 }, { -7.239, -96.597 }, { -16.668, -103.309 }, { -26.292, -109.744 }, { -35.604, -116.58 }, { -45.229, -123.015 }};
+	public static double[][] square3 = { { 11.042, -125.766 }, { 1.846, -118.541 }, { -6.542, -110.657 }, { -15.006, -102.835 }, { -24.202, -95.61 }, { -33.398, -88.386 }, { -42.594, -81.161 }, { -52.425, -74.57 }, { -62.356, -68.08 }, { -72.288, -61.589 }, { -82.226, -55.107 }, { -92.226, -48.692 }, { -102.299, -42.36 }, { -112.461, -36.134 }, { -122.038, -29.394 }, { -126.864, -23.046 }, { -119.53, -14.49 }, { -111.496, -6.384 }, { -104.332, 2.237 }, { -98.026, 11.397 }, { -90.281, 19.752 }, { -82.686, 28.192 }, { -76.434, 37.398 }, { -70.183, 46.605 }, { -64.096, 55.89 }, { -58.043, 65.192 }, { -51.971, 74.483 }, { -45.06, 83.346 }, { -38.15, 92.21 }, { -30.602, 100.691 }, { -23.183, 109.249 }, { -16.344, 118.151 }, { -8.996, 124.234 }, { -0.704, 116.333 }, { 6.114, 107.429 }, { 13.144, 98.661 }, { 21.271, 90.592 }, { 30.467, 83.367 }, { 40.951, 77.704 }, { 51.782, 72.388 }, { 62.198, 66.477 }, { 73.028, 61.112 }, { 84.084, 56.1 }, { 95.272, 51.291 }, { 106.382, 46.364 }, { 116.641, 40.324 }, { 123.136, 34.823 }, { 120.416, 25.851 }, { 116.295, 15.986 }, { 112.277, 5.966 }, { 108.051, -4.033 }, { 102.43, -13.498 }, { 95.794, -22.476 }, { 88.123, -30.88 }, { 80.549, -39.345 }, { 73.079, -47.877 }, { 64.605, -55.703 }, { 56.067, -63.485 }, { 47.604, -71.317 }, { 40.676, -80.167 }, { 32.536, -88.193 }, { 26.484, -97.494 }, { 21.083, -107.072 }, { 13.613, -115.456 }};
+	
+	public static double[][] triangle1 = { { 96.278, 124.017 }, { 85.729, 118.482 }, { 75.626, 111.873 }, { 65.078, 106.337 }, { 54.638, 100.522 }, { 44.403, 94.18 }, { 33.854, 88.644 }, { 23.306, 83.109 }, { 12.733, 77.65 }, { 1.949, 72.837 }, { -8.817, 67.964 }, { -19.569, 63.047 }, { -30.392, 58.367 }, { -41.071, 53.243 }, { -51.811, 48.378 }, { -62.817, 44.444 }, { -73.366, 38.908 }, { -83.847, 33.215 }, { -94.415, 28.578 }, { -105.425, 24.693 }, { -116.606, 21.508 }, { -127.591, 17.427 }, { -138.598, 13.436 }, { -149.822, 10.543 }, { -147.782, 5.054 }, { -137.979, -2.188 }, { -127.898, -8.868 }, { -117.908, -15.756 }, { -107.386, -21.099 }, { -96.722, -25.973 }, { -87.199, -33.801 }, { -77.325, -40.938 }, { -66.996, -46.979 }, { -56.474, -52.552 }, { -46.271, -58.978 }, { -35.945, -65.104 }, { -25.464, -70.808 }, { -14.887, -76.245 }, { -4.68, -82.643 }, { 5.655, -88.665 }, { 16.279, -93.962 }, { 26.365, -100.658 }, { 36.914, -106.039 }, { 47.676, -110.905 }, { 57.525, -117.863 }, { 67.718, -124.241 }, { 74.724, -125.983 }, { 75.827, -112.051 }, { 76.142, -98.06 }, { 77.346, -84.133 }, { 78.698, -70.237 }, { 79.807, -56.427 }, { 81.409, -42.897 }, { 80.181, -28.984 }, { 79.261, -15.029 }, { 79.182, -1.106 }, { 79.439, 12.87 }, { 81.044, 26.651 }, { 84.556, 39.731 }, { 89.364, 52.389 }, { 91.717, 66.091 }, { 95.052, 79.212 }, { 99.411, 91.92 }, { 100.178, 103.852 }};
+	public static double[][] triangle2 = { { 101.95, 121.059 }, { 91.705, 116.929 }, { 81.495, 112.668 }, { 71.466, 107.727 }, { 61.437, 102.785 }, { 51.408, 97.844 }, { 41.379, 92.903 }, { 31.351, 87.962 }, { 21.322, 83.02 }, { 11.293, 78.079 }, { 1.264, 73.138 }, { -8.764, 68.197 }, { -18.793, 63.256 }, { -28.822, 58.314 }, { -38.851, 53.373 }, { -48.795, 48.203 }, { -58.626, 42.723 }, { -68.457, 37.243 }, { -78.441, 32.18 }, { -88.495, 27.321 }, { -98.811, 23.313 }, { -108.979, 18.821 }, { -119.12, 14.312 }, { -129.727, 11.593 }, { -139.843, 6.989 }, { -143.131, 0.527 }, { -133.037, -4.016 }, { -123.629, -10.346 }, { -113.301, -14.312 }, { -103.088, -18.595 }, { -93.593, -24.863 }, { -84.098, -31.13 }, { -75.008, -38.19 }, { -66.003, -45.416 }, { -56.94, -52.535 }, { -47.673, -59.273 }, { -38.407, -66.011 }, { -29.398, -73.229 }, { -20.367, -80.409 }, { -11.257, -87.446 }, { -2.361, -94.838 }, { 6.247, -102.683 }, { 15.915, -108.563 }, { 24.262, -116.813 }, { 33.369, -123.847 }, { 43.19, -128.941 }, { 47.856, -117.575 }, { 51.534, -105.39 }, { 55.803, -93.532 }, { 61.05, -82.19 }, { 66.414, -70.926 }, { 71.36, -59.406 }, { 75.924, -47.649 }, { 79.935, -35.64 }, { 83.117, -23.252 }, { 86.299, -10.863 }, { 91.162, 0.651 }, { 96.589, 11.871 }, { 99.721, 24.176 }, { 102.184, 36.796 }, { 102.833, 49.653 }, { 103.499, 62.538 }, { 104.612, 75.356 }, { 106.869, 86.36 }};
+	public static double[][] triangle3 = { { 116.739, 111.428 }, { 107.06, 107.268 }, { 97.381, 103.108 }, { 87.701, 98.948 }, { 77.813, 96.147 }, { 67.729, 94.589 }, { 57.725, 92.268 }, { 47.809, 89.319 }, { 37.902, 86.314 }, { 28.002, 83.264 }, { 18.116, 80.138 }, { 8.233, 76.989 }, { -1.609, 73.611 }, { -11.451, 70.233 }, { -21.299, 66.888 }, { -31.15, 63.559 }, { -41.001, 60.229 }, { -50.852, 56.9 }, { -60.669, 53.405 }, { -70.348, 49.245 }, { -80.027, 45.085 }, { -89.707, 40.925 }, { -99.386, 36.766 }, { -109.357, 34.267 }, { -119.075, 30.328 }, { -128.755, 26.169 }, { -133.261, 21.458 }, { -125.186, 13.664 }, { -115.911, 8.237 }, { -107.292, 0.934 }, { -98.289, -5.45 }, { -89.69, -12.75 }, { -81.337, -20.605 }, { -72.956, -28.406 }, { -64.575, -36.206 }, { -56.724, -44.906 }, { -49.318, -54.362 }, { -41.912, -63.818 }, { -33.678, -71.9 }, { -25.428, -79.955 }, { -17.301, -88.22 }, { -9.703, -97.389 }, { -2.105, -106.558 }, { 6.541, -113.651 }, { 15.27, -120.643 }, { 23.52, -128.698 }, { 30.619, -138.572 }, { 36.357, -136.762 }, { 38.06, -123.134 }, { 41.434, -110.271 }, { 46.295, -98.248 }, { 49.124, -84.967 }, { 53.928, -72.923 }, { 59.486, -61.352 }, { 64.399, -49.266 }, { 69.085, -36.998 }, { 73.771, -24.731 }, { 79.617, -13.471 }, { 85.79, -2.494 }, { 91.892, 8.557 }, { 96.759, 20.669 }, { 102.721, 31.64 }, { 108.235, 42.519 }, { 114.235, 51.635 }};
+	
+	public static double[][] p1 = { { 158.676, 115.968 }, { 149.495, 112.853 }, { 140.314, 109.739 }, { 131.446, 105.473 }, { 122.29, 102.266 }, { 113.108, 99.151 }, { 103.814, 96.678 }, { 94.475, 94.441 }, { 85.166, 92.015 }, { 75.817, 89.857 }, { 66.429, 87.977 }, { 57.082, 85.82 }, { 47.794, 83.262 }, { 38.51, 80.686 }, { 29.249, 77.974 }, { 19.989, 75.263 }, { 10.728, 72.551 }, { 1.544, 69.452 }, { -7.638, 66.338 }, { -16.819, 63.223 }, { -26, 60.108 }, { -35.182, 56.993 }, { -44.047, 52.685 }, { -53.362, 50.55 }, { -62.581, 47.699 }, { -71.762, 44.584 }, { -80.577, 40.235 }, { -89.758, 37.121 }, { -91.324, 27.753 }, { -91.091, 15.712 }, { -90.511, 3.69 }, { -90.536, -8.351 }, { -90.068, -20.297 }, { -87.61, -31.934 }, { -85.153, -43.57 }, { -82.695, -55.207 }, { -80.238, -66.843 }, { -76.072, -77.638 }, { -70.939, -87.768 }, { -66.128, -98.139 }, { -60.998, -108.217 }, { -55.784, -118.264 }, { -48.844, -126.373 }, { -40.407, -131.226 }, { -31.121, -133.437 }, { -21.638, -134.032 }, { -12.258, -132.091 }, { -3.068, -129.029 }, { 5.886, -125.111 }, { 12.715, -117.01 }, { 17.412, -106.74 }, { 22.971, -97.224 }, { 25.132, -85.577 }, { 27.142, -73.815 }, { 28.557, -61.955 }, { 29.568, -49.991 }, { 29.436, -38.2 }, { 26.979, -26.564 }, { 24.521, -14.927 }, { 22.064, -3.291 }, { 18.543, 7.083 }, { 12.801, 15.202 }, { 8.506, 25.393 }, { 6.048, 37.029 }};
+	public static double[][] p2 = { { 143.659, 117.535 }, { 135.231, 112.91 }, { 124.924, 109.211 }, { 114.618, 105.512 }, { 104.311, 101.814 }, { 93.821, 98.762 }, { 83.179, 96.252 }, { 72.535, 93.752 }, { 61.871, 91.337 }, { 51.208, 88.923 }, { 40.544, 86.508 }, { 29.931, 83.874 }, { 19.34, 81.147 }, { 8.749, 78.419 }, { -1.748, 75.341 }, { -12.208, 72.125 }, { -22.668, 68.91 }, { -33.014, 65.334 }, { -43.321, 61.636 }, { -53.878, 58.9 }, { -64.614, 56.85 }, { -75.252, 54.331 }, { -85.728, 51.218 }, { -96.034, 47.519 }, { -106.341, 43.82 }, { -106.184, 34.963 }, { -102.573, 24.405 }, { -98.963, 13.846 }, { -95.352, 3.287 }, { -91.742, -7.272 }, { -87.907, -17.742 }, { -83.661, -28.05 }, { -79.3, -38.303 }, { -74.438, -48.322 }, { -69.567, -58.335 }, { -63.732, -67.791 }, { -57.988, -77.305 }, { -52.592, -87.031 }, { -46.133, -96.011 }, { -39.245, -104.693 }, { -32.561, -113.54 }, { -24.908, -121.5 }, { -16.246, -128.305 }, { -5.688, -129.499 }, { 4.773, -132.465 }, { 15.428, -130.141 }, { 25.735, -126.442 }, { 34.049, -119.664 }, { 40.093, -110.37 }, { 44.316, -100.111 }, { 45.341, -89.066 }, { 44.763, -77.894 }, { 44.255, -66.718 }, { 43.252, -55.578 }, { 41.779, -44.493 }, { 39.942, -33.469 }, { 38.953, -22.371 }, { 38.787, -11.184 }, { 39.179, -0.006 }, { 39.388, 11.176 }, { 38.265, 22.27 }, { 40.465, 32.947 }, { 40.765, 44.056 }, { 40.14, 54.777 }};
+	public static double[][] p3 = { { 142.277, 131.813 }, { 131.723, 127.745 }, { 121.169, 123.678 }, { 110.615, 119.61 }, { 99.933, 115.86 }, { 89.176, 112.293 }, { 78.513, 108.495 }, { 67.959, 104.427 }, { 57.405, 100.36 }, { 46.851, 96.292 }, { 36.297, 92.224 }, { 25.743, 88.156 }, { 15.19, 84.089 }, { 4.636, 80.021 }, { -5.918, 75.953 }, { -16.472, 71.885 }, { -27.026, 67.818 }, { -37.596, 63.791 }, { -48.399, 60.35 }, { -59.121, 56.705 }, { -69.675, 52.638 }, { -79.341, 47.118 }, { -88.086, 40.257 }, { -95.761, 32.428 }, { -102.052, 23.622 }, { -106.403, 14.009 }, { -107.723, 3.477 }, { -106.931, -7.218 }, { -105.976, -17.906 }, { -105.34, -28.615 }, { -104.594, -39.299 }, { -102.226, -49.793 }, { -99.859, -60.286 }, { -96.074, -70.368 }, { -90.46, -79.614 }, { -82.079, -86.699 }, { -72.924, -93.08 }, { -64.335, -100.138 }, { -55.027, -106.234 }, { -44.949, -111.216 }, { -34.158, -114.691 }, { -23.368, -118.166 }, { -12.092, -118.187 }, { -0.747, -117.095 }, { 10.45, -115.053 }, { 21.441, -112.2 }, { 32.419, -109.338 }, { 42.451, -104.346 }, { 49.643, -96.067 }, { 56.588, -87.563 }, { 61.232, -77.98 }, { 65.16, -67.926 }, { 67.303, -57.412 }, { 68.473, -46.758 }, { 67.159, -36.144 }, { 66.468, -25.473 }, { 64.399, -15.037 }, { 60.218, -5.329 }, { 55.893, 4.596 }, { 51.568, 14.522 }, { 47.873, 24.643 }, { 46.068, 35.211 }, { 43.373, 45.61 }, { 39.048, 55.536 }};
+	
+	
+	static {
+		list = new ArrayList<Template>();
+		
+		list.add(new Template("Right1", right1));
+		list.add(new Template("Right2", right2));
+		list.add(new Template("Right3", right3));
+		
+		list.add(new Template("Left1", left1));
+		list.add(new Template("Left2", left2));
+		list.add(new Template("Left3", left3));
+		
+		list.add(new Template("Stop1", square1));
+		list.add(new Template("Stop2", square2));
+		list.add(new Template("Stop3", square3));
+		
+		list.add(new Template("Play1", triangle1));
+		list.add(new Template("Play2", triangle2));
+		list.add(new Template("Play3", triangle3));
+		
+		list.add(new Template("Pause1", p1));
+		list.add(new Template("Pause2", p2));
+		list.add(new Template("Pause3", p3));
+	}
+}
diff --git a/GestureDetectionApp/GestureRecognizerTest/.classpath b/GestureDetectionApp/GestureRecognizerTest/.classpath
new file mode 100644
index 0000000..9b1e1e7
--- /dev/null
+++ b/GestureDetectionApp/GestureRecognizerTest/.classpath
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER/org.eclipse.jdt.internal.debug.ui.launcher.StandardVMType/JavaSE-1.6"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/GestureRecognition"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>
diff --git a/GestureDetectionApp/GestureRecognizerTest/.project b/GestureDetectionApp/GestureRecognizerTest/.project
new file mode 100644
index 0000000..f5ceaa5
--- /dev/null
+++ b/GestureDetectionApp/GestureRecognizerTest/.project
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>GestureRecognizerTest</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>
diff --git a/GestureDetectionApp/GestureRecognizerTest/.settings/org.eclipse.jdt.core.prefs b/GestureDetectionApp/GestureRecognizerTest/.settings/org.eclipse.jdt.core.prefs
new file mode 100644
index 0000000..a151984
--- /dev/null
+++ b/GestureDetectionApp/GestureRecognizerTest/.settings/org.eclipse.jdt.core.prefs
@@ -0,0 +1,12 @@
+#Thu Jun 09 19:44:30 CEST 2011
+eclipse.preferences.version=1
+org.eclipse.jdt.core.compiler.codegen.inlineJsrBytecode=enabled
+org.eclipse.jdt.core.compiler.codegen.targetPlatform=1.6
+org.eclipse.jdt.core.compiler.codegen.unusedLocal=preserve
+org.eclipse.jdt.core.compiler.compliance=1.6
+org.eclipse.jdt.core.compiler.debug.lineNumber=generate
+org.eclipse.jdt.core.compiler.debug.localVariable=generate
+org.eclipse.jdt.core.compiler.debug.sourceFile=generate
+org.eclipse.jdt.core.compiler.problem.assertIdentifier=error
+org.eclipse.jdt.core.compiler.problem.enumIdentifier=error
+org.eclipse.jdt.core.compiler.source=1.6
diff --git a/GestureDetectionApp/GestureRecognizerTest/src/gui/MainFrame.java b/GestureDetectionApp/GestureRecognizerTest/src/gui/MainFrame.java
new file mode 100644
index 0000000..904bfca
--- /dev/null
+++ b/GestureDetectionApp/GestureRecognizerTest/src/gui/MainFrame.java
@@ -0,0 +1,220 @@
+package gui;
+
+
+import javax.swing.*;
+
+import at.mus.recognition.Point;
+import at.mus.recognition.Recognizer2D;
+import at.mus.recognition.Templates;
+
+import java.awt.*;
+import java.awt.event.*;
+import java.text.DecimalFormat;
+import java.text.NumberFormat;
+import java.util.*;
+import java.util.List;
+
+@SuppressWarnings("serial")
+public class MainFrame extends JFrame implements ActionListener {
+	/* constants */
+	private final int NumPoints = 64;
+	private final double SquareSize = 250;
+	private final Point Origin = new Point(0,0);
+	private static final NumberFormat codePointFormat = DecimalFormat.getInstance(Locale.ENGLISH);
+	
+	/* UI */
+	private PointsPanel rawPanel;
+	private PointsPanel resamplePanel;
+	private PointsPanel rotationPanel;
+	private PointsPanel scaledPanel;
+	private JButton btnMakeTemplate;
+	private JButton btnRecognize;
+	private JTextArea txtCode;
+	private JLabel lblMatch;
+
+	/* logic */
+	private boolean recording;
+	private Thread drawThread;
+	private long delay = 10;
+	
+	/* recognition */
+	private Recognizer2D recognizer;
+	private List<Point> rawPoints;
+	private List<Point> resampledPoints;
+	private List<Point> rotatedPoints;
+	private List<Point> scaledPoints;
+
+	public MainFrame() {
+		super("GestureRecognition");
+
+		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+		setSize(800, 600);
+		setLayout(new BorderLayout(5, 5));
+
+		init();
+		initUI();
+		drawThread.start();
+	}
+
+	private void init() {
+		recognizer = new Recognizer2D();
+		
+		recording = false;
+		rawPoints = new ArrayList<Point>();
+		resampledPoints = new ArrayList<Point>();
+		rotatedPoints = new ArrayList<Point>();
+		scaledPoints = new ArrayList<Point>();
+
+		drawThread = new Thread(new Runnable() {
+			@Override
+			public void run() {
+				while (true) {
+					try {
+						Thread.sleep(delay);
+						if (recording && rawPanel.getMousePosition() != null) {
+							record(new Point(rawPanel.getMousePosition().getX(),
+									rawPanel.getMousePosition().getY()));
+						}
+					} catch (InterruptedException e) {
+						e.printStackTrace();
+					}
+				}
+			}
+		});
+	}
+
+	private void initUI() {
+		/* centerPanel*/
+		JPanel centerPanel = new JPanel();
+		centerPanel.setLayout(new GridLayout(2, 2));
+		getContentPane().add(centerPanel, BorderLayout.CENTER);
+		
+		/* rawPanel */
+		rawPanel = new PointsPanel("Input", rawPoints, Color.orange);
+		rawPanel.addMouseListener(new MouseAdapter() {
+			@Override
+			public void mousePressed(MouseEvent e) {
+				super.mousePressed(e);
+				if (e.getButton() == MouseEvent.BUTTON1 && !recording)
+					startRecording();
+			}
+
+			@Override
+			public void mouseReleased(MouseEvent e) {
+				super.mouseReleased(e);
+				if (e.getButton() == MouseEvent.BUTTON1 && recording)
+					stopRecording();
+			}
+		});
+		centerPanel.add(rawPanel);
+		
+		/* resamplePanel */
+		resamplePanel = new PointsPanel("Resampled", resampledPoints, Color.green);
+		centerPanel.add(resamplePanel);
+		
+		/* rotationPanel */
+		rotationPanel = new PointsPanel("Rotated", rotatedPoints, Color.blue);
+		centerPanel.add(rotationPanel);
+		
+		/* scaledPanel: use offset because origin is (0,0) and points may be negative */
+		scaledPanel = new PointsPanel("Scaled & Translated", scaledPoints, Color.red, SquareSize, SquareSize);
+		centerPanel.add(scaledPanel);
+		
+		/* bottom panel */
+		JPanel botPanel = new JPanel();
+		botPanel.setLayout(new GridLayout(1, 2));
+		getContentPane().add(botPanel, BorderLayout.SOUTH);
+		
+		/* code field */
+		txtCode = new JTextArea();
+		txtCode.setRows(5);
+		txtCode.setLineWrap(true);
+		botPanel.add(txtCode);
+
+		/* buttonPanel */
+		JPanel btnPanel = new JPanel();
+		btnPanel.setLayout(new FlowLayout(FlowLayout.CENTER, 2, 5));
+		getContentPane().add(btnPanel, BorderLayout.NORTH);
+
+		/* buttons */
+		btnMakeTemplate = new JButton("Template");
+		btnMakeTemplate.addActionListener(this);
+		btnPanel.add(btnMakeTemplate);
+		
+		btnRecognize = new JButton("Recognize");
+		btnRecognize.addActionListener(this);
+		btnPanel.add(btnRecognize);
+		
+		/* detection */
+		JLabel label = new JLabel("Match:");
+		btnPanel.add(label);
+		lblMatch = new JLabel("");
+		btnPanel.add(lblMatch);
+		
+	}
+
+	private void startRecording() {
+		recording = true;
+		rawPoints.clear();
+		resampledPoints.clear();
+	}
+
+	private void stopRecording() {
+		recording = false;
+	}
+
+	private void record(at.mus.recognition.Point p) {
+		rawPoints.add(p);
+		SwingUtilities.invokeLater(new Runnable() {
+			@Override
+			public void run() {
+				rawPanel.repaint();
+			}
+		});
+	}
+
+	public static void main(String[] args) {
+		MainFrame frame = new MainFrame();
+		frame.setVisible(true);
+	}
+	
+	private void createPointListCode(List<Point> points) {
+		StringBuilder sb = new StringBuilder();
+		sb.append(String.format("public static double[][] points = { "));
+		
+		int cnt = 0;
+		for (Point p : points) {
+			sb.append(String.format("{ %1$s, %2$s }", codePointFormat.format(p.x), codePointFormat.format(p.y)));
+			++cnt;
+			if (cnt < points.size())
+				sb.append(", ");
+		}
+		sb.append("};");
+		txtCode.setText(sb.toString());
+	}
+
+	@Override
+	public void actionPerformed(ActionEvent e) {
+		if (e.getSource() == btnMakeTemplate) {
+			lblMatch.setText("");
+			resampledPoints = recognizer.resample(new ArrayList<Point>(rawPoints), NumPoints);
+			resamplePanel.update(resampledPoints);
+			
+			rotatedPoints = recognizer.rotateToZero(resampledPoints);
+			rotationPanel.update(rotatedPoints);
+			
+			scaledPoints = recognizer.scaleAndTranslateTo(rotatedPoints, SquareSize, Origin);
+			scaledPanel.update(scaledPoints);
+			
+			createPointListCode(scaledPoints);
+		} else if (e.getSource() == btnRecognize) {
+			lblMatch.setText("");
+			
+			Recognizer2D.Result result = recognizer.recognize(rawPoints, Templates.list, NumPoints, SquareSize, Origin);
+			lblMatch.setText(String.format("%1$s (%2$6.2f)", result.getTemplate().name, result.getMatch() * 100));
+		} else {
+			/* no button recognized */
+		}
+	}
+	
+}
diff --git a/GestureDetectionApp/GestureRecognizerTest/src/gui/PointsPanel.java b/GestureDetectionApp/GestureRecognizerTest/src/gui/PointsPanel.java
new file mode 100644
index 0000000..62a93d2
--- /dev/null
+++ b/GestureDetectionApp/GestureRecognizerTest/src/gui/PointsPanel.java
@@ -0,0 +1,58 @@
+package gui;
+
+import javax.swing.JPanel;
+
+import at.mus.recognition.Point;
+
+import java.awt.Color;
+import java.awt.Graphics;
+import java.util.ArrayList;
+import java.util.List;
+
+@SuppressWarnings("serial")
+public class PointsPanel extends JPanel {
+	/* constants */
+	private final int POINT_SIZE = 7;
+	
+	private String title;
+	private List<Point> points;
+	private Color col;
+	private double offsetX, offsetY;
+	
+	public PointsPanel(String title, List<Point> points, Color col) {
+		this(title, points, col, 0, 0);
+	}
+	
+	public PointsPanel(String title, List<Point> points, Color col, double offsetX, double offsetY) {
+		this.title = title;
+		this.points = points;
+		this.col = col;
+		this.offsetX = offsetX;
+		this.offsetY = offsetY;
+		this.setBackground(Color.white);
+	}
+
+	public void update(List<Point> points) {
+		this.points = new ArrayList<Point>(points);
+		repaint();
+	}
+	
+	@Override
+	public void paint(Graphics g) {
+		super.paint(g);
+		g.setColor(Color.DARK_GRAY);
+		g.drawString(title, 5, 15);
+		g.drawRect(0, 0, getWidth()-1, getHeight()-1);
+		if (offsetX != 0 || offsetY != 0) {
+			g.drawLine(0, (int)offsetY, getWidth(), (int)offsetY);
+			g.drawLine((int)offsetX, 0, (int)offsetX, getHeight());
+		}
+		
+		g.setColor(col);
+		if (points != null) {
+			for (Point p : points) {
+				g.drawOval((int)(p.x + offsetX), (int)(p.y + offsetY), POINT_SIZE, POINT_SIZE);
+			}
+		}
+	}
+}
diff --git a/GestureDetectionApp/GestureSensitiveControl/.classpath b/GestureDetectionApp/GestureSensitiveControl/.classpath
index 609aa00..13b6f0f 100644
--- a/GestureDetectionApp/GestureSensitiveControl/.classpath
+++ b/GestureDetectionApp/GestureSensitiveControl/.classpath
@@ -3,5 +3,6 @@
 	<classpathentry kind="src" path="src"/>
 	<classpathentry kind="src" path="gen"/>
 	<classpathentry kind="con" path="com.android.ide.eclipse.adt.ANDROID_FRAMEWORK"/>
+	<classpathentry combineaccessrules="false" kind="src" path="/GestureRecognition"/>
 	<classpathentry kind="output" path="bin"/>
 </classpath>
diff --git a/GestureDetectionApp/GestureSensitiveControl/src/at/mus/GestureSensitiveControl/GestureActivity.java b/GestureDetectionApp/GestureSensitiveControl/src/at/mus/GestureSensitiveControl/GestureActivity.java
index 64ac9f1..471cf37 100644
--- a/GestureDetectionApp/GestureSensitiveControl/src/at/mus/GestureSensitiveControl/GestureActivity.java
+++ b/GestureDetectionApp/GestureSensitiveControl/src/at/mus/GestureSensitiveControl/GestureActivity.java
@@ -41,6 +41,7 @@ public class GestureActivity extends Activity implements SensorEventListener {
 	private final int TCP_PORT = 35000;
 
 	// sensor
+	private PositionRecorder mPosRecorder;
 	private SensorManager mSensorManager;
 	private Sensor mAccelerometer;
 	private Sensor mOrientation;
@@ -205,6 +206,7 @@ public class GestureActivity extends Activity implements SensorEventListener {
 		mSensorManager.registerListener(this, mOrientation,
 				SensorManager.SENSOR_DELAY_NORMAL);
 
+		mPosRecorder = new PositionRecorder();
 		// maybe start timer
 	}
 
@@ -223,14 +225,17 @@ public class GestureActivity extends Activity implements SensorEventListener {
 	public void onSensorChanged(SensorEvent event) {
 		String s = "";
 		if (event.sensor.getType() == Sensor.TYPE_ACCELEROMETER) {
+			mPosRecorder.setAcceleration(event.values);
+
 			s = String.format("Acc.: X:%f Y:%f Z:%f",
-					event.values[0], event.values[1], event.values[2]);
+					mPosRecorder.x, mPosRecorder.y, mPosRecorder.z);
 			lbAcceleration.setText(s);
 		}
 		if (event.sensor.getType() == Sensor.TYPE_ORIENTATION) {
 			s = String.format("%s %n Orientation: X:%f Y:%f Z:%f", s,
 					event.values[0], event.values[1], event.values[2]);
 			lbOrientation.setText(s);
+			mPosRecorder.setOrientation(event.values);
 		}
 		if (event.sensor.getType() == Sensor.TYPE_GYROSCOPE) {
 			s = String.format("%s %n Gyroscope: X:%f Y:%f Z:%f",
@@ -238,4 +243,5 @@ public class GestureActivity extends Activity implements SensorEventListener {
 			lbGyroscope.setText(s);
 		}
 	}
+	
 }
\ No newline at end of file
diff --git a/GestureDetectionApp/GestureSensitiveControl/src/at/mus/GestureSensitiveControl/PositionRecorder.java b/GestureDetectionApp/GestureSensitiveControl/src/at/mus/GestureSensitiveControl/PositionRecorder.java
new file mode 100644
index 0000000..750d20b
--- /dev/null
+++ b/GestureDetectionApp/GestureSensitiveControl/src/at/mus/GestureSensitiveControl/PositionRecorder.java
@@ -0,0 +1,28 @@
+package at.mus.GestureSensitiveControl;
+
+public class PositionRecorder {
+	private float azimuth, pitch, roll;
+	private float ax, ay, az;
+	
+	public float x, y, z;
+
+	public void setOrientation(float[] orientationValues) {
+		azimuth = orientationValues[0];
+		pitch = orientationValues[1];
+		roll = orientationValues[2];
+	}
+	
+	public void setAcceleration(float[] accelerationValues) {
+		ax = accelerationValues[0];
+		ay = accelerationValues[1];
+		az = accelerationValues[2];
+		calculate();
+	}
+	
+	private void calculate() {
+        x =(float) (ax*(Math.cos(roll)*Math.cos(azimuth)+Math.sin(roll)*Math.sin(pitch)*Math.sin(azimuth)) + ay*(Math.cos(pitch)*Math.sin(azimuth)) + az*(-Math.sin(roll)*Math.cos(azimuth)+Math.cos(roll)*Math.sin(pitch)*Math.sin(azimuth)));
+        y = (float) (ax*(-Math.cos(roll)*Math.sin(azimuth)+Math.sin(roll)*Math.sin(pitch)*Math.cos(azimuth)) + ay*(Math.cos(pitch)*Math.cos(azimuth)) + az*(Math.sin(roll)*Math.sin(azimuth)+ Math.cos(roll)*Math.sin(pitch)*Math.cos(azimuth)));
+        z = (float) (ax*(Math.sin(roll)*Math.cos(pitch)) + ay*(-Math.sin(pitch)) + az*(Math.cos(roll)*Math.cos(pitch)));
+        
+	}
+}
-- 
2.11.4.GIT