abstract sclass ChessOCR_DynPipelinedRecognizer extends DynModule {

  S segmenterPreset;

  transient Iterator<ParameterizedSegmenter> segmenters;

  transient ChessOCR_Pipeline pipeline;

  Rect boardLocation;

  double recognitionScore;

  S status;

  S selectedSquare;

  S piece;

  LPair<S, Double> recognized;

  S fen;

  ChessOCR_BoardsFound boardsFound;

  switchable bool squareHeightAtBottom = true; // for YouTube videos

  transient int recreatedSquareSize = 32;

  transient ReliableSingleThread rst = dm_rst(module(), r recognize);

  transient BufferedImage img, board, square, recreated;

  transient LL<BufferedImage> squareImages;

  transient ImageSurface isInput, isBoard, isSquare, isRecreated;

  transient LS pieces = ai_chessPieces();

  transient Map<Bool, Map<S, BufferedImage>> recreateStock; // false = dark, true = light

  visualize {

    isBoard = jImageSurface();

    imageSurfaceOnHover(isBoard, voidfunc(Pt p) {

      if (board == null || p == null) ret with noToolTip(isBoard);

      setToolTip(isBoard, toolTipForSquare(boardPointToSquare(p));

    });

    imageSurfaceOnLeftClick(isBoard, voidfunc(Pt p) {

      selectSquare(boardPointToSquare(p))

    });

    isRecreated = jImageSurface(recreated);

    imageSurfaceOnHover(isRecreated, voidfunc(Pt p) {

      if (recreated == null || p == null) ret with noToolTip(isRecreated);

      setToolTip(isRecreated, toolTipForSquare(recreatedPointToSquare(p));

    });

    imageSurfaceOnLeftClick(isRecreated, voidfunc(Pt p) {

      selectSquare(recreatedPointToSquare(p))

    });

    isInput = jImageSurface(or_func(img, () -> whiteImage(100)));

    isInput.onNewImage = rst;

    ret withCalc(rst, jvsplit(

      jCenteredSection("Input image", jscroll_center(isInput)),

      northCenterAndSouthWithMargins(

        centerAndEastWithMargin(segmenterSection(),

          hstackWithSpacing(

            jbutton("Recognize", rst),

            jPopDownButton_noText(

              "Show possible chess boards found", rThread showSegments,

              "Publish training image...", rThread publishImage,

              "---", null,

              "Screenshot (hiding OS)", rThread {

                isInput.setImageAndZoomToDisplay(dm_shootScreenHidingOS());

                rst.trigger();

              })

          )),

        hgridWithSpacing(

          jCenteredSection("Recreated", jscroll_center(isRecreated)),

          jCenteredSection("Chess board in image",

            centerAndSouthWithMargin(jscroll_center(isBoard),

            dm_centeredCalculatedLabel(() -> "Recognition score: " + formatDouble(recognitionScore, 2))

          )),

          jCenteredLiveValueSection(dm_calculatedLiveValue(S, () -> "Selected square" + (empty(selectedSquare) ? "" : " (" + selectedSquare + ")")), centerAndSouthWithMargin(

            jscroll_center(isSquare = jImageSurface(square)),

            rightAlignedLine(

              withLabel("Piece: ", dm_comboBox('piece, pieces)),

              jbutton("Save & upload", rThread saveAndUploadPiece))

        ))),

        vstackWithSpacing(

          dm_label('status),

          withLabel("FEN:", dm_label('fen))

        )

      )));

  }

  void recognize {

    if (pipeline != null)

      pipeline.cancel();

    status("Recognizing...");

    segmenters = makeSegmenters();

    if (empty(segmenters)) ret with infoBox(status("No segmenter"));

    //img = dm_shootScreenHidingOS();

    if (isInput != null) img = isInput.getImage();

    ChessPieceRecognizer pieceRecognizer = chessOCR_pieceRecognizer();

    ChessOCR_TwoStageRecognizer rec = new(pieceRecognizer, img, segmenters);

    rec.verbose(true);

    clearImageSurfaces(isBoard, isRecreated);

    setField(fen := "");

    bool done = false;

    new Var<Rect> lastLocation;

    while (!done && !rst.triggered()) {

      done = !rec.step();

      Rect r = rec.bestBoardLocation();

      if (r != null)

        rec.tryRect(print("wiggling", wiggleRect(r)));

      r = rec.bestBoardLocation();

      if (r != null && setVar_trueIfChanged(lastLocation, r))

        newBestLocation(r, pieceRecognizer);

    }

    if (done && !lastLocation.has())

      status("No chess board found");

  }

  S status(S status) { setField(+status); ret status; }

  O _getReloadData() { ret img; }

  void _setReloadData(BufferedImage img) { this.img = img; }

  void setImage(BufferedImage img) {

    this.img = img;

    if (isInput != null) isInput.setImageAndZoomToDisplay(img);

    rst.trigger();

  }

  S boardPointToSquare(Pt p) {

    double space = imageMergeSpacing();

    double squareW = board.getWidth()/8.0+space;

    double squareH = board.getHeight()/8.0+space;

    int x = clamp(iratio_floor(p.x+space/2, squareW), 0, 7);

    int y = clamp(iratio_floor(p.y+space/2, squareH), 0, 7);

    ret strCharPlus('A', x) + (8-y);

  }

  S recreatedPointToSquare(Pt p) {

    int x = clamp(iratio_floor(p.x, recreatedSquareSize), 0, 7);

    int y = clamp(iratio_floor(p.y, recreatedSquareSize), 0, 7);

    ret strCharPlus('A', x) + (8-y);

  }

  void saveAndUploadPiece enter {

    if (square == null || empty(piece)) ret;

    chessOCR_uploadPieceImage(selectedSquare, piece, square);

    if (mapGet(mapGet(recreateStock, chess_isLightSquare(selectedSquare)), piece) == null) recreateStock = null;

    rst.trigger();

  }

  void recreate {

    if (recognized == null) ret;

    if (recreateStock == null)

      recreateStock = mapToValues(ll(false, true), light ->

        mapValues(pairsToMap(reversePairs(chessPieceImagesFromAGIBlue(light))), imageID -> resizeImage(loadImage2(imageID), recreatedSquareSize, recreatedSquareSize)));

    new L<BufferedImage> out;

    int i = 0;

    for (S piece : pairsA(recognized)) {

      bool light = even(i/8+i%8);

      out.add(or_func(mapGet(mapGet(recreateStock, light), piece), () -> whiteImage(recreatedSquareSize, recreatedSquareSize)));

      ++i;

    }

    new L<BufferedImage> rows;

    for (L<BufferedImage> row : listToChunks(out, 8))

      rows.add(mergeBufferedImagesHorizontally(row, spacing := 0));

    recreated = mergeBufferedImagesVertically(rows, spacing := 0);

    if (isRecreated != null) isRecreated.setImageAndZoomToDisplay(recreated);

  }

  Pair<S, Double> recognitionForSquare(S square) {

    int x, y = unpair chess_squareToPos(square);

    ret _get(recognized, y*8+x);

  }

  S toolTipForSquare(S square) {

    Pair<S, Double> rec = recognitionForSquare(square);

    ret square + " - " + (rec == null ? "?" : rec.a + " [" + iround(clamp(rec.b, 0, 100)) + "%]");

  }

  void selectSquare(S _square) {

    setField(selectedSquare := _square);

    S rec = pairA(recognitionForSquare(selectedSquare));

    if (rec != null) setField(piece := rec);

    int x, y = unpair chess_squareToPos(selectedSquare);

    square = _get(_get(squareImages, y), x);

    ChessPieceProfile1 profile = chessOCR_pieceProfileFromRawImage_1(square, withPreprocessedImages := true);

    isSquare.setImage(mergeBufferedImagesHorizontally(

      itemPlusList(square, map toBufferedImage(profile.preprocessedImages))));

    //printVars_str("leftClick", +p, +selectedSquare, +x, +y, +square);

  }

  void showSegments {

    L<Rect> segments = this.segments;

    showImage_centered(n2(segments, "segment") + " found",

      mergeBufferedImagesVertically(map(segments, r -> clipBufferedImage(img, r))));

  }

  void publishImage enter {

    BufferedImage img = this.img;

    S segmenterPreset = this.segmenterPreset;

    JCheckBox cbFound = jcheckbox(true), cbHasBoard = jcheckbox(true);

    JTextField tfFEN = jtextfield(fen), tfComments = jtextfield(),

      tfImageCredits = jtextfield();

    showFormTitled("Publish training image",

      "Image", jImageSurface(scaleImageToWidth(img, 500)),

      "Segmenter used", jlabel(segmenterPreset),

      "Is there a chess board in the image?", cbHasBoard,

      "FEN (empty if no board in image)", tfFEN,

      "Was the chess board found?", cbFound, // TODO: make clearer what this means if there is no board in image

      "Image credits (optional)", tfImageCredits,

      "Random comments", tfComments,

      "NOTE:", jMultiLineLabel("By clicking 'publish', you PUBLISH this image (fair use/public domain)."),

      "", jThreadedButton("Publish", r {

        temp tempInfoBox_noHide("Uploading training image...");

        S imageURL = uploadToImageServer("Chess board recognition training image", img);

        S desc = "Chess board recognition training image " + assertNempty("Parseable image URL", parseSnippetImageURL(imageURL));

        new LinkedHashMap<S> map;

        map.put("Input image", imageURL);

        mapPutIfNemptyValue(map, "Image credits", gtt(tfImageCredits));

        S fen = gtt(tfFEN);

        map.put("Image has chess board", yesNo_short_firstUpper(isChecked(cbHasBoard) || nempty(fen)));

        mapPutIfNemptyValue(map, "FEN", fen);

        map.put("Segmenter used", segmenterPreset);

        map.put("Chess board found", yesNo_short_firstUpper(isChecked(cbFound)));

        if (isChecked(cbFound))

          map.put("Board location", struct(boardLocation));

        S sliceID = agiBlue_chessBoardRecognitionTrainingImagesSliceID();

        new L<Map> toPost;

        S name = agiBlue_createUnusedNumberedPage(sliceID, desc + " #");

        for (S key, value : map)

          toPost.add(litmap(q := name, +key, +value));

        agiBot_postMulti(keyPairForProgram(), toPost, slice := sliceID);

        infoBox("Training image uploaded!");

        openURLInBrowser(agiBlue_linkForPhrase(name, slice := sliceID));

        disposeWindow(heldButton());

      })

    );

  }

  S makeFEN() {

    ret chess_makeFEN(listToChunks(pairsA(recognized), 8));

  }

  void newBestLocation(Rect r, ChessPieceRecognizer pieceRecognizer) {

    setField(segments := singletonUnlessNull(r));

    bool corrected = squareHeightAtBottom && abs(r.w-r.h) > 3;

    if (corrected) r.h = r.w;

    new LS comments;

    if (corrected) comments.add("height-corrected");

    status("Chess board found at: " + r + appendRoundBracketed(joinWithComma(comments)));

    setField(boardLocation := r);

    board = clipBufferedImage(img, r);

    squareImages = bufferedImageMNGrid(board, 8, 8);

    if (isBoard != null)

      isBoard.setImageAndZoomToDisplay(

        mergeBufferedImagesVertically(

          map(bufferedImageNVerticalSlices(8, board), i ->

            mergeBufferedImagesHorizontally(bufferedImageNHorizontalSlices(8, i)))));

    recognized = new L;

    for (BufferedImage img : concatLists(squareImages))

      recognized.add(pieceRecognizer.recognize(img));

    setField(recognitionScore := doubleAvg(pairsB(recognized));

    setField(fen := makeFEN());

    print(recognized);

    recreate();

  }

  Rect wiggleRect(Rect r) {

    if (r == null) null;

    int range = 1;

    ret intersectRects(imageRect(img),

      rectFromPoints(varyInt(range, r.x), varyInt(range, r.y),

        varyInt(range, r.x2()), varyInt(range, r.y2())));

  }

  abstract JComponent segmenterSection();

  abstract Iterator<ParameterizedSegmenter> makeSegmenters();

}