/** * Scales the image and sets the border to {@link BorderType#EXTENDED}. This is normally what you want * to do when scaling an image. If you don't use an extended border when you hit the right and bottom * boundaries it will go outside the image bounds and if a fixed value of 0 is used it will average towards * zero. */ public FDistort scaleExt() { return scale().borderExt(); }
/** * Sets interpolation to use nearest-neighbor */ public FDistort interpNN() { return interp(InterpolationType.NEAREST_NEIGHBOR); }
/** * <p>Sets the border to EXTEND.</p> */ public FDistort borderExt() { return border(BorderType.EXTENDED); }
private void applyScaling() { scaledImage.reshape(panel.getWidth(), panel.getHeight()); if( scaledImage.width <= 0 || scaledImage.height <= 0 ) { return; } if( latestImage.width != 0 && latestImage.height != 0 ) { new FDistort(latestImage, scaledImage).interp(interpType).border(BorderType.EXTENDED).scale().apply(); BufferedImage out = ConvertBufferedImage.convertTo(scaledImage, null, true); panel.setImageUI(out); panel.repaint(); } }
private synchronized void render( Rectangle visibleRect ) { if( visibleRect.width == 0 || visibleRect.height == 0 ) return; if( transformed.width != visibleRect.width || transformed.height != visibleRect.height || workImage == null ) { transformed.reshape(visibleRect.width,visibleRect.height); workImage = new BufferedImage(visibleRect.width,visibleRect.height,BufferedImage.TYPE_INT_RGB); } double x = -visibleRect.x; double y = -visibleRect.y; new FDistort(input,transformed).interpNN().affine(scale,0,0,scale,x,y).apply(); ConvertBufferedImage.convertTo(transformed,workImage,true); }
/** * Constructor which specifies the characteristics of the undistorted image * * @param width Width of undistorted image * @param height Height of undistorted image * @param imageType Type of undistorted image */ public RemovePerspectiveDistortion( int width , int height , ImageType<T> imageType ) { this(width,height); output = imageType.createImage(width,height); distort = new FDistort(imageType); distort.output(output); distort.interp(InterpolationType.BILINEAR).transform(transform); }
/** * Applies distortion removal to the specified region in the input image. The undistorted image is returned. * @param input Input image * @param corner0 Top left corner * @param corner1 Top right corner * @param corner2 Bottom right corner * @param corner3 Bottom left corner * @return true if successful or false if it failed */ public boolean apply( T input , Point2D_F64 corner0 , Point2D_F64 corner1 , Point2D_F64 corner2 , Point2D_F64 corner3 ) { if( createTransform(corner0, corner1, corner2, corner3)) { distort.input(input).apply(); return true; } else { return false; } }
@Override public void initialize(int imageWidth, int imageHeight, int sensorOrientation) { binary.reshape(imageWidth, imageHeight); work.reshape(imageWidth, imageHeight); scaled.reshape(imageWidth/3,imageHeight/3); shrink = new FDistort(); }
/** * Specifies the input and output image and sets interpolation to BILINEAR, black image border, cache is off. */ public FDistort init(ImageBase input, ImageBase output) { this.input = input; this.output = output; inputType = input.getImageType(); interp(InterpolationType.BILINEAR); border(0); cached = false; distorter = null; outputToInput = null; return this; }
/** * Applies a distortion which will rotate the input image by the specified amount. */ public FDistort rotate( double angleInputToOutput ) { PixelTransform2_F32 outputToInput = DistortSupport.transformRotate(input.width/2,input.height/2, output.width/2,output.height/2,(float)angleInputToOutput); return transform(outputToInput); }
public FDistort affine( Affine2D_F64 affine ) { return affine(affine.a11,affine.a12,affine.a21,affine.a22,affine.tx,affine.ty); }
public static PointDeformKeyPoints deformMls(ConfigDeformPointMLS config ) { if( config == null ) config = new ConfigDeformPointMLS(); ImageDeformPointMLS_F32 alg = new ImageDeformPointMLS_F32(config.type); alg.setAlpha(config.alpha); return new PointDeform_MLS(alg, config.rows, config.cols); } }
private void controlPointsModified() { synchronized (pointsUndistorted){ try { // transform needs to go from distorted image to undistorted image alg.setSource(pointsDistorted); alg.setDestination(pointsUndistorted); validTransform = true; } catch( RuntimeException e ) { // System.out.println("Failed because of "+e.getMessage()); // System.out.println(" total points "+pointsDistorted.size()); validTransform = false; } } distortImage.setModel(p2p); if( inputMethod == InputMethod.IMAGE ) { renderDistorted(null, undistorted); } gui.repaint(); }
/** * Constructor in which input and output images are specified. Equivalent to calling * {@link #init(ImageBase, ImageBase)} * * @param input Input image * @param output output image */ public FDistort(ImageBase input, ImageBase output) { init(input, output); }
@Override public void handleAlgorithmChange() { alg = FactoryDistort.deformMls(control.getConfigMLS()); p2p.setTransform(alg); alg.setImageShape(undistorted.width,undistorted.height); controlPointsModified(); }
/** * Used to manually specify a transform. From output to input */ public FDistort transform( Point2Transform2_F32 outputToInput ) { return transform( new PointToPixelTransform_F32(outputToInput)); }
/** * Sets the border to a fixed gray-scale value */ public FDistort border( double value ) { // to recycle here the value also needs to be saved // if( borderType == BorderType.VALUE ) // return this; borderType = BorderType.ZERO; return border(FactoryImageBorder.genericValue(value, inputType)); }
/** * <p>Applies a distortion which will rescale the input image into the output image. You * might want to consider using {@link #scaleExt()} instead since it sets the border behavior * to extended, which is probably what you want to do.</p> * * NOTE: Checks to see if it can recycle the previous transform and update it with a new affine model * to avoid declaring new memory. */ public FDistort scale() { if( outputToInput != null && outputToInput instanceof PixelTransformAffine_F32 ) { PixelTransformAffine_F32 affine = (PixelTransformAffine_F32)outputToInput; DistortSupport.transformScale(output, input, affine); return this; } else { return transform(DistortSupport.transformScale(output, input, null)); } }
/** * Sets the border by type. */ public FDistort border( BorderType type ) { if( borderType == type ) return this; borderType = type; return border(FactoryImageBorder.generic(type, inputType)); }
/** * Affine transform from input to output */ public FDistort affine(double a11, double a12, double a21, double a22, double dx, double dy) { PixelTransformAffine_F32 transform; if( outputToInput != null && outputToInput instanceof PixelTransformAffine_F32 ) { transform = (PixelTransformAffine_F32)outputToInput; } else { transform = new PixelTransformAffine_F32(); } Affine2D_F32 m = new Affine2D_F32(); m.a11 = (float)a11; m.a12 = (float)a12; m.a21 = (float)a21; m.a22 = (float)a22; m.tx = (float)dx; m.ty = (float)dy; m.invert(transform.getModel()); return transform(transform); }