!7

cm GazelleV > DynPrintLogAndEnabled {
  switchable int x1;
  switchable int y1;
  switchable int w = screenWidth();
  switchable int h = screenHeight();
  switchable double maxFPS = 10;
  switchable int previewWidth = 200;
  switchable double statsEvery = 5;
  switchable volatile bool brokenMethod;

  PersistableThrowable lastProcessingError;
  transient WithTimestamp<OKOrError<BufferedImage>> lastScreen;
  transient new Average screenShotTime;
  transient new Average iiTime;
  transient Timestamp loopStarted;
  transient new RestartableCountdown screenShotCountdown;
  transient ImageSurface imageSurface;
  transient Throwable currentProcessingError;
  transient BufferedImage previewImage;
  transient JButton popDownButton;
  transient JComponent topControls;
  transient long screenShotsTaken;
  transient double fps;
  transient Compression longTermCompression;
  transient S longTermCompressionProbability;
  transient S longTermCompressionScore;

  Rect area() { ret rect(x1, y1, w, h); }

  class Compression {
    settable BufferedImage image;
    settable BWIntegralImage ii;
    CompressionSearch_AnyType search;
    int baseLineLength; // length of trivial compression
    GridCodec1 codec;
    double compressionPercentage;

    S score() {
      var submission = search?.bestSubmission();
      Int compressedSize = or(submission.compressedSize(), baseLineLength);
      compressionPercentage = doubleRatio(compressedSize, baseLineLength)*100;
      ret formatDouble(compressionPercentage, 3) + "%";
    }

    IProbabilisticScheduler scheduler() {
      ret search?.scheduler();
    }

    S probability() {
      var scheduler = scheduler();
      if (scheduler == null) ret "-";
      var prob = scheduler.lastExecutedProbability();
      ret formatDouble(prob, 3);
    }

    run {
      int lHex = pixelCount(image)*8;
      baseLineLength = calculateLengthOfFunctionCall imageFromHex(lHex+2);
      print(+baseLineLength);

      codec = new GridCodec1(image);
      search = codec.forward();
      //showImage(codec.renderCellsLinearly());

      thread "Gazelle Visual" {
        repeat 60 {
          stepForNSeconds(1, search);
          print(stepCount := search.scheduler().stepCount());
          setFields(
            longTermCompressionProbability := probability(),
            longTermCompressionScore := score());
        }

        try {
          L<IJavaExpr> cellCompressions = codec.strat.codeForElements();
          //showText("Compression", lines(map shorten_str(cellCompressions)));

          S code = str(codec.winnerCode());
          S name = "Screenshot " + ymdMinusHMS();
          File f = makeFileNameUnique_beforeExtension(
            javaxDataDir("Compressed Screenshots/" + name + ".javax"));
          saveTextFile(f, code);
          printFileInfo(f);          
          saveGZTextFile(f = replaceExtension(f, ".jgz"), code);
          printFileInfo(f);

          /*
          print("Evaling " + nChars(code));
          //LL<Int> lol = cast dm_javaEval(code);
          BufferedImage restored = cast dm_javaEval(code);
          assertImagesIdentical(restored, image);
          print("Image restored!");

          dm_showImage("Restored from " + nChars(code), restored);
          */
        } catch e { printStackTrace(e); }
      }
    }
  }
  
  start-thread {
    dm_registerAs_direct gazelleV();
    dm_watchField enabled(r { if (enabled) dm_reload(); });

    // TODO: react to event sent by OS
    dm_doEvery(1.0, r {
      if (dm_moduleIsPoppedOut()) adjustUIForPoppedOutWindow();
    });
    
    print("Screen bounds: " + allScreenBounds());

    dm_doEvery(min(statsEvery, 10.0), statsEvery, r { if (enabled) printStats(); });

    loopStarted = tsNow();
    shoot();
  }

  void shoot enter {
    if (!enabled) ret;
    
    long targetTime = sysNow()+iround(1000/maxFPS);
    long time = nanoTime();

    try {
      lastScreen = withTimestamp(okOrError(-> screenshot(area())));
      ++screenShotsTaken;
      setField(fps := doubleRatio(screenShotsTaken, elapsedSeconds(loopStarted)));
      screenShotTime.add(nanosToSeconds(nanoTime()-time));
      if (lastScreen->isOK()) {
        time = nanoTime();
        var ii = BWIntegralImage(lastScreen!!);
        //var ii = BWIntegralImage_luminosity(lastScreen!!);
        iiTime.add(nanosToSeconds(nanoTime()-time));

        if (longTermCompression == null) {
          longTermCompression = new Compression()
            .image(lastScreen!!)
            .ii(ii);
          longTermCompression.run();
        }
  
        previewImage =
            // FAST BUT BROKEN!! 
            brokenMethod ? scaledBufferedImageFromBWIntegralImage(ii, previewWidth)
            : scaleDownUsingIntegralImageBW(ii, previewWidth).getBufferedImage();
        imageSurface?.setImage(previewImage);
        
        cpuTotal();
      }

      currentProcessingError = null;
    } catch print e {
      setField(lastProcessingError := currentProcessingError = e);
      sleepSeconds(60); // errors in processing are no good
    }
    
    screenShotCountdown.setTargetTime(targetTime, r shoot);
  }

  void printStats() { print(stats()); }

  S stats() {
    var screen = lastScreen?!;
    ret formatColonProperties_noNulls(
      "Monitored area", area(),
      "Error", screen?.getError(),
      "Last screenshot taken", lastScreen?.timeStamp(),
      "Average time to take a screenshot", screenShotTime,
      "Average time to make integral image", iiTime,
      "Capacity left in first core", percentRatioStrOneDigit(freeInCore()),
      "Total CPU used", cpuTotal(),
    );
  }

  S cpuTotal() {
    ret setFieldAndReturn(cpuTotal := percentRatioStrOneDigit((1-freeInCore())/numberOfCores()));
  }

  double freeInCore() {
    ret ratio(toSeconds(screenShotCountdown.totalSleepTime),
      elapsedSeconds(loopStarted));
  }

  replace jSection with jCenteredSection.  
  {}
  visual
    hsplit(northAndCenterWithMargin(
      topControls = hgrid(
        jSection("FPS", dm_calculatedCenteredLabel(() -> iround(fps))),
        jSection("Compression", dm_centeredFieldLabel longTermCompressionScore()),
        jSection("Probability", dm_centeredFieldLabel longTermCompressionProbability()),
        jSection("CPU (" + numberOfCores() + ")", dm_centeredFieldLabel cpuTotal())
      ),
      super /* print log */),
    jscroll_center(imageSurface = doubleBufferedImageSurface_noAlpha()));
  
  BufferedImage lastScreenImage() { ret getVar(getVar(lastScreen)); }

  void adjustUIForPoppedOutWindow swing {
    if (popDownButton == null) {
      Window window = cast getWindow(dm_vis());

      var popBackInButton = findButton(window, "Pop Back In");
      var parent = getParent(popBackInButton);
      print(+parent);
      
      removeFromParent(parent); // hide controls
      
      popDownButton = jPopDownButton_noText(
        "Pop Back In", r { dm_popInModule(me()) },
        jCheckBoxMenuItem("Always On Top", isAlwaysOnTop(window),
          rEnter dm_toggleAlwaysOnTop),
      );
      addControl(popDownButton);      
    }
  }
}

Began life as a copy of #1033298