!752

concepts.

sclass TestCase {

  BufferedImage screen;

  Rect boardRect;

  RGBImage board;

  int boardW, boardH;

  *() {

    screen = loadBufferedImage("#1006074");

    boardRect = pointRect(194, 179, 501, 485);

    board = new RGBImage(screen).clip(boardRect);

    boardW = board.w();

    boardH = board.h();

  }

  Rect square(int x, int y) {

    ret pointsRect(

      boardW*x/8, boardH*y/8,

      boardW*(x+1)/8, boardH*(y+1)/8);

  }

  Square realSquareType(int x, int y) {

    ret odd(x*8/boardW + y*8/boardH) ? Square.dark : Square.light;

  }

  void showBoard() {

    new L<RGBImage> imgs;

    for y to 8: {

      new L<Rect> l;

      for x to 8: l.add(square(x, y));

      imgs.add(mergeImagePartsHorizontally(board, l));

    }

    showImage(mergeImagesVertically(imgs));

  }

  float testFunction(SquareDetector f) {

    int step = 5; // faster

    int n = 0;

    float points = 0;

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

      for (int x = 0; x < boardW; x++) {

        ++n;

        Square s = f.squareType(board, x, y);

        Square real = realSquareType(x, y);

        if (s == real) ++points;

        else if (s == Square.unknown) points += 0.1f;

      }

    float score = points*100f/n;

    ret score;

  }

}

enum Square { light, dark, none, unknown };

// import static main.Square.*; << stupid Java doesn't want this

sclass SquareDetector {

  Square squareType(RGBImage img, int x, int y) { ret Square.none; }

}

// dummy reference detector

sclass AllUnknown extends SquareDetector {

  Square squareType(RGBImage img, int x, int y) { ret Square.unknown; }

}

sclass Detector1 extends SquareDetector {

  RGB colLight, colDark;

  *() {}

  *(RGB *colLight, RGB *colDark) {}

  *(Color colLight, Color colDark) {

    this.colLight = new RGB(colLight);

    this.colDark = new RGB(colDark);

  }

  Square squareType(RGBImage img, int x, int y) {

    RGB rgb = img.getPixel(x, y);

    float distLight = simpleRGBDistance(rgb, colLight);

    float distDark = simpleRGBDistance(rgb, colLight);

    ret distLight < distDark ? Square.light : Square.dark;

  }

}

sclass Detector2 extends SquareDetector {

  RGB colLight, colDark;

  float range = 0.1f; // area around colors that is accepted

  *() {}

  *(RGB *colLight, RGB *colDark) {}

  *(Color colLight, Color colDark) {

    this.colLight = new RGB(colLight);

    this.colDark = new RGB(colDark);

  }

  Square squareType(RGBImage img, int x, int y) {

    RGB rgb = img.getPixel(x, y);

    float distLight = simpleRGBDistance(rgb, colLight);

    float distDark = simpleRGBDistance(rgb, colLight);

    if (distLight < range) ret Square.light;

    if (distDark < range) ret Square.dark;

    ret Square.unknown;

  }

}

// modifies specimen, updates best

svoid optimizeOneField(O tester, O specimen, S field, O varyField, Best<S> best) {

  O varied = callF(varyField, get(specimen, field));

  set(specimen, field, varied);

  float score = toFloat(callF(tester, specimen));

  showStatus("Field varied to: " + varied + ", score: " + score + ", best: " + best.bestScore());

  if (best.isNewBest(score)) {

    S s = structure(specimen);

    best.put(s, score);

    print("New best! " + score + " - " + shorten(s, 1000));

  }

}

static volatile S showStatus_status = "";

static JLabel showStatus_label;

svoid showStatus(S status) {

  if (showStatus_label == null) awt {

    if (showStatus_label == null) {

      showStatus_label = jlabel();

      JFrame frame = showPackedFrame(showStatus_label);

      setFrameWidth(frame, 300);

      moveToTopRightCorner(frame);

      installTimer(showStatus_label, 50, r {

        S s = showStatus_status;

        if (neq(s, showStatus_label.getText()))

          showStatus_label.setText(s);

      });

    }

  }

  showStatus_status = unnull(status);

}

static RGB replaceColor(RGB color) {

  ret randomColor();

}

concept PersistentBest {

  S bestStructure;

  double score;

  transient new Best<S> best;

  *() { _doneLoading(); }

  void _doneLoading() {

    best.put(bestStructure, score);

    best.onChange = r {

      cset(PersistentBest.this, bestStructure := best.best, score := best.score);

    };

  }

  S get() { ret best.get(); }

  bool has() { ret best.has(); }

}

p {

  concepts();

  final new TestCase tc;

  //tc.showBoard();

  tc.testFunction(new AllUnknown);

  Detector1 detector1 = new Detector1(Color.white, Color.black);

  tc.testFunction(detector1);

  O tester = func(SquareDetector d) { tc.testFunction(d) };

  PersistentBest best = uniq(PersistentBest);

  //optimizeOneField(tester, detector1, "colLight", func replaceColor, best);

  Detector2 detector2 = new Detector2(Color.white, Color.black);

  // Main loop: Make new random specimen + vary best

  while licensed {

    for (S field : ll("colLight", "colDark")) {

      optimizeOneField(tester, detector2, field, func replaceColor, best.best);

      if (best.has())

        optimizeOneField(tester, unstructure(best.get()), field, func varyColor, best.best);

    }

  }

}