@Override public void setModel(PixelTransform2_F32 dstToSrc) { layerDistort.setModel(dstToSrc); }
@Override public void processImage(int sourceID, long frameID, BufferedImage buffered, ImageBase input) { synchronized (imageLock) { // create a copy of the input image for output purposes if (buffEqui.getWidth() != buffered.getWidth() || buffEqui.getHeight() != buffered.getHeight()) { buffEqui = new BufferedImage(buffered.getWidth(), buffered.getHeight(), BufferedImage.TYPE_INT_BGR); panelEqui.setPreferredSize(new Dimension(buffered.getWidth(), buffered.getHeight())); panelEqui.setImageUI(buffEqui); distorter.setEquirectangularShape(input.width, input.height); distortImage.setModel(distorter); } buffEqui.createGraphics().drawImage(buffered, 0, 0, null); equi.setTo((T)input); rerenderPinhole(); } }
@Override public void processImage(int sourceID, long frameID, BufferedImage buffered, ImageBase input) { synchronized (imageLock) { // create a copy of the input image for output purposes if (buffFisheye.getWidth() != buffered.getWidth() || buffFisheye.getHeight() != buffered.getHeight()) { buffFisheye = new BufferedImage(buffered.getWidth(), buffered.getHeight(), BufferedImage.TYPE_INT_BGR); panelFisheye.setPreferredSize(new Dimension(buffered.getWidth(),buffered.getHeight())); panelFisheye.setImageUI(buffFisheye); distortImage.setModel(new PointToPixelTransform_F32(distorter)); } buffFisheye.createGraphics().drawImage(buffered, 0, 0, null); fisheye.setTo((T)input); rerenderPinhole(); } }
@Override protected void handleInputChange(int source, InputMethod method, int width, int height) { super.handleInputChange(source, method, width, height); if( rendered.getWidth() != width || rendered.getHeight() != height ) { rendered = new BufferedImage(width,height,BufferedImage.TYPE_INT_BGR); panelImage.setPreferredSize(new Dimension(width,height)); distorter.setEquirectangularShape(width, height); distortImage.setModel(distorter); // let it know the transform has changed } centerLon = centerLat = 0; distorted.reshape(width,height); distorter.setEquirectangularShape(width,height); }
/** * Creates a {@link boofcv.alg.distort.ImageDistort} for the planar images of the specified image type, transformation * and interpolation instance. * * @param dstToSrc Transform from dst to src image. * @param interp Which interpolation algorithm should be used. */ public static <Input extends ImageGray<Input>,Output extends ImageGray<Output>> ImageDistort<Planar<Input>,Planar<Output>> createDistortPL(Class<Output> outputType, PixelTransform2_F32 dstToSrc, InterpolatePixelS<Input> interp, boolean cached ) { ImageDistort<Input,Output> bandDistort = FactoryDistort.distortSB(cached, interp, outputType); bandDistort.setModel(dstToSrc); return new ImplImageDistort_PL<>(bandDistort); } }
/** * Applies a pixel transform to a single band image. More flexible but order to use function. * * @deprecated As of v0.19. Use {@link FDistort} instead * * @param input Input (source) image. * @param output Where the result of transforming the image image is written to. * @param renderAll true it renders all pixels, even ones outside the input image. * @param transform The transform that is being applied to the image * @param interp Interpolation algorithm. */ public static <Input extends ImageGray<Input>,Output extends ImageGray<Output>> void distortSingle(Input input, Output output, boolean renderAll, PixelTransform2_F32 transform, InterpolatePixelS<Input> interp) { Class<Output> inputType = (Class<Output>)input.getClass(); ImageDistort<Input,Output> distorter = FactoryDistort.distortSB(false, interp, inputType); distorter.setRenderAll(renderAll); distorter.setModel(transform); distorter.apply(input,output); }
@Override public void updateCylinder(int width, int height, double vfov) { synchronized (distorter) { distorter.configure(width,height,(float)UtilAngle.radian(vfov)); distortImage.setModel(distorter); // let it know the transform has changed if( distorted.width != width || distorted.height != height ) { rendered = new BufferedImage(width, height, BufferedImage.TYPE_INT_BGR); distorted.reshape(width, height); } if (inputMethod == InputMethod.IMAGE) { renderOutput(inputCopy); } } }
/** * Configuration constructor * @param clip If true it will first clip the image to make it square before reducing it's size. Otherwise both * sides are scaled independently to make it square * @param imageType Type of image it iwll be processing */ public ClipAndReduce( boolean clip , ImageType<T> imageType ) { this.clip = clip; InterpolatePixel<T> interp = FactoryInterpolation.createPixel(0,255, InterpolationType.BILINEAR, BorderType.EXTENDED,imageType); distort = FactoryDistort.distort(false,interp,imageType); distort.setModel(new PixelTransformAffine_F32(transform)); }
@Override public synchronized void updatedPinholeModel(CameraPinholeRadial desired) { if( undist.width != desired.width || undist.height != desired.height ) { undist.reshape(desired.width, desired.height); SwingUtilities.invokeLater(new Runnable() { @Override public void run() { gui.setPreferredSize(new Dimension(undist.width, undist.height)); // gui.invalidate(); } }); } Point2Transform2_F32 add_p_to_p = LensDistortionOps_F32. transformChangeModel(adjustment, origModel,desired,true,null); undistorter.setModel(new PointToPixelTransform_F32(add_p_to_p)); if( inputMethod == InputMethod.IMAGE ) renderCameraModel(); }
@Override protected void handleInputChange(int source, InputMethod method, int width, int height) { super.handleInputChange(source, method, width, height); if( inputCopy.getWidth() != width || inputCopy.getHeight() != height ) { panelImage.setPreferredSize(new Dimension(width,height)); distortImage.setModel(distorter); // let it know the transform has changed } distorter.setEquirectangularShape(width, height); }
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(); }
@Override public void mouseClicked(MouseEvent e) { GeoLL_F32 geo = new GeoLL_F32(); synchronized (distorter) { EquirectangularTools_F32 tools = distorter.getTools(); double scale = panelImage.scale; distorter.compute((int) (e.getX() / scale), (int) (e.getY() / scale)); tools.equiToLatLonFV(distorter.distX, distorter.distY, geo); panelRotate.setOrientation(UtilAngle.radianToDegree(geo.lat), UtilAngle.radianToDegree(geo.lon),0); distorter.setDirection(geo.lon, geo.lat, 0); distortImage.setModel(distorter); // let it know the transform has changed if (inputMethod == InputMethod.IMAGE) { renderOutput(inputCopy); } } } });
@Override public void mouseClicked(MouseEvent e) { GeoLL_F32 geo = new GeoLL_F32(); synchronized (distorter) { EquirectangularTools_F32 tools = distorter.getTools(); double scale = panelImage.scale; distorter.compute((int) (e.getX() / scale), (int) (e.getY() / scale)); tools.equiToLatLonFV(distorter.distX, distorter.distY, geo); panelRotate.setOrientation(UtilAngle.radianToDegree(geo.lat), UtilAngle.radianToDegree(geo.lon),0); distorter.setDirection(geo.lon, geo.lat, 0); distortImage.setModel(distorter); // let it know the transform has changed if (inputMethod == InputMethod.IMAGE) { renderOutput(inputCopy); } } } });
private void addUndistorted(final String name, final Point2Transform2_F32 model) { // Set up image distort InterpolatePixel<T> interp = FactoryInterpolation. createPixel(0,255,InterpolationType.BILINEAR, BorderType.ZERO, undist.getImageType()); ImageDistort<T,T> undistorter = FactoryDistort.distort(false, interp, undist.getImageType()); undistorter.setModel(new PointToPixelTransform_F32(model)); undistorter.apply(dist,undist); final BufferedImage out = ConvertBufferedImage.convertTo(undist,null,true); // Add this rectified image SwingUtilities.invokeLater(new Runnable() { public void run() { gui.addItem(new ImagePanel(out), name); }}); }
@Override public void updatedOrientation(double pitch, double yaw, double roll) { synchronized (distorter) { ConvertRotation3D_F32.eulerToMatrix(EulerType.ZYX, (float)UtilAngle.degreeToRadian(yaw), (float)UtilAngle.degreeToRadian(pitch), (float)UtilAngle.degreeToRadian(roll), distorter.getRotation()); distortImage.setModel(distorter); // let it know the transform has changed if (inputMethod == InputMethod.IMAGE) { renderOutput(inputCopy); } } }
@Override public void updatedOrientation(double pitch, double yaw, double roll) { synchronized (distorter) { ConvertRotation3D_F32.eulerToMatrix(EulerType.ZYX, (float)UtilAngle.degreeToRadian(yaw), (float)UtilAngle.degreeToRadian(pitch), (float)UtilAngle.degreeToRadian(roll), distorter.getRotation()); distortImage.setModel(distorter); // let it know the transform has changed if (inputMethod == InputMethod.IMAGE) { renderOutput(inputCopy); } } }
/** * Creates an {@link ImageDistort} for rectifying an image given its radial distortion and * rectification matrix. * * @param param Intrinsic parameters. * @param rectify Transform for rectifying the image. * @param imageType Type of single band image the transform is to be applied to. * @return ImageDistort for rectifying the image. */ public static <T extends ImageBase> ImageDistort<T,T> rectifyImage(CameraPinholeRadial param, DenseMatrix64F rectify , BorderType borderType, ImageType<T> imageType) { boolean skip = borderType == BorderType.SKIP; if( skip ) { borderType = BorderType.EXTENDED; } InterpolatePixel<T> interp = FactoryInterpolation.createPixel(0,255, InterpolationType.BILINEAR,borderType,imageType); // only compute the transform once ImageDistort<T,T> ret = FactoryDistort.distort(true, interp, imageType); ret.setRenderAll(!skip); Point2Transform2_F32 transform = transformRectToPixel_F32(param, rectify); ret.setModel(new PointToPixelTransform_F32(transform)); return ret; }
@Override public void initialize(int imageWidth, int imageHeight, int sensorOrientation) { undistorted = imageType.createImage(imageWidth,imageHeight); CameraPinholeRadial intrinsic = app.preference.lookup( imageWidth,imageHeight); if( intrinsic != null ) { // define the transform. Cache the results for quick rendering later on CameraPinhole desired = new CameraPinhole(); desired.set(intrinsic); Point2Transform2_F32 fullView = LensDistortionOps.transformChangeModel_F32(AdjustmentType.FULL_VIEW, intrinsic,desired,false,null); InterpolatePixelS<GrayU8> interp = FactoryInterpolation. bilinearPixelS(GrayU8.class, BorderType.ZERO); // for some reason not caching is faster on a low end phone. Maybe it has to do with CPU memory // cache misses when looking up a point? removeDistortion = FactoryDistort.distort(false,interp,imageType); removeDistortion.setModel(new PointToPixelTransform_F32(fullView)); } }
public void setCalibration(CameraUniversalOmni fisheyeModel) { BoofSwingUtil.checkGuiThread(); LensDistortionNarrowFOV pinholeDistort = new LensDistortionPinhole(pinholeModel); fisheyeDistort = new LensDistortionUniversalOmni(fisheyeModel); distorter = new NarrowToWidePtoP_F32(pinholeDistort,fisheyeDistort); // Create the image distorter which will render the image InterpolatePixel<Planar<GrayF32>> interp = FactoryInterpolation. createPixel(0, 255, InterpolationType.BILINEAR, BorderType.ZERO, imageFisheye.getImageType()); distortImage = FactoryDistort.distort(false,interp,imageFisheye.getImageType()); // Pass in the transform created above distortImage.setModel(new PointToPixelTransform_F32(distorter)); setPinholeCenter(fisheyeModel.width/2,fisheyeModel.height/2); renderPinhole(); }
public void setPinholeCenter( double pixelX , double pixelY ) { this.pixelX = pixelX; this.pixelY = pixelY; Point3D_F32 norm = new Point3D_F32(); fisheyeDistort.undistortPtoS_F32().compute((float)pixelX, (float)pixelY, norm); Rodrigues_F32 rotation = new Rodrigues_F32(); Vector3D_F32 canonical = new Vector3D_F32(0,0,1); rotation.theta = UtilVector3D_F32.acute(new Vector3D_F32(norm),canonical); GeometryMath_F32.cross(canonical,norm,rotation.unitAxisRotation); rotation.unitAxisRotation.normalize(); FMatrixRMaj R = ConvertRotation3D_F32.rodriguesToMatrix(rotation,null); distorter.setRotationWideToNarrow(R); distortImage.setModel(new PointToPixelTransform_F32(distorter)); }