!752

static BWImage bw;

static ImageSurface imageSurface;

static Reproducer reproducer;

static int pivotLength = -1; // no length punishment at start

static int pivotStep = 1;

static int maxQueueLength = 10;

static new LinkedBlockingQueue<S> newProducts;

static double bestScore;

static volatile S bestDesc;

static BWImage bestRendering;

static Thread producer;

!include #1000522 // image helper functions

p {

  bw = loadBWImage("#1004541");

  imageSurface = showImage(bw.getBufferedImage());

  showImage("Full Grab", descToImage(fullGrab(bw)));

  produce();

  reproduceOpenEnd(bw, imageSurface);

  while (solved()) {

    pivotLength = l(bestDesc) - pivotStep;

    print("Trying pivot length " + pivotLength);

    reproduceOpenEnd(bw, imageSurface);

  }

}

static void produce() {

  cancelThread(producer);

  producer = new Thread(r {

    // STRATEGY!

    push(fullGrab(bw));

    int w = 1;

    while licensed {

      push(new RandomSolid().reproduce(bw));

      S best = bestDesc;

      if (best != null)

        push(varyFloat(best));

      if (w+1 < bw.getWidth())

        push(hrepeat(bw, w++));

    }

  }, "Producer");

  producer.start();

}

static S varyFloat(S s) {

  L<S> tok = javaTok(s);

  int i = tok.indexOf("f");

  if (i < 0) null;

  float f = Float.parseFloat(unquote(tok.get(i+2)));

  f = (float) (f+random(-0.1, 0.1));

  tok.set(i+2, quote(str(f)));

  ret join(tok);

}

static void push(S product) {

  if (product == null) ret;

  while (newProducts.size() >= maxQueueLength && mayRun())

    sleep(100);

  newProducts.add(product);

}

static BufferedImage descToImage(S desc) {

  try {

    ret makeRenderer(desc).render(bw.getWidth(), bw.getHeight()).getBufferedImage();

  } catch {

    fail(desc);

  }

}

static double formula(S desc, double pixelScore) {

  int lengthPunishment = pivotLength < 0 ? 0

    : max(0, l(desc)-pivotLength);

  ret pixelScore-lengthPunishment;

}

interface Reproducer {

  public S reproduce(BWImage original);

}

static class Solid extends Renderer {

  float col;

  BWImage render(int w, int h) {

    ret new BWImage(w, h, col);

  }

}

static class RandomSolid implements Reproducer {

  int n = -1;

  public S reproduce(BWImage original) {

    ++n;

    DynamicObject p = new DynamicObject("Solid");

    if (n % 2 == 0) {

      p.put("col", randomBrightness());

    } else {

      p.put("col", probeRandomPixel(original));

    }

    ret structure(p);

  }

}

static abstract class Renderer {

  abstract BWImage render(int w, int h);

}

static void reproduceOpenEnd(BWImage original, ImageSurface imageSurface) {

  bestDesc = null;

  bestScore = 0;

  bestRendering = null;

  Renderer best = null;

  long lastPrint = 0, lastN = 0;

  for (long ntry = 1; ; ntry++) {

    ping();

    long now = now();

    if (now >= lastPrint+1000) {

      long tps = (ntry-lastN)*1000/(now-lastPrint);

      lastPrint = now;

      lastN = ntry;

      String s = "Try " + ntry + " (" + tps + "/s)";

      if (best == null)

        System.out.println(s);

      else {

        System.out.println("Best: " + bestDesc);

        System.out.println(s + ", score: " + formatDouble(bestScore, 2) + "%, structure size: " + structureSize(best, Renderer.class));

      }

    }

    S desc;

    try {

      desc = grabFromQueue(newProducts);

    } catch e {

      print("Production failed: " + exceptionToStringShort(e));

      continue;

    }

    Renderer p;

    try {

      p = makeRenderer(desc);

    } catch {

      print("Can't unstructure: " + desc);

      continue;

    }

    BWImage rendering = render(p, original);

    double pixelScore = 100*(1-diff(original, rendering));

    double score = formula(desc, pixelScore);

    if (bestDesc == null || p != null && score > bestScore) {

      //System.out.println("New best! " + score);

      bestDesc = desc;

      bestScore = score;

      bestRendering = rendering;

      best = p;

      imageSurface.setImage(bestRendering.getBufferedImage());

    }

    if (solved()) {

      print("Solved! l=" + l(bestDesc));

      print(bestDesc);

      break;

    }

  }

}

sbool solved() {

  ret bestScore >= 100.0;

}

static Renderer makeRenderer(S desc) {

  ret (Renderer) unstructure(desc);

}

static class FullGrab extends Renderer {

  int dw, dh;

  byte[] data;

  BWImage render(int w, int h) {

    if (w != dw || h != dh)

      fail("size: \*w*/ \*h*/ \*dw*/ \*dh*/");

    ret new BWImage(w, h, data);

  }

}

static class HRepeat extends Renderer {

  int width;

  S inner;

  BWImage render(int w, int h) {

    BWImage img = new BWImage(w, h);

    BWImage clip = makeRenderer(inner).render(width, h);

    for (int x = 0; x < w; x += width)

      copy(clip, 0, 0, img, x, 0, width, h);

    ret img;

  }

}

static S fullGrab(BWImage img) {

  DynamicObject d = new DynamicObject("FullGrab");

  int w = img.getWidth(), h = img.getHeight();

  d.put("dw", w);

  d.put("dh", h);

  byte[] data = new byte[w*h];

  for (int y = 0; y < h; y++)

    for (int x = 0; x < w; x++)

      data[y*w+x] = img.getByte(x, y);

  d.put("data", data);

  ret structure(d);

}

static S hrepeat(BWImage img, int width) {

  int h = img.getHeight();

  BWImage clip = img.clip(0, 0, width, h);

  ret structure(dynamicObject("HRepeat", "width", width, "inner", fullGrab(clip)));

}

static BWImage render(Renderer p, BWImage original) {

  ret p.render(original.getWidth(), original.getHeight());

}