ruby_wordcram 1.0.1 → 2.0.0

data/src/wordcram/Observer.java

@@ -0,0 +1,9 @@
+package wordcram;
+
+public interface Observer {
+	public void wordsCounted(Word[] words);
+	public void beginDraw();
+	public void wordDrawn(Word word);
+	public void wordSkipped(Word word);
+	public void endDraw();
+}

data/src/wordcram/PlacerHeatMap.java

@@ -0,0 +1,134 @@
+package wordcram;
+
+import java.awt.Shape; // awt: word->shape->rect
+import java.awt.geom.Rectangle2D; // awt: intersects(box), x-y-w-h, bounds
+import java.util.ArrayList;
+import java.util.HashMap;
+
+import processing.core.PApplet;
+import processing.core.PFont;
+import processing.core.PVector;
+
+public class PlacerHeatMap {
+
+  private final Word[] words;
+  private final WordFonter fonter;
+  private final WordSizer sizer;
+  private final WordAngler angler;
+  private final WordPlacer placer;
+  private final WordNudger nudger;
+  private final WordShaper shaper;
+
+  PlacerHeatMap(Word[] words, WordFonter fonter, WordSizer sizer, WordAngler angler, WordPlacer placer, WordNudger nudger, WordShaper shaper) {
+
+    this.fonter = fonter;
+    this.sizer = sizer;
+    this.angler = angler;
+    this.placer = placer;
+    this.nudger = nudger;
+    this.shaper = shaper;
+    this.words = words;
+  }
+
+  class RectStack {
+    ArrayList<Rectangle2D> rects = new ArrayList<>();
+
+    void add(int x, int y, int w, int h) {
+      rects.add(new Rectangle2D.Float(x, y, w, h));
+    }
+
+    int howManyIntersect(int x, int y, int w, int h) {
+      int sum = 0;
+
+      sum = rects.stream().filter((r) -> (r.intersects(x, y, w, h))).map((_item) -> 1).reduce(sum, Integer::sum);
+
+      return sum;
+    }
+  }
+
+  class RectGrid {
+    RectStack stack;
+    HashMap<Rectangle2D, Integer> levels = new HashMap<>();
+
+    RectGrid(RectStack stack) {
+      this.stack = stack;
+    }
+
+    void measure(int x, int y, int w, int h) {
+      Rectangle2D plot = new Rectangle2D.Float(x, y, w, h);
+      int level = stack.howManyIntersect(x, y, w, h);
+      levels.put(plot, level);
+    }
+
+    int maxLevel() {
+      int maxLevel = 0;
+      for (Integer level : levels.values()) {
+        if (level > maxLevel) {
+          maxLevel = level;
+        }
+      }
+      return maxLevel;
+    }
+
+    void draw(PApplet sketch) {
+      int rowHeight = 10;
+      int colWidth = 10;
+      int rows = (int)(sketch.height / (float)rowHeight);
+      int cols = (int)(sketch.width / (float)colWidth);
+
+      for (int i = 0; i < rows; i++) {
+        int y = i * rowHeight;
+        for (int j = 0; j < cols; j++) {
+          int x = j * colWidth;
+
+          measure(x, y, colWidth, rowHeight);
+        }
+      }
+
+      sketch.colorMode(PApplet.HSB);
+
+      int max = maxLevel();
+      levels.keySet().forEach((rect) -> {
+          Integer level = levels.get(rect);
+          
+          int c = sketch.color(0);
+          if (level > 0) {
+              float scaled = (float)level / 8;
+              int hue = (int)PApplet.map(scaled, 0, 1, 85, 0);  // 85 = pure green
+              c = sketch.color(hue, 255, 255);
+          }
+          
+          sketch.fill(c);
+          sketch.rect((float)rect.getX(), (float)rect.getY(), (float)rect.getWidth(), (float)rect.getHeight());
+        });
+    }
+  }
+
+  public void draw(PApplet sketch) {
+    RectStack rectStack = new RectStack();
+
+    for (int i = 0; i < words.length; i++) {
+      Word word = words[i];
+      PFont wordFont = word.getFont(fonter);
+      float wordSize = word.getSize(sizer, i, words.length);
+      float wordAngle = word.getAngle(angler);
+
+      Shape shape = shaper.getShapeFor(word.word, wordFont, wordSize, wordAngle);
+      Rectangle2D rect = shape.getBounds2D();
+      //return r.getHeight() < minShapeSize || r.getWidth() < minShapeSize;
+
+      int wordImageWidth = (int)rect.getWidth();
+      int wordImageHeight = (int)rect.getHeight();
+
+      PVector desiredLocation = word.getTargetPlace(placer, i, words.length, 
+          wordImageWidth, wordImageHeight, sketch.width, sketch.height);
+
+      //sketch.rect(desiredLocation.x, desiredLocation.y, wordImageWidth, wordImageHeight);
+      rectStack.add((int)desiredLocation.x, (int)desiredLocation.y, 
+          wordImageWidth, wordImageHeight);
+    }
+
+    RectGrid grid = new RectGrid(rectStack);
+    grid.draw(sketch);
+  }
+}

data/src/wordcram/Placers.java

@@ -0,0 +1,74 @@
+package wordcram;
+
+import java.util.Random;
+
+import processing.core.PApplet;
+import processing.core.PVector;
+
+public class Placers {
+
+    public static WordPlacer horizLine() {
+        final Random r = new Random();
+
+        return (Word word, int wordIndex, int wordsCount, int wordImageWidth, int wordImageHeight, int fieldWidth, int fieldHeight) -> {
+            int centerHorizLine = (int) ((fieldHeight - wordImageHeight) * 0.5);
+            int centerVertLine = (int) ((fieldWidth - wordImageWidth) * 0.5);
+            
+            float xOff = (float) r.nextGaussian() * ((fieldWidth - wordImageWidth) * 0.2f);
+            float yOff = (float) r.nextGaussian() * 50;
+            
+            return new PVector(centerVertLine + xOff, centerHorizLine + yOff);
+            /*
+            int adjFieldWidth = fieldWidth - wordImageWidth;
+            int adjFieldHeight = fieldHeight - wordImageHeight;
+            
+            float xOff = (float) r.nextGaussian();// * 0.2f;
+            float yOff = (float) r.nextGaussian();// * 0.5f;
+            yOff = (float)Math.pow(yOff, 3) * 1.5f;
+            
+            return new PVector(PApplet.map(xOff, -2, 2, 0, adjFieldWidth),
+            PApplet.map(yOff, -2, 2, 0, adjFieldHeight));
+        */      };
+    }
+
+    public static WordPlacer centerClump() {
+        final Random r = new Random();
+        final float stdev = 0.4f;
+
+        return new WordPlacer() {
+
+            @Override
+            public PVector place(Word word, int wordIndex, int wordsCount,
+                    int wordImageWidth, int wordImageHeight, int fieldWidth, int fieldHeight) {
+                return new PVector(getOneUnder(fieldWidth - wordImageWidth),
+                        getOneUnder(fieldHeight - wordImageHeight));
+            }
+
+            private int getOneUnder(float upperLimit) {
+                return PApplet.round(PApplet.map((float) r.nextGaussian()
+                        * stdev, -2, 2, 0, upperLimit));
+            }
+        };
+    }
+
+    public static WordPlacer horizBandAnchoredLeft() {
+        final Random r = new Random();
+        return (Word word, int wordIndex, int wordsCount, int wordImageWidth, int wordImageHeight, int fieldWidth, int fieldHeight) -> {
+            float x = (1 - word.weight) * fieldWidth * r.nextFloat(); // big=left, small=right
+            float y = ((float) fieldHeight) * 0.5f;
+            return new PVector(x, y);
+        };
+    }
+
+    public static WordPlacer swirl() {
+        return new SwirlWordPlacer();
+    }
+
+    public static WordPlacer upperLeft() {
+        return new UpperLeftWordPlacer();
+    }
+
+    public static WordPlacer wave() {
+        return new WaveWordPlacer();
+    }
+}

data/src/wordcram/PlottingWordNudger.java

@@ -0,0 +1,38 @@
+package wordcram;
+
+import processing.core.PApplet;
+import processing.core.PVector;
+
+/**
+ * If you're using a custom WordNudger, and having difficulty seeing
+ * how well it works, try wrapping it in a PlottingWordNudger. As your
+ * WordCram is drawn, it'll render tiny dots at each location it
+ * nudges your words to, so you can see how well it's working.
+ */
+public class PlottingWordNudger implements WordNudger {
+
+    private final PApplet parent;
+    private final WordNudger wrappedNudger;
+
+    public PlottingWordNudger(PApplet _parent, WordNudger _wrappedNudger) {
+        parent = _parent;
+        wrappedNudger = _wrappedNudger;
+    }
+
+    @Override
+    public PVector nudgeFor(Word word, int attempt) {
+        PVector v = wrappedNudger.nudgeFor(word, attempt);
+        parent.pushStyle();
+        parent.noStroke();
+
+        float alpha = attempt/700f;
+        //alpha = (float) Math.pow(alpha, 3);
+        parent.fill(40, 255, 255); //, alpha * 255);
+
+        PVector wordLoc = PVector.add(v, word.getTargetPlace());
+        parent.ellipse(wordLoc.x, wordLoc.y, 3, 3);
+        parent.popStyle();
+        return v;
+    }
+
+}

data/src/wordcram/PlottingWordPlacer.java

@@ -0,0 +1,36 @@
+package wordcram;
+
+import processing.core.PApplet;
+import processing.core.PVector;
+
+/**
+ * If you're using a custom WordPlacer, and having difficulty seeing
+ * how well it works, try wrapping it in a PlottingWordPlacer. As your
+ * WordCram is drawn, it'll render tiny dots at each word's target
+ * location, so you can sort-of see how far off they are when they're
+ * finally rendered.
+ */
+public class PlottingWordPlacer implements WordPlacer {
+
+    private final PApplet parent;
+    private final WordPlacer wrappedPlacer;
+
+    public PlottingWordPlacer(PApplet _parent, WordPlacer _wrappedPlacer) {
+        parent = _parent;
+        wrappedPlacer = _wrappedPlacer;
+    }
+
+    @Override
+    public PVector place(Word word, int wordIndex, int wordsCount, int wordImageWidth, int wordImageHeight, int fieldWidth, int fieldHeight) {
+        PVector v = wrappedPlacer.place(word, wordIndex, wordsCount, wordImageWidth, wordImageHeight, fieldWidth, fieldHeight);
+        parent.pushStyle();
+        parent.noFill();
+
+        parent.stroke(15, 255, 255, 200);
+
+        parent.ellipse(v.x, v.y, 10, 10);
+        parent.popStyle();
+        return v;
+    }
+
+}

data/src/wordcram/ProcessingWordRenderer.java

@@ -0,0 +1,42 @@
+package wordcram;
+
+import java.awt.Color;  // awt: for fill color
+import java.awt.Graphics2D; // awt: draws the word to the screen
+import java.awt.RenderingHints;  // awt: for constants while rendering a word
+import java.awt.geom.GeneralPath;  // awt: Shape -> Path, fill(path)
+
+import processing.core.PGraphics;
+import processing.awt.PGraphicsJava2D;
+
+class ProcessingWordRenderer implements WordRenderer {
+	PGraphics destination;
+
+	ProcessingWordRenderer(PGraphics destination) {
+		this.destination = destination;
+	}
+
+        @Override
+	public int getWidth() {
+		return destination.width;
+	}
+
+        @Override
+	public int getHeight() {
+		return destination.height;
+	}
+
+        @Override
+	public void drawWord(EngineWord word, Color color) {
+        GeneralPath path2d = new GeneralPath(word.getShape());
+
+//        Graphics2D g2 = (Graphics2D)destination.image.getGraphics();
+        Graphics2D g2 = ((PGraphicsJava2D)destination).g2;
+
+        g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+        g2.setPaint(color);
+        g2.fill(path2d);
+	}
+
+        @Override
+	public void finish() {}
+}

data/src/wordcram/RandomWordNudger.java

@@ -0,0 +1,44 @@
+package wordcram;
+
+import java.util.Random;
+
+import processing.core.PVector;
+
+/**
+ * A RandomWordNudger, where each attempt's PVector has X & Y coords
+ * distributed randomly around the desired point, multiplied by a standard deviation,
+ * and multiplied by the attempt number (so it gets farther, as it gets more
+ * desperate).
+ *
+ * @author Dan Bernier
+ */
+public class RandomWordNudger implements WordNudger {
+
+    private final Random r = new Random();
+    private float stdDev;
+
+    /**
+     * Create a RandomWordNudger with a standard deviation of 0.6.
+     */
+    public RandomWordNudger() {
+        this(0.6f);
+    }
+
+    /**
+     * Create a RandomWordNudger with your own standard deviation.
+     * @param stdDev
+     */
+    public RandomWordNudger(float stdDev) {
+        this.stdDev = stdDev;
+    }
+
+    @Override
+    public PVector nudgeFor(Word w, int attempt) {
+        return new PVector(next(attempt), next(attempt));
+    }
+
+    private float next(int attempt) {
+        return (float)r.nextGaussian() * attempt * stdDev;
+    }
+
+}

data/src/wordcram/RenderOptions.java

@@ -0,0 +1,10 @@
+package wordcram;
+
+class RenderOptions {
+    int maxAttemptsToPlaceWord = -1; // default: based on Word weight
+    int maxNumberOfWordsToDraw = -1; // default: unlimited
+    int minShapeSize = 7;
+    int wordPadding = 1;
+
+    boolean rightToLeft = false;
+}

data/src/wordcram/ShapeBasedPlacer.java

@@ -0,0 +1,66 @@
+package wordcram;
+
+import java.awt.Shape; // awt: passed as arg, turned into Area
+import java.awt.geom.Area; // awt: from Shape, getBounds2D(), contains(box)
+import java.awt.geom.Rectangle2D; // awt: from Area, getMinX() and Y(), getMaxX() and Y()
+import java.util.Random;
+import processing.core.PVector;
+
+public class ShapeBasedPlacer implements WordPlacer, WordNudger {
+
+	Area area;
+	float minX;
+	float minY;
+	float maxX;
+	float maxY;
+	Random random;
+
+	public ShapeBasedPlacer(Shape shape) {
+		this.area = new Area(shape);
+		random = new Random();
+		Rectangle2D areaBounds = area.getBounds2D();
+		this.minX = (float) areaBounds.getMinX();
+		this.minY = (float) areaBounds.getMinY();
+		this.maxX = (float) areaBounds.getMaxX();
+		this.maxY = (float) areaBounds.getMaxY();
+	}
+
+        @Override
+	public PVector place(Word w, int rank, int count, int ww, int wh, int fw,
+			int fh) {
+
+		for (int i = 0; i < 1000; i++) {
+			float newX = randomBetween(minX, maxX);
+			float newY = randomBetween(minY, maxY);
+			if (area.contains(newX, newY, ww, wh)) {
+				return new PVector(newX, newY);
+			}
+		}
+
+		return new PVector(-1, -1);
+	}
+
+        @Override
+	public PVector nudgeFor(Word word, int attempt) {
+		PVector target = word.getTargetPlace();
+		float wx = target.x;
+		float wy = target.y;
+		float ww = word.getRenderedWidth();
+		float wh = word.getRenderedHeight();
+
+		for (int i = 0; i < 1000; i++) {
+			float newX = randomBetween(minX, maxX);
+			float newY = randomBetween(minY, maxY);
+
+			if (area.contains(newX, newY, ww, wh)) {
+				return new PVector(newX - wx, newY - wy);
+			}
+		}
+
+		return new PVector(-1, -1);
+	}
+
+	float randomBetween(float a, float b) {
+		return a + random.nextFloat() * (b - a);
+	}
+}