How to use

checkDeclare

method

in

boofcv.io.image.ConvertBufferedImage

@Override
protected void handleInputChange(int source, InputMethod method, int width, int height)
{
  imageBinary.reshape(width, height);
  visualizedBinary = ConvertBufferedImage.checkDeclare(width, height, visualizedBinary,BufferedImage.TYPE_INT_BGR);
}

@Override
public synchronized void paintComponent(Graphics g) {
  super.paintComponent(g);
  projectScene();
  imageOutput = ConvertBufferedImage.checkDeclare(imageRgb.width,imageRgb.height,imageOutput,BufferedImage.TYPE_INT_RGB);
  DataBufferInt buffer = (DataBufferInt)imageOutput.getRaster().getDataBuffer();
  System.arraycopy(imageRgb.data,0,buffer.getData(),0,imageRgb.width*imageRgb.height);
  g.drawImage(imageOutput,0,0,null);
}

@Override
public void processImage(int sourceID, long frameID, final BufferedImage buffered, ImageBase input) {
  System.out.flush();
  original = ConvertBufferedImage.checkCopy(buffered,original);
  work = ConvertBufferedImage.checkDeclare(buffered,work);
  final double timeInSeconds;
  synchronized (lockProcessing) {
    long before = System.nanoTime();
    detector.process((GrayF32)input);
    long after = System.nanoTime();
    timeInSeconds = (after-before)*1e-9;
  }
  SwingUtilities.invokeLater(new Runnable() {
    @Override
    public void run() {
      controls.setProcessingTime(timeInSeconds);
      viewUpdated();
    }
  });
}

@Override
protected void handleInputChange(int source, InputMethod method, int width, int height) {
  visualized = ConvertBufferedImage.checkDeclare(width,height, visualized,BufferedImage.TYPE_INT_RGB);
  imagePanel.setPreferredSize(new Dimension(width,height));
  double scale = BoofSwingUtil.selectZoomToShowAll(imagePanel,width,height);
  imagePanel.setScaleAndCenter(scale,width/2,height/2);
}

private void renderPinhole() {
  if( distortImage == null )
    return;
  imageRendered.reshape(pinholeModel.width,pinholeModel.height);
  distortImage.apply(imageFisheye,imageRendered);
  bufferedRendered = ConvertBufferedImage.checkDeclare(
      imageRendered.width,imageRendered.height,bufferedRendered,BufferedImage.TYPE_INT_RGB);
  ConvertBufferedImage.convertTo(imageRendered,bufferedRendered,true);
}

  @Override
  public void paintComponent(Graphics g) {
    super.paintComponent(g);
    if( img == null ) return;
    // render to a buffer first to improve performance. This is particularly evident when rendering
    // lines for some reason
    int w = ImageZoomPanel.this.getWidth(),h = ImageZoomPanel.this.getHeight();
    buffer = ConvertBufferedImage.checkDeclare(w,h,buffer,buffer.getType());
    Graphics2D g2 = buffer.createGraphics();
    g2.setColor(getBackground());
    g2.fillRect(0,0,w,h);
    ImageZoomPanel.this.transX = -ImageZoomPanel.this.getHorizontalScrollBar().getValue();
    ImageZoomPanel.this.transY = -ImageZoomPanel.this.getVerticalScrollBar().getValue();
    AffineTransform tran = new AffineTransform(scale,0,0,scale,transX,transY);
    synchronized ( ImageZoomPanel.this ) {
      g2.drawImage(img, tran, null);
    }
    AffineTransform orig = g2.getTransform();
    // make the default behavior be a translate for backwards compatibility. Before it was rendered in a
    // buffered image it was rendered into the full scale panel
    tran = new AffineTransform(1,0,0,1,transX,transY);
    g2.setTransform(tran);
    paintInPanel(tran, g2);
    g2.setTransform(orig);
    g.drawImage(buffer,(int)-transX,(int)-transY,null);
  }
}

  @Override
  public void processImage(int sourceID, long frameID, final BufferedImage buffered, ImageBase input) {

    synchronized (this) {
      original = ConvertBufferedImage.checkCopy(buffered, original);
      work = ConvertBufferedImage.checkDeclare(buffered, work);
    }

//        SwingUtilities.invokeLater(new Runnable() {
//            @Override
//            public void run() {
//                Dimension d = guiImage.getPreferredSize();
//                if( d.getWidth() < buffered.getWidth() || d.getHeight() < buffered.getHeight() ) {
//                    guiImage.setPreferredSize(new Dimension(buffered.getWidth(), buffered.getHeight()));
//                }
//            }});

    synchronized (this) {
      inputToBinary.process((T)input,binary);
      contourAlg.process(binary,labeled);
    }

    SwingUtilities.invokeLater(new Runnable() {
      @Override
      public void run() {
        viewUpdated();
      }
    });
  }

work = ConvertBufferedImage.checkDeclare(buffered, work);

@Override
public void processImage(int sourceID, long frameID, BufferedImage buffered, final ImageBase undistorted)
{
  // do this here instead of a reshape to ensure the number of bands is the same
  distorted = (T)undistorted.createSameShape();
  BufferedImage tmp = distortedBuff;
  distortedBuff = ConvertBufferedImage.checkDeclare(
      undistorted.width,undistorted.height,distortedBuff,buffered.getType());
  if( tmp != distortedBuff ) {
    distorted.reshape(undistorted.width, undistorted.height);
    this.undistorted.reshape(undistorted.width, undistorted.height);
    gui.setPreferredSize(new Dimension(undistorted.width,undistorted.height));
    alg.setImageShape(undistorted.width,undistorted.height);
    synchronized (pointsUndistorted){
      validTransform = false;
      pointsUndistorted.clear();
      pointsDistorted.clear();
    }
  }
  if( inputMethod == InputMethod.IMAGE ) {
    this.undistorted.setTo((T)undistorted);
  }
  renderDistorted(buffered, (T)undistorted);
}

@Override
protected void handleInputChange(int source, InputMethod method, final int width, final int height) {
  super.handleInputChange(source, method, width, height);
  gray.reshape(width, height);
  enhancedGray.reshape(width, height);
  enhancedColor.reshape(width, height);
  output = ConvertBufferedImage.checkDeclare(width,height,output,output.getType());
  BoofSwingUtil.invokeNowOrLater(new Runnable() {
    @Override
    public void run() {
      double zoom = BoofSwingUtil.selectZoomToShowAll(imagePanel,width,height);
      controls.setZoom(zoom);
      imagePanel.getVerticalScrollBar().setValue(0);
      imagePanel.getHorizontalScrollBar().setValue(0);
    }
  });
}

@Override
public void processImage(int sourceID, long frameID, BufferedImage buffered, ImageBase input) {
  visualized = ConvertBufferedImage.checkDeclare(buffered, visualized);
  original = ConvertBufferedImage.checkCopy(buffered, original);
  segmented.reshape(input.width,input.height);
  final double fps;
  synchronized (lockBackground) {
    long timeBefore = System.nanoTime();
    background.updateBackground((GrayU8) input, segmented);
    long timeAfter = System.nanoTime();
    fps = 1000.0/((timeAfter-timeBefore)*1e-6);
  }
  VisualizeBinaryData.renderBinary(segmented, false, visualized);
  BoofSwingUtil.invokeNowOrLater(() -> {
    imagePanels.setImage(0,0,visualized);
    imagePanels.setImage(0,1,original);
    imagePanels.repaint();
    controls.setFPS(fps);
  });
}

@Override
public void processImage(int sourceID, long frameID, final BufferedImage buffered, ImageBase gray) {
  this.input = buffered;
  synchronized ( this ) {
    binary = ConvertBufferedImage.checkDeclare(gray.getWidth(), gray.getHeight(), binary, BufferedImage.TYPE_INT_RGB);
    grayPrev.setTo((GrayF32)gray);
  }
  try {
    processFrame();
  } catch( RuntimeException e ) {
    e.printStackTrace();
    UtilImageIO.saveImage(buffered,"crash_image.png");
  }
  if( controlPanel instanceof DetectCalibrationPolygonPanel ) {
    DetectCalibrationPolygonPanel c = (DetectCalibrationPolygonPanel)controlPanel;
    c.polygonPanel.getThresholdPanel().updateHistogram(grayPrev);
  } else {
    if( controlPanel.threshold != null )
      controlPanel.threshold.updateHistogram(grayPrev);
  }
}

@Override
public synchronized void processImage(int sourceID, long frameID, final BufferedImage buffered, ImageBase input) {
  if( buffered != null ) {
    original = ConvertBufferedImage.checkCopy(buffered,original);
    work = ConvertBufferedImage.checkDeclare(buffered,work);
    binary.reshape(input.getWidth(), input.getHeight());
    filtered.reshape(input.getWidth(),input.getHeight());
    inputPrev.setTo((GrayU8)input);
    SwingUtilities.invokeLater(new Runnable() {
      @Override
      public void run() {
        Dimension d = gui.getPreferredSize();
        if( d.getWidth() < buffered.getWidth() || d.getHeight() < buffered.getHeight() ) {
          gui.setPreferredSize(new Dimension(buffered.getWidth(), buffered.getHeight()));
        }
      }});
  } else {
    input = inputPrev;
  }
  process((GrayU8)input);
}

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);
}

    rectColor1, rectColor2,rectMask, rectifiedK, rectifiedR);
visualRect1 = ConvertBufferedImage.checkDeclare(
    rectColor1.width, rectColor1.height, visualRect1, visualRect1.getType());
visualRect2 = ConvertBufferedImage.checkDeclare(
    rectColor2.width, rectColor2.height, visualRect2, visualRect2.getType());
ConvertBufferedImage.convertTo(rectColor1, visualRect1, true);
visualDisparity = ConvertBufferedImage.checkDeclare(
    disparity.width,disparity.height,visualDisparity,visualDisparity.getType());

work = ConvertBufferedImage.checkDeclare(buffered, work);