diff --git a/.gitignore b/.gitignore
index fea7c45..6a3e68d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1 @@
-
-**/.DS_Store
+**/.DS_Store
\ No newline at end of file
diff --git a/classes/Datasets/Transforms.sc b/classes/Datasets/Transforms.sc
new file mode 100644
index 0000000..f2daee0
--- /dev/null
+++ b/classes/Datasets/Transforms.sc
@@ -0,0 +1,122 @@
+/*****************************************
+Data Transforms
+(C) 2018 Jonathan Reus
+
+Tools for analyzing and transforming datasets: scaling, normalization, standardization, PCA, etc..
+
+
+******************************************/
+
+// TO NORMALIZE:
+// find min / max of features
+// normalized_value = (val - min) / (max - min)
+
+
+/*
+T for Transform
+Normalization:
+1. find min/max of each feature
+2. normalized_value = (val - min) / (max - min)
+*/
+TNormalizer {
+	var <min, <max, <originalData, <normalizedData, dim;
+
+	/*
+	@param dataset a Matrix of rows as feature vectors
+	*/
+	*new {|dataset|
+		^super.new.init(dataset);
+	}
+
+	init {|dataset|
+		if(dataset.isKindOf(SequenceableCollection).not ) { "Dataset must be a Matrix".error;this.halt; };
+		if(dataset.at(0).isKindOf(SequenceableCollection)) {
+			dim = dataset.cols;
+			min = Array.newClear(dim);
+			max = Array.newClear(dim);
+			normalizedData = Matrix.newClear(dataset.rows, dataset.cols);
+			dim.do {|i|
+				var col = dataset.getCol(i);
+				min[i] = col.minItem;
+				max[i] = col.maxItem;
+				normalizedData.putCol(i, this.normalizeSample(col) );
+			};
+		} {
+			min = dataset.minItem; max = dataset.maxItem;
+			normalizedData = dataset.collect {|it,i| this.normalizeSample(it) };
+		};
+		originalData = dataset;
+	}
+
+	// normalize / denormalize a single sample
+	normalizeSample {|samp| (samp - min) / (max - min) }
+	denormalizeSample {|samp| (samp * (max-min)) + min }
+
+
+	// normalize an entire dataset
+	normalizeData {}
+
+	// denormalize a point-slope form 2-dimensional line
+	// of the form [slope, intercept]
+	denormalizeLine {|line|
+			var p1,p2, new_m, new_b, m=line[0], b=line[1];
+			// calculate two normalized samples & denormalize them
+			p1 = [-1,(-1 * m)+b]; p2 = [1,(1 * m)+b];
+			p1 = this.denormalizeSample(p1);
+			p2 = this.denormalizeSample(p2);
+			// calculate denormalized decision boundary
+			new_m = (p2[1]-p1[1]) / (p2[0]-p1[0]); // slope
+			new_b = p1[1] - (new_m*p1[0]); // y-intercept
+			^[new_m,new_b];
+	}
+
+}
+
+/*
+TO STANDARDIZE:
+1. calculate mean and standard deviation of each feature
+2. subtract mean from each feature
+3. divide features by standard deviation
+
+T is for Transform
+*/
+TStandardizer {
+	var <mean, <stddev;
+
+}
+
+/*
+T for Transform
+*/
+TPCA {
+
+}
+
+
+
+/*
+( // feature scaling of reduced dataset
+~dReduced = Matrix.newFrom(~dReduced);
+dim = ~dReduced.cols;
+mean = Array.newClear(dim);
+stdev = Array.newClear(dim);
+
+~standardizeSample = {|v,mean,stddev| (v-mean) / stddev };
+~destandardizeSample = {|v,mean,stddev| (v*stddev) + mean };
+
+~dStandard = Matrix.newClear(~dReduced.rows, dim);
+dim.do {|i|
+	var col = ~dReduced.getCol(i);
+	mean[i] = col.mean;
+	stdev[i] = col.stdDev(mean[i]);
+	~dStandard.putCol(i, ~standardizeSample.(col, mean[i], stdev[i]));
+};
+"MEAN: %   STDDEV: %".format(mean, stdev).postln;
+s1 = [-0.09, 1.45];
+s2 = ~standardizeSample.(s1, mean, stdev);
+s3 = ~destandardizeSample.(s2, mean, stdev);
+"NEW SAMPLE: %   STANDARDIZED: %  DESTANDARDIZED: %".format(s1,s2,s3).postln;
+
+); // END SCALING & STANDARDIZATION OF FEATURES
+
+*/
diff --git a/classes/gui/ScatterView.sc b/classes/gui/ScatterView.sc
index ac774a1..589dfd4 100644
--- a/classes/gui/ScatterView.sc
+++ b/classes/gui/ScatterView.sc
@@ -1,46 +1,248 @@
-// 2005 by till bovermann
-//   bielefeld university
+/*********************************************************************
+(C) 2005 Till Bovermann / Bielefeld University
 
-ScatterView {
-	var <plot, <background;
-	var <>highlightColor, <highlightItem, <>highlightSize, <>isHighlight, <>drawAxis, <>drawValues;
+and later...
+
+(C) 2018 Jonathan Reus / IEM Graz
+
+Views for Cartesian point / scatterplots
+
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program 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.
+
+For more details see: https://www.gnu.org/licenses/
+**********************************************************************/
+
+
+
+/*
+@class ScatterPlotter
+
+A higher level view abstraction that manages multiple scatterplots on a single graph.
+All scatterplots share a single axis specification and commands for drawing / showing axes.
+
+@usage
+
+n = 100;
+x = Array.series(n, 0, 100 / n) + Array.fill(n, {rrand(-15.0, 15.0)});
+y = Array.series(n, 0, 100 / n) + Array.fill(n, {rrand(-15.0, 15.0)});
+p = x.collect {|item,i| [item, y[i]] };
+x = Array.series(n, 0, 100 / n) + Array.fill(n, {rrand(-15.0, 15.0)});
+y = Array.series(n, 0, 100 / n).reverse + Array.fill(n, {rrand(-15.0, 15.0)});
+q = x.collect {|item,i| [item, y[i]] };
+
+w = Window.new("X Scatter", 800@600);
+j = ScatterPlotter.new(w, 800@600, p, [0,100].asSpec, [0,100].asSpec);
+j.drawAxes_(true).drawGrid_(true).drawMethod_(\fillOval).symbolSize_(5@5);
+w.front;
+
+j.addPlot(q);
+j.addPlot([[0,0],[100,100]]);
+j.backgroundColor_(Color.black).axisColor_(Color.gray);
+j.symbolColor_(Color.blue,0);
+j.symbolColor_(Color.green,1);
+j.symbolColor_(Color.red,2).drawMethod_(\lineTo,2).symbolSize_(1,2);
+j.setAxes([1,100,\exp].asSpec, [1,100,\exp].asSpec);
+
+// different random distributions
+o = ScatterPlotter.new(nil, 800@400, Array.fill(100, {|i| [0.5.gauss(0.17), 0.3]}));
+o.drawMethod_(\fillOval).drawAxes_(true).symbolSize_(3@3);
+o.addPlot(Array.fill(100, {|i| [(0.5.bilinrand + 0.5), 0.5]}));
+o.addPlot(Array.fill(100, {|i| [(0.5.sum3rand + 0.5), 0.7]}));
+o.front;
+*/
+ScatterPlotter : CompositeView {
+	var <scatterviews; // list of plots, plot 0 is where axes and grids are drawn.
+	var <>constrainToAxes; // boolean, if true points are constrained to visible axes
+
+	*new {|parent, bounds, data, specX, specY, constrain=false|
+		^super.new(parent, bounds).init(data, specX, specY, constrain);
+	}
+
+	init {|data, specX, specY, constrain|
+		var firstplot;
+		constrainToAxes = constrain;
+		scatterviews = List.new;
+		firstplot = ScatterView.new(this, this.bounds, data, specX, specY);
+		scatterviews.add(firstplot);
+		^this
+	}
+
+	drawAxes_ {|bool| scatterviews.do {|plot| plot.drawAxes_(bool).refresh }; ^this; }
+	drawAxes { ^scatterviews[0].drawAxes; }
+
+	drawGrid_ {|bool| scatterviews[0].drawGrid_(bool).refresh; ^this; }
+	drawGrid { ^scatterviews[0].drawGrid; }
+
+	gridResolution_ {|dim| scatterviews[0].gridResolution_(dim).refresh; ^this; }
+	gridResolution { ^scatterviews[0].gridResolution; }
+
+	axisColor_ {|color| scatterviews[0].axisColor_(color).refresh; ^this; }
+	axisColor { ^scatterviews[0].axisColor; }
+
+
+	gridColor_ {|color| scatterviews[0].gridColor_(color).refresh; ^this; }
+	gridColor { ^scatterviews[0].gridColor; }
+
+	xAxisName_ {|name| scatterviews[0].xAxisName_(name).refresh; ^this; }
+	xAxisName { ^scatterviews[0].xAxisName; }
+
+	yAxisName_ {|name| scatterviews[0].yAxisName_(name).refresh; ^this; }
+	yAxisName { ^scatterviews[0].yAxisName; }
+
+
+	drawGridValues_ {|bool| scatterviews[0].drawGridValues_(bool).refresh; ^this; }
+	drawGridValues { ^scatterviews[0].drawGridValues; }
+
+	backgroundColor_ {|bgcolor| scatterviews[0].backgroundColor_(bgcolor).refresh; ^this; }
+	backgroundColor { ^scatterviews[0].backgroundColor; }
+
+	getPlot {|idx=0| ^scatterviews.at(idx); }
+	deletePlot {|idx| if(idx != 0) { scatterviews.removeAt(idx); } }
+
+	addPlot {|data|
+		var newplot;
+		newplot = ScatterView.new(this, this.bounds, data, scatterviews[0].specX, scatterviews[0].specY);
+		newplot.backgroundColor_(Color.clear).drawMethod_(scatterviews[0].drawMethod);
+		newplot.symbolColor_(Color.rand(0.0, 0.95)).symbolSize_(scatterviews[0].symbolSize);
+		newplot.drawAxes_(scatterviews[0].drawAxes).axisColor_(Color.clear);
+		scatterviews.add(newplot);
+		this.refresh;
+		^newplot;
+	}
+
+	setAxes {|xspec, yspec|
+		scatterviews.do {|plot, idx|
+			plot.setAxes(xspec, yspec, constrainToAxes);
+			plot.refresh;
+		};
+	}
+
+	setAxesLabels {|xlabel, ylabel|
+		scatterviews[0].xAxisName_(xlabel).yAxisName_(ylabel).refresh;
+	}
+
+	data {|idx=0| ^scatterviews[idx].originalData }
+	data_ {|thedata, idx=0, constrainToBounds=false|
+		scatterviews[idx].data_(thedata, constrainToBounds).refresh;
+		^this;
+	}
+
+	drawValues_ {|bool, idx=0| scatterviews[idx].drawValues_(bool).refresh; ^this; }
+	valuesColor_ {|color, idx=0| scatterviews[idx].valuesColor_(color).refresh; ^this; }
+	symbolColor_ {|color, idx=0| scatterviews[idx].symbolColor_(color).refresh; ^this; }
+	symbolSize_ {|dim, idx=0| scatterviews[idx].symbolSize_(dim).refresh; ^this; }
+	drawMethod_ {|method, idx=0| scatterviews[idx].drawMethod_(method).refresh; ^this; }
+}
+
+
+/*
+@class ScatterView
+
+A simple 2-dimensional scatterplot with coordinate axes.
+
+@usage
+
+(
+n = 100;
+x = Array.series(n, 0, 100 / n) + Array.fill(n, {rrand(-15.0, 15.0)});
+y = Array.series(n, 0, 100 / n) + Array.fill(n, {rrand(-15.0, 15.0)});
+p = x.collect {|item,i| [item, y[i]] };
+
+w = Window.new("Linear Scatter", 800@600);
+j = ScatterView.new(w, 800@600, p, [0,100].asSpec,[0,100].asSpec);
+j.drawAxes_(true).drawGrid_(true).drawMethod_(\fillOval);
+j.symbolSize_(5@5).symbolColor_(Color.blue);
+w.front;
+);
+
+// Show axis, grid and value labels
+j.drawAxes_(true).drawGrid_(true).drawValues_(true).refresh;
+
+// Visual style
+j.axisColor_(Color.gray(0.3)).gridColor_(Color.red).valuesColor_(Color.gray(0.7)).backgroundColor_(Color.black).refresh;
+
+
+// Adjust axes & scale
+j.setAxes([-50, 150, \lin].asSpec, [-50,150,\lin].asSpec).symbolSize_(3@3).drawValues_(false).refresh;
+j.setAxes([1, 150, \exp].asSpec, [0, 100,\lin].asSpec).symbolSize_(5@5).drawGridValues_(true).refresh;
+
+
+*/
+ScatterView : View {
+	var <plot, <>backgroundColor;
+	var <>highlightColor, <highlightItem, <>highlightSize, <>isHighlight;
+	var <>drawAxes, <>drawGrid, <>drawGridValues, <>drawValues;
+	var <>gridResolution;
+	var <>axisColor,<>gridColor, <>valuesColor;
 	var <>xAxisName, <>yAxisName;
 	var <symbolSize, <>symbolColor, <>drawMethod = \lineTo;
-	var adjustedData, specX, specY;
+	var <>constrainToBounds;
 
-	*new {|parent, bounds, data, specX, specY|
-		^super.new.initPlot(
-			parent, bounds, data, specX, specY
-		)
+	var <normalizedData; // data normalized to 0-1 for projection on to the view
+	var <originalData, <specX, <specY;
+
+	*new {|parent, bounds, data, specX, specY, constrainToBounds=false|
+		^super.new(parent, bounds).initPlot(data, specX, specY, constrainToBounds);
 	}
-	background_ {|color|
-		background = color;
+
+	*drawMethods { ^[\fillRect, \fillOval, \strokeOval, \strokeRect] }
+
+	setAxes {|xspec,yspec,constrainToBounds|
+		specX = xspec ? specX;
+		specY = yspec ? specY;
+		this.normalizeData(constrainToBounds);
 	}
+
 	highlightItem_{|item|
 		highlightItem = item.isKindOf(Collection).if({item}, {[item]});
 		//this.plot.refresh;
 	}
+
 	highlightItemRel_{|val|
-		this.highlightItem = (val * (adjustedData.size-1)).asInteger;
+		this.highlightItem = (val * (normalizedData.size-1)).asInteger;
 	}
+
 	highlightRange{|start, end|
 		this.highlightItem = (start .. end);
 	}
+
 	highlightRangeRel{|start, end|
 		var startIndex, endIndex;
-		startIndex = (start * (adjustedData.size-1)).asInteger;
-		endIndex = (end * (adjustedData.size-1)).asInteger;
+		startIndex = (start * (normalizedData.size-1)).asInteger;
+		endIndex = (end * (normalizedData.size-1)).asInteger;
 		this.highlightItem = (startIndex .. endIndex);
 	}
+
 	refresh {
 		plot.refresh;
 	}
-	data_{|data|
-		adjustedData = data.collect {|item|
-			[specX.unmap(item[0]), specY.unmap(item[1])];
+
+	data_{|data, constrainToBounds=false|
+		originalData = data.shallowCopy;
+		this.normalizeData(constrainToBounds);
+		highlightItem = min(highlightItem, (normalizedData.size-1));
+	}
+
+	normalizeData {|constrainToBounds|
+		if(constrainToBounds) {
+			normalizedData = originalData.collect {|item|
+				[specX.unmap(item[0]), specY.unmap(item[1])];
+			};
+		} {
+			normalizedData = originalData.collect {|item|
+				[specX.warp.unmap(item[0]), specY.warp.unmap(item[1])];
+			};
 		};
-		highlightItem = min(highlightItem, (adjustedData.size-1));
 	}
+
 	symbolSize_{|point|
 		if(point.isKindOf(Point), {symbolSize = point}, {symbolSize = (point@point)});
 	}
@@ -50,179 +252,233 @@ ScatterView {
 	resize_{arg resize;
 		plot.resize_(resize)
 	}
-	initPlot {
-		arg parent, bounds, data, argSpecX, argSpecY;
-		
+	initPlot {arg data, argSpecX, argSpecY, constrainToBounds;
+
 		var widthSpec, heightSpec, cross;
 		var possibleMethods;
-		
+
 		specX = argSpecX ? [0,1].asSpec;
 		specY = argSpecY ? specX.copy;
-		possibleMethods = [\fillRect, \fillOval, \strokeOval, \strokeRect];
-		
+		possibleMethods = ScatterView.drawMethods;
+
 		this.symbolSize = 1;
 		symbolColor = symbolColor ? Color.black;
-		
-		background = Color.white;
+		axisColor = axisColor ? Color.black;
+		valuesColor = valuesColor ? Color.black;
+		gridColor = gridColor ? Color.gray(0.7);
+
+		backgroundColor = Color.white;
 		highlightColor = Color.red;
 		highlightItem = 0;
 		highlightSize = (2@2);
 		isHighlight = false;
-		drawAxis = false;
+		drawAxes = false;
+		drawGrid = false;
+		drawGridValues = true;
 		drawValues = false;
 		xAxisName= "X";
 		yAxisName= "Y";
-		
-		this.data_(data);
-		
+		gridResolution = 5@5;
+
+		this.data_(data,constrainToBounds);
+
 		cross = {|rect, width, color|
 			var dx, dy, extX, extY;
 			dx = rect.left;
 			dy = rect.top;
 			extX = rect.width;
 			extY = rect.height;
-			GUI.pen.use{
-				GUI.pen.color = color;
-				GUI.pen.translate(dx, dy);
-				GUI.pen.moveTo((0)@(extY*0.5));
-				GUI.pen.lineTo(extX@(extY*0.5));
-				GUI.pen.moveTo((extX*0.5)@(0));
-				GUI.pen.lineTo((extX*0.5)@(extY));
-				GUI.pen.stroke;
+			Pen.use{
+				Pen.color = color;
+				Pen.translate(dx, dy);
+				Pen.moveTo((0)@(extY*0.5));
+				Pen.lineTo(extX@(extY*0.5));
+				Pen.moveTo((extX*0.5)@(0));
+				Pen.lineTo((extX*0.5)@(extY));
+				Pen.stroke;
 			};
 		};
-		
-		plot = GUI.userView.new(parent, bounds)
-			.relativeOrigin_(false)
-			.drawFunc_({|w|
-				var width, height, rect, pad = 10;
-				if (drawAxis) { pad = 60 };
-
-				width =  w.bounds.width  - pad;
-				height = w.bounds.height - pad;
-
-				GUI.pen.use{
-					// clipping into the boundingbox
-					GUI.pen.moveTo((w.bounds.left)@(w.bounds.top));
-					GUI.pen.lineTo(((w.bounds.left)@(w.bounds.top)) 
-							+ (w.bounds.width@0));
-					GUI.pen.lineTo(((w.bounds.left)@(w.bounds.top)) 
-							+ (w.bounds.width@w.bounds.height));
-					GUI.pen.lineTo(((w.bounds.left)@(w.bounds.top)) 
-							+ (0@w.bounds.height));
-					GUI.pen.lineTo((w.bounds.left)@(w.bounds.top));
-					GUI.pen.clip;
-					
-					// draw Background
-					GUI.pen.color = background;
-					GUI.pen.addRect(w.bounds);
-					GUI.pen.fill;
-					
-					// draw data
-					GUI.pen.color = symbolColor;
-					if (possibleMethods.includes(drawMethod), {
-						GUI.pen.beginPath;
-						adjustedData.do{|item, i|
-							rect = Rect(
-								(   item[0]  * width)  - (symbolSize.x/2) + (pad/2),
-								((1-item[1]) * height) - (symbolSize.y/2) + (pad/2), 
-								symbolSize.x, symbolSize.y
-							);
-							GUI.pen.perform(
-								drawMethod,
-								(Rect(w.bounds.left, w.bounds.top, 0, 0) + rect)
-							);
-						}
-					},{ // else draw lines
-						GUI.pen.width = symbolSize.x;
-						// move to first position;
-						if (adjustedData.notNil) {
-							GUI.pen.moveTo(
-								((adjustedData[0][0]  * width) + (pad/2))
-								 @
-								 (((1-adjustedData[0][1]) * height) + (pad/2))
-							   	  + 
-								  (w.bounds.left@w.bounds.top)
-							);
+
+		plot = UserView.new(this, this.bounds).drawFunc_({|w|
+			var width, height, left, top, rect, pad = 10;
+			if (drawAxes) { pad = 60 };
+
+			width =  w.bounds.width  - pad;
+			height = w.bounds.height - pad;
+			left = w.bounds.left + (pad/2);
+			top = w.bounds.top + (pad/2);
+
+
+			Pen.use{
+				// clipping into the boundingbox
+				Pen.moveTo((w.bounds.left)@(w.bounds.top));
+				Pen.lineTo(((w.bounds.left)@(w.bounds.top))
+					+ (w.bounds.width@0));
+				Pen.lineTo(((w.bounds.left)@(w.bounds.top))
+					+ (w.bounds.width@w.bounds.height));
+				Pen.lineTo(((w.bounds.left)@(w.bounds.top))
+					+ (0@w.bounds.height));
+				Pen.lineTo((w.bounds.left)@(w.bounds.top));
+				Pen.clip;
+
+				// draw Background
+				Pen.color = backgroundColor;
+				Pen.addRect(w.bounds);
+				Pen.fill;
+
+				// draw data
+				Pen.color = symbolColor;
+				if (possibleMethods.includes(drawMethod), {
+					Pen.beginPath;
+					normalizedData.do{|item, i|
+						rect = Rect(
+							(   item[0]  * width)  - (symbolSize.x/2) + (pad/2),
+							((1-item[1]) * height) - (symbolSize.y/2) + (pad/2),
+							symbolSize.x, symbolSize.y
+						);
+						Pen.perform(
+							drawMethod,
+							(Rect(w.bounds.left, w.bounds.top, 0, 0) + rect)
+						);
+					}
+				},{ // else draw lines
+					Pen.width = symbolSize.x;
+					// move to first position;
+					if (normalizedData.notNil) {
+						Pen.moveTo(
+							((normalizedData[0][0]  * width) + (pad/2))
+							@
+							(((1-normalizedData[0][1]) * height) + (pad/2))
+							+
+							(w.bounds.left@w.bounds.top)
+						);
+					};
+					// draw lines
+					normalizedData.do{|item, i|
+						Pen.lineTo(
+							((item[0]  * width) + (pad/2))
+							@
+							(((1-item[1]) * height) + (pad/2))
+							+
+							(w.bounds.left@w.bounds.top)
+						)
+					};
+					if(drawMethod == \fill, {Pen.fill},{Pen.stroke});
+				});
+
+				// highlight datapoint
+				if(isHighlight) {
+					highlightItem.do{|item|
+						cross.value((Rect(
+							(normalizedData[item][0]  * width)
+							-
+							(highlightSize.x/2) + (pad/2),
+							((1-normalizedData[item][1]) * height)
+							-
+							(highlightSize.y/2)
+							+
+							(pad/2),
+							highlightSize.x, highlightSize.y)
+						+
+						Rect(w.bounds.left, w.bounds.top, 0, 0)),
+						symbolSize,
+						highlightColor
+						);
+					}; // od
+				};
+
+				// draw grid
+				if (drawGrid) {
+					var xticks = List.new, yticks = List.new;
+					var xlabels = List.new, ylabels = List.new;
+
+
+					gridResolution.x.do {|i|
+						var val, pos;
+						val = specX.minval + (((specX.maxval - specX.minval) / gridResolution.x) * (i+1));
+						pos = (specX.unmap(val) * width) + (pad/2);
+						xticks.add(pos);
+						xlabels.add(val.round(0.01).asString);
+					};
+
+					gridResolution.y.do {|i|
+						var val, pos;
+						val = specY.minval + (((specY.maxval - specY.minval) / gridResolution.y) * (i+1));
+						pos = ((1.0-specY.unmap(val)) * height) + (pad/2);
+						yticks.add(pos);
+						ylabels.add(val.round(0.01).asString);
+					};
+
+					Pen.color = gridColor;
+					xticks.do {|pos| Pen.line(pos@top, pos@(top+height)) };
+					yticks.do {|pos| Pen.line(left@pos, (left+width)@pos) };
+					Pen.stroke;
+
+					// Draw Labels
+					if(drawGridValues) {
+						xticks.do {|pos, i|
+							if(i != (gridResolution.x-1)) {
+								xlabels[i].drawAtPoint((pos-8)@(top+height+2));
+							};
 						};
-						// draw lines
-						adjustedData.do{|item, i|
-							GUI.pen.lineTo(
-								((item[0]  * width) + (pad/2))
-								 @
-								 (((1-item[1]) * height) + (pad/2)) 
-							 	  + 
-							 	  (w.bounds.left@w.bounds.top)
-							)
+						yticks.do {|pos, i|
+							if(i != (gridResolution.y-1)) {
+								Pen.rotate(-pi/2);
+								ylabels[i].drawAtPoint((pos.neg - 8)@(left-17));
+								Pen.rotate(pi/2);
+							};
 						};
-						if(drawMethod == \fill, {GUI.pen.fill},{GUI.pen.stroke});
-					});
-					
-					// highlight datapoint
-					if(isHighlight) {
-						highlightItem.do{|item|
-							cross.value((Rect(
-								(adjustedData[item][0]  * width) 
-								 - 
-								 (highlightSize.x/2) + (pad/2),
-								((1-adjustedData[item][1]) * height) 
-								 - 
-								 (highlightSize.y/2) 
-								  + 
-								  (pad/2), 
-								highlightSize.x, highlightSize.y) 
-								  + 
-								  Rect(w.bounds.left, w.bounds.top, 0, 0)),
-								symbolSize,
-								highlightColor
-							);
-						}; // od
-					};
-						// draw axis
-					if (drawAxis) {
-						GUI.pen.moveTo((w.bounds.left+(pad/2))@(w.bounds.top+(pad/2)));
-						GUI.pen.lineTo((w.bounds.left+(pad/2))@(w.bounds.top+w.bounds.height-(pad/2)));
-						GUI.pen.lineTo(
-							(w.bounds.left-(pad/2)+w.bounds.width)@(w.bounds.top+w.bounds.height-(pad/2)));
-						specX.minval.round(0.001).asString
-							.drawAtPoint(
-								(w.bounds.left+(pad/2)+10)@
-								(w.bounds.height-(pad/2)+10));
-						xAxisName
-							.drawAtPoint(
-								(w.bounds.left+(w.bounds.width/2))@
-								(w.bounds.height-(pad/2)+10));
-						specX.maxval.round(0.001).asString
-							.drawAtPoint(
-								(w.bounds.left+10+w.bounds.width-20-(pad/2))@
-								(w.bounds.height-(pad/2)+10));
-
-
-
-						GUI.pen.rotate(-pi/2); 
-						GUI.pen.translate(w.bounds.height.neg, 0);
-						specY.minval.round(0.001).asString
-							.drawAtPoint((pad/2)@(w.bounds.left+(pad/2) -20));
-						yAxisName.
-							drawAtPoint((w.bounds.height/2)@(w.bounds.left+(pad/2) -20));
-						specY.maxval.round(0.001).asString
-							.drawAtPoint((w.bounds.height - (pad/2))@(w.bounds.left+(pad/2) -20));
-						GUI.pen.translate(w.bounds.height, 0);
-						GUI.pen.rotate(pi/2);
-						GUI.pen.stroke;
+
 					};
-						// draw values
-					if (drawValues) {
-						adjustedData.do{|item, i|
-							data.at(i).round(0.001).asString.drawAtPoint(
-								((item[0]  * width) + (pad/2))
-								@
-								(((1-item[1]) * height) + (pad/2) + 10)
-							)
-						}
+				};
+
+				// draw axis
+				if (drawAxes) {
+					Pen.color = axisColor;
+					Pen.moveTo((w.bounds.left+(pad/2))@(w.bounds.top+(pad/2)));
+					Pen.lineTo((w.bounds.left+(pad/2))@(w.bounds.top+w.bounds.height-(pad/2)));
+					Pen.lineTo(
+						(w.bounds.left-(pad/2)+w.bounds.width)@(w.bounds.top+w.bounds.height-(pad/2)));
+					specX.minval.round(0.001).asString
+					.drawAtPoint(
+						(w.bounds.left+(pad/2)+5)@
+						(w.bounds.height-(pad/2)+10));
+					xAxisName
+					.drawAtPoint(
+						(w.bounds.left+(w.bounds.width/2))@
+						(w.bounds.height-(pad/2)+10));
+					specX.maxval.round(0.001).asString
+					.drawAtPoint(
+						(w.bounds.left+10+w.bounds.width-20-(pad/2))@
+						(w.bounds.height-(pad/2)+10));
+
+
+
+					Pen.rotate(-pi/2);
+					Pen.translate(w.bounds.height.neg, 0);
+					specY.minval.round(0.001).asString
+					.drawAtPoint((pad/2)@(w.bounds.left+(pad/2) -20));
+					yAxisName.
+					drawAtPoint((w.bounds.height/2)@(w.bounds.left+(pad/2) -20));
+					specY.maxval.round(0.001).asString
+					.drawAtPoint((w.bounds.height - (pad/2))@(w.bounds.left+(pad/2) -20));
+					Pen.translate(w.bounds.height, 0);
+					Pen.rotate(pi/2);
+					Pen.stroke;
+				};
+				// draw values
+				if (drawValues) {
+					Pen.color = valuesColor;
+					normalizedData.do{|item, i|
+						data.at(i).round(0.001).asString.drawAtPoint(
+							((item[0]  * width) + (pad/2))
+							@
+							(((1-item[1]) * height) + (pad/2) + 10)
+						)
 					}
-				}; // end GUI.pen.use
-			});
+				}
+			}; // end Pen.use
+		});
 	}
 	canFocus_ { arg state = false;
 		plot.canFocus_(state);
@@ -238,12 +494,44 @@ ScatterView {
 	}
 }
 
-ScatterView3d {
+/*
+@class ScatterView3d
+
+A simple 3-dimensional scatterplot with rotation.
+
+
+@usage
+
+// Generate some toy data with a linear relationship
+n = 100;
+x = Array.series(n, 0.0, 100 / n) + Array.fill(n, {rrand(-10.0, 10.0)}).round(0.01);
+y = Array.series(n, 1.0, 100 / n) + Array.fill(n, {rrand(-10.0, 10.0)}).round(0.01);
+z = Array.series(n, 1.0, 100 / n) + Array.fill(n, {rrand(-10.0, 10.0)}).round(0.01);
+p = x.collect {|item,i| [item, y[i], z[i]] }; // as points
+
+// Plot
+b = Rect(0,0, 800, 600);
+w = Window.new(bounds: b);
+j = ScatterView3d.new(w, b, p, [0,100].asSpec, [0,100].asSpec, [0,100].asSpec);
+j.symbolColor_(Color.black).drawMethod_(\fillRect).symbolSize_(5@5);
+w.front;
+
+Tdef('animate', {
+var i = 0;
+inf.do {
+j.rot(i, i, 0).refresh;
+i = i + 0.03;
+0.05.wait;
+};
+}).play(AppClock);
+
+*/
+ScatterView3d : View {
 	var scatterView;
 	var rotX, rotY, rotZ;
 	var specX, specY, specZ;
 	var data3d;
-	
+
 	*new {|parent, bounds, data, specX, specY, specZ, rotX = 0, rotY = 0, rotZ = 0|
 		^super.new.init3d(parent, bounds, data, specX, specY, specZ, rotX, rotY, rotZ);
 	}
@@ -251,7 +539,7 @@ ScatterView3d {
 	init3d {|parent, bounds, data, argspecX, argspecY, argspecZ, argrotX, argrotY, argrotZ|
 		specX = argspecX ? [0, 1].asSpec;
 		specY = argspecY ? specX.copy;
-		specZ = argspecY ? specX.copy;
+		specZ = argspecZ ? specX.copy;
 
 		rotX = argrotX;
 		rotY = argrotY;
@@ -265,69 +553,92 @@ ScatterView3d {
 		this.data = data;
 		this.refresh
 	}
+
 	data_{|data|
 		data3d = data.collect {|item|
 			Matrix.withFlatArray(3, 1, [
-				specX.unmap(item[0]), 
-				specY.unmap(item[1]), 
+				specX.unmap(item[0]),
+				specY.unmap(item[1]),
 				specZ.unmap(item[2])
 			] * 2 - 1);
 		};
 		scatterView.data = this.pr_project;
 
-//		highlightItem = min(highlightItem, (adjustedData.size-1));
+		//		highlightItem = min(highlightItem, (normalizedData.size-1));
 	}
+
 	refresh {
 		scatterView.refresh;
 	}
+
 	rotX_{|val|
 		this.rot(val, rotY, rotZ);
 	}
+
 	rotY_{|val|
 		this.rot(rotX, val, rotZ);
 	}
+
 	rotZ_{|val|
 		this.rot(rotX, rotY, val);
 	}
+
+	/*
+	@method
+	Rotation in radians
+	*/
 	rot {|rX, rY, rZ|
 		rotX = rX;
 		rotY = rY;
 		rotZ = rZ;
 		scatterView.data = this.pr_project;
 	}
+
 	drawMethod_{|method|
-		scatterView.drawMethod = method;		
+		scatterView.drawMethod = method;
 	}
+
 	symbolSize_{|val|
-		scatterView.symbolSize = val;		
+		scatterView.symbolSize = val;
 	}
+
 	symbolColor_{|val|
-		scatterView.symbolColor = val;		
+		scatterView.symbolColor = val;
 	}
+
 	isHighlight_{|val|
 		scatterView.isHighlight_(val);
 	}
+
 	highlightItem_{|item|
 		scatterView.highlightItem_(item);
 	}
+
 	highlightRange{|start, end|
 		scatterView.highlightRange(start, end);
 	}
+
 	highlightColor_{|color|
 		scatterView.highlightColor_(color);
 	}
+
 	highlightSize_{|size|
 		scatterView.highlightSize_(size);
 	}
-	background_{|val|
-		scatterView.background = val;		
+
+	backgroundColor_{|val|
+		scatterView.backgroundColor_(val);
 	}
+
 	resize{
 		^scatterView.resize
 	}
-	resize_{arg resize;
+
+	resize_{|resize|
 		scatterView.resize_(resize)
 	}
+
+
 	pr_project {
 		var cx, cy, sx, sy, sz, cz, projectionMatrix;
 		sx = sin(rotX);
@@ -337,15 +648,15 @@ ScatterView3d {
 		cx = cos(rotX);
 		cy = cos(rotY);
 		cz = cos(rotZ);
-			
+
 		projectionMatrix = Matrix.with([
 			[( (cy * cz) - (sx * sy * sz)), (sz.neg * cx), ((cz * sy) + (sz * sx * cy))],
 			[( (cy * sz) + (cz * sx * sy)), ( cz * cx),    ((sz * sy) - (sx * cy * cz))]
 		]);
-	
-	
+
+
 		^data3d.collect{|row|
 			(projectionMatrix * row).getCol(0)
 		};
 	}
-}
+}
\ No newline at end of file
diff --git a/classes/gui/ScatterView2.sc b/classes/gui/ScatterView2.sc
index 1486832..8109d9b 100644
--- a/classes/gui/ScatterView2.sc
+++ b/classes/gui/ScatterView2.sc
@@ -1,12 +1,54 @@
-// 2008 by till bovermann
-//   bielefeld university
+/*********************************************************************
+(C) 2008 Till Bovermann / Bielefeld University
 
+and later...
+
+(C) 2018 Jonathan Reus / IEM Graz
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program 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.
+
+    For more details see: https://www.gnu.org/licenses/
+**********************************************************************/
+
+
+
+
+
+
+
+/*
+@class ScatterView2
+
+A simple scatterplot with mouse select interaction.
+
+@usage
+
+n = 20;
+x = Array.series(n, 0.0, 100 / n) + Array.fill(n, {rrand(-10.0, 10.0)}).round(0.01);
+y = Array.series(n, 1.0, 100 / n) + Array.fill(n, {rrand(-10.0, 10.0)}).round(0.01);
+p = x.collect {|item,i| [item, y[i]] }; // as points
+
+b = Rect(0,0, 800, 600);
+w = Window.new(bounds: b);
+j = ScatterView2.new(w, b, p, [0,100].asSpec, [0,100].asSpec).itemSize_(5);
+w.front;
+
+*/
 ScatterView2 {
 	var <plot, <>background;
 
 	var <>colorFunc;
-	var <>itemSize = 2, <>drawMethod = \lineTo;
+	var <>itemSize = 2;
 
+	// TODO:
+	//var <>drawMethod = \lineTo;
 	//var <>highlightColor, <highlightItem, <>highlightSize, <>isHighlight, <>drawAxis, <>drawValues;
 	//var <>xAxisName, <>yAxisName;
 
@@ -20,7 +62,7 @@ ScatterView2 {
 	var selectionRect;
 	var <>action;
 
-	var <>mouseDownAction, <>mouseUpAction, <>mouseMoveAction, <mouseOverAction;	
+	var <>mouseDownAction, <>mouseUpAction, <>mouseMoveAction, <mouseOverAction;
 
 	*new {|parent, bounds, data, specX, specY|
 		^super.new.initPlot(
@@ -31,18 +73,22 @@ ScatterView2 {
 	mouseOverAction_{|func|
 		plot.mouseOverAction = func;
 	}
+
 	refresh {
 		plot.refresh;
 	}
+
 	data_{|data|
 		normedData = data.collect {|item|
 			[specX.unmap(item[0]), specY.unmap(item[1])];
 		};
 		numItems = normedData.size;
 	}
+
 	canFocus_ { arg state = false;
 		plot.canFocus_(state);
 	}
+
 	canFocus {
 		^plot.canFocus;
 	}
@@ -50,29 +96,36 @@ ScatterView2 {
 	visible_ { arg bool;
 		plot.visible_(bool)
 	}
+
 	visible {
 		^plot.visible
 	}
+
 	select{|indices|
 		this.prSelect(indices);
 		plot.refresh;
 	}
+
 	selection{
 		^selected.selectIndex{|elem| elem};
 		//{|elem|elem}
 	}
+
 	prSelect{|indices|
 		selected = false!numItems;
 		indices.asArray.do{|idx|
 			selected[idx] = true;
 		};
 	}
+
 	initPlot {|parent, bounds, data, argSpecX, argSpecY|
-		
+
 		specX = argSpecX ? [0,1].asSpec;
 		specY = argSpecY ? specX.copy;
 		this.data_(data);
 
+		action = {|vals| vals.postln };
+
 		colorFunc = {|idx, selected| selected.if({Color.red}, {Color.red(0.5, 0.5)})};
 		background = Color.white;
 
@@ -98,59 +151,61 @@ ScatterView2 {
 
 		selected = false!numItems;
 
-		plot = GUI.userView.new(parent,bounds).relativeOrigin_(true);
+		plot = UserView.new(parent,bounds);
 
 		plot.drawFunc = {|view|
 			var mult = view.bounds.extent.asArray;
 
 			// clipping into the boundingbox
-			GUI.pen.addRect( view.bounds.moveTo( 0, 0 ));
-			GUI.pen.clip;
-			// draw Background
-			GUI.pen.color = background;
-			GUI.pen.addRect( view.bounds.moveTo( 0, 0 ));
-			GUI.pen.fill;
+			Pen.addRect( view.bounds.moveTo( 0, 0 ));
+			Pen.clip;
 
+			// draw Background
+			Pen.color = background;
+			Pen.addRect( view.bounds.moveTo( 0, 0 ));
+			Pen.fill;
 
 			normedData.do{|pos, i|
-				GUI.pen.color = colorFunc.value(i, selected[i]);
-				GUI.pen.fillRect(((pos * mult  - (itemSize*0.5)) ++ (itemSize!2)).asRect)
+				Pen.color = colorFunc.value(i, selected[i]);
+				Pen.fillRect(((pos * mult  - (itemSize*0.5)) ++ (itemSize!2)).asRect)
 			};
 
 			// draw selection
 			selectionRect.notNil.if{
-				GUI.pen.color = Color.gray(1, 0.3);
-				GUI.pen.fillRect(selectionRect);
-				GUI.pen.color = Color.blue(0.3, 0.6);
-				GUI.pen.strokeRect(selectionRect);
+				Pen.color = Color.gray(1, 0.3);
+				Pen.fillRect(selectionRect);
+				Pen.color = Color.blue(0.3, 0.6);
+				Pen.strokeRect(selectionRect);
 			}
 		};
+
 		plot.mouseDownAction = {|view, x, y, modifiers, buttonNumber, clickCount|
 			var rMult, pos, normedPos, normedItemSize, threshold, index;
-	
+
 			(clickCount == 1).if{
 				pos = [x, y]-view.bounds.leftTop.asArray;
-				
+
 				rMult = view.bounds.extent.asArray.reciprocal;
 				normedPos = pos * rMult;
 				normedItemSize = itemSize * rMult;
 				normedItemSize = min(normedItemSize[0], normedItemSize[1]);
-	
+
 				this.prSelect(selectModes[selectionMode].value(
-					view, 
-					normedData, 
-					normedPos, 
+					view,
+					normedData,
+					normedPos,
 					normedItemSize,
 					selectRegion
 				));
-			};			
-			mouseDownAction.value(this, x, y, modifiers, buttonNumber, clickCount);		};
+			};
+			mouseDownAction.value(this, x, y, modifiers, buttonNumber, clickCount);
+		};
+
 		// draw a rect
 		plot.mouseMoveAction = {|view, x, y, modifiers|
 			var pos;
-			
 			pos = [x, y]-view.bounds.leftTop.asArray;
-	
+
 			selectionRect.isNil.if({
 				selected = false!numItems;
 				selectionRect = (pos++[0, 0]).asRect;
@@ -165,9 +220,10 @@ ScatterView2 {
 			});
 			mouseMoveAction.value(this, x, y, modifiers);
 		};
+
 		plot.mouseUpAction = {|view, x, y, modifiers|
 			var mult = view.bounds.extent.asArray;
-	
+
 			selectionRect.notNil.if{
 				if(selectionRect.width<0){
 					selectionRect.left = selectionRect.left + selectionRect.width;
@@ -177,18 +233,14 @@ ScatterView2 {
 					selectionRect.top = selectionRect.top + selectionRect.height;
 					selectionRect.height = selectionRect.height.neg;
 				};
-	
+
 				selected = normedData.collect{|dat|
 					selectionRect.containsPoint((dat*mult).asPoint)
 				};
 			};
 			selectionRect = nil;
 			plot.refresh;
-			action.value(
-				selected.selectIndex{|item, i|
-					item
-				}
-			);
+			action.value(selected);
 			mouseUpAction.value(this, x, y, modifiers)
 		};
 	}
diff --git a/classes/various/Matrix.sc b/classes/various/Matrix.sc
index e7ec47e..f10b59b 100644
--- a/classes/various/Matrix.sc
+++ b/classes/various/Matrix.sc
@@ -148,8 +148,10 @@ Matrix[slot] : Array {
 		});
 	}
 	// single elements
-	at { arg row, col;
-		^super.at(row).at(col);
+	at { arg row, col=nil;
+		var r = super.at(row);
+		if(col.notNil) { r = r.at(col) };
+		^r;
 	}
 	get { arg row, col; // same as at
 		^super.at(row).at(col);
@@ -170,7 +172,7 @@ Matrix[slot] : Array {
 		},{
 			(vals.size).min(this.cols).do({ arg col;
 				this.put(row, col, vals.at(col))
-			});"Warning: wrong number of vals".postln;
+			});"Warning: wrong number of vals: % received and % expected".format(vals.size, this.cols).postln;
 		})
 	}
 	putCol { arg col, vals;
@@ -181,7 +183,7 @@ Matrix[slot] : Array {
 		},{
 			(vals.size).min(this.rows).do({ arg row;
 				this.put(row, col, vals.at(row))
-			});"Warning: wrong number of vals".postln;
+			});"Warning: wrong number of vals: % received and % expected".format(vals.size, this.cols).postln;
 		});
 	}
 
@@ -207,7 +209,7 @@ Matrix[slot] : Array {
 		this.putCol(posA, this.getCol(posB) );
 		this.putCol(posB, colA);
 	}
-	collect { arg func;
+	collectRowsCols { arg func;
 		var res; res = Matrix.newClear(this.rows, this.cols);
 		this.rows.do({ arg row;
 			this.cols.do({ arg col;
@@ -217,16 +219,43 @@ Matrix[slot] : Array {
 		^res;
 	}
 
+	// collect rows, where row length of the matrix is arbitrary
+	collectRows {arg func;
+		var res, firstRow;
+		if(this.rows<1) { ^this };
+		firstRow = func.value(this.at(0),0);
+		res = Matrix.newClear(this.rows, firstRow.size);
+		res.putRow(0, firstRow);
+		this.rows.do({arg row;
+			if(row>0) { res.putRow(row, func.value(this.at(row))) };
+		});
+		^res;
+	}
+
+	// collect columns, where column length of the new matrix is arbitrary
+	collectCols {arg func;
+		var res, firstCol;
+		if(this.cols<1) { ^this };
+		firstCol = func.value(this.getCol(0), 0);
+		res = Matrix.newClear(firstCol.size, this.cols);
+		res.putCol(0, firstCol);
+		this.cols.do({arg col;
+			if(col>0) { res.putCol(col, func.value(this.getCol(col))) };
+		});
+		^res;
+	}
+
 	addRow { arg rowVals;
 		var res;
-		if( (rowVals.flat.size == this.cols)
-		.and(rowVals.every({arg element; element.isNumber}) ),{
+		if( (this.rows == 0).or((rowVals.flat.size == this.cols)
+			.and(rowVals.every({arg element; element.isNumber}))), {
 			res = this.copy;
 			res = res.add(rowVals);
-			^res},{
+			^res }, {
 			error("wrong type or size in Matrix-addRow");this.halt;
 		});
 	}
+
 	insertRow { arg col, rowVals;
 		var res;
 		if( (rowVals.flat.size == this.cols)
@@ -239,8 +268,8 @@ Matrix[slot] : Array {
 	}
 	addCol { arg colVals;
 		var res;
-		if( (colVals.flat.size == this.rows)
-		.and(colVals.every({arg element; element.isNumber}) ),{
+		if( (this.rows == 0).or((colVals.flat.size == this.rows)
+			.and(colVals.every({arg element; element.isNumber}))), {
 			res = Matrix.newClear(this.rows, this.cols+1);
 			res.rows.do({ arg row;
 				var rowArray;
@@ -248,7 +277,7 @@ Matrix[slot] : Array {
 				rowArray = rowArray.add(colVals.at(row));
 				res.putRow( row, rowArray);
 			});
-			^res},{
+			^res}, {
 			error("wrong type or size in Matrix-addCol");this.halt;
 		});
 	}