Add a DataPoint, and DataPoint collection to keep track of the data in the algorithm

Author: Agathe Lenclen

examples/UsingSquarify/UsingSquarify.pde

@@ -9,7 +9,7 @@ float CANVAS_ORIGIN_X = 0;    // The x origin of the canvas to fill
 float CANVAS_ORIGIN_Y = 0;    // The y origin of the canvas to fill
 
 // SQUARIFY DATA
-ArrayList<SquarifiedRect> rects;  // The rects list will contain geometry for each rectangle to draw
+ArrayList<SquarifyRect> rects;  // The rects list will contain geometry for each rectangle to draw
 ArrayList<Float> values = new ArrayList<Float>(Arrays.asList(50f, 25f, 100f, 10f, 75f)); // Values defining the squarified layout
 
 void setup() {
@@ -25,13 +25,14 @@ void draw() {
 
   for (int i = 0; i < rects.size(); i++) {
     // Draw a rectangle
-    SquarifiedRect r = rects.get(i);
+    SquarifyRect r = rects.get(i);
     fill(map(r.getValue(), 0, 100, 50, 255));
     rect(r.getX(), r.getY(), r.getDx(), r.getDy());
 
     // Draw rectangle value
+    textAlign(CENTER, CENTER);
     textSize(14);
     fill(0);
-    text(round(r.getValue()), r.getX() + r.getDx()/2, r.getY() + r.getDy()/2);
+    text("Id: " + r.getId() + ", Value: " + round(r.getValue()), r.getX() + r.getDx()/2, r.getY() + r.getDy()/2);
    }
 }

src/squarify/library/Squarify.java

@@ -1,9 +1,10 @@
 package squarify.library;
 
 import java.util.ArrayList;
-import java.util.Collections;
 import java.util.List;
 
+import squarify.library.SquarifyData.DataPoint;
+
 /**
  * A class to generate a squarified treemap layout from a set of values.
  * 
@@ -13,82 +14,31 @@
 
 public class Squarify {
 
-	private ArrayList<SquarifiedRect> rects;
-	private ArrayList<Float> sizes;
-	private float width, height;
+	private ArrayList<SquarifyRect> rects;
+	private SquarifyData data;
 
 	public Squarify(ArrayList<Float> sizes, float x, float y, float width, float height) {
-		this.width = width;
-		this.height = height;
-		this.sizes = this.sortDescending(sizes);
-		
-		List<Float> values = this.normalizeSizes(this.sizes, width, height);
-		rects = squarify(values, x, y, width, height);
+		data = new SquarifyData(sizes, width, height);
+		rects = squarify(data.getDataPoints(), x, y, width, height);
 	}
 
 	/**
 	 * Getter for the list of rectangle's geometry
 	 * @return rects
 	 */
-	public ArrayList<SquarifiedRect> getRects() {
+	public ArrayList<SquarifyRect> getRects() {
 		return this.rects;
 	}
-	
-	/**
-	 * Helper that sorts a list in descending order
-	 * @param s A list of values
-	 * @return The list of values ordered descending
-	 */
-	private ArrayList<Float> sortDescending(ArrayList<Float> s) {
-		Collections.sort(s);
-		Collections.reverse(s);
-		return s;
-	}
-	
-	/**
-	 * Helper that normalizes the sizes to the proportion of the canvas. 
-	 * 
-	 * @param sizes  A list of values to squarify
-	 * @param width  The canvas width
-	 * @param height The canvas height
-	 * @return
-	 */
-	private ArrayList<Float> normalizeSizes(ArrayList<Float> sizes, float width, float height) {
-		float totalSize = sum(sizes);
-		float totalArea = width * height;
-		ArrayList<Float> normalized = new ArrayList<Float>(sizes.size());
 
-		for (int i = 0; i < sizes.size(); i++) {
-			normalized.add(sizes.get(i) * totalArea / totalSize);
-		}
-		return normalized;
-	}
-	
-	/**
-	 * Helper that denormalized a normalized size to its original value
-	 * This helper is only needed if you want to print the size in the rectangles on your canvas.
-	 * 
-	 * @param sizes 			The list of sizes to squarify 
-	 * @param normalizedValue   The normalized size to reverse
-	 * @param width  The canvas width
-	 * @param height The canvas height
-	 * @return
-	 */
-	private Float denormalizeSize(ArrayList<Float> sizes, float normalizedValue, float width, float height) {
-		float totalSize = sum(sizes);
-		float totalArea = width * height;
-		return (float) normalizedValue * totalSize / totalArea;
-	}
-	
 	/** 
-	 * Helper that sums all the values of float list
-	 * @param values A list of float values
+	 * Helper that sums all the values of DataPoint
+	 * @param values A list of DataPoint values
 	 * @return The sum of these values
 	 */
-	private float sum(List<Float> values) {
+	private float sumNormalizedValues(List<DataPoint> l) {
 		float result = 0;
-		for (int i = 0; i < values.size(); i++) {
-			result += values.get(i);
+		for (int i = 0; i < l.size(); i++) {
+			result += l.get(i).getNormalizedValue();
 		}
 		return result;
 	}
@@ -105,13 +55,13 @@ private float sum(List<Float> values) {
 	 * @param dy
 	 * @return
 	 */
-	private ArrayList<SquarifiedRect> layoutRow(List<Float> values, float x, float y, float dx, float dy) {
-		float coveredArea = sum(values);
+	private ArrayList<SquarifyRect> layoutRow(List<DataPoint> values, float x, float y, float dx, float dy) {
+		float coveredArea = sumNormalizedValues(values);
 		float width = coveredArea / dy;
-		ArrayList<SquarifiedRect> rects = new ArrayList<SquarifiedRect>();
+		ArrayList<SquarifyRect> rects = new ArrayList<SquarifyRect>();
 		for (int i = 0; i < values.size(); i++) {
-			rects.add(new SquarifiedRect(x, y, width, values.get(i) / width,  denormalizeSize(this.sizes, values.get(i), this.width, this.height)));
-			y += values.get(i) / width;
+			rects.add(new SquarifyRect(x, y, width, values.get(i).getNormalizedValue() / width, values.get(i).getId(), values.get(i).getValue()));
+			y += values.get(i).getNormalizedValue() / width;
 		}
 		return rects;
 	}
@@ -128,13 +78,13 @@ private ArrayList<SquarifiedRect> layoutRow(List<Float> values, float x, float y
 	 * @param dy
 	 * @return
 	 */
-	private ArrayList<SquarifiedRect> layoutCol(List<Float> values, float x, float y, float dx, float dy) {
-		float coveredArea = sum(values);
+	private ArrayList<SquarifyRect> layoutCol(List<DataPoint> values, float x, float y, float dx, float dy) {
+		float coveredArea = sumNormalizedValues(values);
 		float height = coveredArea / dx;
-		ArrayList<SquarifiedRect> rects = new ArrayList<SquarifiedRect>();
+		ArrayList<SquarifyRect> rects = new ArrayList<SquarifyRect>();
 		for (int i = 0; i < values.size(); i++) {
-			rects.add(new SquarifiedRect(x, y, values.get(i) / height, height, denormalizeSize(this.sizes, values.get(i), this.width, this.height)));
-			x += values.get(i) / height;
+			rects.add(new SquarifyRect(x, y, values.get(i).getNormalizedValue() / height, height, values.get(i).getId(), values.get(i).getValue()));
+			x += values.get(i).getNormalizedValue() / height;
 		}
 		return rects;
 	}
@@ -148,14 +98,14 @@ private ArrayList<SquarifiedRect> layoutCol(List<Float> values, float x, float y
 	 * @param dy
 	 * @return
 	 */
-	private SquarifiedRect leftoverRow(List<Float> values, float x, float y, float dx, float dy) {
-		float coveredArea = sum(values);
+	private SquarifyRect leftoverRow(List<DataPoint> values, float x, float y, float dx, float dy) {
+		float coveredArea = sumNormalizedValues(values);
 		float width = coveredArea / dy;
 		float leftoverX = x + width;
 		float leftoverY = y;
 		float leftoverDx = dx - width;
 		float leftoverDy = dy;
-		return new SquarifiedRect(leftoverX, leftoverY, leftoverDx, leftoverDy);
+		return new SquarifyRect(leftoverX, leftoverY, leftoverDx, leftoverDy);
 	}
 
 	/**
@@ -167,14 +117,14 @@ private SquarifiedRect leftoverRow(List<Float> values, float x, float y, float d
 	 * @param dy
 	 * @return
 	 */
-	private SquarifiedRect leftoverCol(List<Float> values, float x, float y, float dx, float dy) {
-		float coveredArea = sum(values);
+	private SquarifyRect leftoverCol(List<DataPoint> values, float x, float y, float dx, float dy) {
+		float coveredArea = sumNormalizedValues(values);
 		float height = coveredArea / dx;
 		float leftoverX = x;
 		float leftoverY = y + height;
 		float leftoverDx = dx;
 		float leftoverDy = dy - height;
-		return new SquarifiedRect(leftoverX, leftoverY, leftoverDx, leftoverDy);
+		return new SquarifyRect(leftoverX, leftoverY, leftoverDx, leftoverDy);
 	}
 
 	/**
@@ -186,7 +136,7 @@ private SquarifiedRect leftoverCol(List<Float> values, float x, float y, float d
 	 * @param dy
 	 * @return
 	 */
-	private SquarifiedRect leftover(List<Float> values, float x, float y, float dx, float dy) {
+	private SquarifyRect leftover(List<DataPoint> values, float x, float y, float dx, float dy) {
 		if (dx >= dy) {
 			return leftoverRow(values, x, y, dx, dy);
 		}
@@ -202,7 +152,7 @@ private SquarifiedRect leftover(List<Float> values, float x, float y, float dx,
 	 * @param dy
 	 * @return
 	 */
-	private ArrayList<SquarifiedRect> layout(List<Float> values, float x, float y, float dx, float dy) {
+	private ArrayList<SquarifyRect> layout(List<DataPoint> values, float x, float y, float dx, float dy) {
 		if (dx >= dy) {
 			return layoutRow(values, x, y, dx, dy);
 		}
@@ -219,8 +169,8 @@ private ArrayList<SquarifiedRect> layout(List<Float> values, float x, float y, f
 	 * @param dy
 	 * @return
 	 */
-	private float worstRatio(List<Float> values, float x, float y, float dx, float dy) {
-		ArrayList<SquarifiedRect> rects = layout(values, x, y, dx, dy);
+	private float worstRatio(List<DataPoint> values, float x, float y, float dx, float dy) {
+		ArrayList<SquarifyRect> rects = layout(values, x, y, dx, dy);
 		float max = 0;
 		for (int i = 0; i < rects.size(); i++) {
 			float rectDx = rects.get(i).getDx();
@@ -242,15 +192,15 @@ private float worstRatio(List<Float> values, float x, float y, float dx, float d
 	 * @param dy     Current height of leftover canvas
 	 * @return
 	 */
-	private ArrayList<SquarifiedRect> squarify(List<Float> values, float x, float y, float dx, float dy) {
-		ArrayList<SquarifiedRect> rects = new ArrayList<SquarifiedRect>();
+	private ArrayList<SquarifyRect> squarify(List<DataPoint> values, float x, float y, float dx, float dy) {
+		ArrayList<SquarifyRect> rects = new ArrayList<SquarifyRect>();
 
 		if (values.size() == 0) {
 	        return rects;
 		}
 
 		if (values.size() == 1) {
-			rects.add(new SquarifiedRect(x, y, dx, dy, denormalizeSize(this.sizes, values.get(0), this.width, this.height)));
+			rects.add(new SquarifyRect(x, y, dx, dy, values.get(0).getId(), values.get(0).getValue()));
 			return rects;
 		}
 
@@ -259,10 +209,10 @@ private ArrayList<SquarifiedRect> squarify(List<Float> values, float x, float y,
 			i += 1;
 		}
 
-		List<Float> current = values.subList(0, i);
-		List<Float> remaining = values.subList(i, values.size());
+		List<DataPoint> current = values.subList(0, i);
+		List<DataPoint> remaining = values.subList(i, values.size());
 
-		SquarifiedRect currentLeftover = leftover(current, x, y, dx, dy);
+		SquarifyRect currentLeftover = leftover(current, x, y, dx, dy);
 		rects.addAll(layout(current, x, y, dx, dy));
 		rects.addAll(squarify(remaining, currentLeftover.getX(), currentLeftover.getY(), currentLeftover.getDx(), currentLeftover.getDy()));
 		return rects;

src/squarify/library/SquarifyData.java

@@ -0,0 +1,129 @@
+package squarify.library;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.List;
+
+
+public class SquarifyData {
+	private ArrayList<DataPoint> data;	// List of data points holding value, normalized value and id
+	private static float totalSize;	 	// Total size of values
+	private static float totalArea;	 	// Total area of canvas
+	private static int length;			// Total amount of values
+	
+	public SquarifyData(ArrayList<Float> values, float width, float height) {
+		// Process data
+		this.data = new ArrayList<DataPoint>();
+		setValues(values);
+		sortDescending();
+		
+		// Compute values
+		totalSize = sumValues(this.data);
+		length = values.size();
+		totalArea = width * height;
+		
+		// Normalize data to canvas area
+		normalize();
+	}
+	
+	/**
+	 * Helper that sorts a list in descending order
+	 * @param s A list of values
+	 * @return The list of values ordered descending
+	 */
+	private void sortDescending() {
+		Collections.sort(this.data, new Comparator<DataPoint>() {
+		    @Override
+		    public int compare(DataPoint a1, DataPoint a2) {
+		        return Float.compare(a1.getValue(), a2.getValue());
+		    }
+		});
+		Collections.reverse(this.data);
+	}
+
+	/**
+	 * Create one DataPoint per size value
+	 * @param values
+	 */
+	private void setValues(ArrayList<Float> values) {
+		for (int i = 0; i < values.size(); i++) {
+			data.add(new DataPoint(i, values.get(i)));
+		}
+	}
+	
+	/**
+	 * Normalize data to canvas area
+	 */
+	private void normalize() {
+		for (int i = 0; i < this.data.size(); i++) {
+			this.data.get(i).normalize();
+		}
+	}
+	
+	/** 
+	 * Helper that sums all the values of DataPoint
+	 * @param values A list of DataPoint values
+	 * @return The sum of these values
+	 */
+	private float sumValues(List<DataPoint> l) {
+		float result = 0;
+		for (int i = 0; i < l.size(); i++) {
+			result += l.get(i).getValue();
+		}
+		return result;
+	}
+	
+	public float getTotalSize() {
+		return totalSize;
+	}
+	
+	public int getLength() {
+		return length;
+	}
+	
+	public ArrayList<DataPoint> getDataPoints() {
+		return this.data;
+	}
+	
+	public DataPoint getDataPoint(int i) {
+		return this.data.get(i);
+	}
+	
+	/**
+	 * DataPoint holds the original size value passed as parameter to Squarify
+	 * It also stores the id of the value, to keep track of it as the squarify
+	 * algorithm requires to sort values descending.
+	 * @author agathelenclen
+	 *
+	 */
+	public class DataPoint {
+		private float value;
+		private float normalizedValue;
+		private int id;
+		
+		public DataPoint(int id, float value) {
+			this.id = id;
+			this.value = value;
+		}
+		
+		/**
+		 * Normalizes the value size to the proportion of the canvas. 
+		 */
+		private void normalize() {
+			this.normalizedValue = this.value * totalArea / totalSize;
+		}
+		
+		public float getValue() {
+			return value;
+		}
+		
+		public float getNormalizedValue() {
+			return normalizedValue;
+		}
+	
+		public int getId() {
+			return id;
+		}
+	}
+}