ruby_wordcram 1.0.1 → 2.0.0

data/src/wordcram/BBTree.java

@@ -0,0 +1,133 @@
+package wordcram;
+
+import java.util.ArrayList;
+
+import processing.core.PGraphics;
+
+public class BBTree {
+
+    private final int left;
+    private final int top;
+    private final int right;
+    private final int bottom;
+    private BBTree[] kids;
+
+    private BBTree parent;
+    private int rootX;
+    private int rootY;
+
+    private int swelling = 0;
+
+    BBTree(int left, int top, int right, int bottom) {
+        this.left = left;
+        this.top = top;
+        this.right = right;
+        this.bottom = bottom;
+    }
+
+    void addKids(BBTree... _kids) {
+        ArrayList<BBTree> kidList = new ArrayList<>();
+        for (BBTree kid : _kids) {
+            if (kid != null) {
+                kidList.add(kid);
+		kid.parent = this;
+            }
+        }
+
+        kids = kidList.toArray(new BBTree[0]);
+    }
+
+    public void setLocation(int left, int top) {
+    	rootX = left;
+    	rootY = top;
+    }
+
+    private BBTree getRoot() {
+	   return parent == null ? this : parent.getRoot();
+    }
+
+    public boolean overlaps(BBTree otherTree) {
+        if (rectCollide(this, otherTree)) {
+            if (this.isLeaf() && otherTree.isLeaf()) {
+                return true;
+            }
+            else if (this.isLeaf()) {  // Then otherTree isn't a leaf.
+                for (BBTree otherKid : otherTree.kids) {
+                    if (this.overlaps(otherKid)) {
+                        return true;
+                    }
+                }
+            }
+            else {
+                for (BBTree myKid : this.kids) {
+                    if (otherTree.overlaps(myKid)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean rectCollide(BBTree aTree, BBTree bTree) {
+        int[] a = aTree.getPoints();
+        int[] b = bTree.getPoints();
+
+        return a[3] > b[1] && a[1] < b[3] && a[2] > b[0] && a[0] < b[2];
+    }
+
+    private int[] getPoints() {
+	BBTree root = getRoot();
+        return new int[] {
+                root.rootX - swelling + left,
+                root.rootY - swelling + top,
+                root.rootX + swelling + right,
+                root.rootY + swelling + bottom
+        };
+    }
+
+    boolean containsPoint(float x, float y) {
+        BBTree root = getRoot();
+        return root.rootX + this.left < x &&
+            root.rootX + this.right > x &&
+            root.rootY + this.top < y &&
+            root.rootY + this.bottom > y;
+    }
+
+    boolean isLeaf() {
+        return kids == null;
+    }
+
+    void swell(int extra) {
+        swelling += extra;
+        if (!isLeaf()) {
+            for (BBTree kid : kids) {
+                kid.swell(extra);
+            }
+        }
+    }
+
+    public void draw(PGraphics g) {
+        g.pushStyle();
+        g.noFill();
+
+        g.stroke(30, 255, 255, 50);
+        drawLeaves(g);
+
+        g.popStyle();
+    }
+
+    private void drawLeaves(PGraphics g) {
+        if (this.isLeaf()) {
+            drawBounds(g, getPoints());
+        } else {
+            for (BBTree kid : kids) {
+                kid.drawLeaves(g);
+            }
+        }
+    }
+
+    private void drawBounds(PGraphics g, int[] rect) {
+        g.rect(rect[0], rect[1], rect[2], rect[3]);
+    }
+}

data/src/wordcram/BBTreeBuilder.java

@@ -0,0 +1,61 @@
+package wordcram;
+
+import java.awt.Shape; // awt: getBounds2D(), contains(box), intersects(box)
+import java.awt.geom.Rectangle2D; // awt: from shape bounding box, getX() and Y(), width() and height()
+
+public class BBTreeBuilder {
+    public BBTree makeTree(Shape shape, int swelling) {
+        Rectangle2D bounds = shape.getBounds2D();
+        int minBoxSize = 1;
+        int x = (int) bounds.getX();
+        int y = (int) bounds.getY();
+        int right = x + (int) bounds.getWidth();
+        int bottom = y + (int) bounds.getHeight();
+
+        BBTree tree = makeTree(shape, minBoxSize, x, y, right, bottom);
+        tree.swell(swelling);
+        return tree;
+    }
+
+    private BBTree makeTree(Shape shape, int minBoxSize, int x, int y,
+            int right, int bottom) {
+
+        int width = right - x;
+        int height = bottom - y;
+
+        if (shape.contains(x, y, width, height)) {
+            return new BBTree(x, y, right, bottom);
+        }
+        else if (shape.intersects(x, y, width, height)) {
+            BBTree tree = new BBTree(x, y, right, bottom);
+
+            boolean tooSmallToContinue = width <= minBoxSize;
+            if (!tooSmallToContinue) {
+                int centerX = avg(x, right);
+                int centerY = avg(y, bottom);
+
+                // upper left
+                BBTree t0 = makeTree(shape, minBoxSize, x, y, centerX, centerY);
+                // upper right
+                BBTree t1 = makeTree(shape, minBoxSize, centerX, y, right, centerY);
+                // lower left
+                BBTree t2 = makeTree(shape, minBoxSize, x, centerY, centerX, bottom);
+                // lower right
+                BBTree t3 = makeTree(shape, minBoxSize, centerX, centerY, right, bottom);
+
+                tree.addKids(t0, t1, t2, t3);
+            }
+
+            return tree;
+        }
+        else {  // neither contains nor intersects
+            return null;
+        }
+    }
+
+    private int avg(int a, int b) {
+        // reminder: x >> 1 == x / 2
+        // avg = (a+b)/2 = (a/2)+(b/2) = (a>>1)+(b>>1)
+        return (a + b) >> 1;
+    }
+}

data/src/wordcram/Colorers.java

@@ -0,0 +1,52 @@
+package wordcram;
+
+import java.util.Random;
+
+import processing.core.PApplet;
+
+public class Colorers {
+
+    public static WordColorer twoHuesRandomSats(final PApplet host) {
+
+        final float[] hues = new float[] { host.random(256), host.random(256) };
+
+        return new HsbWordColorer(host) {
+            @Override
+            public int getColorFor(Word w) {
+
+                float hue = hues[(int)host.random(hues.length)];
+                float sat = host.random(256);
+                float val = host.random(100, 256);
+
+                return host.color(hue, sat, val);
+            }
+        };
+    }
+
+    public static WordColorer twoHuesRandomSatsOnWhite(final PApplet host) {
+
+        final float[] hues = new float[] { host.random(256), host.random(256) };
+
+        return new HsbWordColorer(host) {
+            @Override
+            public int getColorFor(Word w) {
+
+                float hue = hues[(int)host.random(hues.length)];
+                float sat = host.random(256);
+                float val = host.random(156);
+
+                return host.color(hue, sat, val);
+            }
+        };
+    }
+
+    public static WordColorer pickFrom(final int... colors) {
+        final Random r = new Random();
+        return (Word w) -> colors[r.nextInt(colors.length)];
+    }
+
+    // TODO add an overload that takes 1 int (greyscale), 2 ints (greyscale/alpha), etc
+    public static WordColorer alwaysUse(final int color) {
+        return (Word w) -> color;
+    }
+}

data/src/wordcram/EngineWord.java

@@ -0,0 +1,73 @@
+package wordcram;
+
+import java.awt.Shape;  // awt: holds it; from the Word
+import java.awt.geom.AffineTransform;  // awt: for translating shapes
+
+import processing.core.PVector;
+
+class EngineWord {
+    Word word;
+    int rank;
+
+    private Shape shape;
+    private final BBTreeBuilder bbTreeBuilder;
+    private BBTree bbTree;
+
+    private PVector desiredLocation;
+    private PVector currentLocation;
+
+    EngineWord(Word word, int rank, int wordCount, BBTreeBuilder bbTreeBuilder) {
+        this.word = word;
+        this.rank = rank;
+        this.bbTreeBuilder = bbTreeBuilder;
+        word.setEngineWord(this);
+    }
+
+    void setShape(Shape shape, int swelling) {
+        this.shape = shape;
+        this.bbTree = bbTreeBuilder.makeTree(shape, swelling);
+    }
+
+    Shape getShape() {
+        return shape;
+    }
+
+    boolean overlaps(EngineWord other) {
+        return bbTree.overlaps(other.bbTree);
+    }
+
+
+    boolean containsPoint(float x, float y) {
+        return bbTree.containsPoint(x, y);
+    }
+
+    void setDesiredLocation(WordPlacer placer, int count, int wordImageWidth, int wordImageHeight, int fieldWidth, int fieldHeight) {
+        desiredLocation = word.getTargetPlace(placer, rank, count, wordImageWidth, wordImageHeight, fieldWidth, fieldHeight);
+        currentLocation = desiredLocation.copy();
+    }
+
+    void nudge(PVector nudge) {
+        currentLocation = PVector.add(desiredLocation, nudge);
+        bbTree.setLocation((int)currentLocation.x, (int)currentLocation.y);
+    }
+
+    void finalizeLocation() {
+        AffineTransform transform = AffineTransform.getTranslateInstance(
+                currentLocation.x, currentLocation.y);
+        shape = transform.createTransformedShape(shape);
+        bbTree.setLocation((int)currentLocation.x, (int)currentLocation.y);
+        word.setRenderedPlace(currentLocation);
+    }
+
+    PVector getCurrentLocation() {
+        return currentLocation.copy();
+    }
+
+    boolean wasPlaced() {
+        return word.wasPlaced();
+    }
+
+    boolean wasSkipped() {
+        return word.wasSkipped();
+    }
+}

data/src/wordcram/Fonters.java

@@ -0,0 +1,17 @@
+package wordcram;
+
+import java.util.Random;
+
+import processing.core.PFont;
+
+public class Fonters {
+
+    public static WordFonter alwaysUse(final PFont pfont) {
+        return (Word word) -> pfont;
+    }
+
+    public static WordFonter pickFrom(final PFont... fonts) {
+        final Random r = new Random();
+        return (Word w) -> fonts[r.nextInt(fonts.length)];
+    }
+}

data/src/wordcram/HsbWordColorer.java

@@ -0,0 +1,28 @@
+package wordcram;
+
+import processing.core.PApplet;
+import processing.core.PConstants;
+
+abstract class HsbWordColorer implements WordColorer {
+    private PApplet host;
+    private int range;
+
+    HsbWordColorer(PApplet host) {
+        this(host, 255);
+    }
+    HsbWordColorer(PApplet host, int range) {
+        this.host = host;
+        this.range = range;
+    }
+
+    @Override
+    public int colorFor(Word word) {
+        host.pushStyle();
+        host.colorMode(PConstants.HSB, range);
+        int color = getColorFor(word);
+        host.popStyle();
+        return color;
+    }
+
+    abstract int getColorFor(Word word);
+}

data/src/wordcram/ImageShaper.java

@@ -0,0 +1,91 @@
+package wordcram;
+
+import java.awt.Shape;
+import java.awt.Rectangle;
+import java.awt.geom.Area;
+import processing.core.PImage;
+import java.util.ArrayList;
+
+public class ImageShaper {
+
+	public Shape shape(PImage image, int color) {
+		RectTree tree = new RectTree(0, 0, image.width, image.height);
+		return tree.toShape(image, color);
+	}
+
+	// TODO combine this somehow with BBTree(Builder). It's the same idea.
+	class RectTree {
+		ArrayList<RectTree> kids = null;
+
+		int left; int top; int right; int bottom;
+		int width; int height;
+		RectTree(int l, int t, int r, int b) {
+			left = l;
+			top = t;
+			right = r;
+			bottom = b;
+
+			width = right - left;
+			height = bottom - top;  // Yep: upside-down.
+
+			split();
+		}
+
+		private void split() {
+
+			/*
+			Saying width < 2 OR height < 2 means we miss a few odd pixels.
+			Saying width < 2 AND height < 2 means we get them, but it goes a bit slower.
+			For now, we'll go with faster.
+			*/
+			if (width < 2 || height < 2) return;
+
+			int centerX = avg(left, right);
+			int centerY = avg(top, bottom);
+			kids = new ArrayList<>();
+			kids.add(new RectTree(left, top, centerX, centerY));
+			kids.add(new RectTree(centerX, top, right, centerY));
+			kids.add(new RectTree(left, centerY, centerX, bottom));
+			kids.add(new RectTree(centerX, centerY, right, bottom));
+		}
+
+		private int avg(int a, int b) {
+			// reminder: x >> 1 == x / 2
+			// avg = (a+b)/2 = (a/2)+(b/2) = (a>>1)+(b>>1)
+			return (a + b) >> 1;
+		}
+
+		Shape toShape(PImage img, int color) {
+			Area area = new Area();
+			if (isAllCovered(img, color)) {
+				area.add(new Area(new Rectangle(left, top, width, height)));
+			}
+			else if (kids != null) {
+                            kids.forEach((kid) -> {
+                                area.add(new Area(kid.toShape(img, color)));
+                            });
+			}
+			return area;
+		}
+
+		private Boolean isAllCoveredMemo;
+		private boolean isAllCovered(PImage img, int color) {
+			if (isAllCoveredMemo == null) {
+				if (kids == null) {
+					isAllCoveredMemo = (img.get(left, top) == color);
+				}
+				else {
+					// isAllCoveredMemo = kids.all?(&:isAllCovered);
+					isAllCoveredMemo = true;
+					for (RectTree kid : kids) {
+						if (!kid.isAllCovered(img, color)) {
+							isAllCoveredMemo = false;
+							break;
+						}
+					}
+				}
+			}
+			return isAllCoveredMemo;
+		}
+	}
+}