!752

static BWImage bw;
static ImageSurface imageSurface;
static Thread producer;
static Reproducing rp;

!include #1000522 // image helper functions

p {
  rp = new Reproducing;
  bw = rp.bw = loadBWImage("#1004541");
  imageSurface = showImage(rp.bw.getBufferedImage());
  rp.imageSurfaceToUpdateWithBest = imageSurface;
  
  //showImage("Full Grab", descToImage(fullGrab(bw)));
  
  produce();
  rp.reproduceOpenEnd();
  
  while (rp.solved()) {
    rp.pivotLength = l(rp.bestDesc) - rp.pivotStep;
    print("Trying pivot length " + rp.pivotLength);

    produce();
    rp.reproduceOpenEnd();
  }
}

static void produce() {
  cancelThread(producer);
  producer = new Thread(r {
    // STRATEGY!
    
    rp.push(fullGrab(bw));
    int w = 1;
    while licensed {
      rp.push(new RandomSolid().reproduce(bw));
      S best = rp.bestDesc;
      if (best != null)
        rp.push(varyFloat(best));
      if (w < rp.bw.getWidth())
        rp.push(hrepeat(bw, w++));
    }
  }, "Producer");
  producer.start();
}

sclass Best {
  S desc;
  double score;
  BWImage image;
  
  *() {}
  *(S *desc, double *score, BWImage *image) {}
  
  int l() { ret main.l(desc); }
}

sclass Reproducing {
  BWImage bw; // original
  ImageSurface imageSurfaceToUpdateWithBest;
  new LinkedBlockingQueue<S> newProducts;
  int maxQueueLength = 10;
  Best shortest100;
  double bestScore;
  volatile S bestDesc;
  BWImage bestRendering;
  int pivotLength = -1; // no length punishment at start
  int pivotStep = 1;
  int fullGrabLength; // length of full grab for reference

  void push(S product) {
    if (product == null) ret;
    while (newProducts.size() >= maxQueueLength && mayRun())
      sleep(100);
    newProducts.add(product);
  }
  
  double formula(S desc, double pixelScore) {
    int lengthPunishment = pivotLength < 0 ? 0
      : max(0, l(desc)-pivotLength);
    ret pixelScore-lengthPunishment;
  }
  
  void reproduceOpenEnd() {
    bestDesc = null;
    bestScore = 0;
    bestRendering = null;
    Renderer best = null;
    fullGrabLength = l(fullGrab(bw));
    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) + "%, l=" + l(bestDesc) + ", pivotL=" + pivotLength + "/" + fullGrabLength + (shortest100 == null ? "" : ", shortest100=" + shortest100.l()));
        }
      }
      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, bw);
      double pixelScore = 100*(1-diff(bw, 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;
        if (pixelScore >= 100 && (shortest100 == null || shortest100.l() > l(desc))) {
          shortest100 = new Best(desc, pixelScore, rendering);
          saveTextFile(getProgramFile("shortest100.txt"), bw.getWidth() + " " + bw.getHeight() + " " + desc);
        }
        imageSurface.setImage(bestRendering.getBufferedImage());
      }
      
      if (solved()) {
        print("Solved! l=" + l(bestDesc));
        print(bestDesc);
        break;
      }
    }
  }
  
  bool solved() {
    ret bestScore >= 100.0;
  }
  
  BufferedImage descToImage(S desc) {
    try {
      ret makeRenderer(desc).render(bw.getWidth(), bw.getHeight()).getBufferedImage();
    } catch {
      fail(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 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 BWImage render(Renderer p, BWImage original) {
  ret p.render(original.getWidth(), original.getHeight());
}

static 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 Renderer makeRenderer(S desc) {
  ret (Renderer) unstructure(desc);
}

static BufferedImage render(S fullDesc) {
  if (fullDesc == null) null;
  new Matches m;
  assertTrue(jmatchStart("* *", fullDesc, m));
  int w = m.psi(0), h = m.psi(1);
  S desc = m.unq(2);
  ret makeRenderer(desc).render(w, h).getBufferedImage();
}

static S shortest100() {
  ret loadTextFile(getProgramFile("shortest100.txt"));
}

static BufferedImage renderShortest100() {
  ret render(shortest100());
}

Began life as a copy of #1004545