/** * @see GThresholdImageOps#localMean */ public LocalMeanBinaryFilter(ConfigLength width, double scale, boolean down, ImageType<T> inputType) { this.regionWidth = width; this.scale = scale; this.down = down; this.inputType = inputType; work1 = inputType.createImage(1,1); work2 = inputType.createImage(1,1); }
public static <I extends ImageBase<I>, D extends ImageBase<D>> ImageType<D> getDerivativeType( ImageType<I> imageType ) { switch( imageType.getFamily() ) { case GRAY: return ImageType.single(getDerivativeType(imageType.getImageClass())); case PLANAR: { int numBands = imageType.getNumBands(); return ImageType.pl(numBands, getDerivativeType(imageType.getImageClass())); } case INTERLEAVED: int numBands = imageType.getNumBands(); switch ( imageType.getDataType() ) { case F32: return (ImageType)ImageType.il(numBands, ImageDataType.F32); case F64: return (ImageType)ImageType.il(numBands, ImageDataType.F64); case U8: return (ImageType)ImageType.il(numBands, ImageDataType.S16); case U16: return (ImageType)ImageType.il(numBands, ImageDataType.S32); } } throw new IllegalArgumentException("Unknown image type"); }
public CacheSequenceStream( ImageType<T> imageType ) { queueBoof = imageType.createArray(2); queueBuff = new BufferedImage[2]; for (int i = 0; i < 2; i++) { queueBoof[i] = imageType.createImage(1,1); queueBuff[i] = new BufferedImage(1,1,BufferedImage.TYPE_INT_RGB); } this.imageType = imageType; }
public DescribeImageDense_Convert(DescribeImageDense<ImageBase,Desc> describer , ImageType<T> inputType ) { ImageType describerType = describer.getImageType(); if( inputType.getFamily() != describerType.getFamily() ) throw new IllegalArgumentException("Image types must have the same family"); if( inputType.getDataType() == describerType.getDataType() ) throw new IllegalArgumentException("Data types are the same. Why do you want to use this class?"); workspace = describerType.createImage(1,1); this.describer = describer; this.inputType = inputType; }
private void createStorage() { if( inputType.getFamily() == ImageType.Family.PLANAR ) { storage = (T)GeneralizedImageOps.createSingleBand(inputType.getImageClass(),1,1); } else { storage = inputType.createImage(1,1); } }
/** * Configures the detector * @param requestedBlockWidth About how wide and tall you wish a block to be in pixels. */ public ThresholdBlockCommon(ConfigLength requestedBlockWidth, boolean thresholdFromLocalBlocks, Class<T> imageClass ) { this.requestedBlockWidth = requestedBlockWidth; this.imageType = ImageType.single(imageClass); this.thresholdFromLocalBlocks = thresholdFromLocalBlocks; }
/** * Given different types input images it creates the correct algorithm for computing the image gradient. The * actualy calulcation is always done using {@link DerivativeType#THREE} */ static <Input extends ImageBase> ImageGradient<Input,GrayF32> createGradient( ImageType<Input> imageType ) { ImageGradient<Input,GrayF32> gradient; ImageType<GrayF32> typeF32 = ImageType.single(GrayF32.class); if( imageType.getDataType() != ImageDataType.F32 ) throw new IllegalArgumentException("Input image type must be F32"); if( imageType.getFamily() == ImageType.Family.GRAY) { gradient = FactoryDerivative.gradient(DerivativeType.THREE,imageType, typeF32); } else if( imageType.getFamily() == ImageType.Family.PLANAR ) { ImageType<Planar<GrayF32>> typePF32 = ImageType.pl(imageType.getNumBands(),GrayF32.class); ImageGradient<Planar<GrayF32>,Planar<GrayF32>> gradientMB = FactoryDerivative.gradient(DerivativeType.THREE,typePF32, typePF32); gradient = (ImageGradient)FactoryDerivative.gradientReduce(gradientMB, DerivativeReduceType.MAX_F, GrayF32.class); } else { throw new IllegalArgumentException("Unsupported image type "+imageType); } return gradient; }
public BackgroundProcessing(BackgroundModelStationary<T> model ) { super(model.getImageType()); this.model = model; this.scaled = model.getImageType().createImage(1, 1); this.work = GeneralizedImageOps.createSingleBand(model.getImageType().getDataType(),1,1); }
/** * @see ThresholdBlockOtsu */ public InputToBinarySwitch(InputToBinary alg, Class<T> inputType) { this.alg = alg; this.inputType = ImageType.single(inputType); if( !alg.getInputType().isSameType(this.inputType)) { work = (ImageGray)alg.getInputType().createImage(1,1); } }
public static <T extends ImageMultiBand> PixelLikelihood<T> likelihoodHueSatHistIndependent( double maxPixelValue , int numHistogramBins , ImageType<T> imageType ) { if( imageType.getFamily() != ImageType.Family.PLANAR) throw new IllegalArgumentException("Only Planar images supported currently"); if( imageType.getNumBands() != 3 ) throw new IllegalArgumentException("Input image type must have 3 bands."); if( imageType.getDataType() == ImageDataType.U8 ) { return (PixelLikelihood)new LikelihoodHueSatHistInd_PL_U8((int)maxPixelValue,numHistogramBins); } else { throw new RuntimeException("Band type not yet supported "+imageType.getDataType()); } }
public static GImageMultiBand create( ImageType imageType ) { if( imageType.getFamily() == ImageType.Family.GRAY ) { return new GSingleToMB(FactoryGImageGray.create(imageType.getImageClass())); } if( imageType.getFamily() == ImageType.Family.PLANAR) { return new PL(); } else if( imageType.getFamily() == ImageType.Family.INTERLEAVED ) { switch( imageType.getDataType() ) { case U8: return new IL_U8(); case S8: return new IL_S8(); case F32: return new IL_F32(); default: throw new IllegalArgumentException("Need to support more data types"); } } else { throw new RuntimeException("Add support for more families"); } }
public static <T extends ImageMultiBand<T>> InterpolatePixelMB<T> bilinearPixelMB(ImageType<T> imageType, BorderType borderType ) { InterpolatePixelMB<T> alg; int numBands = imageType.getNumBands(); if( imageType.getFamily() == ImageType.Family.INTERLEAVED ) { switch( imageType.getDataType()) { case U8: alg = (InterpolatePixelMB<T>)new ImplBilinearPixel_IL_U8(numBands); break; case S16: alg = (InterpolatePixelMB<T>)new ImplBilinearPixel_IL_S16(numBands); break; case S32: alg = (InterpolatePixelMB<T>)new ImplBilinearPixel_IL_S32(numBands); break; case F32: alg = (InterpolatePixelMB<T>)new ImplBilinearPixel_IL_F32(numBands); break; case F64: alg = (InterpolatePixelMB<T>)new ImplBilinearPixel_IL_F64(numBands); break; default: throw new IllegalArgumentException("Add support"); } if( borderType != null ) alg.setBorder(FactoryImageBorder.interleaved(imageType.getImageClass(), borderType)); } else { throw new IllegalArgumentException("Only interleaved current supported here"); } return alg; }
public static <In extends ImageBase<In>, Out extends ImageBase<Out>> ConvolveDown<In,Out> convolve(Kernel1D kernel, BorderType border , boolean isHorizontal , int skip , ImageType<In> inputType , ImageType<Out> outputType ) { switch( inputType.getFamily() ) { case PLANAR: return convolvePL(kernel, border, isHorizontal, skip, inputType.getNumBands(), inputType.getImageClass(), outputType.getImageClass()); case GRAY: return convolveSB(kernel, border, isHorizontal, skip, inputType.getImageClass(), outputType.getImageClass()); case INTERLEAVED: throw new IllegalArgumentException("Interleaved images are not yet supported"); } throw new IllegalArgumentException("Unknown image type"); }
public static <T extends ImageBase<T>> ImageBorder<T> generic( BorderType borderType, ImageType<T> imageType ) { switch( imageType.getFamily() ) { case GRAY: return single(imageType.getImageClass(),borderType); case PLANAR: return single(imageType.getImageClass(),borderType); case INTERLEAVED: return interleaved(imageType.getImageClass(),borderType); default: throw new IllegalArgumentException("Unknown family"); } }
public static <T extends ImageBase> PixelLikelihood<T> likelihoodHistogramCoupled( double maxPixelValue , int numHistogramBins , ImageType<T> imageType ) { switch( imageType.getFamily() ) { case GRAY: if( imageType.getDataType() != ImageDataType.U8 ) throw new IllegalArgumentException("Only U8 currently supported"); return (PixelLikelihood)new LikelihoodHistCoupled_SB_U8((int)maxPixelValue,numHistogramBins); case PLANAR: if( imageType.getDataType() == ImageDataType.U8 ) { return (PixelLikelihood)new LikelihoodHistCoupled_PL_U8((int)maxPixelValue,numHistogramBins); } else { throw new RuntimeException("Band type not yet supported "+imageType.getDataType()); } default: throw new IllegalArgumentException("Image family not yet supported. Try Planar"); } }
public Class getImageClass() { return getImageClass(family,dataType); }
public static <Input extends ImageInterleaved<Input>, Output extends ImageInterleaved<Output>> ImageDistort<Input, Output> distortIL(boolean cached, InterpolatePixelMB<Input> interp, ImageType<Output> outputType) { if( cached ) { throw new IllegalArgumentException("Cached not supported yet"); } else { switch( outputType.getDataType() ) { case F32: return (ImageDistort<Input, Output>) new ImplImageDistort_IL_F32((InterpolatePixelMB)interp); case U8: return (ImageDistort<Input, Output>) new ImplImageDistort_IL_U8((InterpolatePixelMB)interp); default: throw new IllegalArgumentException("Not supported yet"); } } }
public PlanarConvolveDown(ConvolveDown<In, Out> down, int numBands ) { this.down = down; inputType = ImageType.pl(numBands, down.getInputType().getDataType()); outputType = ImageType.pl(numBands, down.getOutputType().getDataType()); }
@Override public ImageType<Planar<GrayU8>> getInputType() { return ImageType.pl(3,GrayU8.class); }