public static void main(String args[]) throws FileNotFoundException {

    DetectCalibrationChessApp app = new DetectCalibrationChessApp();

    //		String prefix = "../data/applet/calibration/mono/Sony_DSC-HX5V_Chess/";
    String prefix = "../data/applet/calibration/stereo/Bumblebee2_Chess/";

    app.loadConfigurationFile(prefix + "info.txt");

    app.setBaseDirectory(prefix);
    //		app.loadInputData(prefix+"images.txt");

    List<PathLabel> inputs = new ArrayList<PathLabel>();

    for (int i = 1; i <= 12; i++) {
      //			inputs.add(new PathLabel(String.format("View
      // %02d",i),String.format("%sframe%02d.jpg",prefix,i)));
      inputs.add(
          new PathLabel(String.format("View %02d", i), String.format("%sleft%02d.jpg", prefix, i)));
    }

    app.setInputList(inputs);

    // wait for it to process one image so that the size isn't all screwed up
    while (!app.getHasProcessedImage()) {
      Thread.yield();
    }

    ShowImages.showWindow(app, "Calibration Target Detection", true);
  }
  public static void main(String args[]) {

    IntensityFeatureScaleSpacePyramidApp<ImageFloat32, ImageFloat32> app =
        new IntensityFeatureScaleSpacePyramidApp<ImageFloat32, ImageFloat32>(
            ImageFloat32.class, ImageFloat32.class);

    //		IntensityFeatureScaleSpacePyramidApp<ImageUInt8, ImageSInt16> app2 =
    //				new
    // IntensityFeatureScaleSpacePyramidApp<ImageUInt8,ImageSInt16>(ImageUInt8.class,ImageSInt16.class);

    java.util.List<PathLabel> inputs = new ArrayList<PathLabel>();

    inputs.add(new PathLabel("shapes", "../data/evaluation/shapes01.png"));
    inputs.add(new PathLabel("sunflowers", "../data/evaluation/sunflowers.png"));
    inputs.add(new PathLabel("beach", "../data/evaluation/scale/beach02.jpg"));

    app.setInputList(inputs);

    // wait for it to process one image so that the size isn't all screwed up
    while (!app.getHasProcessedImage()) {
      Thread.yield();
    }

    ShowImages.showWindow(app, "Feature Scale Space Pyramid Intensity");
  }
  /**
   * Detects contours inside the binary image generated by canny. Only the external contour is
   * relevant. Often easier to deal with than working with Canny edges directly.
   */
  public static void fitCannyBinary(ImageFloat32 input) {

    BufferedImage displayImage =
        new BufferedImage(input.width, input.height, BufferedImage.TYPE_INT_RGB);
    ImageUInt8 binary = new ImageUInt8(input.width, input.height);

    // Finds edges inside the image
    CannyEdge<ImageFloat32, ImageFloat32> canny =
        FactoryEdgeDetectors.canny(2, false, true, ImageFloat32.class, ImageFloat32.class);

    canny.process(input, 0.1f, 0.3f, binary);

    List<Contour> contours = BinaryImageOps.contour(binary, 8, null);

    Graphics2D g2 = displayImage.createGraphics();
    g2.setStroke(new BasicStroke(2));

    // used to select colors for each line
    Random rand = new Random(234);

    for (Contour c : contours) {
      // Only the external contours are relevant.
      List<PointIndex_I32> vertexes =
          ShapeFittingOps.fitPolygon(c.external, true, toleranceDist, toleranceAngle, 100);

      g2.setColor(new Color(rand.nextInt()));
      VisualizeShapes.drawPolygon(vertexes, true, g2);
    }

    ShowImages.showWindow(displayImage, "Canny Contour");
  }
  /**
   * Fits a sequence of line-segments into a sequence of points found using the Canny edge detector.
   * In this case the points are not connected in a loop. The canny detector produces a more complex
   * tree and the fitted points can be a bit noisy compared to the others.
   */
  public static void fitCannyEdges(ImageFloat32 input) {

    BufferedImage displayImage =
        new BufferedImage(input.width, input.height, BufferedImage.TYPE_INT_RGB);

    // Finds edges inside the image
    CannyEdge<ImageFloat32, ImageFloat32> canny =
        FactoryEdgeDetectors.canny(2, true, true, ImageFloat32.class, ImageFloat32.class);

    canny.process(input, 0.1f, 0.3f, null);
    List<EdgeContour> contours = canny.getContours();

    Graphics2D g2 = displayImage.createGraphics();
    g2.setStroke(new BasicStroke(2));

    // used to select colors for each line
    Random rand = new Random(234);

    for (EdgeContour e : contours) {
      g2.setColor(new Color(rand.nextInt()));

      for (EdgeSegment s : e.segments) {
        // fit line segments to the point sequence.  Note that loop is false
        List<PointIndex_I32> vertexes =
            ShapeFittingOps.fitPolygon(s.points, false, toleranceDist, toleranceAngle, 100);

        VisualizeShapes.drawPolygon(vertexes, false, g2);
      }
    }

    ShowImages.showWindow(displayImage, "Canny Trace");
  }
  public static void main(String args[]) {
    BufferedImage input = UtilImageIO.loadImage("../data/evaluation/sunflowers.png");
    //		BufferedImage input = UtilImageIO.loadImage("../data/evaluation/shapes01.png");

    ImageFloat32 gray = ConvertBufferedImage.convertFromSingle(input, null, ImageFloat32.class);

    SiftDetector alg = FactoryInterestPointAlgs.siftDetector(new ConfigSiftDetector(3, 10, 150, 5));
    SiftImageScaleSpace imageSS = new SiftImageScaleSpace(1.6f, 5, 4, false);

    imageSS.constructPyramid(gray);
    imageSS.computeFeatureIntensity();

    alg.process(imageSS);

    System.out.println("total features found: " + alg.getFoundPoints().size());

    VisualizeFeatures.drawScalePoints(
        input.createGraphics(),
        alg.getFoundPoints().toList(),
        BoofDefaults.SCALE_SPACE_CANONICAL_RADIUS);

    ListDisplayPanel dog = new ListDisplayPanel();
    for (int i = 0; i < alg.ss.dog.length; i++) {
      int scale = i % (alg.ss.numScales - 1);
      int octave = i / (alg.ss.numScales - 1);

      BufferedImage img = VisualizeImageData.colorizeSign(alg.ss.dog[i], null, -1);
      dog.addImage(img, octave + "  " + scale);
    }

    ListDisplayPanel ss = new ListDisplayPanel();
    for (int i = 0; i < alg.ss.scale.length; i++) {
      int scale = i % alg.ss.numScales;
      int octave = i / alg.ss.numScales;

      BufferedImage img = VisualizeImageData.grayMagnitude(alg.ss.scale[i], null, 255);
      ss.addImage(img, octave + "  " + scale);
    }
    ShowImages.showWindow(dog, "Octave DOG");
    ShowImages.showWindow(ss, "Octave Scales");
    ShowImages.showWindow(input, "Found Features");

    System.out.println("Done");
  }
  public static void main(String args[]) {
    BufferedImage input = UtilImageIO.loadImage("corn1.png");

    detectLines(input, ImageUInt8.class, ImageSInt16.class);

    // line segment detection is still under development and only works for F32 images right now
    detectLineSegments(input, ImageFloat32.class, ImageFloat32.class);

    ShowImages.showWindow(listPanel, "Detected Lines");
  }
  public static void main(String args[]) {
    // load and convert the image into a usable format
    BufferedImage image = UtilImageIO.loadImage("../data/applet/shapes02.png");
    ImageFloat32 input = ConvertBufferedImage.convertFromSingle(image, null, ImageFloat32.class);

    ShowImages.showWindow(image, "Original");

    fitCannyEdges(input);
    fitCannyBinary(input);
    fitBinaryImage(input);
  }
  public static void main(String[] args) {

    DescribeImageDense<ImageUInt8, TupleDesc_F64> desc =
        (DescribeImageDense)
            FactoryDescribeImageDense.surfFast(
                null, new ConfigDenseSample(DESC_SCALE, DESC_SKIP, DESC_SKIP), ImageUInt8.class);

    ComputeClusters<double[]> clusterer =
        FactoryClustering.kMeans_F64(null, MAX_KNN_ITERATIONS, 20, 1e-6);
    clusterer.setVerbose(true);

    NearestNeighbor<HistogramScene> nn = FactoryNearestNeighbor.exhaustive();
    ExampleClassifySceneKnn example = new ExampleClassifySceneKnn(desc, clusterer, nn);

    File trainingDir = new File(UtilIO.pathExample("learning/scene/train"));
    File testingDir = new File(UtilIO.pathExample("learning/scene/test"));

    if (!trainingDir.exists() || !testingDir.exists()) {
      System.err.println(
          "Please follow instructions in data/applet/learning/scene and download the");
      System.err.println("required files");
      System.exit(1);
    }

    example.loadSets(trainingDir, null, testingDir);
    // train the classifier
    example.learnAndSave();
    // now load it for evaluation purposes from the files
    example.loadAndCreateClassifier();

    // test the classifier on the test set
    Confusion confusion = example.evaluateTest();
    confusion.getMatrix().print();
    System.out.println("Accuracy = " + confusion.computeAccuracy());

    // Show confusion matrix
    // Not the best coloration scheme...  perfect = red diagonal and blue elsewhere.
    ShowImages.showWindow(
        new ConfusionMatrixPanel(confusion.getMatrix(), 400, true), "Confusion Matrix", true);

    // For  "fast"  SURF descriptor the accuracy is 52.2%
    // For "stable" SURF descriptor the accuracy is 49.4%

    // This is interesting. When matching images "stable" is significantly better than "fast"
    // One explanation is that the descriptor for "fast" samples a smaller region than "stable", by
    // a
    // couple of pixels at scale of 1.  Thus there is less overlap between the features.

    // Reducing the size of "stable" to 0.95 does slightly improve performance to 50.5%, can't scale
    // it down
    // much more without performance going down
  }
  public static void main(String args[]) {
    Class imageType = ImageFloat32.class;
    Class derivType = GImageDerivativeOps.getDerivativeType(imageType);

    VisualizeAssociationMatchesApp app = new VisualizeAssociationMatchesApp(imageType, derivType);

    List<PathLabel> inputs = new ArrayList<PathLabel>();

    inputs.add(
        new PathLabel(
            "Cave",
            "../data/evaluation/stitch/cave_01.jpg",
            "../data/evaluation/stitch/cave_02.jpg"));
    inputs.add(
        new PathLabel(
            "Kayak",
            "../data/evaluation/stitch/kayak_02.jpg",
            "../data/evaluation/stitch/kayak_03.jpg"));
    inputs.add(
        new PathLabel(
            "Forest",
            "../data/evaluation/scale/rainforest_01.jpg",
            "../data/evaluation/scale/rainforest_02.jpg"));
    inputs.add(
        new PathLabel(
            "Building",
            "../data/evaluation/stitch/apartment_building_01.jpg",
            "../data/evaluation/stitch/apartment_building_02.jpg"));
    inputs.add(
        new PathLabel(
            "Trees Rotate",
            "../data/evaluation/stitch/trees_rotate_01.jpg",
            "../data/evaluation/stitch/trees_rotate_03.jpg"));

    app.setPreferredSize(new Dimension(1000, 500));
    app.setSize(1000, 500);
    app.setInputList(inputs);

    // wait for it to process one image so that the size isn't all screwed up
    while (!app.getHasProcessedImage()) {
      Thread.yield();
    }

    ShowImages.showWindow(app, "Associated Features");
  }
  public static void main(String args[]) {
    //		VisualizeScaleSpaceApp app = new VisualizeScaleSpaceApp(ImageFloat32.class);
    VisualizeScaleSpaceApp app = new VisualizeScaleSpaceApp(ImageUInt8.class);

    List<PathLabel> inputs = new ArrayList<PathLabel>();
    inputs.add(new PathLabel("boat", "../data/evaluation/standard/boat.png"));
    inputs.add(new PathLabel("shapes", "../data/evaluation/shapes01.png"));
    inputs.add(new PathLabel("sunflowers", "../data/evaluation/sunflowers.png"));

    app.setInputList(inputs);

    // wait for it to process one image so that the size isn't all screwed up
    while (!app.getHasProcessedImage()) {
      Thread.yield();
    }

    ShowImages.showWindow(app, "Scale Space");
  }
  public static void main(String args[]) {
    DemoBinaryImageOpsApp app = new DemoBinaryImageOpsApp(GrayF32.class);

    java.util.List<PathLabel> inputs = new ArrayList<>();
    inputs.add(new PathLabel("particles", UtilIO.pathExample("particles01.jpg")));
    inputs.add(new PathLabel("shapes", UtilIO.pathExample("shapes/shapes01.png")));

    app.setInputList(inputs);

    // wait for it to process one image so that the size isn't all screwed up
    while (!app.getHasProcessedImage()) {
      Thread.yield();
    }

    ShowImages.showWindow(app, "Binary Image Ops", true);

    System.out.println("Done");
  }
  public void process(final SimpleImageSequence<T> sequence) {

    if (!sequence.hasNext()) throw new IllegalArgumentException("Empty sequence");

    image = sequence.next();
    gui.setFrame((BufferedImage) sequence.getGuiImage());
    ShowImages.showWindow(gui, "Circulant Tracker");

    //		tracker.initialize(image,273,156,358-273,293-156);

    paused = true;

    while (paused) {
      Thread.yield();
    }

    int totalFrames = 0;
    long totalTime = 0;

    while (sequence.hasNext()) {
      totalFrames++;

      image = sequence.next();
      gui.setFrame((BufferedImage) sequence.getGuiImage());

      long before = System.nanoTime();
      tracker.performTracking(image);
      long after = System.nanoTime();

      totalTime += after - before;
      System.out.println("FPS = " + (totalFrames) / (totalTime / 2e9));

      gui.update(tracker);

      Rectangle2D_F32 r = tracker.getTargetLocation();
      System.out.println("Target: " + r);
      gui.repaint();

      while (paused) {
        Thread.yield();
      }
    }
    System.out.println("DONE");
  }
  public static void main(String args[]) {
    FourierVisualizeApp app = new FourierVisualizeApp(ImageDataType.F32);
    //		FourierVisualizeApp app = new FourierVisualizeApp(ImageTypeInfo.F64);

    java.util.List<PathLabel> inputs = new ArrayList<PathLabel>();
    inputs.add(new PathLabel("lena", "../data/evaluation/standard/lena512.bmp"));
    inputs.add(new PathLabel("boat", "../data/evaluation/standard/boat.png"));
    inputs.add(new PathLabel("fingerprint", "../data/evaluation/standard/fingerprint.png"));
    inputs.add(new PathLabel("shapes", "../data/evaluation/shapes01.png"));
    inputs.add(new PathLabel("sunflowers", "../data/evaluation/sunflowers.png"));

    app.setInputList(inputs);

    // wait for it to process one image so that the size isn't all screwed up
    while (!app.getHasProcessedImage()) {
      Thread.yield();
    }

    ShowImages.showWindow(app, "Discrete Fourier Transform");
  }
  /** Fits polygons to found contours around binary blobs. */
  public static void fitBinaryImage(ImageFloat32 input) {

    ImageUInt8 binary = new ImageUInt8(input.width, input.height);
    BufferedImage polygon =
        new BufferedImage(input.width, input.height, BufferedImage.TYPE_INT_RGB);

    // the mean pixel value is often a reasonable threshold when creating a binary image
    double mean = ImageStatistics.mean(input);

    // create a binary image by thresholding
    ThresholdImageOps.threshold(input, binary, (float) mean, true);

    // reduce noise with some filtering
    ImageUInt8 filtered = BinaryImageOps.erode8(binary, null);
    filtered = BinaryImageOps.dilate8(filtered, null);

    // Find the contour around the shapes
    List<Contour> contours = BinaryImageOps.contour(filtered, 8, null);

    // Fit a polygon to each shape and draw the results
    Graphics2D g2 = polygon.createGraphics();
    g2.setStroke(new BasicStroke(2));

    for (Contour c : contours) {
      // Fit the polygon to the found external contour.  Note loop = true
      List<PointIndex_I32> vertexes =
          ShapeFittingOps.fitPolygon(c.external, true, toleranceDist, toleranceAngle, 100);

      g2.setColor(Color.RED);
      VisualizeShapes.drawPolygon(vertexes, true, g2);

      // handle internal contours now
      g2.setColor(Color.BLUE);
      for (List<Point2D_I32> internal : c.internal) {
        vertexes = ShapeFittingOps.fitPolygon(internal, true, toleranceDist, toleranceAngle, 100);
        VisualizeShapes.drawPolygon(vertexes, true, g2);
      }
    }

    ShowImages.showWindow(polygon, "Binary Blob Contours");
  }
  public static void main(String[] args) {

    String nameIntrinsic = null;
    int cameraId = 0;

    if (args.length >= 1) {
      cameraId = Integer.parseInt(args[0]);
    }
    if (args.length >= 2) {
      nameIntrinsic = args[1];
    } else {
      System.out.println();
      System.out.println("SERIOUSLY YOU NEED TO CALIBRATE THE CAMERA YOURSELF!");
      System.out.println("There will be a lot more jitter and inaccurate pose");
      System.out.println();
    }

    System.out.println();
    System.out.println("camera ID = " + cameraId);
    System.out.println("intrinsic file = " + nameIntrinsic);
    System.out.println();

    Webcam webcam = Webcam.getWebcams().get(cameraId);
    UtilWebcamCapture.adjustResolution(webcam, 640, 480);
    webcam.open();

    Dimension d = webcam.getDevice().getResolution();
    int imageWidth = d.width;
    int imageHeight = d.height;

    ConfigPolygonDetector config = new ConfigPolygonDetector(4);
    config.configRefineLines.sampleRadius = 2;
    config.configRefineLines.maxIterations = 30;

    InputToBinary<ImageFloat32> inputToBinary =
        FactoryThresholdBinary.globalOtsu(0, 255, true, ImageFloat32.class);
    //				FactoryThresholdBinary.globalEntropy(0,255,true,ImageFloat32.class);
    //				FactoryThresholdBinary.adaptiveSquare(10,0,true,ImageFloat32.class);
    BinaryPolygonConvexDetector<ImageFloat32> detector =
        FactoryShapeDetector.polygon(
            inputToBinary, new ConfigPolygonDetector(4), ImageFloat32.class);

    ImageFloat32 gray = new ImageFloat32(imageWidth, imageHeight);
    ImagePanel gui = new ImagePanel(imageWidth, imageHeight);
    ShowImages.showWindow(gui, "Fiducials", true);

    while (true) {
      BufferedImage frame = webcam.getImage();

      ConvertBufferedImage.convertFrom(frame, gray);

      detector.process(gray);

      // display the results
      Graphics2D g2 = frame.createGraphics();

      List<Polygon2D_F64> shapes = detector.getFound().toList();

      g2.setStroke(new BasicStroke(4));
      g2.setColor(Color.RED);
      g2.setRenderingHint(RenderingHints.KEY_STROKE_CONTROL, RenderingHints.VALUE_STROKE_PURE);
      g2.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
      Line2D.Double l = new Line2D.Double();

      for (int i = 0; i < shapes.size(); i++) {
        Polygon2D_F64 poly = shapes.get(i);

        for (int j = 0; j < poly.size(); j++) {
          int k = (j + 1) % poly.size();

          l.setLine(poly.get(j).x, poly.get(j).y, poly.get(k).x, poly.get(k).y);
          g2.draw(l);
        }
      }

      gui.setBufferedImageSafe(frame);
      gui.repaint();
    }
  }
  public void evaluate(String dataName, TldTracker<T, ?> tracker) {
    System.out.println("Processing " + dataName);

    String path = "data/track_rect/TLD/" + dataName;

    Rectangle2D_F64 initial = UtilTldData.parseRectangle(path + "/init.txt");
    Rectangle2D_F64 found = new Rectangle2D_F64();

    TldVisualizationPanel gui = null;

    String imageType = new File(path + "/00001.jpg").exists() ? "jpg" : "png";

    int imageNum = 0;
    while (true) {
      String imageName = String.format("%s/%05d.%s", path, imageNum + 1, imageType);
      BufferedImage image = UtilImageIO.loadImage(imageName);
      if (image == null) break;

      input.reshape(image.getWidth(), image.getHeight());
      ConvertBufferedImage.convertFrom(image, input, true);

      boolean detected;

      if (imageNum == 0) {
        gui = new TldVisualizationPanel(this);
        gui.setFrame(image);
        gui.setSelectRectangle(false);
        ShowImages.showWindow(gui, dataName);
        tracker.initialize(
            input, (int) initial.p0.x, (int) initial.p0.y, (int) initial.p1.x, (int) initial.p1.y);
        detected = true;
      } else {
        detected = tracker.track(input);
        found.set(tracker.getTargetRegion());
      }

      if (!detected) {
        System.out.println("No Detection");
      } else {
        System.out.printf(
            "Detection: %f,%f,%f,%f\n", found.p0.x, found.p0.y, found.p1.x, found.p1.y);

        Graphics2D g2 = image.createGraphics();

        int w = (int) found.getWidth();
        int h = (int) found.getHeight();

        g2.drawRect((int) found.p0.x, (int) found.p0.y, w, h);
      }

      gui.setFrame(image);
      gui.update(tracker, detected);
      gui.repaint();

      imageNum++;

      while (paused) {
        Thread.yield();
      }

      //			BoofMiscOps.pause(30);
    }
    System.out.println();
  }
  public static void main(String[] args) {

    // Example with a moving camera.  Highlights why motion estimation is sometimes required
    String fileName = UtilIO.pathExample("tracking/chipmunk.mjpeg");
    // Camera has a bit of jitter in it.  Static kinda works but motion reduces false positives
    //		String fileName = UtilIO.pathExample("background/horse_jitter.mp4");

    // Comment/Uncomment to switch input image type
    ImageType imageType = ImageType.single(GrayF32.class);
    //		ImageType imageType = ImageType.il(3, InterleavedF32.class);
    //		ImageType imageType = ImageType.il(3, InterleavedU8.class);

    // Configure the feature detector
    ConfigGeneralDetector confDetector = new ConfigGeneralDetector();
    confDetector.threshold = 10;
    confDetector.maxFeatures = 300;
    confDetector.radius = 6;

    // Use a KLT tracker
    PointTracker tracker =
        FactoryPointTracker.klt(new int[] {1, 2, 4, 8}, confDetector, 3, GrayF32.class, null);

    // This estimates the 2D image motion
    ImageMotion2D<GrayF32, Homography2D_F64> motion2D =
        FactoryMotion2D.createMotion2D(
            500, 0.5, 3, 100, 0.6, 0.5, false, tracker, new Homography2D_F64());

    ConfigBackgroundBasic configBasic = new ConfigBackgroundBasic(30, 0.005f);

    // Configuration for Gaussian model.  Note that the threshold changes depending on the number of
    // image bands
    // 12 = gray scale and 40 = color
    ConfigBackgroundGaussian configGaussian = new ConfigBackgroundGaussian(12, 0.001f);
    configGaussian.initialVariance = 64;
    configGaussian.minimumDifference = 5;

    // Comment/Uncomment to switch background mode
    BackgroundModelMoving background =
        FactoryBackgroundModel.movingBasic(
            configBasic, new PointTransformHomography_F32(), imageType);
    //				FactoryBackgroundModel.movingGaussian(configGaussian, new PointTransformHomography_F32(),
    // imageType);

    MediaManager media = DefaultMediaManager.INSTANCE;
    SimpleImageSequence video = media.openVideo(fileName, background.getImageType());
    //				media.openCamera(null,640,480,background.getImageType());

    // ====== Initialize Images

    // storage for segmented image.  Background = 0, Foreground = 1
    GrayU8 segmented = new GrayU8(video.getNextWidth(), video.getNextHeight());
    // Grey scale image that's the input for motion estimation
    GrayF32 grey = new GrayF32(segmented.width, segmented.height);

    // coordinate frames
    Homography2D_F32 firstToCurrent32 = new Homography2D_F32();
    Homography2D_F32 homeToWorld = new Homography2D_F32();
    homeToWorld.a13 = grey.width / 2;
    homeToWorld.a23 = grey.height / 2;

    // Create a background image twice the size of the input image.  Tell it that the home is in the
    // center
    background.initialize(grey.width * 2, grey.height * 2, homeToWorld);

    BufferedImage visualized =
        new BufferedImage(segmented.width, segmented.height, BufferedImage.TYPE_INT_RGB);
    ImageGridPanel gui = new ImageGridPanel(1, 2);
    gui.setImages(visualized, visualized);

    ShowImages.showWindow(gui, "Detections", true);

    double fps = 0;
    double alpha = 0.01; // smoothing factor for FPS

    while (video.hasNext()) {
      ImageBase input = video.next();

      long before = System.nanoTime();
      GConvertImage.convert(input, grey);

      if (!motion2D.process(grey)) {
        throw new RuntimeException("Should handle this scenario");
      }

      Homography2D_F64 firstToCurrent64 = motion2D.getFirstToCurrent();
      UtilHomography.convert(firstToCurrent64, firstToCurrent32);

      background.segment(firstToCurrent32, input, segmented);
      background.updateBackground(firstToCurrent32, input);
      long after = System.nanoTime();

      fps = (1.0 - alpha) * fps + alpha * (1.0 / ((after - before) / 1e9));

      VisualizeBinaryData.renderBinary(segmented, false, visualized);
      gui.setImage(0, 0, (BufferedImage) video.getGuiImage());
      gui.setImage(0, 1, visualized);
      gui.repaint();

      System.out.println("FPS = " + fps);

      try {
        Thread.sleep(5);
      } catch (InterruptedException e) {
      }
    }
  }