How to use

convertFrom

method

in

boofcv.io.image.ConvertBufferedImage

/**
 * Converts a buffered image into an image of the specified type.  In a 'dst' image is provided
 * it will be used for output, otherwise a new image will be created.
 */
public static <T extends ImageGray> T convertFromSingle(BufferedImage src, T dst, Class<T> type) {
  if (type == GrayU8.class) {
    return (T) convertFrom(src, (GrayU8) dst);
  } else if( GrayI16.class.isAssignableFrom(type) ) {
    return (T) convertFrom(src, (GrayI16) dst,(Class)type);
  } else if (type == GrayF32.class) {
    return (T) convertFrom(src, (GrayF32) dst);
  } else {
    throw new IllegalArgumentException("Unknown type " + type);
  }
}

@Override
public T next() {
  if( bufferedImage == null )
    bufferedImage = webcam.getImage();
  ConvertBufferedImage.convertFrom(bufferedImage, output, true);
  return output;
}

public GrayF32 getGrayF32() {
  GrayF32 gray = new GrayF32(bufferred.getWidth(),bufferred.getHeight());
  ConvertBufferedImage.convertFrom(bufferred,gray);
  return gray;
}

public GrayU8 getGrayU8() {
  GrayU8 gray = new GrayU8(bufferred.getWidth(),bufferred.getHeight());
  ConvertBufferedImage.convertFrom(bufferred,gray);
  return gray;
}

@Override
public T next() {
  if( bufferedImage == null )
    bufferedImage = webcam.getImage();
  ConvertBufferedImage.convertFrom(bufferedImage, output, true);
  return output;
}

private void loadImage( String imagePath ) {
  BufferedImage in = UtilImageIO.loadImage(imagePath);
  image = ConvertBufferedImage.convertFrom(in,(GrayF32)null);
}

public static <T extends ImageBase> T loadImage( File image, boolean orderRgb, ImageType<T> imageType ) {
  BufferedImage img = loadImage(image.getAbsolutePath());
  if( img == null )
    return null;
  T output = imageType.createImage(img.getWidth(),img.getHeight());
  ConvertBufferedImage.convertFrom(img, orderRgb, output);
  return output;
}

@Override
public T next() {
  original = next;
  image.reshape(original.getWidth(),original.getHeight());
  ConvertBufferedImage.convertFrom(original,image,true);
  readNext();
  return image;
}

@Override
public T next() {
  original = next;
  image.reshape(original.getWidth(),original.getHeight());
  ConvertBufferedImage.convertFrom(original,image, true);
  readNext();
  return image;
}

/**
 *
 */
public BufferedFileImageSequence(ImageType<T> type, BufferedImage[] orig) {
  this.type = type;
  this.orig = orig;
  images = type.createArray( orig.length );
  for( int i = 0; i < orig.length; i++ ) {
    BufferedImage b = orig[i];
    images[i] = type.createImage(b.getWidth(),b.getHeight());
    ConvertBufferedImage.convertFrom(orig[i], images[i], true);
  }
}

@Override
public T next() {
  if( finished)
    return null;
  current.createGraphics().drawImage(next,0,0,null);
  try {
    next = converter.convert(frameGrabber.grab());
    frameNumber++;
  } catch (FrameGrabber.Exception e) {
    finished = true;
  }
  if( frameNumber >= frameGrabber.getLengthInFrames() )
    finished = true;
  ConvertBufferedImage.convertFrom(current,currentBoof,true);
  return currentBoof;
}

private void setupImages(BufferedImage input) {
 int w = input.getWidth();
 int h = input.getHeight();
 this.input = input;
 // create output images
 this.work = new BufferedImage(w,h,BufferedImage.TYPE_INT_RGB);
 this.selected = new InterleavedU8(w,h,1);
 // Convert the input image into the HSV color model
 hsv = new Planar<GrayF32>(GrayF32.class,w,h,3);
 Planar<GrayF32> inputMS = new Planar<GrayF32>(GrayF32.class,w,h,3);
 ConvertBufferedImage.convertFrom(input, inputMS, true);
 ColorHsv.rgbToHsv_F32(inputMS, hsv);
 hsv = inputMS;
}

public void process( BufferedImage image , Gaussian3D_F64 model ) {
 binary.reshape(image.getWidth(),image.getHeight());
 colorRGB.reshape(image.getWidth(),image.getHeight());
 ConvertBufferedImage.convertFrom(image, colorRGB, true);
 GaussianColorClassifier.classify(colorRGB,model,12,binary);
 int color = 0xe394bb;
 for( int y = 0; y < binary.height; y++ ) {
   for( int x = 0; x < binary.width; x++ ) {
    int[] data = new int[1];
    binary.get(x,y, data);
    if( data[0] != 0 ) {
      image.setRGB(x,y,color);
    }
   }
 }
 ShowImages.showWindow(image,"Segmented");
}

public void process( BufferedImage input ) {
  setInputImage(input);
  image.reshape(input.getWidth(),input.getHeight());
  transform.reshape(input.getWidth(),input.getHeight());
  magnitude.reshape(input.getWidth(),input.getHeight());
  phase.reshape(input.getWidth(),input.getHeight());
  ConvertBufferedImage.convertFrom(input, image, true);
  fft.forward(image,transform);
  GDiscreteFourierTransformOps.shiftZeroFrequency(transform,true);
  GDiscreteFourierTransformOps.magnitude(transform, magnitude);
  GDiscreteFourierTransformOps.phase(transform, phase);
  // Convert it to a log scale for visibility
  GPixelMath.log(magnitude, magnitude);
  SwingUtilities.invokeLater(new Runnable() {
    public void run() {
      setPreferredSize(new Dimension(image.width+50,image.height+20));
      processedImage = true;
    }});
  doRefreshAll();
}

public boolean estimateCameraPose(BufferedImage leftEye)
{
 if (!hasIntrinsic)
   return false;
 gray.reshape(leftEye.getWidth(), leftEye.getHeight());
 ConvertBufferedImage.convertFrom(leftEye, gray);
 if (!target.process(gray))
   return false;
 if (!computeH.computeHomography(target.getDetectedPoints()))
   return false;
 DenseMatrix64F H = computeH.getHomography();
 targetToOrigin.set(decomposeH.decompose(H));
 return true;
}

public VisualizeTldDetectionApp( BufferedImage input , Class<T> imageType ) {
  super(new BorderLayout());
  this.input = input;
  gray = GeneralizedImageOps.createSingleBand(imageType,input.getWidth(),input.getHeight());
  ConvertBufferedImage.convertFrom(input,gray,true);
  Class<D> derivType = GImageDerivativeOps.getDerivativeType(imageType);
  InterpolatePixelS<T> interpolate = FactoryInterpolation.bilinearPixelS(imageType, BorderType.EXTENDED);
  ImageGradient<T,D> gradient =  FactoryDerivative.sobel(imageType, derivType);
  tracker = new TldTracker<>(new TldParameters(), interpolate, gradient, imageType, derivType);
  tracker.setPerformLearning(false);
  addMouseListener(this);
  requestFocus();
  setPreferredSize(new Dimension(gray.width,gray.height));
  ShowImages.showWindow(this,"Visualize Detection");
}

@Override
public void setBufferedImage(BufferedImage image) {
  BoofSwingUtil.checkGuiThread();
  super.setBufferedImage(image);
  ConvertBufferedImage.convertFrom(image,imageFisheye,true);
  if( imageFisheye.getNumBands() != imageRendered.getNumBands() ) {
    imageRendered = imageFisheye.createNew(1,1);
  }
  renderPinhole();
}

  public static void main(String[] args) {
    BufferedImage image = UtilImageIO.loadImage(UtilIO.pathExample("segment/berkeley_horses.jpg"));
    GrayU8 gray = new GrayU8(image.getWidth(),image.getHeight());

    ConvertBufferedImage.convertFrom(image, gray);

    WatershedVincentSoille1991 alg = FactorySegmentationAlg.watershed(ConnectRule.FOUR);
    alg.process(gray);

    GrayS32 pixelToRegion = alg.getOutput();

    VisualizeRegions.watersheds(pixelToRegion,image,0);

    alg.removeWatersheds();
    int numRegions = alg.getTotalRegions();
    BufferedImage outRegions = VisualizeRegions.regions(pixelToRegion,numRegions,null);

    ShowImages.showWindow(image, "Watershed");
    ShowImages.showWindow(outRegions, "Regions");
  }
}

private void undoRadialDistortion(BufferedImage image) {
  if( undoRadial == null )
    return;
  ConvertBufferedImage.convertFrom(image,origMS,true);
  if( correctedMS.getNumBands() != origMS.getNumBands() )
    correctedMS.setNumberOfBands(origMS.getNumBands());
  correctedMS.reshape(origMS.width,origMS.height);
  for( int i = 0; i < origMS.getNumBands(); i++ ) {
    GrayF32 in = origMS.getBand(i);
    GrayF32 out = correctedMS.getBand(i);
    undoRadial.apply(in,out);
  }
  undistorted = ConvertBufferedImage.checkDeclare(origMS.width,origMS.height,undistorted,image.getType());
  ConvertBufferedImage.convertTo(correctedMS,undistorted,true);
}

  public static void main(String[] args) {
    BufferedImage input = UtilImageIO.loadImage(UtilIO.pathExample("sunflowers.jpg"));
    GrayU8 gray = ConvertBufferedImage.convertFrom(input,(GrayU8)null);

    GrayU8 flipH = gray.clone();
    GrayU8 flipV = gray.clone();
    GrayU8 rotateCW = new GrayU8(gray.height,gray.width);
    GrayU8 rotateCCW = new GrayU8(gray.height,gray.width);

    ImageMiscOps.flipHorizontal(flipH);
    ImageMiscOps.flipVertical(flipV);
    ImageMiscOps.rotateCW(gray, rotateCW);
    ImageMiscOps.rotateCCW(gray, rotateCCW);

    ShowImages.showWindow(gray,"Input");
    ShowImages.showWindow(flipH,"Flip Horizontal");
    ShowImages.showWindow(flipV,"Flip Vertical");
    ShowImages.showWindow(rotateCW,"Rotate CW");
    ShowImages.showWindow(rotateCCW,"Rotate CCW");

  }
}