How to use

convertFromPlanar

method

in

boofcv.io.image.ConvertBufferedImage

public void process( final BufferedImage image ) {
  input.reshape(image.getWidth(),image.getHeight());
  output.reshape(image.getWidth(),image.getHeight());
  ConvertBufferedImage.convertFromPlanar(image, input,true, GrayF32.class);
  SwingUtilities.invokeLater(new Runnable() {
    public void run() {
      setInputImage(image);
      doRefreshAll();
    }});
}

public void process( final BufferedImage image ) {
  input.reshape(image.getWidth(),image.getHeight());
  output.reshape(image.getWidth(),image.getHeight());
  storage.reshape(image.getWidth(),image.getHeight());
  ConvertBufferedImage.convertFromPlanar(image, input, true, imageType);
  SwingUtilities.invokeLater(new Runnable() {
    public void run() {
      setInputImage(image);
      renderedImage = new BufferedImage(input.width, input.height,BufferedImage.TYPE_INT_BGR);
      gui.setImage(renderedImage);
      gui.setPreferredSize(new Dimension(input.width,input.height));
      gui.repaint();
      processedImage = true;
      doRefreshAll();
    }});
}

/**
 * The actual classification of the images by using the pre-trained model.
 */
private static Entry<String, Double> classifyWithModel(ImageClassifierVggCifar10 classifier, BufferedImage image) {
  Planar<GrayF32> planar = new Planar<>(GrayF32.class, image.getWidth(), image.getHeight(), 3);
  ConvertBufferedImage.convertFromPlanar(image, planar, true, GrayF32.class);
  classifier.classify(planar);
  return classifier.getAllResults().stream()
      .map(score -> entry(classifier.getCategories().get(score.category), score.score))
      .max(Comparator.comparing(Entry::getValue)).get();
}

public void process(final BufferedImage buffLeft, final BufferedImage buffRight) {
  imageLeft.reshape(buffLeft.getWidth(), buffLeft.getHeight());
  imageRight.reshape(buffRight.getWidth(), buffRight.getHeight());
  grayLeft.reshape(buffLeft.getWidth(), buffLeft.getHeight());
  grayRight.reshape(buffRight.getWidth(), buffRight.getHeight());
  ConvertBufferedImage.convertFromPlanar(buffLeft, imageLeft, true, imageType);
  ConvertBufferedImage.convertFromPlanar(buffRight, imageRight, true, imageType);
  GConvertImage.average(imageLeft, grayLeft);
  GConvertImage.average(imageRight, grayRight);
  SwingUtilities.invokeLater(new Runnable() {
    public void run() {
      panel.setImages(buffLeft, buffRight);
      processedImage = true;
      doRefreshAll();
    }
  });
}

private void setDescriptorInput() {
  if( describe != null )  {
    if( describe.getImageType().getFamily() == ImageType.Family.GRAY) {
      T input = ConvertBufferedImage.convertFromSingle(image, null, imageType);
      describe.setImage(input);
    } else {
      Planar<T> input = ConvertBufferedImage.convertFromPlanar(image, null, true, imageType);
      describe.setImage(input);
    }
  }
}

  public static void main(String[] args) {
    BufferedImage original = UtilImageIO.loadImage(UtilIO.pathExample("simple_objects.jpg"));

    Planar<GrayF32> input = new Planar<>(GrayF32.class,
        original.getWidth(),original.getHeight(),3);

    ConvertBufferedImage.convertFromPlanar(original,input,true,GrayF32.class);

    Planar<GrayF32> output = new Planar<>(GrayF32.class,
        original.getWidth()/3,original.getHeight()/3,3);
    Planar<GrayF32> output2 = new Planar<>(GrayF32.class,
        original.getWidth()/3,original.getHeight()/3,3);

    AverageDownSampleOps.down(input, output);
    new FDistort(input,output2).scaleExt().apply();

    BufferedImage outputFull = ConvertBufferedImage.convertTo_F32(output, null, true);
    BufferedImage outputFull2 = ConvertBufferedImage.convertTo_F32(output2, null, true);

    ShowImages.showWindow(original,"Original");
    ShowImages.showWindow(outputFull,"3x small average");
    ShowImages.showWindow(outputFull2,"3x small bilinear");
  }
}

distLeft = ConvertBufferedImage.convertFromPlanar(origLeft, null, true, GrayF32.class);
distRight = ConvertBufferedImage.convertFromPlanar(origRight, null, true, GrayF32.class);