1 files changed, 244 insertions, 0 deletions

@@ -0,0 +1,244 @@
+#include "designer.h"
+#include <dirent.h>
+#include <stdexcept>
+#include <iostream>
+#include "util.h"
+
+designer::designer(std::string fontsDir)
+{
+  DIR* fontdir;
+  struct dirent* ent;
+  if ((fontdir = opendir(fontsDir.c_str())) == nullptr)
+  {
+    throw std::invalid_argument("Couldn't find fonts");
+  }
+
+  while ((ent = readdir(fontdir)) != nullptr)
+  {
+    std::string dname(ent->d_name);
+    if ((dname.find(".otf") != std::string::npos)
+      || (dname.find(".ttf") != std::string::npos))
+    {
+      fonts.push_back(fontsDir + "/" + dname);
+    }
+  }
+
+  closedir(fontdir);
+}
+
+Magick::Image designer::generate(
+  size_t width,
+  size_t height,
+  const std::string& text,
+  std::mt19937& rng) const
+{
+  // Initialize two layers: the text, and a shadow to increase contrast.
+  Magick::Image textimage(Magick::Geometry(width, height), "transparent");
+  Magick::Image shadowimage(Magick::Geometry(width, height), "transparent");
+
+  textimage.fillColor(Magick::Color(MaxRGB, MaxRGB, MaxRGB, MaxRGB * 0.0));
+  shadowimage.fillColor(Magick::Color(0, 0, 0, 0));
+  shadowimage.strokeColor("black");
+
+  bool hasFont = false;
+  std::uniform_int_distribution<size_t> fontDist(0, fonts.size() - 1);
+
+  std::vector<std::string> words = split<std::vector<std::string>>(text, " ");
+  std::vector<std::string>::const_iterator curWord = std::begin(words);
+
+  size_t top = V_PADDING;
+  size_t minWords = 1;
+  while (curWord != std::end(words))
+  {
+    // There is a 1 in 10 chance of randomly changing the font. We also have to
+    // set the font if this is the beginning of generation.
+    if (!hasFont || (std::bernoulli_distribution(0.1)(rng)))
+    {
+      std::string font = fonts[fontDist(rng)];
+
+      textimage.font(font);
+      shadowimage.font(font);
+
+      hasFont = true;
+    }
+
+    // Choose a font size for the current line.
+    std::uniform_int_distribution<size_t> sizeDist(
+      MIN_FONT_SIZE, MAX_FONT_SIZE);
+
+    size_t size = sizeDist(rng);
+    textimage.fontPointsize(size);
+
+    // Decide what words to put on this line.
+    size_t maxWords = maxWordsInLine(curWord, std::end(words), textimage);
+
+    size_t lineLen;
+    if (minWords > maxWords)
+    {
+      lineLen = maxWords;
+    } else {
+      std::uniform_int_distribution<size_t> lenDist(minWords, maxWords);
+      lineLen = lenDist(rng);
+    }
+
+    std::string prefixText = implode(curWord, curWord + lineLen, " ");
+
+    // Determine if the choice of font, font size, and number of words, would
+    // prevent the algorithm from being about to layout the entire string even
+    // if the rest of it were rendered in the smallest font size.
+    Magick::TypeMetric metric;
+    textimage.fontTypeMetrics(prefixText, &metric);
+
+    textimage.fontPointsize(MIN_FONT_SIZE);
+
+    // This is how much vertical space would be required to render the rest of
+    // the string at the minimum font size.
+    int lowpadding = minHeightRequired(
+      curWord + lineLen,
+      std::end(words),
+      textimage);
+
+    // This is the amount of space that would be left over if the rest of the
+    // string were rendered at the minimum font size.
+    int freespace =
+      static_cast<int>(height) - static_cast<int>(V_PADDING)
+        - static_cast<int>(top) - lowpadding - metric.textHeight();
+
+    // Some debug text.
+    std::cout << "top of " << top << " with lowpad of " << lowpadding
+      << " and textheight of " << metric.textHeight() << " with freespace="
+      << freespace << std::endl;
+
+    // If there wouldn't be enough room to render the rest of the string at the
+    // minimum font size, go back to the top of the loop and choose a different
+    // font, font size, and number of words.
+    if (freespace < 0)
+    {
+      minWords = lineLen;
+
+      continue;
+    }
+
+    minWords = 1;
+
+    // Determine how much space to leave between this line and the previous one.
+    size_t toppadding;
+    if (std::bernoulli_distribution(0.5)(rng))
+    {
+      // Exponential distribution, biased toward top
+      std::uniform_int_distribution<size_t> expDist(
+        1, static_cast<size_t>(exp(freespace + 1)));
+
+      toppadding = log(expDist(rng));
+    } else {
+      // Linear distribution, biased toward bottom
+      std::uniform_int_distribution<size_t> linDist(0, freespace);
+
+      toppadding = linDist(rng);
+    }
+
+    // Determine the x-coordinate of this line.
+    std::uniform_int_distribution<size_t> leftDist(
+      H_PADDING,
+      width - H_PADDING - static_cast<size_t>(metric.textWidth()) - 1);
+
+    size_t leftx = leftDist(rng);
+
+    // Render this line.
+    size_t ycor = top + toppadding + metric.ascent();
+
+    std::cout << "printing at " << leftx << "," << ycor << std::endl;
+
+    textimage.fontPointsize(size);
+    textimage.annotate(prefixText, Magick::Geometry(0, 0, leftx, ycor));
+
+    shadowimage.fontPointsize(size);
+    shadowimage.strokeWidth(size / 10);
+    shadowimage.annotate(prefixText, Magick::Geometry(0, 0, leftx, ycor));
+
+    top += toppadding + metric.textHeight();
+
+    std::advance(curWord, lineLen);
+  }
+
+  // Make the shadow layer semi-transparent.
+  Magick::PixelPacket* shadpixels = shadowimage.getPixels(0, 0, width, height);
+  Magick::PixelPacket* textpixels = textimage.getPixels(0, 0, width, height);
+  for (size_t j = 0; j < height; j++)
+  {
+    for (size_t i = 0; i < width; i++)
+    {
+      size_t ind = j * width + i;
+
+      if (shadpixels[ind].opacity != MaxRGB)
+      {
+        shadpixels[ind].opacity = MaxRGB * 0.25;
+      }
+    }
+  }
+
+  shadowimage.syncPixels();
+  textimage.syncPixels();
+
+  // Add some blur to the text and shadow.
+  shadowimage.blur(10.0, 20.0);
+  textimage.blur(0.0, 0.5);
+
+  // Put the text layer on top of the shadow.
+  shadowimage.composite(textimage, 0, 0, Magick::OverCompositeOp);
+
+  return shadowimage;
+}
+
+size_t designer::maxWordsInLine(
+  std::vector<std::string>::const_iterator first,
+  std::vector<std::string>::const_iterator last,
+  Magick::Image& textimage) const
+{
+  size_t result = 0;
+
+  std::string curline = "";
+  for (; first != last; first++)
+  {
+    curline += " " + *first;
+
+    Magick::TypeMetric metric;
+    textimage.fontTypeMetrics(curline, &metric);
+
+    if (metric.textWidth() > ((textimage.columns() / 10) * 9))
+    {
+      break;
+    } else {
+      result++;
+    }
+  }
+
+  return result;
+}
+
+size_t designer::minHeightRequired(
+  std::vector<std::string>::const_iterator first,
+  std::vector<std::string>::const_iterator last,
+  Magick::Image& textimage) const
+{
+  if (first == last)
+  {
+    return 0;
+  } else {
+    size_t result = 0;
+
+    while (first != last)
+    {
+      size_t prefixlen = maxWordsInLine(first, last, textimage);
+      std::string prefixText = implode(first, first + prefixlen, " ");
+
+      Magick::TypeMetric metric;
+      textimage.fontTypeMetrics(prefixText, &metric);
+      result += metric.textHeight() + V_PADDING;
+
+      std::advance(first, prefixlen);
+    }
+
+    return result - V_PADDING;
+  }
+}