Uses of Interface net.imagej.ops.Op (ImageJ2 Javadocs 0-SNAPSHOT API)

Packages that use Op
Package	Description
net.imagej.ops
net.imagej.ops.cached
net.imagej.ops.coloc.icq
net.imagej.ops.coloc.kendallTau
net.imagej.ops.coloc.maxTKendallTau
net.imagej.ops.coloc.pearsons
net.imagej.ops.coloc.pValue
net.imagej.ops.commands.project
net.imagej.ops.commands.threshold
net.imagej.ops.convert
net.imagej.ops.convert.clip
net.imagej.ops.convert.copy
net.imagej.ops.convert.imageType
net.imagej.ops.convert.normalizeScale
net.imagej.ops.convert.scale
net.imagej.ops.copy
net.imagej.ops.create.img
net.imagej.ops.create.imgFactory
net.imagej.ops.create.imgLabeling
net.imagej.ops.create.imgPlus
net.imagej.ops.create.integerType
net.imagej.ops.create.kernel
net.imagej.ops.create.kernelBiGauss
net.imagej.ops.create.kernelDiffraction
net.imagej.ops.create.kernelGabor
net.imagej.ops.create.kernelGauss
net.imagej.ops.create.kernelLog
net.imagej.ops.create.kernelSobel
net.imagej.ops.create.labelingMapping
net.imagej.ops.create.nativeType
net.imagej.ops.create.object
net.imagej.ops.deconvolve
net.imagej.ops.deconvolve.accelerate
net.imagej.ops.eval
net.imagej.ops.features.haralick
net.imagej.ops.features.haralick.helper
net.imagej.ops.features.hog
net.imagej.ops.features.lbp2d
net.imagej.ops.features.tamura2d
net.imagej.ops.features.zernike
net.imagej.ops.features.zernike.helper
net.imagej.ops.filter
net.imagej.ops.filter.addNoise
net.imagej.ops.filter.addPoissonNoise
net.imagej.ops.filter.bilateral
net.imagej.ops.filter.convolve
net.imagej.ops.filter.correlate
net.imagej.ops.filter.derivative
net.imagej.ops.filter.derivativeGauss
net.imagej.ops.filter.dog
net.imagej.ops.filter.fft
net.imagej.ops.filter.fftSize
net.imagej.ops.filter.gauss
net.imagej.ops.filter.hessian
net.imagej.ops.filter.ifft
net.imagej.ops.filter.max
net.imagej.ops.filter.mean
net.imagej.ops.filter.median
net.imagej.ops.filter.min
net.imagej.ops.filter.pad
net.imagej.ops.filter.sigma
net.imagej.ops.filter.sobel
net.imagej.ops.filter.tubeness
net.imagej.ops.filter.variance
net.imagej.ops.filter.vesselness
net.imagej.ops.geom
net.imagej.ops.geom.geom2d
net.imagej.ops.geom.geom3d
net.imagej.ops.geom.geom3d.mesh
net.imagej.ops.help
net.imagej.ops.identity
net.imagej.ops.image.ascii
net.imagej.ops.image.cooccurrenceMatrix
net.imagej.ops.image.distancetransform
net.imagej.ops.image.equation
net.imagej.ops.image.fill
net.imagej.ops.image.histogram
net.imagej.ops.image.integral
net.imagej.ops.image.invert
net.imagej.ops.image.normalize
net.imagej.ops.image.watershed
net.imagej.ops.imagemoments
net.imagej.ops.imagemoments.centralmoments
net.imagej.ops.imagemoments.hu
net.imagej.ops.imagemoments.moments
net.imagej.ops.imagemoments.normalizedcentralmoments
net.imagej.ops.join
net.imagej.ops.labeling
net.imagej.ops.labeling.cca
net.imagej.ops.linalg.rotate
net.imagej.ops.logic
net.imagej.ops.lookup
net.imagej.ops.loop
net.imagej.ops.map
net.imagej.ops.map.neighborhood
net.imagej.ops.math
net.imagej.ops.math.multiply
net.imagej.ops.morphology.blackTopHat
net.imagej.ops.morphology.close
net.imagej.ops.morphology.dilate
net.imagej.ops.morphology.erode
net.imagej.ops.morphology.extractHoles
net.imagej.ops.morphology.fillHoles
net.imagej.ops.morphology.floodFill
net.imagej.ops.morphology.open
net.imagej.ops.morphology.outline
net.imagej.ops.morphology.thin
net.imagej.ops.morphology.topHat
net.imagej.ops.run
net.imagej.ops.segment.detectJunctions
net.imagej.ops.segment.detectRidges
net.imagej.ops.slice
net.imagej.ops.special
net.imagej.ops.special.chain
net.imagej.ops.special.computer
net.imagej.ops.special.function
net.imagej.ops.special.hybrid
net.imagej.ops.special.inplace
net.imagej.ops.stats
net.imagej.ops.stats.regression.leastSquares
net.imagej.ops.thread.chunker
net.imagej.ops.threshold
net.imagej.ops.threshold.apply
net.imagej.ops.threshold.huang
net.imagej.ops.threshold.ij1
net.imagej.ops.threshold.intermodes
net.imagej.ops.threshold.isoData
net.imagej.ops.threshold.li
net.imagej.ops.threshold.localBernsen
net.imagej.ops.threshold.localContrast
net.imagej.ops.threshold.localMean
net.imagej.ops.threshold.localMedian
net.imagej.ops.threshold.localMidGrey
net.imagej.ops.threshold.localNiblack
net.imagej.ops.threshold.localPhansalkar
net.imagej.ops.threshold.localSauvola
net.imagej.ops.threshold.maxEntropy
net.imagej.ops.threshold.maxLikelihood
net.imagej.ops.threshold.mean
net.imagej.ops.threshold.minError
net.imagej.ops.threshold.minimum
net.imagej.ops.threshold.moments
net.imagej.ops.threshold.otsu
net.imagej.ops.threshold.percentile
net.imagej.ops.threshold.renyiEntropy
net.imagej.ops.threshold.rosin
net.imagej.ops.threshold.shanbhag
net.imagej.ops.threshold.triangle
net.imagej.ops.threshold.yen
net.imagej.ops.topology
net.imagej.ops.topology.eulerCharacteristic
net.imagej.ops.transform.addDimensionView
net.imagej.ops.transform.collapseNumericView
net.imagej.ops.transform.collapseRealView
net.imagej.ops.transform.collapseView
net.imagej.ops.transform.concatenateView
net.imagej.ops.transform.crop
net.imagej.ops.transform.dropSingletonDimensionsView
net.imagej.ops.transform.extendBorderView
net.imagej.ops.transform.extendMirrorDoubleView
net.imagej.ops.transform.extendMirrorSingleView
net.imagej.ops.transform.extendPeriodicView
net.imagej.ops.transform.extendRandomView
net.imagej.ops.transform.extendValueView
net.imagej.ops.transform.extendView
net.imagej.ops.transform.extendZeroView
net.imagej.ops.transform.flatIterableView
net.imagej.ops.transform.hyperSliceView
net.imagej.ops.transform.interpolateView
net.imagej.ops.transform.intervalView
net.imagej.ops.transform.invertAxisView
net.imagej.ops.transform.offsetView
net.imagej.ops.transform.permuteCoordinatesInverseView
net.imagej.ops.transform.permuteCoordinatesView
net.imagej.ops.transform.permuteView
net.imagej.ops.transform.project
net.imagej.ops.transform.rasterView
net.imagej.ops.transform.rotateView
net.imagej.ops.transform.scaleView
net.imagej.ops.transform.shearView
net.imagej.ops.transform.stackView
net.imagej.ops.transform.subsampleView
net.imagej.ops.transform.translateView
net.imagej.ops.transform.unshearView
net.imagej.ops.transform.zeroMinView

Uses of Op in net.imagej.ops

Subinterfaces of Op in net.imagej.ops
Modifier and Type	Interface and Description
`static interface`	`Ops.Coloc.Costes` Base interface for "costes" operations.
`static interface`	`Ops.Coloc.ICQ` Base interface for "icq" operations.
`static interface`	`Ops.Coloc.KendallTau` Base interface for "kendallTau" operations.
`static interface`	`Ops.Coloc.Manders` Base interface for "manders" operations.
`static interface`	`Ops.Coloc.MaxTKendallTau` Base interface for "maxTKendallTau" operations.
`static interface`	`Ops.Coloc.Pearsons` Base interface for "pearsons" operations.
`static interface`	`Ops.Coloc.PValue` Base interface for "pValue" operations.
`static interface`	`Ops.Coloc.Spearman` Base interface for "spearman" operations.
`static interface`	`Ops.Convert.Bit` Base interface for "bit" operations.
`static interface`	`Ops.Convert.Cfloat32` Base interface for "cfloat32" operations.
`static interface`	`Ops.Convert.Cfloat64` Base interface for "cfloat64" operations.
`static interface`	`Ops.Convert.Clip` Base interface for "clip" operations.
`static interface`	`Ops.Convert.Copy` Base interface for "copy" operations.
`static interface`	`Ops.Convert.Float32` Base interface for "float32" operations.
`static interface`	`Ops.Convert.Float64` Base interface for "float64" operations.
`static interface`	`Ops.Convert.ImageType` Base interface for "imageType" operations.
`static interface`	`Ops.Convert.Int16` Base interface for "int16" operations.
`static interface`	`Ops.Convert.Int32` Base interface for "int32" operations.
`static interface`	`Ops.Convert.Int64` Base interface for "int64" operations.
`static interface`	`Ops.Convert.Int8` Base interface for "int8" operations.
`static interface`	`Ops.Convert.NormalizeScale` Base interface for "normalizeScale" operations.
`static interface`	`Ops.Convert.Scale` Base interface for "scale" operations.
`static interface`	`Ops.Convert.Uint12` Base interface for "uint12" operations.
`static interface`	`Ops.Convert.Uint128` Base interface for "uint128" operations.
`static interface`	`Ops.Convert.Uint16` Base interface for "uint16" operations.
`static interface`	`Ops.Convert.Uint2` Base interface for "uint2" operations.
`static interface`	`Ops.Convert.Uint32` Base interface for "uint32" operations.
`static interface`	`Ops.Convert.Uint4` Base interface for "uint4" operations.
`static interface`	`Ops.Convert.Uint64` Base interface for "uint64" operations.
`static interface`	`Ops.Convert.Uint8` Base interface for "uint8" operations.
`static interface`	`Ops.Copy.Img` Base interface for "img" operations.
`static interface`	`Ops.Copy.ImgLabeling` Base interface for "imgLabeling" operations.
`static interface`	`Ops.Copy.ImgPlus` Base interface for "imgPlus" operations.
`static interface`	`Ops.Copy.IterableInterval` Base interface for "iterableInterval" operations.
`static interface`	`Ops.Copy.LabelingMapping` Base interface for "labelingMapping" operations.
`static interface`	`Ops.Copy.RAI` Base interface for "rai" operations.
`static interface`	`Ops.Copy.Type` Base interface for "type" operations.
`static interface`	`Ops.Create.Img` Base interface for "img" operations.
`static interface`	`Ops.Create.ImgFactory` Base interface for "imgFactory" operations.
`static interface`	`Ops.Create.ImgLabeling` Base interface for "imgLabeling" operations.
`static interface`	`Ops.Create.ImgPlus` Base interface for "imgPlus" operations.
`static interface`	`Ops.Create.IntegerType` Base interface for "integerType" operations.
`static interface`	`Ops.Create.Kernel` Base interface for "kernel" operations.
`static interface`	`Ops.Create.Kernel2ndDerivBiGauss` Base interface for "kernel2ndDerivBiGauss" operations.
`static interface`	`Ops.Create.KernelBiGauss` Base interface for "kernelBiGauss" operations.
`static interface`	`Ops.Create.KernelDiffraction` Base interface for "kernelDiffraction" operations.
`static interface`	`Ops.Create.KernelGabor` Base interface for "kernelGabor" operations.
`static interface`	`Ops.Create.KernelGauss` Base interface for "kernelGauss" operations.
`static interface`	`Ops.Create.KernelLog` Base interface for "kernelLog" operations.
`static interface`	`Ops.Create.KernelSobel` Base interface for "kernelSobel" operations.
`static interface`	`Ops.Create.LabelingMapping` Base interface for "labelingMapping" operations.
`static interface`	`Ops.Create.NativeImg` Base interface for "nativeImg" operations.
`static interface`	`Ops.Create.NativeType` Base interface for "nativeType" operations.
`static interface`	`Ops.Create.Object` Base interface for "object" operations.
`static interface`	`Ops.Create.Type` Base interface for "type" operations.
`static interface`	`Ops.Deconvolve.Accelerate` Base interface for "accelerate" operations.
`static interface`	`Ops.Deconvolve.FirstGuess` Base interface for "firstGuess" operations.
`static interface`	`Ops.Deconvolve.NormalizationFactor` Base interface for "normalizationFactor" operations.
`static interface`	`Ops.Deconvolve.RichardsonLucy` Base interface for "richardsonLucy" operations.
`static interface`	`Ops.Deconvolve.RichardsonLucyCorrection` Base interface for "richardsonLucyCorrection" operations.
`static interface`	`Ops.Deconvolve.RichardsonLucyTV` Base interface for "richardsonLucyTV" operations.
`static interface`	`Ops.Deconvolve.RichardsonLucyUpdate` Base interface for "richardsonLucyUpdate" operations.
`static interface`	`Ops.Eval` Base interface for "eval" operations.
`static interface`	`Ops.Filter.AddNoise` Base interface for "addNoise" operations.
`static interface`	`Ops.Filter.AddPoissonNoise` Base interface for "addPoissonNoise" operations.
`static interface`	`Ops.Filter.AllPartialDerivatives` Base interface for "allPartialDerivatives" operations.
`static interface`	`Ops.Filter.Bilateral` Base interface for "bilateral" operations.
`static interface`	`Ops.Filter.Convolve` Base interface for "convolve" operations.
`static interface`	`Ops.Filter.Correlate` Base interface for "correlate" operations.
`static interface`	`Ops.Filter.CreateFFTOutput` Base interface for "createFFTOutput" operations.
`static interface`	`Ops.Filter.DerivativeGauss` Base interface for "derivativeGauss" operations.
`static interface`	`Ops.Filter.DoG` Base interface for "dog" operations.
`static interface`	`Ops.Filter.FFT` Base interface for "fft" operations.
`static interface`	`Ops.Filter.FFTSize` Base interface for "fftSize" operations.
`static interface`	`Ops.Filter.FrangiVesselness` Base interface for "frangiVesselness" operations.
`static interface`	`Ops.Filter.Gauss` Base interface for "gauss" operations.
`static interface`	`Ops.Filter.Hessian` Base interface for "hessian" operations.
`static interface`	`Ops.Filter.IFFT` Base interface for "ifft" operations.
`static interface`	`Ops.Filter.LinearFilter` Base interface for "linearFilter" operations.
`static interface`	`Ops.Filter.Max` Base interface for "max" operations.
`static interface`	`Ops.Filter.Mean` Base interface for "mean" operations.
`static interface`	`Ops.Filter.Median` Base interface for "median" operations.
`static interface`	`Ops.Filter.Min` Base interface for "min" operations.
`static interface`	`Ops.Filter.PaddingIntervalCentered` Base interface for "paddingIntervalCentered" operations.
`static interface`	`Ops.Filter.PaddingIntervalOrigin` Base interface for "paddingIntervalOrigin" operations.
`static interface`	`Ops.Filter.PadFFTInput` Base interface for "padFFTInput" operations.
`static interface`	`Ops.Filter.PadInput` Base interface for "padInput" operations.
`static interface`	`Ops.Filter.PadShiftFFTKernel` Base interface for "padShiftFFTKernel" operations.
`static interface`	`Ops.Filter.PartialDerivative` Base interface for "partialDerivative" operations.
`static interface`	`Ops.Filter.Sigma` Base interface for "sigma" operations.
`static interface`	`Ops.Filter.Sobel` Base interface for "sobel" operations.
`static interface`	`Ops.Filter.Tubeness` Base interface for "tubeness" operations.
`static interface`	`Ops.Filter.Variance` Base interface for "variance" operations.
`static interface`	`Ops.Geometric.Boundary` Base interface for "boundary" operations.
`static interface`	`Ops.Geometric.BoundaryConvexHull` Base interface for "boundaryConvexHull" operations.
`static interface`	`Ops.Geometric.BoundarySize` Base interface for "boundarySize" operations.
`static interface`	`Ops.Geometric.BoundarySizeConvexHull` Base interface for "boundarySizeConvexHull" operations.
`static interface`	`Ops.Geometric.BoundingBox` Base interface for "boundingBox" operations.
`static interface`	`Ops.Geometric.Boxivity` Base interface for "boxivity" operations.
`static interface`	`Ops.Geometric.CenterOfGravity` Base interface for "centerOfGravity" operations.
`static interface`	`Ops.Geometric.Centroid` Base interface for "centroid" operations.
`static interface`	`Ops.Geometric.Circularity` Base interface for "circularity" operations.
`static interface`	`Ops.Geometric.Compactness` Base interface for "compactness" operations.
`static interface`	`Ops.Geometric.Contour` Base interface for "contour" operations.
`static interface`	`Ops.Geometric.ConvexHull` Base interface for "convexHull" operations.
`static interface`	`Ops.Geometric.Convexity` Base interface for "convexity" operations.
`static interface`	`Ops.Geometric.Eccentricity` Base interface for "eccentricity" operations.
`static interface`	`Ops.Geometric.FeretsAngle` Base interface for "feretsAngle" operations.
`static interface`	`Ops.Geometric.FeretsDiameter` Base interface for "feretsDiameter" operations.
`static interface`	`Ops.Geometric.MainElongation` Base interface for "mainElongation" operations.
`static interface`	`Ops.Geometric.MajorAxis` Base interface for "majorAxis" operations.
`static interface`	`Ops.Geometric.MarchingCubes` Base interface for "marchingCubes" operations.
`static interface`	`Ops.Geometric.MaximumFeret` Base interface for "maximumFeret" operations.
`static interface`	`Ops.Geometric.MaximumFeretsAngle` Base interface for "maximumFeretsAngle" operations.
`static interface`	`Ops.Geometric.MaximumFeretsDiameter` Base interface for "maximumFeretsDiameter" operations.
`static interface`	`Ops.Geometric.MedianElongation` Base interface for "medianElongation" operations.
`static interface`	`Ops.Geometric.MinimumFeret` Base interface for "minimumFeret" operations.
`static interface`	`Ops.Geometric.MinimumFeretsAngle` Base interface for "minimumFeretsAngle" operations.
`static interface`	`Ops.Geometric.MinimumFeretsDiameter` Base interface for "minimumFeretsDiameter" operations.
`static interface`	`Ops.Geometric.MinorAxis` Base interface for "minorAxis" operations.
`static interface`	`Ops.Geometric.Roundness` Base interface for "roundness" operations.
`static interface`	`Ops.Geometric.SecondMoment` Base interface for "secondMoment" operations.
`static interface`	`Ops.Geometric.Size` Base interface for "size" operations.
`static interface`	`Ops.Geometric.SizeConvexHull` Base interface for "sizeConvexHull" operations.
`static interface`	`Ops.Geometric.SmallestEnclosingBoundingBox` Base interface for "smallestEnclosingBoundingBox" operations.
`static interface`	`Ops.Geometric.Solidity` Base interface for "solidity" operations.
`static interface`	`Ops.Geometric.Spareness` Base interface for "spareness" operations.
`static interface`	`Ops.Geometric.Sphericity` Base interface for "sphericity" operations.
`static interface`	`Ops.Geometric.VertexInterpolator` Base interface for "vertexInterpolator" operations.
`static interface`	`Ops.Geometric.VerticesCount` Base interface for "verticesCount" operations.
`static interface`	`Ops.Geometric.VerticesCountConvexHull` Base interface for "verticesCountConvexHull" operations.
`static interface`	`Ops.Geometric.Voxelization` Base interface for "voxelization" operations.
`static interface`	`Ops.Haralick.ASM` Base interface for "asm" operations.
`static interface`	`Ops.Haralick.ClusterPromenence` Base interface for "clusterPromenence" operations.
`static interface`	`Ops.Haralick.ClusterShade` Base interface for "clusterShade" operations.
`static interface`	`Ops.Haralick.Contrast` Base interface for "contrast" operations.
`static interface`	`Ops.Haralick.Correlation` Base interface for "correlation" operations.
`static interface`	`Ops.Haralick.DifferenceEntropy` Base interface for "differenceEntropy" operations.
`static interface`	`Ops.Haralick.DifferenceVariance` Base interface for "differenceVariance" operations.
`static interface`	`Ops.Haralick.Entropy` Base interface for "entropy" operations.
`static interface`	`Ops.Haralick.ICM1` Base interface for "icm1" operations.
`static interface`	`Ops.Haralick.ICM2` Base interface for "icm2" operations.
`static interface`	`Ops.Haralick.IFDM` Base interface for "ifdm" operations.
`static interface`	`Ops.Haralick.MaxProbability` Base interface for "maxProbability" operations.
`static interface`	`Ops.Haralick.SumAverage` Base interface for "sumAverage" operations.
`static interface`	`Ops.Haralick.SumEntropy` Base interface for "sumEntropy" operations.
`static interface`	`Ops.Haralick.SumVariance` Base interface for "sumVariance" operations.
`static interface`	`Ops.Haralick.TextureHomogeneity` Base interface for "textureHomogeneity" operations.
`static interface`	`Ops.Haralick.Variance` Base interface for "variance" operations.
`static interface`	`Ops.Help` Base interface for "help" operations.
`static interface`	`Ops.HoG.HistogramOfOrientedGradients` Base interface for "hog" operations.
`static interface`	`Ops.Identity` Base interface for "identity" operations.
`static interface`	`Ops.Image.ASCII` Base interface for "ascii" operations.
`static interface`	`Ops.Image.CooccurrenceMatrix` Base interface for "cooccurrenceMatrix" operations.
`static interface`	`Ops.Image.DistanceTransform` Base interface for "distancetransform" operations.
`static interface`	`Ops.Image.Equation` Base interface for "equation" operations.
`static interface`	`Ops.Image.Fill` Base interface for "fill" operations.
`static interface`	`Ops.Image.Histogram` Base interface for "histogram" operations.
`static interface`	`Ops.Image.Integral` Base interface for "integral" operations.
`static interface`	`Ops.Image.Invert` Base interface for "invert" operations.
`static interface`	`Ops.Image.Normalize` Base interface for "normalize" operations.
`static interface`	`Ops.Image.SquareIntegral` Base interface for "squareIntegral" operations.
`static interface`	`Ops.Image.Watershed` Base interface for "watershed" operations.
`static interface`	`Ops.ImageMoments.CentralMoment00` Base interface for "centralMoment00" operations.
`static interface`	`Ops.ImageMoments.CentralMoment01` Base interface for "centralMoment01" operations.
`static interface`	`Ops.ImageMoments.CentralMoment02` Base interface for "centralMoment02" operations.
`static interface`	`Ops.ImageMoments.CentralMoment03` Base interface for "centralMoment03" operations.
`static interface`	`Ops.ImageMoments.CentralMoment10` Base interface for "centralMoment10" operations.
`static interface`	`Ops.ImageMoments.CentralMoment11` Base interface for "centralMoment11" operations.
`static interface`	`Ops.ImageMoments.CentralMoment12` Base interface for "centralMoment12" operations.
`static interface`	`Ops.ImageMoments.CentralMoment20` Base interface for "centralMoment20" operations.
`static interface`	`Ops.ImageMoments.CentralMoment21` Base interface for "centralMoment21" operations.
`static interface`	`Ops.ImageMoments.CentralMoment30` Base interface for "centralMoment30" operations.
`static interface`	`Ops.ImageMoments.HuMoment1` Base interface for "huMoment1" operations.
`static interface`	`Ops.ImageMoments.HuMoment2` Base interface for "huMoment2" operations.
`static interface`	`Ops.ImageMoments.HuMoment3` Base interface for "huMoment3" operations.
`static interface`	`Ops.ImageMoments.HuMoment4` Base interface for "huMoment4" operations.
`static interface`	`Ops.ImageMoments.HuMoment5` Base interface for "huMoment5" operations.
`static interface`	`Ops.ImageMoments.HuMoment6` Base interface for "huMoment6" operations.
`static interface`	`Ops.ImageMoments.HuMoment7` Base interface for "huMoment7" operations.
`static interface`	`Ops.ImageMoments.Moment00` Base interface for "moment00" operations.
`static interface`	`Ops.ImageMoments.Moment01` Base interface for "moment01" operations.
`static interface`	`Ops.ImageMoments.Moment10` Base interface for "moment10" operations.
`static interface`	`Ops.ImageMoments.Moment11` Base interface for "moment11" operations.
`static interface`	`Ops.ImageMoments.NormalizedCentralMoment02` Base interface for "normalizedCentralMoment02" operations.
`static interface`	`Ops.ImageMoments.NormalizedCentralMoment03` Base interface for "normalizedCentralMoment03" operations.
`static interface`	`Ops.ImageMoments.NormalizedCentralMoment11` Base interface for "normalizedCentralMoment11" operations.
`static interface`	`Ops.ImageMoments.NormalizedCentralMoment12` Base interface for "normalizedCentralMoment12" operations.
`static interface`	`Ops.ImageMoments.NormalizedCentralMoment20` Base interface for "normalizedCentralMoment20" operations.
`static interface`	`Ops.ImageMoments.NormalizedCentralMoment21` Base interface for "normalizedCentralMoment21" operations.
`static interface`	`Ops.ImageMoments.NormalizedCentralMoment30` Base interface for "normalizedCentralMoment30" operations.
`static interface`	`Ops.Join` Base interface for "join" operations.
`static interface`	`Ops.Labeling.CCA` Base interface for "cca" operations.
`static interface`	`Ops.Labeling.Merge` Base interface for "merge" operations.
`static interface`	`Ops.LBP.LBP2D` Base interface for "lbp2D" operations.
`static interface`	`Ops.LinAlg.Rotate` Base interface for "rotate" operations.
`static interface`	`Ops.Logic.And` Base interface for "and" operations.
`static interface`	`Ops.Logic.Bool` Base interface for "bool" operations.
`static interface`	`Ops.Logic.Conditional` Base interface for "conditional" operations.
`static interface`	`Ops.Logic.Equal` Base interface for "equal" operations.
`static interface`	`Ops.Logic.GreaterThan` Base interface for "greaterThan" operations.
`static interface`	`Ops.Logic.GreaterThanOrEqual` Base interface for "greaterThanOrEqual" operations.
`static interface`	`Ops.Logic.LessThan` Base interface for "lessThan" operations.
`static interface`	`Ops.Logic.LessThanOrEqual` Base interface for "lessThanOrEqual" operations.
`static interface`	`Ops.Logic.Not` Base interface for "not" operations.
`static interface`	`Ops.Logic.NotEqual` Base interface for "notEqual" operations.
`static interface`	`Ops.Logic.Or` Base interface for "or" operations.
`static interface`	`Ops.Logic.Xor` Base interface for "xor" operations.
`static interface`	`Ops.Lookup` Base interface for "op" operations.
`static interface`	`Ops.Loop` Base interface for "loop" operations.
`static interface`	`Ops.Map` Base interface for "map" operations.
`static interface`	`Ops.Math.Abs` Base interface for "abs" operations.
`static interface`	`Ops.Math.Add` Base interface for "add" operations.
`static interface`	`Ops.Math.And` Base interface for "and" operations.
`static interface`	`Ops.Math.Arccos` Base interface for "arccos" operations.
`static interface`	`Ops.Math.Arccosh` Base interface for "arccosh" operations.
`static interface`	`Ops.Math.Arccot` Base interface for "arccot" operations.
`static interface`	`Ops.Math.Arccoth` Base interface for "arccoth" operations.
`static interface`	`Ops.Math.Arccsc` Base interface for "arccsc" operations.
`static interface`	`Ops.Math.Arccsch` Base interface for "arccsch" operations.
`static interface`	`Ops.Math.Arcsec` Base interface for "arcsec" operations.
`static interface`	`Ops.Math.Arcsech` Base interface for "arcsech" operations.
`static interface`	`Ops.Math.Arcsin` Base interface for "arcsin" operations.
`static interface`	`Ops.Math.Arcsinh` Base interface for "arcsinh" operations.
`static interface`	`Ops.Math.Arctan` Base interface for "arctan" operations.
`static interface`	`Ops.Math.Arctanh` Base interface for "arctanh" operations.
`static interface`	`Ops.Math.Assign` Base interface for "assign" operations.
`static interface`	`Ops.Math.Ceil` Base interface for "ceil" operations.
`static interface`	`Ops.Math.Complement` Base interface for "complement" operations.
`static interface`	`Ops.Math.ComplexConjugateMultiply` Base interface for "complexConjugateMultiply" operations.
`static interface`	`Ops.Math.Cos` Base interface for "cos" operations.
`static interface`	`Ops.Math.Cosh` Base interface for "cosh" operations.
`static interface`	`Ops.Math.Cot` Base interface for "cot" operations.
`static interface`	`Ops.Math.Coth` Base interface for "coth" operations.
`static interface`	`Ops.Math.Csc` Base interface for "csc" operations.
`static interface`	`Ops.Math.Csch` Base interface for "csch" operations.
`static interface`	`Ops.Math.CubeRoot` Base interface for "cubeRoot" operations.
`static interface`	`Ops.Math.Divide` Base interface for "divide" operations.
`static interface`	`Ops.Math.Exp` Base interface for "exp" operations.
`static interface`	`Ops.Math.ExpMinusOne` Base interface for "expMinusOne" operations.
`static interface`	`Ops.Math.Floor` Base interface for "floor" operations.
`static interface`	`Ops.Math.Gamma` Base interface for "gamma" operations.
`static interface`	`Ops.Math.Invert` Base interface for "invert" operations.
`static interface`	`Ops.Math.LeftShift` Base interface for "leftShift" operations.
`static interface`	`Ops.Math.Log` Base interface for "log" operations.
`static interface`	`Ops.Math.Log10` Base interface for "log10" operations.
`static interface`	`Ops.Math.Log2` Base interface for "log2" operations.
`static interface`	`Ops.Math.LogOnePlusX` Base interface for "logOnePlusX" operations.
`static interface`	`Ops.Math.Max` Base interface for "max" operations.
`static interface`	`Ops.Math.Min` Base interface for "min" operations.
`static interface`	`Ops.Math.Multiply` Base interface for "multiply" operations.
`static interface`	`Ops.Math.NearestInt` Base interface for "nearestInt" operations.
`static interface`	`Ops.Math.Negate` Base interface for "negate" operations.
`static interface`	`Ops.Math.Or` Base interface for "or" operations.
`static interface`	`Ops.Math.Power` Base interface for "power" operations.
`static interface`	`Ops.Math.RandomGaussian` Base interface for "randomGaussian" operations.
`static interface`	`Ops.Math.RandomUniform` Base interface for "randomUniform" operations.
`static interface`	`Ops.Math.Reciprocal` Base interface for "reciprocal" operations.
`static interface`	`Ops.Math.Remainder` Base interface for "remainder" operations.
`static interface`	`Ops.Math.RightShift` Base interface for "rightShift" operations.
`static interface`	`Ops.Math.Round` Base interface for "round" operations.
`static interface`	`Ops.Math.Sec` Base interface for "sec" operations.
`static interface`	`Ops.Math.Sech` Base interface for "sech" operations.
`static interface`	`Ops.Math.Signum` Base interface for "signum" operations.
`static interface`	`Ops.Math.Sin` Base interface for "sin" operations.
`static interface`	`Ops.Math.Sinc` Base interface for "sinc" operations.
`static interface`	`Ops.Math.SincPi` Base interface for "sincPi" operations.
`static interface`	`Ops.Math.Sinh` Base interface for "sinh" operations.
`static interface`	`Ops.Math.Sqr` Base interface for "sqr" operations.
`static interface`	`Ops.Math.Sqrt` Base interface for "sqrt" operations.
`static interface`	`Ops.Math.Step` Base interface for "step" operations.
`static interface`	`Ops.Math.Subtract` Base interface for "subtract" operations.
`static interface`	`Ops.Math.Tan` Base interface for "tan" operations.
`static interface`	`Ops.Math.Tanh` Base interface for "tanh" operations.
`static interface`	`Ops.Math.Ulp` Base interface for "ulp" operations.
`static interface`	`Ops.Math.UnsignedRightShift` Base interface for "unsignedRightShift" operations.
`static interface`	`Ops.Math.Xor` Base interface for "xor" operations.
`static interface`	`Ops.Math.Zero` Base interface for "zero" operations.
`static interface`	`Ops.Morphology.BlackTopHat` Base interface for "blackTopHat" operations.
`static interface`	`Ops.Morphology.Close` Base interface for "close" operations.
`static interface`	`Ops.Morphology.Dilate` Base interface for "dilate" operations.
`static interface`	`Ops.Morphology.Erode` Base interface for "erode" operations.
`static interface`	`Ops.Morphology.ExtractHoles` Base interface for "extractHoles" operations.
`static interface`	`Ops.Morphology.FillHoles` Base interface for "fillHoles" operations.
`static interface`	`Ops.Morphology.FloodFill` Base interface for "floodFill" operations.
`static interface`	`Ops.Morphology.Open` Base interface for "open" operations.
`static interface`	`Ops.Morphology.Outline` Base interface for "outline" operations.
`static interface`	`Ops.Morphology.ThinGuoHall` Base interface for "thinGuoHall" operations.
`static interface`	`Ops.Morphology.ThinHilditch` Base interface for "thinHilditch" operations.
`static interface`	`Ops.Morphology.ThinMorphological` Base interface for "thinMorphological" operations.
`static interface`	`Ops.Morphology.ThinZhangSuen` Base interface for "thinZhangSuen" operations.
`static interface`	`Ops.Morphology.TopHat` Base interface for "topHat" operations.
`static interface`	`Ops.Run` Base interface for "run" operations.
`static interface`	`Ops.Segment.DetectJunctions` Base interface for "detectJunctions" operations.
`static interface`	`Ops.Segment.DetectRidges` Base interface for "detectRidges" operations.
`static interface`	`Ops.Slice` Base interface for "slice" operations.
`static interface`	`Ops.Stats.GeometricMean` Base interface for "geometricMean" operations.
`static interface`	`Ops.Stats.HarmonicMean` Base interface for "harmonicMean" operations.
`static interface`	`Ops.Stats.IntegralMean` Base interface for "integralMean" operations.
`static interface`	`Ops.Stats.IntegralSum` Base interface for "integralSum" operations.
`static interface`	`Ops.Stats.IntegralVariance` Base interface for "integralVariance" operations.
`static interface`	`Ops.Stats.Kurtosis` Base interface for "kurtosis" operations.
`static interface`	`Ops.Stats.LeastSquares` Base interface for "leastSquares" operations.
`static interface`	`Ops.Stats.Max` Base interface for "max" operations.
`static interface`	`Ops.Stats.Mean` Base interface for "mean" operations.
`static interface`	`Ops.Stats.Median` Base interface for "median" operations.
`static interface`	`Ops.Stats.Min` Base interface for "min" operations.
`static interface`	`Ops.Stats.MinMax` Base interface for "minMax" operations.
`static interface`	`Ops.Stats.Moment1AboutMean` Base interface for "moment1AboutMean" operations.
`static interface`	`Ops.Stats.Moment2AboutMean` Base interface for "moment2AboutMean" operations.
`static interface`	`Ops.Stats.Moment3AboutMean` Base interface for "moment3AboutMean" operations.
`static interface`	`Ops.Stats.Moment4AboutMean` Base interface for "moment4AboutMean" operations.
`static interface`	`Ops.Stats.Percentile` Base interface for "percentile" operations.
`static interface`	`Ops.Stats.Quantile` Base interface for "quantile" operations.
`static interface`	`Ops.Stats.Size` Base interface for "size" operations.
`static interface`	`Ops.Stats.Skewness` Base interface for "skewness" operations.
`static interface`	`Ops.Stats.StdDev` Base interface for "stdDev" operations.
`static interface`	`Ops.Stats.Sum` Base interface for "sum" operations.
`static interface`	`Ops.Stats.SumOfInverses` Base interface for "sumOfInverses" operations.
`static interface`	`Ops.Stats.SumOfLogs` Base interface for "sumOfLogs" operations.
`static interface`	`Ops.Stats.SumOfSquares` Base interface for "sumOfSquares" operations.
`static interface`	`Ops.Stats.Variance` Base interface for "variance" operations.
`static interface`	`Ops.Tamura.Coarseness` Base interface for "coarseness" operations.
`static interface`	`Ops.Tamura.Contrast` Base interface for "contrast" operations.
`static interface`	`Ops.Tamura.Directionality` Base interface for "directionality" operations.
`static interface`	`Ops.Thread.Chunker` Base interface for "chunker" operations.
`static interface`	`Ops.Threshold.Apply` Base interface for "apply" operations.
`static interface`	`Ops.Threshold.Huang` Base interface for "huang" operations.
`static interface`	`Ops.Threshold.IJ1` Base interface for "ij1" operations.
`static interface`	`Ops.Threshold.Intermodes` Base interface for "intermodes" operations.
`static interface`	`Ops.Threshold.IsoData` Base interface for "isoData" operations.
`static interface`	`Ops.Threshold.Li` Base interface for "li" operations.
`static interface`	`Ops.Threshold.LocalBernsenThreshold` Base interface for "localBernsenThreshold" operations.
`static interface`	`Ops.Threshold.LocalContrastThreshold` Base interface for "localContrastThreshold" operations.
`static interface`	`Ops.Threshold.LocalMeanThreshold` Base interface for "localMeanThreshold" operations.
`static interface`	`Ops.Threshold.LocalMedianThreshold` Base interface for "localMedianThreshold" operations.
`static interface`	`Ops.Threshold.LocalMidGreyThreshold` Base interface for "localMidGreyThreshold" operations.
`static interface`	`Ops.Threshold.LocalNiblackThreshold` Base interface for "localNiblackThreshold" operations.
`static interface`	`Ops.Threshold.LocalPhansalkarThreshold` Base interface for "localPhansalkarThreshold" operations.
`static interface`	`Ops.Threshold.LocalSauvolaThreshold` Base interface for "localSauvolaThreshold" operations.
`static interface`	`Ops.Threshold.MaxEntropy` Base interface for "maxEntropy" operations.
`static interface`	`Ops.Threshold.MaxLikelihood` Base interface for "maxLikelihood" operations.
`static interface`	`Ops.Threshold.Mean` Base interface for "mean" operations.
`static interface`	`Ops.Threshold.MinError` Base interface for "minError" operations.
`static interface`	`Ops.Threshold.Minimum` Base interface for "minimum" operations.
`static interface`	`Ops.Threshold.Moments` Base interface for "moments" operations.
`static interface`	`Ops.Threshold.Otsu` Base interface for "otsu" operations.
`static interface`	`Ops.Threshold.Percentile` Base interface for "percentile" operations.
`static interface`	`Ops.Threshold.RenyiEntropy` Base interface for "renyiEntropy" operations.
`static interface`	`Ops.Threshold.Rosin` Base interface for "rosin" operations.
`static interface`	`Ops.Threshold.Shanbhag` Base interface for "shanbhag" operations.
`static interface`	`Ops.Threshold.Triangle` Base interface for "triangle" operations.
`static interface`	`Ops.Threshold.Yen` Base interface for "yen" operations.
`static interface`	`Ops.Topology.BoxCount` Base interface for "boxCount" operations.
`static interface`	`Ops.Topology.EulerCharacteristic26N` Base interface for "eulerCharacteristic26N" operations.
`static interface`	`Ops.Topology.EulerCharacteristic26NFloating` Base interface for "eulerCharacteristic26NFloating" operations.
`static interface`	`Ops.Topology.EulerCorrection` Base interface for "eulerCorrection" operations.
`static interface`	`Ops.Transform.AddDimensionView` Base interface for "addDimensionView" operations.
`static interface`	`Ops.Transform.CollapseNumericView` Base interface for "collapseNumericView" operations.
`static interface`	`Ops.Transform.CollapseRealView` Base interface for "collapseRealView" operations.
`static interface`	`Ops.Transform.CollapseView` Base interface for "collapseView" operations.
`static interface`	`Ops.Transform.ConcatenateView` Base interface for "concatenateView" operations.
`static interface`	`Ops.Transform.Crop` Base interface for "crop" operations.
`static interface`	`Ops.Transform.DropSingletonDimensionsView` Base interface for "dropSingletonDimensionsView" operations.
`static interface`	`Ops.Transform.ExtendBorderView` Base interface for "extendBorderView" operations.
`static interface`	`Ops.Transform.ExtendMirrorDoubleView` Base interface for "extendMirrorDoubleView" operations.
`static interface`	`Ops.Transform.ExtendMirrorSingleView` Base interface for "extendMirrorSingleView" operations.
`static interface`	`Ops.Transform.ExtendPeriodicView` Base interface for "extendPeriodicView" operations.
`static interface`	`Ops.Transform.ExtendRandomView` Base interface for "extendRandomView" operations.
`static interface`	`Ops.Transform.ExtendValueView` Base interface for "extendValueView" operations.
`static interface`	`Ops.Transform.ExtendView` Base interface for "extendView" operations.
`static interface`	`Ops.Transform.ExtendZeroView` Base interface for "extendZeroView" operations.
`static interface`	`Ops.Transform.FlatIterableView` Base interface for "flatIterableView" operations.
`static interface`	`Ops.Transform.HyperSliceView` Base interface for "hyperSliceView" operations.
`static interface`	`Ops.Transform.InterpolateView` Base interface for "interpolateView" operations.
`static interface`	`Ops.Transform.IntervalView` Base interface for "intervalView" operations.
`static interface`	`Ops.Transform.InvertAxisView` Base interface for "invertAxisView" operations.
`static interface`	`Ops.Transform.IterableView` Base interface for "iterableView" operations.
`static interface`	`Ops.Transform.OffsetView` Base interface for "offsetView" operations.
`static interface`	`Ops.Transform.PermuteCoordinatesInverseView` Base interface for "permuteCoordinatesInverseView" operations.
`static interface`	`Ops.Transform.PermuteCoordinatesView` Base interface for "permuteCoordinatesView" operations.
`static interface`	`Ops.Transform.PermuteView` Base interface for "permuteView" operations.
`static interface`	`Ops.Transform.Project` Base interface for "project" operations.
`static interface`	`Ops.Transform.RasterView` Base interface for "rasterView" operations.
`static interface`	`Ops.Transform.RotateView` Base interface for "rotateView" operations.
`static interface`	`Ops.Transform.ScaleView` Base interface for "scaleView" operations.
`static interface`	`Ops.Transform.ShearView` Base interface for "shearView" operations.
`static interface`	`Ops.Transform.StackView` Base interface for "stackView" operations.
`static interface`	`Ops.Transform.SubsampleView` Base interface for "subsampleView" operations.
`static interface`	`Ops.Transform.TranslateView` Base interface for "translateView" operations.
`static interface`	`Ops.Transform.UnshearView` Base interface for "unshearView" operations.
`static interface`	`Ops.Transform.ZeroMinView` Base interface for "zeroMinView" operations.
`static interface`	`Ops.Zernike.Magnitude` Base interface for "magnitude" operations.
`static interface`	`Ops.Zernike.Phase` Base interface for "phase" operations.

Classes in net.imagej.ops that implement Op
Modifier and Type	Class and Description
`class`	`AbstractOp` Abstract superclass for `Op` implementations.

Methods in net.imagej.ops with type parameters of type Op
Modifier and Type	Method and Description
`default <OP extends Op> OP`	OpEnvironment.`op(Class<OP> type, Object... args)` Gets the best `Op` to use for the given operation type and arguments, populating its inputs.

Methods in net.imagej.ops that return Op
Modifier and Type	Method and Description
`default Op`	OpEnvironment.`op(List<OpRef> refs)` Looks up an op whose constraints are specified by the given list of `OpRef` descriptor.
`default Op`	OpEnvironment.`op(OpRef ref)` Looks up an op whose constraints are specified by the given `OpRef` descriptor.
`default Op`	OpEnvironment.`op(String name, Object... args)` Gets the best `Op` to use for the given operation and arguments, populating its inputs.
`static Op`	OpUtils.`unwrap(Module module, Collection<? extends Type> types)` Unwraps the delegate object of the given `Module`, ensuring it is an instance of the specified type(s).
`static Op`	OpUtils.`unwrap(Module module, OpRef ref)` Unwraps the delegate object of the given `Module`, ensuring it is an instance whose type matches the specified `OpRef`.

Methods in net.imagej.ops that return types with arguments of type Op
Modifier and Type	Method and Description
`Class<Op>`	DefaultOpService.`getPluginType()`
`Class<? extends Op>`	OpInfo.`getType()` Gets the type of op, as specified via `@Plugin(type = <type>)`).

Methods in net.imagej.ops with parameters of type Op
Modifier and Type	Method and Description
`default String`	OpEnvironment.`help(Op op)` Executes the "help" operation on the given arguments.
`default OpInfo`	OpEnvironment.`info(Op op)` Gets the metadata for a given `Op`.
`default Module`	OpEnvironment.`module(Op op, Object... args)` Wraps the given `Op` as a `Module`, populating its inputs.
`default Object`	OpEnvironment.`run(Op op, Object... args)` Executes the given `Op` with the specified arguments.

Method parameters in net.imagej.ops with type arguments of type Op
Modifier and Type	Method and Description
`default String`	OpEnvironment.`help(String name, Class<? extends Op> opType)` Executes the "help" operation on the given arguments.
`default String`	OpEnvironment.`help(String name, Class<? extends Op> opType, Integer arity)` Executes the "help" operation on the given arguments.
`default String`	OpEnvironment.`help(String name, Class<? extends Op> opType, Integer arity, SpecialOp.Flavor flavor)` Executes the "help" operation on the given arguments.
`OpInfo`	OpEnvironment.`info(Class<? extends Op> type)` Gets the metadata for a given `Op` class.
`OpInfo`	DefaultOpService.`info(Class<? extends Op> type)`
`OpInfo`	CustomOpEnvironment.`info(Class<? extends Op> type)`
`default Module`	OpEnvironment.`module(Class<? extends Op> type, Object... args)` Gets the best `Op` to use for the given operation type and arguments, wrapping it as a `Module` with populated inputs.
`default Object`	OpEnvironment.`run(Class<? extends Op> type, Object... args)` Executes the operation of the given type with the specified arguments.

Constructor parameters in net.imagej.ops with type arguments of type Op
Constructor and Description
`OpInfo(Class<? extends Op> opClass)`

Uses of Op in net.imagej.ops.cached

Methods in net.imagej.ops.cached that return Op
Modifier and Type Method and Description

Op CachedOpEnvironment.op(OpRef ref)

Methods in net.imagej.ops.cached that return Op
Modifier and Type	Method and Description
`Op`	CachedOpEnvironment.`op(OpRef ref)`

Uses of Op in net.imagej.ops.coloc.icq

Classes in net.imagej.ops.coloc.icq that implement Op
Modifier and Type	Class and Description
`class`	`LiICQ<T extends RealType<T>,U extends RealType<U>>` This algorithm calculates Li et al.'s ICQ (intensity correlation quotient).

Uses of Op in net.imagej.ops.coloc.kendallTau

Classes in net.imagej.ops.coloc.kendallTau that implement Op
Modifier and Type	Class and Description
`class`	`KendallTauBRank<T extends RealType<T>,U extends RealType<U>>` This algorithm calculates Kendall's Tau-b rank correlation coefficient

Uses of Op in net.imagej.ops.coloc.maxTKendallTau

Classes in net.imagej.ops.coloc.maxTKendallTau that implement Op
Modifier and Type	Class and Description
`class`	`MTKT<T extends RealType<T>,U extends RealType<U>>` This algorithm calculates Maximum Trunctated Kendall Tau (MTKT) from Wang et al.

Uses of Op in net.imagej.ops.coloc.pearsons

Classes in net.imagej.ops.coloc.pearsons that implement Op
Modifier and Type	Class and Description
`class`	`DefaultPearsons<T extends RealType<T>,U extends RealType<U>>` A class that represents the mean calculation of the two source images in the data container.

Uses of Op in net.imagej.ops.coloc.pValue

Classes in net.imagej.ops.coloc.pValue that implement Op
Modifier and Type	Class and Description
`class`	`DefaultPValue<T extends RealType<T>,U extends RealType<U>>` This algorithm repeatedly executes a colocalization algorithm, computing a p-value.

Uses of Op in net.imagej.ops.commands.project

Subinterfaces of Op in net.imagej.ops.commands.project
Modifier and Type	Interface and Description
`interface`	`ProjectMethod<T extends RealType<T>>` Interface marking functions that can be used within the `ProjectCommand`.

Uses of Op in net.imagej.ops.commands.threshold

Classes in net.imagej.ops.commands.threshold that implement Op
Modifier and Type	Class and Description
`class`	`GlobalThresholder<T extends RealType<T>>` TODO: should actually live in a different package!! OR: can this be auto-generated?? (e.g.

Uses of Op in net.imagej.ops.convert

Classes in net.imagej.ops.convert that implement Op
Modifier and Type	Class and Description
`static class`	`ConvertImages.Bit<C extends ComplexType<C>>`
`static class`	`ConvertImages.Cfloat32<C extends ComplexType<C>>`
`static class`	`ConvertImages.Cfloat64<C extends ComplexType<C>>`
`static class`	`ConvertImages.Float32<C extends ComplexType<C>>`
`static class`	`ConvertImages.Float64<C extends ComplexType<C>>`
`static class`	`ConvertImages.Int16<C extends ComplexType<C>>`
`static class`	`ConvertImages.Int32<C extends ComplexType<C>>`
`static class`	`ConvertImages.Int64<C extends ComplexType<C>>`
`static class`	`ConvertImages.Int8<C extends ComplexType<C>>`
`static class`	`ConvertImages.Uint12<C extends ComplexType<C>>`
`static class`	`ConvertImages.Uint128<C extends ComplexType<C>>`
`static class`	`ConvertImages.Uint16<C extends ComplexType<C>>`
`static class`	`ConvertImages.Uint2<C extends ComplexType<C>>`
`static class`	`ConvertImages.Uint32<C extends ComplexType<C>>`
`static class`	`ConvertImages.Uint4<C extends ComplexType<C>>`
`static class`	`ConvertImages.Uint64<C extends ComplexType<C>>`
`static class`	`ConvertImages.Uint8<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToBit<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToCfloat32<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToCfloat64<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToFloat32<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToFloat64<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToInt16<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToInt32<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToInt64<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToInt8<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToUint12<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToUint128<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToUint16<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToUint2<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToUint32<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToUint4<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToUint64<C extends ComplexType<C>>`
`static class`	`ConvertTypes.ComplexToUint8<C extends ComplexType<C>>`
`static class`	`ConvertTypes.IntegerToBit<T extends IntegerType<T>>`
`static class`	`ConvertTypes.IntegerToInt16<T extends IntegerType<T>>`
`static class`	`ConvertTypes.IntegerToInt32<T extends IntegerType<T>>`
`static class`	`ConvertTypes.IntegerToInt64<T extends IntegerType<T>>`
`static class`	`ConvertTypes.IntegerToInt8<T extends IntegerType<T>>`
`static class`	`ConvertTypes.IntegerToUint12<T extends IntegerType<T>>`
`static class`	`ConvertTypes.IntegerToUint128<T extends IntegerType<T>>`
`static class`	`ConvertTypes.IntegerToUint16<T extends IntegerType<T>>`
`static class`	`ConvertTypes.IntegerToUint2<T extends IntegerType<T>>`
`static class`	`ConvertTypes.IntegerToUint32<T extends IntegerType<T>>`
`static class`	`ConvertTypes.IntegerToUint4<T extends IntegerType<T>>`
`static class`	`ConvertTypes.IntegerToUint64<T extends IntegerType<T>>`
`static class`	`ConvertTypes.IntegerToUint8<T extends IntegerType<T>>`
`class`	`RealTypeConverter<I extends RealType<I>,O extends RealType<O>>` Base class for ops which convert between `RealType`s.

Uses of Op in net.imagej.ops.convert.clip

Classes in net.imagej.ops.convert.clip that implement Op
Modifier and Type	Class and Description
`class`	`ClipRealTypes<I extends RealType<I>,O extends RealType<O>>` Copies the value of one `RealType` to another, and clips values which are outside of the output types range.

Uses of Op in net.imagej.ops.convert.copy

Classes in net.imagej.ops.convert.copy that implement Op
Modifier and Type	Class and Description
`class`	`CopyRealTypes<I extends RealType<I>,O extends RealType<O>>` Copies the value of one `RealType` into another using `double` precision.

Uses of Op in net.imagej.ops.convert.imageType

Classes in net.imagej.ops.convert.imageType that implement Op
Modifier and Type Class and Description

class ConvertIIs<I extends RealType<I>,O extends RealType<O>>

Classes in net.imagej.ops.convert.imageType that implement Op
Modifier and Type	Class and Description
`class`	`ConvertIIs<I extends RealType<I>,O extends RealType<O>>`

Uses of Op in net.imagej.ops.convert.normalizeScale

Classes in net.imagej.ops.convert.normalizeScale that implement Op
Modifier and Type	Class and Description
`class`	`NormalizeScaleRealTypes<I extends RealType<I>,O extends RealType<O>>` Scales input values to their corresponding value in the output type range based on the min/max values of an `IterableInterval` not the range of the input type.

Uses of Op in net.imagej.ops.convert.scale

Classes in net.imagej.ops.convert.scale that implement Op
Modifier and Type	Class and Description
`class`	`ScaleRealTypes<I extends RealType<I>,O extends RealType<O>>` Scales input values to their corresponding value in the output type range.

Uses of Op in net.imagej.ops.copy

Classes in net.imagej.ops.copy that implement Op
Modifier and Type	Class and Description
`class`	`CopyArrayImg<T extends NativeType<T>,A extends ArrayDataAccess<A>>` Copying `ArrayImg` into another `ArrayImg`
`class`	`CopyII<T>` Copies an `IterableInterval` into another `IterableInterval`
`class`	`CopyImg<T extends NativeType<T>>` Copying `Img` into another `Img`.
`class`	`CopyImgLabeling<T extends IntegerType<T> & NativeType<T>,L>` Copying `ImgLabeling` into another `ImgLabeling`
`class`	`CopyLabelingMapping<L>` Copies a `LabelingMapping` into another `LabelingMapping`
`class`	`CopyRAI<T>` Copies a `RandomAccessibleInterval` into another `RandomAccessibleInterval`
`class`	`CopyType<T extends Type<T>>` Copy `Type` to another `Type`

Uses of Op in net.imagej.ops.create.img

Classes in net.imagej.ops.create.img that implement Op
Modifier and Type	Class and Description
`class`	`CreateImgFromDimsAndType<T extends NativeType<T>>` Creates an `Img` with the given `Dimensions` and `NativeType`.
`class`	`CreateImgFromII<T extends NativeType<T>>` Create an `Img` from an `IterableInterval` using its type `T`.
`class`	`CreateImgFromImg<T extends Type<T>>` Create an `Img` from another `Img` implementation using its `Type` and `ImgFactory`.
`class`	`CreateImgFromInterval` Creates an `Img` from an `Interval` with no additional hints.
`class`	`CreateImgFromRAI<T extends NativeType<T>>` Create an `Img` from a `RandomAccessibleInterval` using its type `T`.

Uses of Op in net.imagej.ops.create.imgFactory

Classes in net.imagej.ops.create.imgFactory that implement Op
Modifier and Type	Class and Description
`class`	`CreateImgFactoryFromImg<T>` Gets an `ImgFactory` for the given `Img`.
`class`	`DefaultCreateImgFactory<T extends NativeType<T>>` Default implementation of the "create.imgFactory" op.

Uses of Op in net.imagej.ops.create.imgLabeling

Classes in net.imagej.ops.create.imgLabeling that implement Op
Modifier and Type	Class and Description
`class`	`CreateImgLabelingFromInterval<L,T extends IntegerType<T>>` Creates an `ImgLabeling` from an `Interval`.
`class`	`DefaultCreateImgLabeling<L,T extends IntegerType<T>>` Default implementation of the "create.imgLabeling" op.

Uses of Op in net.imagej.ops.create.imgPlus

Classes in net.imagej.ops.create.imgPlus that implement Op
Modifier and Type Class and Description

class DefaultCreateImgPlus<T>
Default implementation of the "create.imgPlus" op.
Uses of Op in net.imagej.ops.create.integerType

Classes in net.imagej.ops.create.integerType that implement Op
Modifier and Type Class and Description

class DefaultCreateIntegerType
Create an IntegerType with at least maxValue maximum.

Classes in net.imagej.ops.create.imgPlus that implement Op
Modifier and Type	Class and Description
`class`	`DefaultCreateImgPlus<T>` Default implementation of the "create.imgPlus" op.

Classes in net.imagej.ops.create.integerType that implement Op
Modifier and Type	Class and Description
`class`	`DefaultCreateIntegerType` Create an IntegerType with at least `maxValue` maximum.

Uses of Op in net.imagej.ops.create.kernel

Classes in net.imagej.ops.create.kernel that implement Op
Modifier and Type	Class and Description
`class`	`CreateKernel2D<T extends ComplexType<T>>` This Op takes a 2-D array of explicit values and creates a simple image, e.g.

Uses of Op in net.imagej.ops.create.kernelBiGauss

Classes in net.imagej.ops.create.kernelBiGauss that implement Op
Modifier and Type	Class and Description
`class`	`CreateKernel2ndDerivBiGaussDoubleType` Creates 2nd derivative of an isotropic BiGauss kernel of type `DoubleType`, uses `DefaultCreateKernel2ndDerivBiGauss` to do the job.
`class`	`CreateKernelBiGaussDoubleType` Creates an isotropic BiGauss kernel of type `DoubleType`, uses `DefaultCreateKernelBiGauss` to do the job.
`class`	`DefaultCreateKernel2ndDerivBiGauss<T extends ComplexType<T>>` Creates 2nd derivative of an isotropic BiGauss kernel with the pair of sigmas specification.
`class`	`DefaultCreateKernelBiGauss<T extends ComplexType<T>>` Creates an isotropic BiGauss kernel with the pair of sigmas specification.

Uses of Op in net.imagej.ops.create.kernelDiffraction

Classes in net.imagej.ops.create.kernelDiffraction that implement Op
Modifier and Type	Class and Description
`class`	`DefaultCreateKernelGibsonLanni<T extends ComplexType<T> & NativeType<T>>` Creates a Gibson Lanni Kernel.

Uses of Op in net.imagej.ops.create.kernelGabor

Classes in net.imagej.ops.create.kernelGabor that implement Op
Modifier and Type	Class and Description
`class`	`CreateKernelGaborComplexDoubleType` Creates a Gabor kernel of type `ComplexDoubleType`, uses `DefaultCreateKernelGabor` to do the job.
`class`	`CreateKernelGaborDoubleType` Creates a Gabor kernel of type `DoubleType`, uses `DefaultCreateKernelGabor` to do the job.
`class`	`CreateKernelGaborIsotropic<T extends ComplexType<T>>` Creates an isotropic Gabor kernel, i.e., with one sigma for all axes, and a period vector.
`class`	`CreateKernelGaborIsotropicComplexDoubleType` Creates an isotropic Gabor kernel of type `ComplexDoubleType`, uses `DefaultCreateKernelGabor` to do the job.
`class`	`CreateKernelGaborIsotropicDoubleType` Creates an isotropic Gabor kernel of type `DoubleType`, uses `DefaultCreateKernelGabor` to do the job.
`class`	`DefaultCreateKernelGabor<T extends ComplexType<T>>` Creates a Gabor kernel with specifications for individual sigma per axis, and a period vector.

Uses of Op in net.imagej.ops.create.kernelGauss

Classes in net.imagej.ops.create.kernelGauss that implement Op
Modifier and Type	Class and Description
`class`	`CreateKernelGaussDoubleType` Creates a Gaussian kernel of type `DoubleType`.
`class`	`CreateKernelGaussSymmetric<T extends ComplexType<T>>` Creates a symmetric Gaussian kernel.
`class`	`CreateKernelGaussSymmetricDoubleType` Creates a symmetric Gaussian kernel of type `DoubleType`.
`class`	`DefaultCreateKernelGauss<T extends ComplexType<T>>` Creates a Gaussian Kernel

Uses of Op in net.imagej.ops.create.kernelLog

Classes in net.imagej.ops.create.kernelLog that implement Op
Modifier and Type	Class and Description
`class`	`CreateKernelLogDoubleType` Creates a log kernel of type `DoubleType`.
`class`	`CreateKernelLogSymmetric<T extends ComplexType<T>>` Creates a Gaussian Kernel
`class`	`CreateKernelLogSymmetricDoubleType` Creates a symmetric log kernel of type `DoubleType`.
`class`	`DefaultCreateKernelLog<T extends ComplexType<T>>` Laplacian of Gaussian filter ported from fiji.plugin.trackmate.detection.DetectionUtil.

Uses of Op in net.imagej.ops.create.kernelSobel

Classes in net.imagej.ops.create.kernelSobel that implement Op
Modifier and Type Class and Description

class CreateKernelSobel<T extends ComplexType<T>>
Creates a separated sobel kernel.

Classes in net.imagej.ops.create.kernelSobel that implement Op
Modifier and Type	Class and Description
`class`	`CreateKernelSobel<T extends ComplexType<T>>` Creates a separated sobel kernel.

Uses of Op in net.imagej.ops.create.labelingMapping

Classes in net.imagej.ops.create.labelingMapping that implement Op
Modifier and Type	Class and Description
`class`	`DefaultCreateLabelingMapping<L>` Create a LabelingMapping which can store at least maxNumSets different Sets

Uses of Op in net.imagej.ops.create.nativeType

Classes in net.imagej.ops.create.nativeType that implement Op
Modifier and Type	Class and Description
`class`	`CreateNativeTypeFromClass<T extends NativeType<T>>` Creates the `NativeType` given by the input `Class`.
`class`	`DefaultCreateNativeType` Default implementation of the "create.nativeType" op.

Uses of Op in net.imagej.ops.create.object

Classes in net.imagej.ops.create.object that implement Op
Modifier and Type Class and Description

class CreateObjectFromClass<T>
Instantiates an object given by the input Class.

Classes in net.imagej.ops.create.object that implement Op
Modifier and Type	Class and Description
`class`	`CreateObjectFromClass<T>` Instantiates an object given by the input `Class`.

Uses of Op in net.imagej.ops.deconvolve

Classes in net.imagej.ops.deconvolve that implement Op
Modifier and Type	Class and Description
`class`	`NonCirculantFirstGuess<I extends RealType<I>,O extends RealType<O>,K extends RealType<K>,C extends ComplexType<C>>` Calculate non-circulant first guess.
`class`	`NonCirculantNormalizationFactor<I extends RealType<I>,O extends RealType<O>,K extends RealType<K>,C extends ComplexType<C>>` Calculate non-circulant normalization factor.
`class`	`PadAndRichardsonLucy<I extends RealType<I> & NativeType<I>,O extends RealType<O> & NativeType<O>,K extends RealType<K> & NativeType<K>,C extends ComplexType<C> & NativeType<C>>` Richardson Lucy function op that operates on (@link RandomAccessibleInterval) (Lucy, L.
`class`	`PadAndRichardsonLucyTV<I extends RealType<I> & NativeType<I>,O extends RealType<O> & NativeType<O>,K extends RealType<K> & NativeType<K>,C extends ComplexType<C> & NativeType<C>>` Richardson Lucy with total variation function op that operates on (@link RandomAccessibleInterval) (Richardson-Lucy algorithm with total variation regularization for 3D confocal microscope deconvolution Microsc Res Rech 2006 Apr; 69(4)- 260-6)
`class`	`RichardsonLucyC<I extends RealType<I>,O extends RealType<O>,K extends RealType<K>,C extends ComplexType<C>>` Richardson Lucy algorithm for (@link RandomAccessibleInterval) (Lucy, L.
`class`	`RichardsonLucyCorrection<I extends RealType<I>,O extends RealType<O>,C extends ComplexType<C>>` Computes Richardson Lucy correction factor for (@link RandomAccessibleInterval) (Lucy, L.
`class`	`RichardsonLucyTVUpdate<T extends RealType<T> & NativeType<T>,I extends RandomAccessibleInterval<T>>` Implements update step for Richardson-Lucy algorithm with total variation regularization for 3D confocal microscope deconvolution Microsc Res Rech 2006 Apr; 69(4)- 260-6 The div_unit_grad function has been adapted from IOCBIOS, Pearu Peterson https://code.google.com/p/iocbio/
`class`	`RichardsonLucyUpdate<T extends RealType<T>>` Implements update step for Richardson-Lucy algorithm on `RandomAccessibleInterval`.

Uses of Op in net.imagej.ops.deconvolve.accelerate

Classes in net.imagej.ops.deconvolve.accelerate that implement Op
Modifier and Type	Class and Description
`class`	`VectorAccelerator<T extends RealType<T> & NativeType<T>>` Vector Accelerator implements acceleration scheme described in Acceleration of iterative image restoration algorithms David S.C.

Uses of Op in net.imagej.ops.eval

Classes in net.imagej.ops.eval that implement Op
Modifier and Type Class and Description

class DefaultEval
Evaluates an expression.

Classes in net.imagej.ops.eval that implement Op
Modifier and Type	Class and Description
`class`	`DefaultEval` Evaluates an expression.

Uses of Op in net.imagej.ops.features.haralick

Subinterfaces of Op in net.imagej.ops.features.haralick
Modifier and Type	Interface and Description
`interface`	`HaralickFeature<T extends RealType<T>>` Simple marker interface for Haralick Features.

Classes in net.imagej.ops.features.haralick that implement Op
Modifier and Type	Class and Description
`class`	`AbstractHaralickFeature<T extends RealType<T>>` Abstract class for HaralickFeatures.
`class`	`DefaultASM<T extends RealType<T>>` Implementation of Angular Second Moment Haralick Feature
`class`	`DefaultClusterPromenence<T extends RealType<T>>` Implementation of Cluster Promenence Haralick Feature
`class`	`DefaultClusterShade<T extends RealType<T>>` Implementation of Cluster Shade Haralick Feature
`class`	`DefaultContrast<T extends RealType<T>>` Implementation of texture contrast haralick feature.
`class`	`DefaultCorrelation<T extends RealType<T>>` Implementation of texture correlation haralick feature based on http://earlglynn.github.io/RNotes/package/EBImage/Haralick-Textural-Features.html .
`class`	`DefaultDifferenceEntropy<T extends RealType<T>>` Implementation of Difference Entropy Haralick Feature
`class`	`DefaultDifferenceVariance<T extends RealType<T>>` Implementation of Difference Variance Haralick Feature
`class`	`DefaultEntropy<T extends RealType<T>>` Implementation of Entropy Haralick Feature Definition: -( sum_{i=1}^q sum_{j=1}^q c(i,j) log(c(i,j)) )
`class`	`DefaultICM1<T extends RealType<T>>` Implementation of Information Measure of Correlation 1 Haralick Feature
`class`	`DefaultICM2<T extends RealType<T>>` Implementation of Information Measure of Correlation 2 Haralick Feature
`class`	`DefaultIFDM<T extends RealType<T>>` Implementation of Inverse Difference Moment Haralick Feature based on http://www.uio.no/studier/emner/matnat/ifi/INF4300/h08/undervisningsmateriale/glcm.pdf .
`class`	`DefaultMaxProbability<T extends RealType<T>>` Implementation of Maximum Probability Haralick Feature
`class`	`DefaultSumAverage<T extends RealType<T>>` Implementation of Sum Average Haralick Feature
`class`	`DefaultSumEntropy<T extends RealType<T>>` Implementation of Sum Entropy Haralick Feature
`class`	`DefaultSumVariance<T extends RealType<T>>` Implementation of Sum Variance Haralick Feature according to http://murphylab.web.cmu.edu/publications/boland/boland_node26.html .
`class`	`DefaultTextureHomogeneity<T extends RealType<T>>` Implementation of Texture Homogeneity Haralick Feature

Uses of Op in net.imagej.ops.features.haralick.helper

Classes in net.imagej.ops.features.haralick.helper that implement Op
Modifier and Type	Class and Description
`class`	`CoocHXY` NB: Helper class.
`class`	`CoocMeanX` NB: Helper class.
`class`	`CoocMeanY` NB: Helper class.
`class`	`CoocPX` NB: Helper class.
`class`	`CoocPXMinusY` NB: Helper class.
`class`	`CoocPXPlusY` NB: Helper class.
`class`	`CoocPY` NB: Helper class.
`class`	`CoocStdX` NB: Helper class.
`class`	`CoocStdY` NB: Helper class.

Uses of Op in net.imagej.ops.features.hog

Classes in net.imagej.ops.features.hog that implement Op
Modifier and Type	Class and Description
`class`	`HistogramOfOrientedGradients2D<T extends RealType<T>>` Calculates a histogram of oriented gradients which is a feature descriptor.

Uses of Op in net.imagej.ops.features.lbp2d

Subinterfaces of Op in net.imagej.ops.features.lbp2d
Modifier and Type	Interface and Description
`interface`	`LBP2DFeature<I extends RealType<I>>` Marker interface for 2D local binary pattern feature.

Classes in net.imagej.ops.features.lbp2d that implement Op
Modifier and Type	Class and Description
`class`	`AbstractLBP2DFeature<I extends RealType<I>>` Abstract class for 2d local binary pattern feature
`class`	`DefaultLBP2D<I extends RealType<I>>` Default implementation of 2d local binary patterns

Uses of Op in net.imagej.ops.features.tamura2d

Subinterfaces of Op in net.imagej.ops.features.tamura2d
Modifier and Type	Interface and Description
`interface`	`TamuraFeature<I extends RealType<I>,O extends RealType<O>>` Marker interface for tamura features.

Classes in net.imagej.ops.features.tamura2d that implement Op
Modifier and Type	Class and Description
`class`	`AbstractTamuraFeature<I extends RealType<I>,O extends RealType<O>>` Abstract tamura feature.
`class`	`DefaultCoarsenessFeature<I extends RealType<I>,O extends RealType<O>>` Implementation of Tamura's Coarseness feature
`class`	`DefaultContrastFeature<I extends RealType<I>,O extends RealType<O>>` Default implementation of tamura feature contrast.
`class`	`DefaultDirectionalityFeature<I extends RealType<I>,O extends RealType<O>>` Implementation of Tamura's Directionality Feature

Uses of Op in net.imagej.ops.features.zernike

Subinterfaces of Op in net.imagej.ops.features.zernike
Modifier and Type	Interface and Description
`interface`	`ZernikeFeature<I extends RealType<I>,O extends RealType<O>>` Marker interface for zernike ops.

Classes in net.imagej.ops.features.zernike that implement Op
Modifier and Type	Class and Description
`class`	`AbstractZernikeFeature<I extends RealType<I>,O extends RealType<O>>` Abstract Zernike Op.
`class`	`DefaultMagnitudeFeature<T extends RealType<T>,O extends RealType<O>>` Get Magnitude of Zernike moment as feature
`class`	`DefaultPhaseFeature<T extends RealType<T>,O extends RealType<O>>` Get Phase of Zernike moment as feature

Uses of Op in net.imagej.ops.features.zernike.helper

Classes in net.imagej.ops.features.zernike.helper that implement Op
Modifier and Type Class and Description

class ZernikeComputer<T extends RealType<T>>
Computes a specific zernike moment

Uses of Op in net.imagej.ops.filter

Classes in net.imagej.ops.filter that implement Op
Modifier and Type	Class and Description
`class`	`AbstractCenterAwareNeighborhoodBasedFilter<I,O>`
`class`	`AbstractFFTFilterC<I extends RealType<I>,O extends RealType<O>,K extends RealType<K>,C extends ComplexType<C>>` Abstract class for FFT based filter computers
`class`	`AbstractIterativeFFTFilterC<I extends RealType<I>,O extends RealType<O>,K extends RealType<K>,C extends ComplexType<C>>` Abstract class for iterative FFT filters that perform on RAI.
`class`	`AbstractNeighborhoodBasedFilter<I,O>`
`class`	`AbstractPadAndFFTFilter<I extends RealType<I>,O extends RealType<O> & NativeType<O>,K extends RealType<K>,C extends ComplexType<C> & NativeType<C>>` Abstract class for binary filter that performs operations using an image and kernel in the frequency domain using the imglib2 FFTMethods library.
`class`	`FFTMethodsLinearFFTFilterC<I extends RealType<I>,O extends RealType<O>,K extends RealType<K>,C extends ComplexType<C>>` Convolve op for (@link RandomAccessibleInterval)

Uses of Op in net.imagej.ops.filter.addNoise

Classes in net.imagej.ops.filter.addNoise that implement Op
Modifier and Type	Class and Description
`class`	`AddNoiseRealType<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the addition of the real component of an input real number with an amount of Gaussian noise.
`class`	`AddNoiseRealTypeCFI<T extends RealType<T>>` Adds Gaussian noise to a real number.

Uses of Op in net.imagej.ops.filter.addPoissonNoise

Classes in net.imagej.ops.filter.addPoissonNoise that implement Op
Modifier and Type	Class and Description
`class`	`AddPoissonNoiseMap<T extends ComplexType<T>>`
`class`	`AddPoissonNoiseRealType<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to a real number sampled from a Poisson distribution with lambda of the input real number.

Uses of Op in net.imagej.ops.filter.bilateral

Classes in net.imagej.ops.filter.bilateral that implement Op
Modifier and Type	Class and Description
`class`	`DefaultBilateral<I extends RealType<I>,O extends RealType<O>>` Performs a bilateral filter on an image.

Uses of Op in net.imagej.ops.filter.convolve

Classes in net.imagej.ops.filter.convolve that implement Op
Modifier and Type	Class and Description
`class`	`ConvolveFFTC<I extends RealType<I>,O extends RealType<O>,K extends RealType<K>,C extends ComplexType<C>>` Convolve op for (@link RandomAccessibleInterval)
`class`	`ConvolveNaiveC<I extends RealType<I>,K extends RealType<K>,O extends RealType<O>>` Convolves an image naively.
`class`	`ConvolveNaiveF<I extends RealType<I>,O extends RealType<O> & NativeType<O>,K extends RealType<K>>` Function adapter for `ConvolveFFTC`.
`class`	`PadAndConvolveFFT<I extends RealType<I> & NativeType<I>,O extends RealType<O> & NativeType<O>,K extends RealType<K> & NativeType<K>,C extends ComplexType<C> & NativeType<C>>` Convolve op for (@link Img)
`class`	`PadAndConvolveFFTF<I extends RealType<I>,O extends RealType<O> & NativeType<O>,K extends RealType<K>>` Function adapter for `PadAndConvolveFFT`.

Uses of Op in net.imagej.ops.filter.correlate

Classes in net.imagej.ops.filter.correlate that implement Op
Modifier and Type	Class and Description
`class`	`CorrelateFFTC<I extends RealType<I>,O extends RealType<O>,K extends RealType<K>,C extends ComplexType<C>>` Correlate op for (@link RandomAccessibleInterval)
`class`	`PadAndCorrelateFFT<I extends RealType<I> & NativeType<I>,O extends RealType<O> & NativeType<O>,K extends RealType<K> & NativeType<K>,C extends ComplexType<C> & NativeType<C>>` Correlate op for (@link Img)

Uses of Op in net.imagej.ops.filter.derivative

Classes in net.imagej.ops.filter.derivative that implement Op
Modifier and Type	Class and Description
`class`	`PartialDerivativeRAI<T extends RealType<T>>` Calculates the derivative (with sobel kernel) of an image in a given dimension.
`class`	`PartialDerivativesRAI<T extends RealType<T>>` Convenience op for partial derivatives.

Uses of Op in net.imagej.ops.filter.derivativeGauss

Classes in net.imagej.ops.filter.derivativeGauss that implement Op
Modifier and Type	Class and Description
`class`	`DefaultDerivativeGauss<T extends RealType<T>>` Performs the 2-D partial derivative Gaussian kernel convolutions on an image, at a particular point.

Uses of Op in net.imagej.ops.filter.dog

Classes in net.imagej.ops.filter.dog that implement Op
Modifier and Type	Class and Description
`class`	`DefaultDoG<T extends NumericType<T> & NativeType<T>>` Low-level difference of Gaussians (DoG) implementation which leans on other ops to do the work.
`class`	`DoGSingleSigmas<T extends NumericType<T> & NativeType<T>>` Difference of Gaussians (DoG) implementation where all sigmas are the same in each dimension.
`class`	`DoGVaryingSigmas<T extends NumericType<T> & NativeType<T>>` Difference of Gaussians (DoG) implementation where sigmas can vary by dimension.

Uses of Op in net.imagej.ops.filter.fft

Classes in net.imagej.ops.filter.fft that implement Op
Modifier and Type	Class and Description
`class`	`CreateOutputFFTMethods<T>` Function that creates an output for FFTMethods FFT
`class`	`FFTMethodsOpC<T extends RealType<T>,C extends ComplexType<C>>` Forward FFT computer that operates on an RAI and wraps FFTMethods.
`class`	`FFTMethodsOpF<T extends RealType<T>,C extends ComplexType<C>>` Function that uses FFTMethods to perform a forward FFT

Uses of Op in net.imagej.ops.filter.fftSize

Classes in net.imagej.ops.filter.fftSize that implement Op
Modifier and Type	Class and Description
`class`	`ComputeFFTMethodsSize` Op that calculates FFT sizes.
`class`	`DefaultComputeFFTSize` Op that calculates FFT fast sizes according to the following logic.

Uses of Op in net.imagej.ops.filter.gauss

Classes in net.imagej.ops.filter.gauss that implement Op
Modifier and Type	Class and Description
`class`	`DefaultGaussRA<T extends NumericType<T> & NativeType<T>>` Gaussian filter, wrapping `Gauss3` of imglib2-algorithms.
`class`	`DefaultGaussRAI<T extends NumericType<T> & NativeType<T>>` Gaussian filter, wrapping `Gauss3` of imglib2-algorithms.
`class`	`GaussRAISingleSigma<T extends NumericType<T> & NativeType<T>>` Gaussian filter which can be called with single sigma, i.e.

Uses of Op in net.imagej.ops.filter.hessian

Classes in net.imagej.ops.filter.hessian that implement Op
Modifier and Type	Class and Description
`class`	`HessianRAI<T extends RealType<T>>` Hessian filter using the sobel filter with separated kernel.

Uses of Op in net.imagej.ops.filter.ifft

Classes in net.imagej.ops.filter.ifft that implement Op
Modifier and Type	Class and Description
`class`	`IFFTMethodsOpC<C extends ComplexType<C>,T extends RealType<T>>` Inverse FFT computer that operates on an RAI and wraps FFTMethods.
`class`	`IFFTMethodsOpI<C extends ComplexType<C>>` Inverse FFT inplace operator -- complex to complex only, output size must conform to supported FFT size.

Uses of Op in net.imagej.ops.filter.max

Subinterfaces of Op in net.imagej.ops.filter.max
Modifier and Type Interface and Description

interface MaxFilterOp<I,O>
A typed "max" filter.

Classes in net.imagej.ops.filter.max that implement Op
Modifier and Type Class and Description

class DefaultMaxFilter<T,V>
Default implementation of MaxFilterOp.
Uses of Op in net.imagej.ops.filter.mean

Subinterfaces of Op in net.imagej.ops.filter.mean
Modifier and Type Interface and Description

interface MeanFilterOp<I,O>
A typed "mean" filter.

Classes in net.imagej.ops.filter.mean that implement Op
Modifier and Type Class and Description

class DefaultMeanFilter<T,V>
Default implementation of MeanFilterOp.
Uses of Op in net.imagej.ops.filter.median

Subinterfaces of Op in net.imagej.ops.filter.median
Modifier and Type Interface and Description

interface MedianFilterOp<I,O>
A typed "median" filter.

Classes in net.imagej.ops.filter.median that implement Op
Modifier and Type Class and Description

class DefaultMedianFilter<T,V>
Default implementation of MedianFilterOp.
Uses of Op in net.imagej.ops.filter.min

Subinterfaces of Op in net.imagej.ops.filter.min
Modifier and Type Interface and Description

interface MinFilterOp<T,V>
A typed "min" filter.

Classes in net.imagej.ops.filter.min that implement Op
Modifier and Type Class and Description

class DefaultMinFilter<T,V>
Default implementation of MinFilterOp.

Uses of Op in net.imagej.ops.filter.pad

Classes in net.imagej.ops.filter.pad that implement Op
Modifier and Type	Class and Description
`class`	`DefaultPadInputFFT<T extends ComplexType<T>,I extends RandomAccessibleInterval<T>,O extends RandomAccessibleInterval<T>>` Op used to pad the image using the default FFT padding scheme.
`class`	`DefaultPadShiftKernelFFT<T extends ComplexType<T>,I extends RandomAccessibleInterval<T>,O extends RandomAccessibleInterval<T>>` Op used to pad the kernel using the default FFT padding scheme and shift the center of the kernel to the origin
`class`	`PaddingIntervalCentered<T extends ComplexType<T>,I extends RandomAccessibleInterval<T>,O extends Interval>` Op used to calculate and return a centered padding interval given an input RAI and the desired padded dimensions
`class`	`PaddingIntervalOrigin<T extends ComplexType<T>,I extends RandomAccessibleInterval<T>,O extends Interval>` Op used to translate the center of an interval the origin.
`class`	`PadInput<T extends ComplexType<T>,I extends RandomAccessibleInterval<T>,O extends RandomAccessibleInterval<T>>` Op used to pad the image by extending the borders
`class`	`PadInputFFT<T extends ComplexType<T>,I extends RandomAccessibleInterval<T>,O extends RandomAccessibleInterval<T>>` Abstract Op used to pad the image by extending the borders optionally using an "fftSize" op to make the final image size compatible with an FFT library.
`class`	`PadInputFFTMethods<T extends ComplexType<T>,I extends RandomAccessibleInterval<T>,O extends RandomAccessibleInterval<T>>` Op used to pad the image to a size that is compatible with FFTMethods
`class`	`PadShiftKernel<T extends ComplexType<T>,I extends RandomAccessibleInterval<T>,O extends RandomAccessibleInterval<T>>` Op used to pad a kernel and shift the center of the kernel to the origin
`class`	`PadShiftKernelFFTMethods<T extends ComplexType<T>,I extends RandomAccessibleInterval<T>,O extends RandomAccessibleInterval<T>>` Op used to pad a kernel to a size that is compatible with FFTMethods and shift the center of the kernel to the origin

Uses of Op in net.imagej.ops.filter.sigma

Subinterfaces of Op in net.imagej.ops.filter.sigma
Modifier and Type	Interface and Description
`interface`	`SigmaFilterOp<T,V>` A typed "sigma" filter.

Classes in net.imagej.ops.filter.sigma that implement Op
Modifier and Type	Class and Description
`class`	`DefaultSigmaFilter<T extends RealType<T>,V extends RealType<V>>` Default implementation of `SigmaFilterOp`.

Uses of Op in net.imagej.ops.filter.sobel

Classes in net.imagej.ops.filter.sobel that implement Op
Modifier and Type	Class and Description
`class`	`SobelRAI<T extends RealType<T>>` Sobel filter implementation using separated sobel kernel.

Uses of Op in net.imagej.ops.filter.tubeness

Classes in net.imagej.ops.filter.tubeness that implement Op
Modifier and Type	Class and Description
`class`	`DefaultTubeness<T extends RealType<T>>` The Tubeness filter: enhance filamentous structures of a specified thickness.

Uses of Op in net.imagej.ops.filter.variance

Subinterfaces of Op in net.imagej.ops.filter.variance
Modifier and Type Interface and Description

interface VarianceFilterOp<I,O>
A typed "variance" filter.

Classes in net.imagej.ops.filter.variance that implement Op
Modifier and Type Class and Description

class DefaultVarianceFilter<T,V>
Default implementation of VarianceFilterOp.

Uses of Op in net.imagej.ops.filter.vesselness

Classes in net.imagej.ops.filter.vesselness that implement Op
Modifier and Type	Class and Description
`class`	`DefaultFrangi<T extends RealType<T>,U extends RealType<U>>` Input is a 2- or 3-dimensional grayscales image.

Uses of Op in net.imagej.ops.geom

Subinterfaces of Op in net.imagej.ops.geom
Modifier and Type	Interface and Description
`interface`	`GeometricOp<I,O>` Simple marker interface for Geoemtric ops.

Classes in net.imagej.ops.geom that implement Op
Modifier and Type	Class and Description
`class`	`AbstractBoundarySizeConvexHull<I>` Generic implementation of `Ops.Geometric.BoundarySizeConvexHull`.
`class`	`AbstractBoxivity<I>` Generic implementation of `Ops.Geometric.Boxivity`.
`class`	`AbstractConvexity<I>` Generic implementation of `Ops.Geometric.Convexity`.
`class`	`AbstractSizeConvexHull<I>` Generic implementation of `Ops.Geometric.SizeConvexHull` .
`class`	`AbstractSolidity<I>` Generic implementation of `Ops.Geometric.Solidity`.
`class`	`CentroidII` This `Op` computes the centroid of a `IterableRegion` (Label).
`class`	`CentroidLabelRegion` This `Op` computes the centroid of a `IterableRegion` (Label).
`class`	`CentroidMesh` Generic implementation of `geom.centroid`.
`class`	`CentroidPolygon` Generic implementation of `geom.centroid`.
`class`	`DefaultCenterOfGravity<T extends RealType<T>>` This `Op` computes the center of gravity of a `IterableRegion` (Label).
`class`	`SizeII` Generic implementation of `Ops.Geometric.Size`.

Uses of Op in net.imagej.ops.geom.geom2d

Classes in net.imagej.ops.geom.geom2d that implement Op
Modifier and Type	Class and Description
`class`	`DefaultBoundarySizeConvexHullPolygon`
`class`	`DefaultBoundingBox` Generic implementation of `geom.boundingBox`.
`class`	`DefaultBoxivityPolygon`
`class`	`DefaultCircularity` Generic implementation of `geom.circularity`.
`class`	`DefaultContour<B extends BooleanType<B>>` Generic implementation of `geom.contour`.
`class`	`DefaultConvexHull2D` Generic implementation of `geom.convexHull`.
`class`	`DefaultConvexityPolygon`
`class`	`DefaultEccentricity` Generic implementation of `geom.eccentricity`.
`class`	`DefaultElongation` Generic implementation of `geom.mainElongation` based on http://www.math.uci.edu/icamp/summer/research_11/park/ shape_descriptors_survey.pdf.
`class`	`DefaultFeretsAngle` Generic implementation of `geom.feretsAngle`.
`class`	`DefaultFeretsDiameter` Generic implementation of `geom.feretsDiameter`.
`class`	`DefaultFeretsDiameterForAngle` Ferets Diameter for a certain angle.
`class`	`DefaultMajorAxis` Generic implementation of `geom.majorAxis`.
`class`	`DefaultMaximumFeret` Maximum Feret of a polygon.
`class`	`DefaultMaximumFeretAngle`
`class`	`DefaultMaximumFeretDiameter`
`class`	`DefaultMinimumFeret` Minimum Feret of a polygon.
`class`	`DefaultMinimumFeretAngle`
`class`	`DefaultMinimumFeretDiameter`
`class`	`DefaultMinorAxis` Generic implementation of `geom.minorAxis`.
`class`	`DefaultMinorMajorAxis` Generic implementation of `geom.secondMultiVariate`.
`class`	`DefaultPerimeterLength` Generic implementation of `geom.boundarySize`.
`class`	`DefaultRoundness` Generic implementation of `geom.roundness`.
`class`	`DefaultSizeConvexHullPolygon`
`class`	`DefaultSizePolygon` Specific implementation of `Area` for a Polygon2D.
`class`	`DefaultSmallestEnclosingRectangle` Generic implementation of `geom.smallestBoundingBox`.
`class`	`DefaultSolidityPolygon`
`class`	`DefaultVerticesCountConvexHullPolygon`
`class`	`DefaultVerticesCountPolygon`

Uses of Op in net.imagej.ops.geom.geom3d

Classes in net.imagej.ops.geom.geom3d that implement Op
Modifier and Type	Class and Description
`class`	`DefaultBoxivityMesh`
`class`	`DefaultCompactness` Generic implementation of `Ops.Geometric.Compactness`.
`class`	`DefaultConvexHull3D` This quickhull implementation is based on the paper "The Quickhull Algorithm for Convex Hulls" by Barber, Dobkin and Huhdanpaa (http://dpd.cs.princeton.edu/Papers/BarberDobkinHuhdanpaa.pdf).
`class`	`DefaultConvexityMesh`
`class`	`DefaultInertiaTensor3D<B extends BooleanType<B>>` This `Op` computes the 2nd multi variate of a `IterableRegion` (Label).
`class`	`DefaultInertiaTensor3DMesh` This `Op` computes the 2nd multi variate of a `IterableRegion` (Label).
`class`	`DefaultMainElongation` Generic implementation of `Ops.Geometric.MainElongation` Adapted to 3D from http://www.math.uci.edu/icamp/summer/research_11/park/ shape_descriptors_survey.pdf
`class`	`DefaultMarchingCubes<T extends BooleanType<T>>` This is a marching cubes implementation.
`class`	`DefaultMedianElongation` Generic implementation of `Ops.Geometric.MedianElongation`.
`class`	`DefaultSolidityMesh`
`class`	`DefaultSparenessMesh` Generic implementation of `Ops.Geometric.Spareness`.
`class`	`DefaultSphericity` Generic implementation of `Ops.Geometric.Sphericity`.
`class`	`DefaultSurfaceArea` Generic implementation of `Ops.Geometric.BoundarySize`.
`class`	`DefaultSurfaceAreaConvexHullMesh`
`class`	`DefaultVerticesCountConvexHullMesh`
`class`	`DefaultVerticesCountMesh` Generic implementation of `geom.boundaryPixelCount`.
`class`	`DefaultVolumeConvexHullMesh`
`class`	`DefaultVolumeMesh` Generic implementation of `Ops.Geometric.Size`.
`class`	`DefaultVoxelization3D` This is a voxelizer that produces a binary image with values filled in along the surface of the mesh.

Uses of Op in net.imagej.ops.geom.geom3d.mesh

Subinterfaces of Op in net.imagej.ops.geom.geom3d.mesh
Modifier and Type	Interface and Description
`interface`	`VertexInterpolator`

Classes in net.imagej.ops.geom.geom3d.mesh that implement Op
Modifier and Type	Class and Description
`class`	`AbstractVertexInterpolator` This is the `AbstractVertexInterpolator`.
`class`	`BitTypeVertexInterpolator` The `BitTypeVertexInterpolator` returns the point which is in the middle of the two input vertices.
`class`	`DefaultSmallestOrientedBoundingBox` Generic implementation of `geom.smallestBoundingBox`.
`class`	`DefaultVertexInterpolator` Linearly interpolate the position where an isosurface cuts an edge between two vertices, each with their own scalar value

Uses of Op in net.imagej.ops.help

Classes in net.imagej.ops.help that implement Op
Modifier and Type	Class and Description
`class`	`AbstractHelp` Base class for help operations.
`class`	`HelpCandidates` Gets documentation for ops of the given name and/or type.
`class`	`HelpForNamespace` Gets documentation for the given `Namespace`.
`class`	`HelpForOp` Gets documentation for the given op.

Uses of Op in net.imagej.ops.identity

Subinterfaces of Op in net.imagej.ops.identity
Modifier and Type	Interface and Description
`interface`	`IdentityOp<A>` A typed "identity" function.

Classes in net.imagej.ops.identity that implement Op
Modifier and Type	Class and Description
`class`	`AbstractIdentity<T>` Abstract superclass of `IdentityOp` implementations.
`class`	`DefaultIdentity<A>` Default implementation of the `IdentityOp` op.

Uses of Op in net.imagej.ops.image.ascii

Classes in net.imagej.ops.image.ascii that implement Op
Modifier and Type Class and Description

class DefaultASCII<T extends RealType<T>>
Generates an ASCII version of an image.

Uses of Op in net.imagej.ops.image.cooccurrenceMatrix

Classes in net.imagej.ops.image.cooccurrenceMatrix that implement Op
Modifier and Type	Class and Description
`class`	`CooccurrenceMatrix2D<T extends RealType<T>>` Calculates coocccurrence matrix from an 2D-`IterableInterval`.
`class`	`CooccurrenceMatrix3D<T extends RealType<T>>` Calculates coocccurrence matrix from an 3D-`IterableInterval`.

Uses of Op in net.imagej.ops.image.distancetransform

Classes in net.imagej.ops.image.distancetransform that implement Op
Modifier and Type	Class and Description
`class`	`DefaultDistanceTransform<B extends BooleanType<B>,T extends RealType<T>>` Computes a distance transform, i.e.
`class`	`DefaultDistanceTransformCalibration<B extends BooleanType<B>,T extends RealType<T>>` Computes a distance transform, i.e.
`class`	`DistanceTransform2D<B extends BooleanType<B>,T extends RealType<T>>` Computes a distance transform, i.e.
`class`	`DistanceTransform2DCalibration<B extends BooleanType<B>,T extends RealType<T>>` Computes a distance transform, i.e.
`class`	`DistanceTransform3D<B extends BooleanType<B>,T extends RealType<T>>` Computes a distance transform, i.e.
`class`	`DistanceTransform3DCalibration<B extends BooleanType<B>,T extends RealType<T>>` Computes a distance transform, i.e.

Uses of Op in net.imagej.ops.image.equation

Subinterfaces of Op in net.imagej.ops.image.equation
Modifier and Type	Interface and Description
`interface`	`CoordinatesEquationOp<T,N extends Number>` An operation which computes image values based on coordinates.
`interface`	`DoubleBinaryEquationOp<T>` An equation operation which computes image values from real coordinates using a binary lambda.
`interface`	`EquationOp<T>` An "equation" operation which computes image values from interval coordinates using an equation.

Classes in net.imagej.ops.image.equation that implement Op
Modifier and Type	Class and Description
`class`	`DefaultCoordinatesEquation<T extends RealType<T>,N extends Number>` An equation operation which computes image values from coordinates using another op.
`class`	`DefaultEquation<T extends RealType<T>>` Computes an image using an equation.
`class`	`DefaultXYEquation<T extends RealType<T>>` An equation operation which computes image values from x and y coordinates using a binary lambda.

Uses of Op in net.imagej.ops.image.fill

Classes in net.imagej.ops.image.fill that implement Op
Modifier and Type Class and Description

class DefaultFill<T extends Type<T>>
Fill an IterableInterval with some constant value.
Uses of Op in net.imagej.ops.image.histogram

Classes in net.imagej.ops.image.histogram that implement Op
Modifier and Type Class and Description

class HistogramCreate<T extends RealType<T>>

Uses of Op in net.imagej.ops.image.integral

Classes in net.imagej.ops.image.integral that implement Op
Modifier and Type	Class and Description
`class`	`AbstractIntegralImg<I extends RealType<I>>` Abstract base class for n-dimensional integral images.
`class`	`DefaultIntegralImg<I extends RealType<I>>` n-dimensional integral image that stores sums using `RealType`.
`class`	`SquareIntegralImg<I extends RealType<I>>` n-dimensional squared integral image that stores sums using `RealType`.
`class`	`WrappedIntegralImg<I extends RealType<I>>` Wrapper op for the creation of integral images with `net.imglib2.algorithm.integral.IntegralImg`.

Uses of Op in net.imagej.ops.image.invert

Classes in net.imagej.ops.image.invert that implement Op
Modifier and Type	Class and Description
`class`	`InvertII<T extends RealType<T>>`
`class`	`InvertIIInteger<T extends IntegerType<T>>`

Uses of Op in net.imagej.ops.image.normalize

Classes in net.imagej.ops.image.normalize that implement Op
Modifier and Type	Class and Description
`class`	`NormalizeIIComputer<T extends RealType<T>>` Normalizes an `IterableInterval` given its minimum and maximum to another range defined by minimum and maximum.
`class`	`NormalizeIIFunction<T extends RealType<T>>` Normalizes an `IterableInterval` given its minimum and maximum to another range defined by minimum and maximum.

Uses of Op in net.imagej.ops.image.watershed

Classes in net.imagej.ops.image.watershed that implement Op
Modifier and Type	Class and Description
`class`	`Watershed<T extends RealType<T>,B extends BooleanType<B>>` The Watershed algorithm segments and labels a grayscale image analogous to a heightmap.
`class`	`WatershedBinary<T extends BooleanType<T>,B extends BooleanType<B>>` The Watershed algorithm segments and labels a grayscale image analogous to a heightmap.
`class`	`WatershedBinarySingleSigma<T extends BooleanType<T>,B extends BooleanType<B>>` The Watershed algorithm segments and labels a grayscale image analogous to a heightmap.
`class`	`WatershedSeeded<T extends RealType<T>,B extends BooleanType<B>>` The Watershed algorithm segments and labels a grayscale image analogous to a heightmap.

Uses of Op in net.imagej.ops.imagemoments

Subinterfaces of Op in net.imagej.ops.imagemoments
Modifier and Type	Interface and Description
`interface`	`ImageMomentOp<I,O>` marker interface for image moment ops.

Classes in net.imagej.ops.imagemoments that implement Op
Modifier and Type	Class and Description
`class`	`AbstractImageMomentOp<I extends RealType<I>,O extends RealType<O>>` Abstract `ImageMomentOp`.

Uses of Op in net.imagej.ops.imagemoments.centralmoments

Classes in net.imagej.ops.imagemoments.centralmoments that implement Op
Modifier and Type	Class and Description
`class`	`DefaultCentralMoment00<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.centralMoment00`.
`class`	`DefaultCentralMoment01<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.centralMoment01` directly.
`class`	`DefaultCentralMoment02<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.centralMoment02`.
`class`	`DefaultCentralMoment03<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.centralMoment03` using
`class`	`DefaultCentralMoment10<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.centralMoment10` directly.
`class`	`DefaultCentralMoment11<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.centralMoment11`.
`class`	`DefaultCentralMoment12<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.centralMoment12`.
`class`	`DefaultCentralMoment20<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.centralMoment20`.
`class`	`DefaultCentralMoment21<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.centralMoment21`.
`class`	`DefaultCentralMoment30<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.centralMoment30`.
`class`	`IterableCentralMoment00<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.centralMoment00` directly.
`class`	`IterableCentralMoment11<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.centralMoment11` directly.

Uses of Op in net.imagej.ops.imagemoments.hu

Classes in net.imagej.ops.imagemoments.hu that implement Op
Modifier and Type	Class and Description
`class`	`DefaultHuMoment1<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.huMoment1`.
`class`	`DefaultHuMoment2<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.huMoment2`.
`class`	`DefaultHuMoment3<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.huMoment3`.
`class`	`DefaultHuMoment4<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.huMoment4`.
`class`	`DefaultHuMoment5<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.huMoment5`.
`class`	`DefaultHuMoment6<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.huMoment6`.
`class`	`DefaultHuMoment7<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.huMoment7`.

Uses of Op in net.imagej.ops.imagemoments.moments

Classes in net.imagej.ops.imagemoments.moments that implement Op
Modifier and Type	Class and Description
`class`	`DefaultMoment00<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.moment00`.
`class`	`DefaultMoment01<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.moment01`.
`class`	`DefaultMoment10<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.moment10`.
`class`	`DefaultMoment11<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.moment11`.

Uses of Op in net.imagej.ops.imagemoments.normalizedcentralmoments

Classes in net.imagej.ops.imagemoments.normalizedcentralmoments that implement Op
Modifier and Type	Class and Description
`class`	`DefaultNormalizedCentralMoment02<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.normalizedCentralMoment02`.
`class`	`DefaultNormalizedCentralMoment03<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.normalizedCentralMoment03`.
`class`	`DefaultNormalizedCentralMoment11<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.normalizedCentralMoment11`.
`class`	`DefaultNormalizedCentralMoment12<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.normalizedCentralMoment12`.
`class`	`DefaultNormalizedCentralMoment20<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.normalizedCentralMoment20`.
`class`	`DefaultNormalizedCentralMoment21<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.normalizedCentralMoment21`.
`class`	`DefaultNormalizedCentralMoment30<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `imageMoments.normalizedCentralMoment30`.

Uses of Op in net.imagej.ops.join

Classes in net.imagej.ops.join with type parameters of type Op
Modifier and Type	Interface and Description
`interface`	`Join2Ops<OP1 extends Op,OP2 extends Op>` A join operation which joins two `UnaryComputerOp`s.
`interface`	`Join2Ops<OP1 extends Op,OP2 extends Op>` A join operation which joins two `UnaryComputerOp`s.
`interface`	`JoinNOps<OP extends Op>` A join operation which joins two `UnaryComputerOp`s.

Subinterfaces of Op in net.imagej.ops.join
Modifier and Type	Interface and Description
`interface`	`Join2Computers<A,B,C>` A join operation which joins two `UnaryComputerOp`s.
`interface`	`Join2Inplaces<A,B extends A,C extends B>` A join operation which joins two `UnaryInplaceOp`s.
`interface`	`Join2Ops<OP1 extends Op,OP2 extends Op>` A join operation which joins two `UnaryComputerOp`s.
`interface`	`JoinComputerAndInplace<A,BI,BO extends BI>` Joins an `UnaryInplaceOp` with a `UnaryComputerOp`.
`interface`	`JoinInplaceAndComputer<AI,AO extends AI,B>` Joins an `UnaryInplaceOp` with a `UnaryComputerOp`.
`interface`	`JoinNComputers<A>` A join operation which joins a list of `UnaryComputerOp`s.
`interface`	`JoinNInplaces<I,O extends I>` A join operation which joins a list of `UnaryInplaceOp`s.
`interface`	`JoinNOps<OP extends Op>` A join operation which joins two `UnaryComputerOp`s.

Classes in net.imagej.ops.join that implement Op
Modifier and Type	Class and Description
`class`	`DefaultJoin2Computers<A,B,C>` Joins two `UnaryComputerOp`s.
`class`	`DefaultJoin2Inplaces<A>` Joins two `UnaryInplaceOp`s.
`class`	`DefaultJoinComputerAndInplace<A,B>` Joins a `UnaryComputerOp` with an `UnaryInplaceOp`.
`class`	`DefaultJoinInplaceAndComputer<A,B>` Joins an `UnaryInplaceOp` with a `UnaryComputerOp`.
`class`	`DefaultJoinNComputers<A>` Joins a list of `UnaryComputerOp`s.
`class`	`DefaultJoinNInplaces<A>` Joins a list of `UnaryInplaceOp`s.

Uses of Op in net.imagej.ops.labeling

Classes in net.imagej.ops.labeling that implement Op
Modifier and Type	Class and Description
`class`	`MergeLabeling<L,I extends IntegerType<I>,B extends BooleanType<B>>` Merges the labels of two `ImgLabeling` within a defined mask (if provided).

Uses of Op in net.imagej.ops.labeling.cca

Classes in net.imagej.ops.labeling.cca that implement Op
Modifier and Type	Class and Description
`class`	`DefaultCCA<T extends IntegerType<T>,L,I extends IntegerType<I>>` Default Implementation wrapping `ConnectedComponents` of ImgLib2-algorithms.

Uses of Op in net.imagej.ops.linalg.rotate

Classes in net.imagej.ops.linalg.rotate that implement Op
Modifier and Type	Class and Description
`class`	`Rotate3d` Rotates the vector by the quaternion.
`class`	`Rotate3f` Rotates the vector by the quaternion.

Uses of Op in net.imagej.ops.logic

Classes in net.imagej.ops.logic that implement Op
Modifier and Type	Class and Description
`static class`	`BooleanTypeLogic.And<T extends BooleanType<T>>` Performs logical and (&&) between two `BooleanType`s.
`static class`	`BooleanTypeLogic.ComparableGreaterThan<I extends Comparable<I>,O extends BooleanType<O>>` Performs greater-than (>) between two `Comparable`s.
`static class`	`BooleanTypeLogic.ComparableGreaterThanOrEqual<I extends Comparable<I>,O extends BooleanType<O>>` Performs greater-than-or-equal (>=) between two `Comparable`s.
`static class`	`BooleanTypeLogic.ComparableLessThan<I extends Comparable<I>,O extends BooleanType<O>>` Performs less-than (<) between two `Comparable`s.
`static class`	`BooleanTypeLogic.ComparableLessThanOrEqual<I extends Comparable<I>,O extends BooleanType<O>>` Performs less-than-or-equal (<=) between two `Comparable`s.
`static class`	`BooleanTypeLogic.Not<T extends BooleanType<T>>` Performs logical not (!) on a `BooleanType`.
`static class`	`BooleanTypeLogic.ObjectsEqual<O extends BooleanType<O>>` Performs equals (==) between two `Object`s.
`static class`	`BooleanTypeLogic.ObjectsNotEqual<O extends BooleanType<O>>` Performs not-equals (!=) between two `Object`s.
`static class`	`BooleanTypeLogic.Or<T extends BooleanType<T>>` Performs logical or (\|\|) between two `BooleanType`s.
`static class`	`BooleanTypeLogic.Xor<T extends BooleanType<T>>` Performs logical xor (^) between two `BooleanType`s.
`class`	`Default<I extends BooleanType<I>,O extends Type<O>>` An Op that sets the output to the `defaultVal` iff the input is evaluated as false.
`class`	`If<I extends BooleanType<I>,O extends Type<O>>` An Op that works the same way as the `?:` operator.
`static class`	`IIToIIOutputII.And<T extends BooleanType<T>>`
`static class`	`IIToIIOutputII.Or<T extends BooleanType<T>>`
`static class`	`IIToIIOutputII.Xor<T extends BooleanType<T>>`
`static class`	`IIToRAIOutputII.And<T extends NumericType<T>>`
`static class`	`IIToRAIOutputII.Or<T extends NumericType<T>>`
`static class`	`IIToRAIOutputII.Xor<T extends NumericType<T>>`
`static class`	`PrimitiveLogic.BooleanAnd` Op that computes the logical AND (&&) of two boolean values.
`static class`	`PrimitiveLogic.BooleanEqual` Op that tests for equality (==) between two boolean values.
`static class`	`PrimitiveLogic.BooleanNot` Op that computes the logical NOT (!) of a boolean value.
`static class`	`PrimitiveLogic.BooleanNotEqual` Op that tests for inequality (!=) between two boolean values.
`static class`	`PrimitiveLogic.BooleanOr` Op that computes the logical OR (\|\|) of two boolean values.
`static class`	`PrimitiveLogic.BooleanXor` Op that computes the logical XOR (^) of two boolean values.
`static class`	`PrimitiveLogic.DoubleEqual` Op that tests for equality (==) between two double values.
`static class`	`PrimitiveLogic.DoubleGreaterThan` Op that performs a greater-than (>) comparison on two double values.
`static class`	`PrimitiveLogic.DoubleGreaterThanOrEqual` Op that performs a greater-than-or-equal (>=) comparison on two double values.
`static class`	`PrimitiveLogic.DoubleLessThan` Op that performs a less-than (<) comparison on two double values.
`static class`	`PrimitiveLogic.DoubleLessThanOrEqual` Op that performs a less-than-or-equal (<=) comparison on two double values.
`static class`	`PrimitiveLogic.DoubleNotEqual` Op that tests for inequality (!=) between two double values.
`static class`	`PrimitiveLogic.FloatEqual` Op that tests for equality (==) between two float values.
`static class`	`PrimitiveLogic.FloatGreaterThan` Op that performs a greater-than (>) comparison on two float values.
`static class`	`PrimitiveLogic.FloatGreaterThanOrEqual` Op that performs a greater-than-or-equal (>=) comparison on two float values.
`static class`	`PrimitiveLogic.FloatLessThan` Op that performs a less-than (<) comparison on two float values.
`static class`	`PrimitiveLogic.FloatLessThanOrEqual` Op that performs a less-than-or-equal (<=) comparison on two float values.
`static class`	`PrimitiveLogic.FloatNotEqual` Op that tests for inequality (!=) between two float values.
`static class`	`PrimitiveLogic.IntegerEqual` Op that tests for equality (==) between two int values.
`static class`	`PrimitiveLogic.IntegerGreaterThan` Op that performs a greater-than (>) comparison on two int values.
`static class`	`PrimitiveLogic.IntegerGreaterThanOrEqual` Op that performs a greater-than-or-equal (>=) comparison on two int values.
`static class`	`PrimitiveLogic.IntegerLessThan` Op that performs a less-than (<) comparison on two int values.
`static class`	`PrimitiveLogic.IntegerLessThanOrEqual` Op that performs a less-than-or-equal (<=) comparison on two int values.
`static class`	`PrimitiveLogic.IntegerNotEqual` Op that tests for inequality (!=) between two int values.
`static class`	`PrimitiveLogic.LongEqual` Op that tests for equality (==) between two long values.
`static class`	`PrimitiveLogic.LongGreaterThan` Op that performs a greater-than (>) comparison on two long values.
`static class`	`PrimitiveLogic.LongGreaterThanOrEqual` Op that performs a greater-than-or-equal (>=) comparison on two long values.
`static class`	`PrimitiveLogic.LongLessThan` Op that performs a less-than (<) comparison on two long values.
`static class`	`PrimitiveLogic.LongLessThanOrEqual` Op that performs a less-than-or-equal (<=) comparison on two long values.
`static class`	`PrimitiveLogic.LongNotEqual` Op that tests for inequality (!=) between two long values.

Uses of Op in net.imagej.ops.lookup

Classes in net.imagej.ops.lookup that implement Op
Modifier and Type	Class and Description
`class`	`LookupByName` Implementation of "op" that finds the op by name.
`class`	`LookupByType` Implementation of "op" that finds the op by type.

Methods in net.imagej.ops.lookup that return Op
Modifier and Type	Method and Description
`Op`	LookupByType.`calculate(Class<? extends Op> input)`
`Op`	LookupByName.`calculate(String input)`

Method parameters in net.imagej.ops.lookup with type arguments of type Op
Modifier and Type	Method and Description
`Op`	LookupByType.`calculate(Class<? extends Op> input)`

Uses of Op in net.imagej.ops.loop

Classes in net.imagej.ops.loop with type parameters of type Op
Modifier and Type	Interface and Description
`interface`	`LoopOp<OP extends Op>` A typed "loop" operation.

Subinterfaces of Op in net.imagej.ops.loop
Modifier and Type	Interface and Description
`interface`	`LoopComputer<I>` Loops over an injected `UnaryComputerOp`.
`interface`	`LoopInplace<I,O extends I>` Loops over an injected `UnaryInplaceOp`.
`interface`	`LoopOp<OP extends Op>` A typed "loop" operation.

Classes in net.imagej.ops.loop that implement Op
Modifier and Type	Class and Description
`class`	`DefaultLoopComputer<I>` Applies a `UnaryComputerOp` multiple times to an image.
`class`	`DefaultLoopInplace<A>` Default implementation of a `LoopInplace`.

Uses of Op in net.imagej.ops.map

Classes in net.imagej.ops.map with type parameters of type Op
Modifier and Type	Interface and Description
`interface`	`MapOp<OP extends Op>` Typed interface for "map" ops.

Subinterfaces of Op in net.imagej.ops.map
Modifier and Type	Interface and Description
`interface`	`MapBinaryComputer<EI1,EI2,EO,OP extends BinaryComputerOp<EI1,EI2,EO>>` Typed interface for "map" `BinaryComputerOp`s.
`interface`	`MapBinaryInplace<EI,EO extends EI,OP extends BinaryInplaceOp<EI,EO>>` Typed interface for "map" `BinaryInplaceOp`s.
`interface`	`MapBinaryInplace1<EI1,EI2,EO extends EI1,OP extends BinaryInplace1Op<EI1,EI2,EO>>` Typed interface for "map" `BinaryInplace1Op`s.
`interface`	`MapInplace<EI,EO extends EI,OP extends UnaryInplaceOp<EI,EO>>` Typed interface for "map" `UnaryInplaceOp`s.
`interface`	`MapNullaryComputer<EO,OP extends NullaryComputerOp<EO>>` Typed interface for "map" `NullaryComputerOp`s.
`interface`	`MapOp<OP extends Op>` Typed interface for "map" ops.
`interface`	`MapUnaryComputer<EI,EO,OP extends UnaryComputerOp<EI,EO>>` Typed interface for "map" `UnaryComputerOp`s.
`interface`	`MapView<EI,EO,PI,PO>` A `MapUnaryComputer` `UnaryFunctionOp` which converts entries on demand by wrapping in a thin "view" data structure.

Classes in net.imagej.ops.map that implement Op
Modifier and Type	Class and Description
`class`	`AbstractMapBinaryComputer<EI1,EI2,EO,PI1,PI2,PO>` Abstract base class for `MapBinaryComputer` implementations.
`class`	`AbstractMapBinaryInplace<EI,EO extends EI,PA>` Abstract base class for `MapBinaryInplace` implementations.
`class`	`AbstractMapBinaryInplace1<EI1,EI2,EO extends EI1,PA,PI>` Abstract base class for `MapBinaryInplace1` implementations.
`class`	`AbstractMapComputer<EI,EO,PI,PO>` Abstract base class for `MapUnaryComputer` implementations.
`class`	`AbstractMapInplace<EI,EO extends EI,PA>` Abstract base class for `MapInplace` implementations.
`class`	`AbstractMapIterableInplace<EI,EO extends EI,PA extends Iterable<EI>>` Abstract base class for `MapInplace` implementations that operate on `Iterable`s.
`class`	`AbstractMapNullaryComputer<EO,PO>` Abstract base class for `MapNullaryComputer` implementations.
`class`	`AbstractMapView<EI,EO,PI,PO>` Abstract base class for `MapView` implementations.
`static class`	`MapBinaryComputers.IIAndIIToII<EI1,EI2,EO>` `MapBinaryComputer` from `IterableInterval` and `IterableInterval` to `IterableInterval`.
`static class`	`MapBinaryComputers.IIAndIIToIIParallel<EI1,EI2,EO>` Parallelized `MapBinaryComputer` from `IterableInterval` and `IterableInterval` to `IterableInterval`.
`static class`	`MapBinaryComputers.IIAndIIToRAI<EI1,EI2,EO>` `MapBinaryComputer` from `IterableInterval` and `IterableInterval` to `RandomAccessibleInterval`.
`static class`	`MapBinaryComputers.IIAndIIToRAIParallel<EI1,EI2,EO>` Parallelized `MapBinaryComputer` from `IterableInterval` and `IterableInterval` to `RandomAccessibleInterval`.
`static class`	`MapBinaryComputers.IIAndRAIToII<EI1,EI2,EO>` `MapBinaryComputer` from `IterableInterval` and `RandomAccessibleInterval` to `IterableInterval`.
`static class`	`MapBinaryComputers.IIAndRAIToIIParallel<EI1,EI2,EO>` Parallelized `MapBinaryComputer` from `IterableInterval` and `RandomAccessibleInterval` to `IterableInterval`.
`static class`	`MapBinaryComputers.IIAndRAIToRAI<EI1,EI2,EO>` `MapBinaryComputer` from `IterableInterval` and `RandomAccessibleInterval` to `RandomAccessibleInterval`.
`static class`	`MapBinaryComputers.IIAndRAIToRAIParallel<EI1,EI2,EO>` Parallelized `MapBinaryComputer` from `IterableInterval` and `RandomAccessibleInterval` to `RandomAccessibleInterval`.
`static class`	`MapBinaryComputers.RAIAndIIToII<EI1,EI2,EO>` `MapBinaryComputer` from `RandomAccessibleInterval` and `IterableInterval` to `IterableInterval`.
`static class`	`MapBinaryComputers.RAIAndIIToIIParallel<EI1,EI2,EO>` Parallelized `MapBinaryComputer` from `RandomAccessibleInterval` and `IterableInterval` to `IterableInterval`.
`static class`	`MapBinaryComputers.RAIAndIIToRAI<EI1,EI2,EO>` `MapBinaryComputer` from `RandomAccessibleInterval` and `IterableInterval` to `RandomAccessibleInterval`.
`static class`	`MapBinaryComputers.RAIAndIIToRAIParallel<EI1,EI2,EO>` Parallelized `MapBinaryComputer` from `RandomAccessibleInterval` and `IterableInterval` to `RandomAccessibleInterval`.
`static class`	`MapBinaryComputers.RAIAndRAIToII<EI1,EI2,EO>` `MapBinaryComputer` from `RandomAccessibleInterval` and `RandomAccessibleInterval` to `IterableInterval`.
`static class`	`MapBinaryComputers.RAIAndRAIToIIParallel<EI1,EI2,EO>` Parallelized `MapBinaryComputer` from `RandomAccessibleInterval` and `RandomAccessibleInterval` to `IterableInterval`.
`static class`	`MapBinaryInplace1s.IIAndII<EA,EI>` `MapBinaryInplace1` of `IterableInterval` with additional input of `IterableInterval`.
`static class`	`MapBinaryInplace1s.IIAndIIParallel<EA,EI>` Parallelized `MapBinaryInplace1` of `IterableInterval` with additional input of `IterableInterval`.
`static class`	`MapBinaryInplace1s.IIAndRAI<EA,EI>` `MapBinaryInplace1` of `IterableInterval` with additional input of `RandomAccessibleInterval`.
`static class`	`MapBinaryInplace1s.IIAndRAIParallel<EA,EI>` Parallelized `MapBinaryInplace1` of `IterableInterval` with additional input of `RandomAccessibleInterval`.
`static class`	`MapBinaryInplace1s.RAIAndII<EA,EI>` `MapBinaryInplace1` of `RandomAccessibleInterval` with additional input of `IterableInterval`.
`static class`	`MapBinaryInplace1s.RAIAndIIParallel<EA,EI>` Parallelized `MapBinaryInplace1` of `RandomAccessibleInterval` with additional input of `IterableInterval`.
`class`	`MapIIAndIIInplace<EA>` `MapBinaryInplace` over 2 `IterableInterval`s
`class`	`MapIIAndIIInplaceParallel<EA>` `MapBinaryInplace` over 2 `IterableInterval`s
`class`	`MapIIInplaceParallel<A>` Parallelized `MapInplace` over an `IterableInterval`.
`class`	`MapIterableInplace<A>` A `MapInplace` over an `Iterable`.
`class`	`MapIterableToIterable<EI,EO>` `MapUnaryComputer` from `Iterable` input to `Iterable` output.
`class`	`MapNullaryII<O>` A paralleled version of `MapNullaryComputer` over an `IterableInterval`.
`class`	`MapNullaryIterable<O>` A `MapNullaryComputer` over an `Iterable`.
`static class`	`MapUnaryComputers.IIToII<EI,EO>` `MapUnaryComputer` from `IterableInterval` to `IterableInterval`.
`static class`	`MapUnaryComputers.IIToIIParallel<EI,EO>` Parallelized `MapUnaryComputer` from `IterableInterval` to `IterableInterval`.
`static class`	`MapUnaryComputers.IIToRAI<EI,EO>` `MapUnaryComputer` from `IterableInterval` to `RandomAccessibleInterval`.
`static class`	`MapUnaryComputers.IIToRAIParallel<EI,EO>` Parallelized `MapUnaryComputer` from `IterableInterval` to `RandomAccessibleInterval`.
`static class`	`MapUnaryComputers.RAIToII<EI,EO>` `MapUnaryComputer` from `RandomAccessibleInterval` to `IterableInterval`.
`static class`	`MapUnaryComputers.RAIToIIParallel<EI,EO>` Parallelized `MapUnaryComputer` from `RandomAccessibleInterval` to `IterableInterval`.
`class`	`MapViewIIToII<EI,EO extends Type<EO>>` `MapView` which converts an `IterableInterval` between element types.
`class`	`MapViewRAIToRAI<EI,EO extends Type<EO>>` `MapView` which converts an `RandomAccessibleInterval` between element types.
`class`	`MapViewRandomAccessToRandomAccess<EI,EO extends Type<EO>>` `MapView` which converts a `RandomAccessible` between element types.

Uses of Op in net.imagej.ops.map.neighborhood

Classes in net.imagej.ops.map.neighborhood with type parameters of type Op
Modifier and Type	Class and Description
`class`	`AbstractMapNeighborhood<EI,EO,PI,PO,OP extends Op>` Abstract base class for `MapNeighborhood` implementations.
`interface`	`MapNeighborhood<EI,EO,PI,PO,OP extends Op>` Typed interface for "map" ops that work with neighborhoods.

Subinterfaces of Op in net.imagej.ops.map.neighborhood
Modifier and Type	Interface and Description
`interface`	`CenterAwareComputerOp<I,O>` A center aware computer calculates a result from a given input and its surrounding neighborhood, storing it into the specified output reference.
`interface`	`CenterAwareIntegralComputerOp<I,O>` A center-aware computer calculates a result from a given input and the surrounding rectangular neighborhood in (multiple) integral images.
`interface`	`MapNeighborhood<EI,EO,PI,PO,OP extends Op>` Typed interface for "map" ops that work with neighborhoods.

Classes in net.imagej.ops.map.neighborhood that implement Op
Modifier and Type	Class and Description
`class`	`AbstractCenterAwareComputerOp<I,O>` Abstract superclass for `CenterAwareComputerOp` implementations.
`class`	`AbstractMapNeighborhood<EI,EO,PI,PO,OP extends Op>` Abstract base class for `MapNeighborhood` implementations.
`class`	`DefaultMapNeighborhood<I,O>` Evaluates a `UnaryComputerOp` for each `Neighborhood` on the input `RandomAccessibleInterval`.
`class`	`MapNeighborhoodWithCenter<I,O>` Evaluates a `CenterAwareComputerOp` for each `Neighborhood` on the input `RandomAccessibleInterval` and sets the value of the corresponding pixel on the output `IterableInterval`.

Uses of Op in net.imagej.ops.math

Classes in net.imagej.ops.math that implement Op
Modifier and Type	Class and Description
`static class`	`BinaryRealTypeMath.Add<I1 extends RealType<I1>,I2 extends RealType<I2>,O extends RealType<O>>` Sets the real component of an output real number to the addition of the real components of two input real numbers.
`static class`	`BinaryRealTypeMath.And<I1 extends RealType<I1>,I2 extends RealType<I2>,O extends RealType<O>>` Sets the real component of an output real number to the logical AND of the real component of two input real numbers.
`static class`	`BinaryRealTypeMath.Divide<I1 extends RealType<I1>,I2 extends RealType<I2>,O extends RealType<O>>` Sets the real component of an output real number to the division of the real component of two input real numbers.
`static class`	`BinaryRealTypeMath.Multiply<I1 extends RealType<I1>,I2 extends RealType<I2>,O extends RealType<O>>` Sets the real component of an output real number to the multiplication of the real component of two input real numbers.
`static class`	`BinaryRealTypeMath.Or<I1 extends RealType<I1>,I2 extends RealType<I2>,O extends RealType<O>>` Sets the real component of an output real number to the logical OR of the real component of two input real numbers.
`static class`	`BinaryRealTypeMath.Subtract<I1 extends RealType<I1>,I2 extends RealType<I2>,O extends RealType<O>>` Sets the real component of an output real number to the subtraction between the real component of two input real numbers.
`static class`	`BinaryRealTypeMath.Xor<I1 extends RealType<I1>,I2 extends RealType<I2>,O extends RealType<O>>` Sets the real component of an output real number to the logical XOR of the real component of two input real numbers.
`static class`	`ConstantToArrayImage.AddByte`
`static class`	`ConstantToArrayImage.AddDouble`
`static class`	`ConstantToArrayImage.AddFloat`
`static class`	`ConstantToArrayImage.AddInt`
`static class`	`ConstantToArrayImage.AddLong`
`static class`	`ConstantToArrayImage.AddShort`
`static class`	`ConstantToArrayImage.AddUnsignedByte`
`static class`	`ConstantToArrayImage.AddUnsignedInt`
`static class`	`ConstantToArrayImage.AddUnsignedLong`
`static class`	`ConstantToArrayImage.AddUnsignedShort`
`static class`	`ConstantToArrayImage.DivideByte`
`static class`	`ConstantToArrayImage.DivideDouble`
`static class`	`ConstantToArrayImage.DivideFloat`
`static class`	`ConstantToArrayImage.DivideInt`
`static class`	`ConstantToArrayImage.DivideLong`
`static class`	`ConstantToArrayImage.DivideShort`
`static class`	`ConstantToArrayImage.DivideUnsignedByte`
`static class`	`ConstantToArrayImage.DivideUnsignedInt`
`static class`	`ConstantToArrayImage.DivideUnsignedLong`
`static class`	`ConstantToArrayImage.DivideUnsignedShort`
`static class`	`ConstantToArrayImage.MultiplyByte`
`static class`	`ConstantToArrayImage.MultiplyDouble`
`static class`	`ConstantToArrayImage.MultiplyFloat`
`static class`	`ConstantToArrayImage.MultiplyInt`
`static class`	`ConstantToArrayImage.MultiplyLong`
`static class`	`ConstantToArrayImage.MultiplyShort`
`static class`	`ConstantToArrayImage.MultiplyUnsignedByte`
`static class`	`ConstantToArrayImage.MultiplyUnsignedInt`
`static class`	`ConstantToArrayImage.MultiplyUnsignedLong`
`static class`	`ConstantToArrayImage.MultiplyUnsignedShort`
`static class`	`ConstantToArrayImage.SubtractByte`
`static class`	`ConstantToArrayImage.SubtractDouble`
`static class`	`ConstantToArrayImage.SubtractFloat`
`static class`	`ConstantToArrayImage.SubtractInt`
`static class`	`ConstantToArrayImage.SubtractLong`
`static class`	`ConstantToArrayImage.SubtractShort`
`static class`	`ConstantToArrayImage.SubtractUnsignedByte`
`static class`	`ConstantToArrayImage.SubtractUnsignedInt`
`static class`	`ConstantToArrayImage.SubtractUnsignedLong`
`static class`	`ConstantToArrayImage.SubtractUnsignedShort`
`static class`	`ConstantToArrayImageP.AddByte` Multi-threaded version of optimized add constant for `ArrayImg`s of type `ByteType`
`static class`	`ConstantToArrayImageP.AddDouble` Multi-threaded version of optimized add constant for `ArrayImg`s of type `DoubleType`
`static class`	`ConstantToArrayImageP.AddFloat` Multi-threaded version of optimized add constant for `ArrayImg`s of type `FloatType`
`static class`	`ConstantToArrayImageP.AddInt` Multi-threaded version of optimized add constant for `ArrayImg`s of type `IntType`
`static class`	`ConstantToArrayImageP.AddLong` Multi-threaded version of optimized add constant for `ArrayImg`s of type `LongType`
`static class`	`ConstantToArrayImageP.AddShort` Multi-threaded version of optimized add constant for `ArrayImg`s of type `ShortType`
`static class`	`ConstantToArrayImageP.AddUnsignedByte` Multi-threaded version of optimized add constant for `ArrayImg`s of type `UnsignedByteType`
`static class`	`ConstantToArrayImageP.AddUnsignedInt` Multi-threaded version of optimized add constant for `ArrayImg`s of type `UnsignedIntType`
`static class`	`ConstantToArrayImageP.AddUnsignedLong` Multi-threaded version of optimized add constant for `ArrayImg`s of type `UnsignedLongType`
`static class`	`ConstantToArrayImageP.AddUnsignedShort` Multi-threaded version of optimized add constant for `ArrayImg`s of type `UnsignedShortType`
`static class`	`ConstantToArrayImageP.DivideByte` Multi-threaded version of optimized divide constant from `ArrayImg`s of type `ByteType`
`static class`	`ConstantToArrayImageP.DivideDouble` Multi-threaded version of optimized divide constant from `ArrayImg`s of type `DoubleType`
`static class`	`ConstantToArrayImageP.DivideFloat` Multi-threaded version of optimized divide constant from `ArrayImg`s of type `FloatType`
`static class`	`ConstantToArrayImageP.DivideInt` Multi-threaded version of optimized divide constant from `ArrayImg`s of type `IntType`
`static class`	`ConstantToArrayImageP.DivideLong` Multi-threaded version of optimized divide constant from `ArrayImg`s of type `LongType`
`static class`	`ConstantToArrayImageP.DivideShort` Multi-threaded version of optimized divide constant from `ArrayImg`s of type `ShortType`
`static class`	`ConstantToArrayImageP.DivideUnsignedByte` Multi-threaded version of optimized divide constant from `ArrayImg`s of type `UnsignedByteType`
`static class`	`ConstantToArrayImageP.DivideUnsignedInt` Multi-threaded version of optimized divide constant from `ArrayImg`s of type `UnsignedIntType`
`static class`	`ConstantToArrayImageP.DivideUnsignedLong` Multi-threaded version of optimized divide constant from `ArrayImg`s of type `UnsignedLongType`
`static class`	`ConstantToArrayImageP.DivideUnsignedShort` Multi-threaded version of optimized divide constant from `ArrayImg`s of type `UnsignedShortType`
`static class`	`ConstantToArrayImageP.MultiplyByte` Multi-threaded version of optimized multiply constant for `ArrayImg`s of type `ByteType`
`static class`	`ConstantToArrayImageP.MultiplyDouble` Multi-threaded version of optimized multiply constant for `ArrayImg`s of type `DoubleType`
`static class`	`ConstantToArrayImageP.MultiplyFloat` Multi-threaded version of optimized multiply constant for `ArrayImg`s of type `FloatType`
`static class`	`ConstantToArrayImageP.MultiplyInt` Multi-threaded version of optimized multiply constant for `ArrayImg`s of type `IntType`
`static class`	`ConstantToArrayImageP.MultiplyLong` Multi-threaded version of optimized multiply constant for `ArrayImg`s of type `LongType`
`static class`	`ConstantToArrayImageP.MultiplyShort` Multi-threaded version of optimized multiply constant for `ArrayImg`s of type `ShortType`
`static class`	`ConstantToArrayImageP.MultiplyUnsignedByte` Multi-threaded version of optimized multiply constant for `ArrayImg`s of type `UnsignedByteType`
`static class`	`ConstantToArrayImageP.MultiplyUnsignedInt` Multi-threaded version of optimized multiply constant for `ArrayImg`s of type `UnsignedIntType`
`static class`	`ConstantToArrayImageP.MultiplyUnsignedLong` Multi-threaded version of optimized multiply constant for `ArrayImg`s of type `UnsignedLongType`
`static class`	`ConstantToArrayImageP.MultiplyUnsignedShort` Multi-threaded version of optimized multiply constant for `ArrayImg`s of type `UnsignedShortType`
`static class`	`ConstantToArrayImageP.SubtractByte` Multi-threaded version of optimized subtract constant from `ArrayImg`s of type `ByteType`
`static class`	`ConstantToArrayImageP.SubtractDouble` Multi-threaded version of optimized subtract constant from `ArrayImg`s of type `DoubleType`
`static class`	`ConstantToArrayImageP.SubtractFloat` Multi-threaded version of optimized subtract constant from `ArrayImg`s of type `FloatType`
`static class`	`ConstantToArrayImageP.SubtractInt` Multi-threaded version of optimized subtract constant from `ArrayImg`s of type `IntType`
`static class`	`ConstantToArrayImageP.SubtractLong` Multi-threaded version of optimized subtract constant from `ArrayImg`s of type `LongType`
`static class`	`ConstantToArrayImageP.SubtractShort` Multi-threaded version of optimized subtract constant from `ArrayImg`s of type `ShortType`
`static class`	`ConstantToArrayImageP.SubtractUnsignedByte` Multi-threaded version of optimized subtract constant from `ArrayImg`s of type `UnsignedByteType`
`static class`	`ConstantToArrayImageP.SubtractUnsignedInt` Multi-threaded version of optimized subtract constant from `ArrayImg`s of type `UnsignedIntType`
`static class`	`ConstantToArrayImageP.SubtractUnsignedLong` Multi-threaded version of optimized subtract constant from `ArrayImg`s of type `UnsignedLongType`
`static class`	`ConstantToArrayImageP.SubtractUnsignedShort` Multi-threaded version of optimized subtract constant from `ArrayImg`s of type `UnsignedShortType`
`static class`	`ConstantToIIOutputII.Add<T extends NumericType<T>>`
`static class`	`ConstantToIIOutputII.Divide<T extends NumericType<T>>`
`static class`	`ConstantToIIOutputII.Multiply<T extends NumericType<T>>`
`static class`	`ConstantToIIOutputII.Subtract<T extends NumericType<T>>`
`static class`	`ConstantToIIOutputRAI.Add<T extends NumericType<T>>`
`static class`	`ConstantToIIOutputRAI.Divide<T extends NumericType<T>>`
`static class`	`ConstantToIIOutputRAI.Multiply<T extends NumericType<T>>`
`static class`	`ConstantToIIOutputRAI.Subtract<T extends NumericType<T>>`
`static class`	`ConstantToPlanarImage.AddByte`
`static class`	`ConstantToPlanarImage.AddDouble`
`static class`	`ConstantToPlanarImage.AddFloat`
`static class`	`ConstantToPlanarImage.AddInt`
`static class`	`ConstantToPlanarImage.AddLong`
`static class`	`ConstantToPlanarImage.AddShort`
`static class`	`ConstantToPlanarImage.AddUnsignedByte`
`static class`	`ConstantToPlanarImage.AddUnsignedInt`
`static class`	`ConstantToPlanarImage.AddUnsignedLong`
`static class`	`ConstantToPlanarImage.AddUnsignedShort`
`static class`	`ConstantToPlanarImage.DivideByte`
`static class`	`ConstantToPlanarImage.DivideDouble`
`static class`	`ConstantToPlanarImage.DivideFloat`
`static class`	`ConstantToPlanarImage.DivideInt`
`static class`	`ConstantToPlanarImage.DivideLong`
`static class`	`ConstantToPlanarImage.DivideShort`
`static class`	`ConstantToPlanarImage.DivideUnsignedByte`
`static class`	`ConstantToPlanarImage.DivideUnsignedInt`
`static class`	`ConstantToPlanarImage.DivideUnsignedLong`
`static class`	`ConstantToPlanarImage.DivideUnsignedShort`
`static class`	`ConstantToPlanarImage.MultiplyByte`
`static class`	`ConstantToPlanarImage.MultiplyDouble`
`static class`	`ConstantToPlanarImage.MultiplyFloat`
`static class`	`ConstantToPlanarImage.MultiplyInt`
`static class`	`ConstantToPlanarImage.MultiplyLong`
`static class`	`ConstantToPlanarImage.MultiplyShort`
`static class`	`ConstantToPlanarImage.MultiplyUnsignedByte`
`static class`	`ConstantToPlanarImage.MultiplyUnsignedInt`
`static class`	`ConstantToPlanarImage.MultiplyUnsignedLong`
`static class`	`ConstantToPlanarImage.MultiplyUnsignedShort`
`static class`	`ConstantToPlanarImage.SubtractByte`
`static class`	`ConstantToPlanarImage.SubtractDouble`
`static class`	`ConstantToPlanarImage.SubtractFloat`
`static class`	`ConstantToPlanarImage.SubtractInt`
`static class`	`ConstantToPlanarImage.SubtractLong`
`static class`	`ConstantToPlanarImage.SubtractShort`
`static class`	`ConstantToPlanarImage.SubtractUnsignedByte`
`static class`	`ConstantToPlanarImage.SubtractUnsignedInt`
`static class`	`ConstantToPlanarImage.SubtractUnsignedLong`
`static class`	`ConstantToPlanarImage.SubtractUnsignedShort`
`static class`	`IIToIIOutputII.Add<T extends NumericType<T>>`
`static class`	`IIToIIOutputII.Divide<T extends NumericType<T>>`
`static class`	`IIToIIOutputII.Multiply<T extends NumericType<T>>`
`static class`	`IIToIIOutputII.Subtract<T extends NumericType<T>>`
`static class`	`IIToRAIOutputII.Add<T extends NumericType<T>>`
`static class`	`IIToRAIOutputII.Divide<T extends NumericType<T>>`
`static class`	`IIToRAIOutputII.Multiply<T extends NumericType<T>>`
`static class`	`IIToRAIOutputII.Subtract<T extends NumericType<T>>`
`static class`	`NullaryNumericTypeMath.Assign<T extends Type<T>>` Sets the output to a constant.
`static class`	`NullaryNumericTypeMath.Zero<T extends NumericType<T>>` Sets the output to zero.
`static class`	`NumericTypeBinaryMath.Add<T extends NumericType<T>>` Op that adds (+) two NumericType values.
`static class`	`NumericTypeBinaryMath.Divide<T extends NumericType<T>>` Op that divides (/) two NumericType values.
`static class`	`NumericTypeBinaryMath.Multiply<T extends NumericType<T>>` Op that multiplies (*) two NumericType values.
`static class`	`NumericTypeBinaryMath.Subtract<T extends NumericType<T>>` Op that subtracts (-) two NumericType values.
`static class`	`PrimitiveMath.DoubleAbs` Op that computes the absolute value of a double value.
`static class`	`PrimitiveMath.DoubleAdd` Op that adds (+) two double values.
`static class`	`PrimitiveMath.DoubleArccos` Op that computes the arccosine of a double value.
`static class`	`PrimitiveMath.DoubleArcsin` Op that computes the arcsine of a double value.
`static class`	`PrimitiveMath.DoubleArctan` Op that computes the arctangent of a double value.
`static class`	`PrimitiveMath.DoubleCeil` Op that computes the ceiling of a double value.
`static class`	`PrimitiveMath.DoubleCos` Op that computes the cosine of a double value.
`static class`	`PrimitiveMath.DoubleCosh` Op that computes the hyperbolic cosine of a double value.
`static class`	`PrimitiveMath.DoubleCubeRoot` Op that computes the cubic root of a double value.
`static class`	`PrimitiveMath.DoubleDivide` Op that divides (/) two double values.
`static class`	`PrimitiveMath.DoubleExp` Op that computes the natural exponent of a double value.
`static class`	`PrimitiveMath.DoubleFloor` Op that computes the floor of a double value.
`static class`	`PrimitiveMath.DoubleLog` Op that computes the natural logarithm of a double value.
`static class`	`PrimitiveMath.DoubleLog10` Op that computes the base 10 logarithm of a double value.
`static class`	`PrimitiveMath.DoubleLogOnePlusX` Op that computes the natural logarithm of one plus a double value.
`static class`	`PrimitiveMath.DoubleMax` Op that computes the maximum of two double values.
`static class`	`PrimitiveMath.DoubleMin` Op that computes the minimum of two double values.
`static class`	`PrimitiveMath.DoubleMultiply` Op that multiplies (*) two double values.
`static class`	`PrimitiveMath.DoubleNegate` Op that negates (-) a double value.
`static class`	`PrimitiveMath.DoublePower` Op that exponentiate two double values.
`static class`	`PrimitiveMath.DoubleRemainder` Op that computes the remainder (%) of two double values.
`static class`	`PrimitiveMath.DoubleRound` Op that rounds a double value.
`static class`	`PrimitiveMath.DoubleSignum` Op that computes the signum of a double value.
`static class`	`PrimitiveMath.DoubleSin` Op that computes the sine of a double value.
`static class`	`PrimitiveMath.DoubleSinh` Op that computes the hyperbolic sine of a double value.
`static class`	`PrimitiveMath.DoubleSqrt` Op that computes the square root of a double value.
`static class`	`PrimitiveMath.DoubleSubtract` Op that subtracts (-) two double values.
`static class`	`PrimitiveMath.DoubleTan` Op that computes the tangent of a double value.
`static class`	`PrimitiveMath.DoubleTanh` Op that computes the hyperbolic tangent of a double value.
`static class`	`PrimitiveMath.FloatAbs` Op that computes the absolute value of a float value.
`static class`	`PrimitiveMath.FloatAdd` Op that adds (+) two float values.
`static class`	`PrimitiveMath.FloatDivide` Op that divides (/) two float values.
`static class`	`PrimitiveMath.FloatMax` Op that computes the maximum of two float values.
`static class`	`PrimitiveMath.FloatMin` Op that computes the minimum of two float values.
`static class`	`PrimitiveMath.FloatMultiply` Op that multiplies (*) two float values.
`static class`	`PrimitiveMath.FloatNegate` Op that negates (-) a float value.
`static class`	`PrimitiveMath.FloatRemainder` Op that computes the remainder (%) of two float values.
`static class`	`PrimitiveMath.FloatRound` Op that rounds a float value.
`static class`	`PrimitiveMath.FloatSignum` Op that computes the signum of a float value.
`static class`	`PrimitiveMath.FloatSubtract` Op that subtracts (-) two float values.
`static class`	`PrimitiveMath.IntegerAbs` Op that computes the absolute value of a int value.
`static class`	`PrimitiveMath.IntegerAdd` Op that adds (+) two int values.
`static class`	`PrimitiveMath.IntegerAnd` Op that computes the bitwise AND (&) of two int values.
`static class`	`PrimitiveMath.IntegerComplement` Op that computes the bitwise complement (~) of a int value.
`static class`	`PrimitiveMath.IntegerDivide` Op that divides (/) two int values.
`static class`	`PrimitiveMath.IntegerLeftShift` Op that computes the signed left shift (<<) of two int values.
`static class`	`PrimitiveMath.IntegerMax` Op that computes the maximum of two int values.
`static class`	`PrimitiveMath.IntegerMin` Op that computes the minimum of two int values.
`static class`	`PrimitiveMath.IntegerMultiply` Op that multiplies (*) two int values.
`static class`	`PrimitiveMath.IntegerNegate` Op that negates (-) a int value.
`static class`	`PrimitiveMath.IntegerOr` Op that computes the bitwise OR (\|) of two int values.
`static class`	`PrimitiveMath.IntegerRemainder` Op that computes the remainder (%) of two int values.
`static class`	`PrimitiveMath.IntegerRightShift` Op that computes the signed right shift (>>) of two int values.
`static class`	`PrimitiveMath.IntegerSubtract` Op that subtracts (-) two int values.
`static class`	`PrimitiveMath.IntegerUnsignedRightShift` Op that computes the unsigned right shift (>>>) of two int values.
`static class`	`PrimitiveMath.IntegerXor` Op that computes the bitwise XOR (^) of two int values.
`static class`	`PrimitiveMath.LongAbs` Op that computes the absolute value of a long value.
`static class`	`PrimitiveMath.LongAdd` Op that adds (+) two long values.
`static class`	`PrimitiveMath.LongAnd` Op that computes the bitwise AND (&) of two long values.
`static class`	`PrimitiveMath.LongComplement` Op that computes the bitwise complement (~) of a long value.
`static class`	`PrimitiveMath.LongDivide` Op that divides (/) two long values.
`static class`	`PrimitiveMath.LongLeftShift` Op that computes the signed left shift (<<) of two long values.
`static class`	`PrimitiveMath.LongMax` Op that computes the maximum of two long values.
`static class`	`PrimitiveMath.LongMin` Op that computes the minimum of two long values.
`static class`	`PrimitiveMath.LongMultiply` Op that multiplies (*) two long values.
`static class`	`PrimitiveMath.LongNegate` Op that negates (-) a long value.
`static class`	`PrimitiveMath.LongOr` Op that computes the bitwise OR (\|) of two long values.
`static class`	`PrimitiveMath.LongRemainder` Op that computes the remainder (%) of two long values.
`static class`	`PrimitiveMath.LongRightShift` Op that computes the signed right shift (>>) of two long values.
`static class`	`PrimitiveMath.LongSubtract` Op that subtracts (-) two long values.
`static class`	`PrimitiveMath.LongUnsignedRightShift` Op that computes the unsigned right shift (>>>) of two long values.
`static class`	`PrimitiveMath.LongXor` Op that computes the bitwise XOR (^) of two long values.
`static class`	`UnaryRealTypeMath.Abs<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the absolute value of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Arccos<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the inverse cosine of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Arccosh<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the inverse hyperbolic cosine of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Arccot<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the inverse cotangent of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Arccoth<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the inverse hyperbolic cotangent of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Arccsc<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the inverse cosecant of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Arccsch<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the inverse hyperbolic cosecant of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Arcsec<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the inverse secant of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Arcsech<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the inverse hyperbolic secant of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Arcsin<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the inverse sine of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Arcsinh<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the inverse hyperbolic sine of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Arctan<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the inverse tangent of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Arctanh<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the inverse hyperbolic tangent of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Ceil<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the ceiling of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Cos<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the cosine of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Cosh<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the hyperbolic cosine of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Cot<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the cotangent of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Coth<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the hyperbolic cotangent of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Csc<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the cosecant of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Csch<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the hyperbolic cosecant of the real component of an input real number.
`static class`	`UnaryRealTypeMath.CubeRoot<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the cube root of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Exp<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the exponentiation of the real component of an input real number.
`static class`	`UnaryRealTypeMath.ExpMinusOne<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to e^x - 1.
`static class`	`UnaryRealTypeMath.Floor<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the floor of the real component of an input real number.
`static class`	`UnaryRealTypeMath.GammaConstant<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the gamma value of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Invert<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the inversion of the real component of an input real number about a range.
`static class`	`UnaryRealTypeMath.Log<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the natural log of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Log10<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the 10-based log of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Log2<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the base 2 log of the real component of an input real number.
`static class`	`UnaryRealTypeMath.LogOnePlusX<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the natural logarithm of the sum of the argument and 1.
`static class`	`UnaryRealTypeMath.MaxConstant<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the real component of an input real number unless it exceeds a maximum value.
`static class`	`UnaryRealTypeMath.MinConstant<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the real component of an input real number unless it is less then a minimum value.
`static class`	`UnaryRealTypeMath.NearestInt<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the nearest integral value of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Negate<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the negation of the real component of an input real number.
`static class`	`UnaryRealTypeMath.PowerConstant<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the raising of the real component of an input real number to a constant value.
`static class`	`UnaryRealTypeMath.RandomGaussian<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to a random value using a gaussian distribution.
`static class`	`UnaryRealTypeMath.RandomUniform<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to a random value between 0 and (input real number).
`static class`	`UnaryRealTypeMath.Reciprocal<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the reciprocal of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Round<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the rounding of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Sec<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the secant of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Sech<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the hyperbolic secant of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Signum<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the signum of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Sin<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the sine of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Sinc<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the sinc value of the real component of an input real number.
`static class`	`UnaryRealTypeMath.SincPi<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the sinc (pi version) of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Sinh<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the hyperbolic sine of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Sqr<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the square of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Sqrt<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the square root of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Step<I extends RealType<I>,O extends RealType<O>>` Sets an output real number to 0 if the input real number is less than 0.
`static class`	`UnaryRealTypeMath.Tan<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the tangent of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Tanh<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the hyperbolic tangent of the real component of an input real number.
`static class`	`UnaryRealTypeMath.Ulp<I extends RealType<I>,O extends RealType<O>>` Sets the real component of an output real number to the size of the ulp of an input real number.

Uses of Op in net.imagej.ops.math.multiply

Classes in net.imagej.ops.math.multiply that implement Op
Modifier and Type	Class and Description
`class`	`ComplexConjugateMultiplyMap<T extends ComplexType<T>>`
`class`	`ComplexConjugateMultiplyOp<T extends ComplexType<T>>`

Uses of Op in net.imagej.ops.morphology.blackTopHat

Classes in net.imagej.ops.morphology.blackTopHat that implement Op
Modifier and Type	Class and Description
`class`	`ListBlackTopHat<T extends RealType<T>>` Computes the black-top-hat of a `RandomAccessibleInterval` using a `List` of `Shape`s.

Uses of Op in net.imagej.ops.morphology.close

Classes in net.imagej.ops.morphology.close that implement Op
Modifier and Type	Class and Description
`class`	`ListClose<T extends RealType<T>>` Computes the closing of a `RandomAccessibleInterval` using a `List` of `Shape`s.

Uses of Op in net.imagej.ops.morphology.dilate

Classes in net.imagej.ops.morphology.dilate that implement Op
Modifier and Type	Class and Description
`class`	`DefaultDilate<T extends RealType<T>>` Computes the dilation of a `RandomAccessibleInterval` using a single `Shape`.
`class`	`ListDilate<T extends RealType<T>>` Computes the dilation of a `RandomAccessibleInterval` using a `List` of `Shape`s.

Uses of Op in net.imagej.ops.morphology.erode

Classes in net.imagej.ops.morphology.erode that implement Op
Modifier and Type	Class and Description
`class`	`DefaultErode<T extends RealType<T>>` Computes the erosion of a `RandomAccessibleInterval` using a single `Shape`.
`class`	`ListErode<T extends RealType<T>>` Computes the erosion of a `RandomAccessibleInterval` using a `List` of `Shape`s.

Uses of Op in net.imagej.ops.morphology.extractHoles

Classes in net.imagej.ops.morphology.extractHoles that implement Op
Modifier and Type	Class and Description
`class`	`DefaultExtractHolesComputer<T extends BooleanType<T>>` Extracts the holes from a binary image.
`class`	`DefaultExtractHolesFunction<T extends BooleanType<T>>`

Uses of Op in net.imagej.ops.morphology.fillHoles

Classes in net.imagej.ops.morphology.fillHoles that implement Op
Modifier and Type	Class and Description
`class`	`DefaultFillHoles<T extends BooleanType<T>>` Fills the holes of a BooleanType image.

Uses of Op in net.imagej.ops.morphology.floodFill

Classes in net.imagej.ops.morphology.floodFill that implement Op
Modifier and Type Class and Description

class DefaultFloodFill<T extends Type<T> & Comparable<T>>

Uses of Op in net.imagej.ops.morphology.open

Classes in net.imagej.ops.morphology.open that implement Op
Modifier and Type	Class and Description
`class`	`ListOpen<T extends RealType<T>>` Computes the closing of a `RandomAccessibleInterval` using a `List` of `Shape`s.

Uses of Op in net.imagej.ops.morphology.outline

Classes in net.imagej.ops.morphology.outline that implement Op
Modifier and Type	Class and Description
`class`	`Outline<B extends BooleanType<B>>` The Op creates an output interval where the objects are hollow versions from the input.

Uses of Op in net.imagej.ops.morphology.thin

Classes in net.imagej.ops.morphology.thin that implement Op
Modifier and Type	Class and Description
`class`	`AbstractThin` Thinning Operation
`class`	`ThinGuoHall` Thinning Operation
`class`	`ThinHilditch` Thinning Operation
`class`	`ThinMorphological` Thinning Operation
`class`	`ThinZhangSuen` Thinning Operation

Uses of Op in net.imagej.ops.morphology.topHat

Classes in net.imagej.ops.morphology.topHat that implement Op
Modifier and Type	Class and Description
`class`	`ListTopHat<T extends RealType<T>>` Computes the top-hat of a `RandomAccessibleInterval` using a `List` of `Shape`s.

Uses of Op in net.imagej.ops.run

Classes in net.imagej.ops.run that implement Op
Modifier and Type	Class and Description
`class`	`RunByName` Implementation of "run" that invokes the op by name.
`class`	`RunByOp` Implementation of "run" that invokes the specified `Op` instance.
`class`	`RunByType` Implementation of "run" that invokes the op by type.

Methods in net.imagej.ops.run with parameters of type Op
Modifier and Type	Method and Description
`Object`	RunByOp.`calculate(Op input)`

Method parameters in net.imagej.ops.run with type arguments of type Op
Modifier and Type	Method and Description
`Object`	RunByType.`calculate(Class<? extends Op> input)`

Uses of Op in net.imagej.ops.segment.detectJunctions

Classes in net.imagej.ops.segment.detectJunctions that implement Op
Modifier and Type	Class and Description
`class`	`DefaultDetectJunctions` Finds the junctions between a `ArrayList` of `WritablePolyline`, intended to be used optionally after running `DefaultDetectRidges` but applicable to all groups of polylines.

Uses of Op in net.imagej.ops.segment.detectRidges

Classes in net.imagej.ops.segment.detectRidges that implement Op
Modifier and Type	Class and Description
`class`	`DefaultDetectRidges<T extends RealType<T>>` Performs the Ridge Detection algorithm on a 2-Dimensional, gray-scale image.

Uses of Op in net.imagej.ops.slice

Subinterfaces of Op in net.imagej.ops.slice
Modifier and Type	Interface and Description
`interface`	`SliceOp<I,O>` A typed "slice" function.

Classes in net.imagej.ops.slice that implement Op
Modifier and Type	Class and Description
`class`	`SliceRAI2RAI<I,O>` `SliceOp` implementation for `RandomAccessibleInterval` input and `RandomAccessibleInterval` output.

Uses of Op in net.imagej.ops.special

Subinterfaces of Op in net.imagej.ops.special
Modifier and Type	Interface and Description
`interface`	`BinaryOp<I1,I2,O>` A binary operation computes a result from two given inputs.
`interface`	`NullaryOp<O>` A nullary operation computes a result in a vacuum, without any input values.
`interface`	`SpecialOp` A special operation is one intended to be used repeatedly from other ops.
`interface`	`UnaryOp<I,O>` A unary operation computes a result from a given input.

Classes in net.imagej.ops.special that implement Op
Modifier and Type	Class and Description
`class`	`AbstractBinaryOp<I1,I2,O>` Abstract base class for `BinaryOp` implementations.
`class`	`AbstractNullaryOp<O>` Abstract base class for `NullaryOp` implementations.
`class`	`AbstractUnaryOp<I,O>` Abstract base class for `UnaryOp` implementations.

Method parameters in net.imagej.ops.special with type arguments of type Op
Modifier and Type	Method and Description
`static List<OpCandidate>`	SpecialOp.`candidates(OpEnvironment ops, String name, Class<? extends Op> opType, int arity, SpecialOp.Flavor flavor)`
`static <S extends SpecialOp,O> S`	SpecialOp.`op(OpEnvironment ops, Class<? extends Op> opType, Class<S> specialType, Class<O> outType, Object... args)` Gets the best `SpecialOp` implementation for the given types and arguments, populating its inputs.

Uses of Op in net.imagej.ops.special.chain

Subinterfaces of Op in net.imagej.ops.special.chain
Modifier and Type	Interface and Description
`interface`	`DelegatingBinaryOp<I1,I2,O,DI1,DI2,DO,OP extends BinaryOp<DI1,DI2,DO>>` Base interface for `BinaryOp`s that delegate to other `BinaryOp`s.
`interface`	`DelegatingUnaryOp<I,O,DI,DO,OP extends UnaryOp<DI,DO>>` Base interface for `UnaryOp`s that delegate to other `UnaryOp`s.

Classes in net.imagej.ops.special.chain that implement Op
Modifier and Type	Class and Description
`class`	`BCViaBC<I1 extends DI1,I2 extends DI2,O extends DO,DI1,DI2,DO>` Base class for `BinaryComputerOp`s that delegate to other `BinaryComputerOp`s.
`class`	`BCViaBCAllSame<IO>` Base class for `BinaryComputerOp`s that delegate to other `BinaryComputerOp`s with all matching types (inputs same as output).
`class`	`BCViaBCSameIO<I1,I2,O>` Base class for `BinaryComputerOp`s that delegate to other `BinaryComputerOp`s with the same input and output types.
`class`	`BFViaBC<I1 extends DI1,I2 extends DI2,O extends DO,DI1,DI2,DO>` Base class for `BinaryFunctionOp`s that delegate to `BinaryComputerOp`s.
`class`	`BFViaBCAllSame<IO>` Base class for `BinaryFunctionOp`s that delegate to `BinaryComputerOp`s with all matching types (inputs same as output).
`class`	`BFViaBCSameIO<I1,I2,O>` Base class for `BinaryFunctionOp`s that delegate to `BinaryComputerOp`s with the same input and output types.
`class`	`BFViaBF<I1 extends DI1,I2 extends DI2,O,DI1,DI2,DO extends O>` Base class for `BinaryFunctionOp`s that delegate to other `BinaryFunctionOp`s.
`class`	`BFViaBFAllSame<IO>` Base class for `BinaryFunctionOp`s that delegate to other `BinaryFunctionOp`s with all matching types (inputs same as output).
`class`	`BFViaBFSameIO<I1,I2,O>` Base class for `BinaryFunctionOp`s that delegate to other `BinaryFunctionOp`s with the same input and output types.
`class`	`BHCFViaBC<I1 extends DI1,I2 extends DI2,O extends DO,DI1,DI2,DO>` Base class for `BinaryHybridCF`s that delegate to `BinaryComputerOp`s.
`class`	`BHCFViaBCAllSame<IO>` Base class for `BinaryHybridCF`s that delegate to `BinaryComputerOp`s with all matching types (inputs same as output).
`class`	`BHCFViaBCSameIO<I1,I2,O>` Base class for `BinaryHybridCF`s that delegate to `BinaryComputerOp`s with the same input and output types.
`class`	`BHCFViaBHCF<I1 extends DI1,I2 extends DI2,O,DI1,DI2>` Base class for `BinaryHybridCF`s that delegate to `BinaryHybridCF`s.
`class`	`BHCFViaBHCFAllSame<IO>` Base class for `BinaryHybridCF`s that delegate to `BinaryHybridCF`s with all matching types (inputs same as output).
`class`	`BHCFViaBHCFSameIO<I1,I2,O>` Base class for `BinaryHybridCF`s that delegate to `BinaryHybridCF`s with the same input and output types.
`class`	`BIOViaBI<A extends DO,DI,DO extends DI>` Base class for `BinaryInplaceOnlyOp`s that delegate to `BinaryInplaceOp`s.
`class`	`BIOViaBISame<A>` Base class for `BinaryInplaceOnlyOp`s that delegate to `BinaryInplaceOp`s with all matching types (inputs same as output).
`class`	`UCViaUC<I extends DI,O extends DO,DI,DO>` Base class for `UnaryComputerOp`s that delegate to other `UnaryComputerOp`s.
`class`	`UCViaUCAllSame<IO>` Base class for `UnaryComputerOp`s that delegate to other `UnaryComputerOp`s with all matching types (input same as output).
`class`	`UCViaUCSameIO<I,O>` Base class for `UnaryComputerOp`s that delegate to other `UnaryComputerOp`s with the same input and output types.
`class`	`UFViaUC<I extends DI,O extends DO,DI,DO>` Base class for `UnaryFunctionOp`s that delegate to `UnaryComputerOp`s.
`class`	`UFViaUCAllSame<IO>` Base class for `UnaryFunctionOp`s that delegate to `UnaryComputerOp`s with all matching types (input same as output).
`class`	`UFViaUCSameIO<I,O>` Base class for `UnaryFunctionOp`s that delegate to `UnaryComputerOp`s with the same input and output types.
`class`	`UFViaUF<I extends DI,O,DI,DO extends O>` Base class for `UnaryFunctionOp`s that delegate to other `UnaryFunctionOp`s.
`class`	`UFViaUFAllSame<IO>` Base class for `UnaryFunctionOp`s that delegate to other `UnaryFunctionOp`s with all matching types (input same as output).
`class`	`UFViaUFSameIO<I,O>` Base class for `UnaryFunctionOp`s that delegate to other `UnaryFunctionOp`s with the same input and output types.
`class`	`UHCFViaUC<I extends DI,O extends DO,DI,DO>` Base class for `UnaryHybridCF`s that delegate to `UnaryComputerOp`s.
`class`	`UHCFViaUCAllSame<IO>` Base class for `UnaryHybridCF`s that delegate to `UnaryComputerOp`s with all matching types (input same as output).
`class`	`UHCFViaUCSameIO<I,O>` Base class for `UnaryHybridCF`s that delegate to `UnaryComputerOp`s with the same input and output types.
`class`	`UHCFViaUHCF<I extends DI,O,DI>` Base class for `UnaryHybridCF`s that delegate to other `UnaryHybridCF`s.
`class`	`UHCFViaUHCFAllSame<IO>` Base class for `UnaryHybridCF`s that delegate to other `UnaryHybridCF`s with all matching types (input same as output).
`class`	`UHCFViaUHCFSameIO<I,O>` Base class for `UnaryHybridCF`s that delegate to other `UnaryHybridCF`s with the same input and output types.
`class`	`UIOViaUI<A extends DO,DI,DO extends DI>` Base class for `UnaryInplaceOnlyOp`s that delegate to `UnaryInplaceOp`s.
`class`	`UIOViaUISame<A>` Base class for `UnaryInplaceOnlyOp`s that delegate to `UnaryInplaceOp`s with all matching types (input same as output).

Method parameters in net.imagej.ops.special.chain with type arguments of type Op
Modifier and Type	Method and Description
`static <I1,I2,O extends RealType<O>> BinaryComputerOp<I1,I2,O>`	RTs.`binaryComputer(OpEnvironment ops, Class<? extends Op> opType, I1 in1, I2 in2, Object... otherArgs)`
`static <T> BinaryComputerOp<IterableInterval<T>,IterableInterval<T>,IterableInterval<T>>`	IIs.`binaryComputer(OpEnvironment ops, Class<? extends Op> opType, IterableInterval<T> in1, IterableInterval<T> in2, Object... otherArgs)`
`static <T> BinaryComputerOp<RandomAccessibleInterval<T>,RandomAccessibleInterval<T>,RandomAccessibleInterval<T>>`	RAIs.`binaryComputer(OpEnvironment ops, Class<? extends Op> opType, RandomAccessibleInterval<T> in1, RandomAccessibleInterval<T> in2, Object... otherArgs)`
`static <I1,I2,O extends RealType<O>> BinaryFunctionOp<I1,I2,O>`	RTs.`binaryFunction(OpEnvironment ops, Class<? extends Op> opType, I1 in1, I2 in2, Object... otherArgs)`
`static <T> BinaryFunctionOp<IterableInterval<T>,IterableInterval<T>,IterableInterval<T>>`	IIs.`binaryFunction(OpEnvironment ops, Class<? extends Op> opType, IterableInterval<T> in1, IterableInterval<T> in2, Object... otherArgs)`
`static <T> BinaryFunctionOp<RandomAccessibleInterval<T>,RandomAccessibleInterval<T>,RandomAccessibleInterval<T>>`	RAIs.`binaryFunction(OpEnvironment ops, Class<? extends Op> opType, RandomAccessibleInterval<T> in1, RandomAccessibleInterval<T> in2, Object... otherArgs)`
`static <I1,I2,O extends RealType<O>> BinaryHybridCF<I1,I2,O>`	RTs.`binaryHybrid(OpEnvironment ops, Class<? extends Op> opType, I1 in1, I2 in2, Object... otherArgs)`
`static <T> BinaryHybridCF<IterableInterval<T>,IterableInterval<T>,IterableInterval<T>>`	IIs.`binaryHybrid(OpEnvironment ops, Class<? extends Op> opType, IterableInterval<T> in1, IterableInterval<T> in2, Object... otherArgs)`
`static <T> BinaryHybridCF<RandomAccessibleInterval<T>,RandomAccessibleInterval<T>,RandomAccessibleInterval<T>>`	RAIs.`binaryHybrid(OpEnvironment ops, Class<? extends Op> opType, RandomAccessibleInterval<T> in1, RandomAccessibleInterval<T> in2, Object... otherArgs)`
`static <I,O extends RealType<O>> UnaryComputerOp<I,O>`	RTs.`computer(OpEnvironment ops, Class<? extends Op> opType, I in, Object... otherArgs)`
`static <T> UnaryComputerOp<IterableInterval<T>,IterableInterval<T>>`	IIs.`computer(OpEnvironment ops, Class<? extends Op> opType, IterableInterval<T> in, Object... otherArgs)`
`static <T,F> UnaryComputerOp<RandomAccessibleInterval<T>,RandomAccessibleInterval<F>>`	RAIs.`computer(OpEnvironment ops, Class<? extends Op> opType, RandomAccessibleInterval<F> out, RandomAccessibleInterval<T> in, Object... otherArgs)`
`static <T> UnaryComputerOp<RandomAccessibleInterval<T>,RandomAccessibleInterval<T>>`	RAIs.`computer(OpEnvironment ops, Class<? extends Op> opType, RandomAccessibleInterval<T> in, Object... otherArgs)`
`static <I,O extends RealType<O>> UnaryFunctionOp<I,O>`	RTs.`function(OpEnvironment ops, Class<? extends Op> opType, I in, Object... otherArgs)`
`static <T> UnaryFunctionOp<IterableInterval<T>,IterableInterval<T>>`	IIs.`function(OpEnvironment ops, Class<? extends Op> opType, IterableInterval<T> in, Object... otherArgs)`
`static <T> UnaryFunctionOp<RandomAccessibleInterval<T>,RandomAccessibleInterval<T>>`	RAIs.`function(OpEnvironment ops, Class<? extends Op> opType, RandomAccessibleInterval<T> in, Object... otherArgs)`
`static <I,O extends RealType<O>> UnaryHybridCF<I,O>`	RTs.`hybrid(OpEnvironment ops, Class<? extends Op> opType, I in, Object... otherArgs)`
`static <T> UnaryHybridCF<IterableInterval<T>,IterableInterval<T>>`	IIs.`hybrid(OpEnvironment ops, Class<? extends Op> opType, IterableInterval<T> in, Object... otherArgs)`
`static <T,F> UnaryHybridCF<RandomAccessibleInterval<T>,RandomAccessibleInterval<F>>`	RAIs.`hybrid(OpEnvironment ops, Class<? extends Op> opType, RandomAccessibleInterval<F> out, RandomAccessibleInterval<T> in, Object... otherArgs)`
`static <T> UnaryHybridCF<RandomAccessibleInterval<T>,RandomAccessibleInterval<T>>`	RAIs.`hybrid(OpEnvironment ops, Class<? extends Op> opType, RandomAccessibleInterval<T> in, Object... otherArgs)`
`static <A extends RealType<A>> UnaryInplaceOp<? super A,A>`	RTs.`inplace(OpEnvironment ops, Class<? extends Op> opType, A arg, Object... otherArgs)`
`static <T> UnaryInplaceOp<? super IterableInterval<T>,IterableInterval<T>>`	IIs.`inplace(OpEnvironment ops, Class<? extends Op> opType, IterableInterval<T> arg, Object... otherArgs)`
`static <T> UnaryInplaceOp<? super RandomAccessibleInterval<T>,RandomAccessibleInterval<T>>`	RAIs.`inplace(OpEnvironment ops, Class<? extends Op> opType, RandomAccessibleInterval<T> arg, Object... otherArgs)`

Uses of Op in net.imagej.ops.special.computer

Subinterfaces of Op in net.imagej.ops.special.computer
Modifier and Type	Interface and Description
`interface`	`BinaryComputerOp<I1,I2,O>` A binary computer computes a result from two given inputs, storing it into the specified output reference.
`interface`	`NullaryComputerOp<O>` A nullary computer computes a result, storing it into the specified output reference.
`interface`	`UnaryComputerOp<I,O>` A unary computer calculates a result from the given input, storing it into the specified output reference.

Classes in net.imagej.ops.special.computer that implement Op
Modifier and Type	Class and Description
`class`	`AbstractBinaryComputerOp<I1,I2,O>` Abstract superclass for `BinaryComputerOp` implementations.
`class`	`AbstractNullaryComputerOp<O>` Abstract superclass for `BinaryComputerOp` implementations.
`class`	`AbstractUnaryComputerOp<I,O>` Abstract superclass for `UnaryComputerOp` implementations.

Method parameters in net.imagej.ops.special.computer with type arguments of type Op
Modifier and Type	Method and Description
`static <I1,I2,O> BinaryComputerOp<I1,I2,O>`	Computers.`binary(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Class<I1> in1Type, Class<I2> in2Type, Object... otherArgs)` Gets the best `BinaryComputerOp` implementation for the given types and arguments, populating its inputs.
`static <I1,I2,O> BinaryComputerOp<I1,I2,O>`	Computers.`binary(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, I1 in1, I2 in2, Object... otherArgs)` Gets the best `BinaryComputerOp` implementation for the given types and arguments, populating its inputs.
`static <I1,I2,O> BinaryComputerOp<I1,I2,O>`	Computers.`binary(OpEnvironment ops, Class<? extends Op> opType, O out, I1 in1, I2 in2, Object... otherArgs)` Gets the best `BinaryComputerOp` implementation for the given types and arguments, populating its inputs.
`static <O> NullaryComputerOp<O>`	Computers.`nullary(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Object... otherArgs)` Gets the best `NullaryComputerOp` implementation for the given types and arguments, populating its inputs.
`static <O> NullaryComputerOp<O>`	Computers.`nullary(OpEnvironment ops, Class<? extends Op> opType, O out, Object... otherArgs)` Gets the best `NullaryComputerOp` implementation for the given types and arguments, populating its inputs.
`static <I,O> UnaryComputerOp<I,O>`	Computers.`unary(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Class<I> inType, Object... otherArgs)` Gets the best `UnaryComputerOp` implementation for the given types and arguments, populating its inputs.
`static <I,O> UnaryComputerOp<I,O>`	Computers.`unary(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, I in, Object... otherArgs)` Gets the best `UnaryComputerOp` implementation for the given types and arguments, populating its inputs.
`static <I,O> UnaryComputerOp<I,O>`	Computers.`unary(OpEnvironment ops, Class<? extends Op> opType, O out, I in, Object... otherArgs)` Gets the best `UnaryComputerOp` implementation for the given types and arguments, populating its inputs.

Uses of Op in net.imagej.ops.special.function

Subinterfaces of Op in net.imagej.ops.special.function
Modifier and Type	Interface and Description
`interface`	`BinaryFunctionOp<I1,I2,O>` A binary function calculates a result from two given inputs, returning it as a new object.
`interface`	`NullaryFunctionOp<O>` A nullary function calculates a result, returning it as a new object.
`interface`	`UnaryFunctionOp<I,O>` A unary function calculates a result from the given input, returning it as a new object.

Classes in net.imagej.ops.special.function that implement Op
Modifier and Type	Class and Description
`class`	`AbstractBinaryFunctionOp<I1,I2,O>` Abstract superclass for `BinaryFunctionOp` implementations.
`class`	`AbstractNullaryFunctionOp<O>` Abstract superclass for `NullaryFunctionOp` implementations.
`class`	`AbstractUnaryFunctionOp<I,O>` Abstract superclass for `UnaryFunctionOp` implementations.

Method parameters in net.imagej.ops.special.function with type arguments of type Op
Modifier and Type	Method and Description
`static <I1,I2,O> BinaryFunctionOp<I1,I2,O>`	Functions.`binary(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Class<I1> in1Type, Class<I2> in2Type, Object... otherArgs)` Gets the best `BinaryFunctionOp` implementation for the given types and arguments, populating its inputs.
`static <I1,I2,O> BinaryFunctionOp<I1,I2,O>`	Functions.`binary(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, I1 in1, I2 in2, Object... otherArgs)` Gets the best `BinaryFunctionOp` implementation for the given types and arguments, populating its inputs.
`static <O> NullaryFunctionOp<O>`	Functions.`nullary(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Object... args)` Gets the best `NullaryFunctionOp` implementation for the given types and arguments, populating its inputs.
`static <I,O> UnaryFunctionOp<I,O>`	Functions.`unary(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Class<I> inType, Object... otherArgs)` Gets the best `UnaryFunctionOp` implementation for the given types and arguments, populating its inputs.
`static <I,O> UnaryFunctionOp<I,O>`	Functions.`unary(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, I in, Object... otherArgs)` Gets the best `UnaryFunctionOp` implementation for the given types and arguments, populating its inputs.

Uses of Op in net.imagej.ops.special.hybrid

Subinterfaces of Op in net.imagej.ops.special.hybrid
Modifier and Type	Interface and Description
`interface`	`BinaryHybridCF<I1,I2,O>` A hybrid binary operation which can be used as a `BinaryComputerOp` or `BinaryFunctionOp`.
`interface`	`BinaryHybridCFI<I,O extends I>` A hybrid binary operation which can be used as a `BinaryComputerOp`, `BinaryFunctionOp` or `BinaryInplaceOp`.
`interface`	`BinaryHybridCFI1<I1,I2,O extends I1>` A hybrid binary operation which can be used as a `BinaryComputerOp`, `BinaryFunctionOp` or `BinaryInplace1Op`.
`interface`	`BinaryHybridCI<I,O extends I>` A hybrid binary operation which can be used as a `BinaryComputerOp` or `BinaryInplaceOp`.
`interface`	`BinaryHybridCI1<I1,I2,O extends I1>` A hybrid binary operation which can be used as a `BinaryComputerOp`, or `BinaryInplace1Op`.
`interface`	`NullaryHybridCF<O>` A hybrid nullary operation which can be used as a `NullaryComputerOp` or `NullaryFunctionOp`.
`interface`	`UnaryHybridCF<I,O>` A hybrid unary operation which can be used as a `UnaryComputerOp` or `UnaryFunctionOp`.
`interface`	`UnaryHybridCFI<I,O extends I>` A hybrid unary operation which can be used as a `UnaryComputerOp`, `UnaryFunctionOp` or `UnaryInplaceOp`.
`interface`	`UnaryHybridCI<I,O extends I>` A hybrid unary operation which can be used as a `UnaryComputerOp` or `UnaryInplaceOp`.

Classes in net.imagej.ops.special.hybrid that implement Op
Modifier and Type	Class and Description
`class`	`AbstractBinaryHybridC<I1,I2,O>` Abstract superclass for `BinaryHybridCF` and `BinaryHybridCI1` implementations.
`class`	`AbstractBinaryHybridCF<I1,I2,O>` Abstract superclass for `BinaryHybridCF` implementations.
`class`	`AbstractBinaryHybridCFI<I,O extends I>` Abstract superclass for `BinaryHybridCFI` implementations.
`class`	`AbstractBinaryHybridCFI1<I1,I2,O extends I1>` Abstract superclass for `BinaryHybridCFI1` implementations.
`class`	`AbstractBinaryHybridCI<I,O extends I>` Abstract superclass for `BinaryHybridCI` implementations.
`class`	`AbstractBinaryHybridCI1<I1,I2,O extends I1>` Abstract superclass for `BinaryHybridCI1` implementations.
`class`	`AbstractNullaryHybridCF<O>` Abstract superclass for `NullaryHybridCF` implementations.
`class`	`AbstractUnaryHybridC<I,O>` Abstract superclass for `UnaryHybridCF` and `UnaryHybridCI` implementations.
`class`	`AbstractUnaryHybridCF<I,O>` Abstract superclass for `UnaryHybridCF` implementations.
`class`	`AbstractUnaryHybridCFI<I,O extends I>` Abstract superclass for `UnaryHybridCFI` implementations.
`class`	`AbstractUnaryHybridCI<I,O extends I>` Abstract superclass for `UnaryHybridCI` implementations.

Method parameters in net.imagej.ops.special.hybrid with type arguments of type Op
Modifier and Type	Method and Description
`static <I1,I2,O> BinaryHybridCF<I1,I2,O>`	Hybrids.`binaryCF(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Class<I1> in1Type, Class<I2> in2Type, Object... otherArgs)` Gets the best `BinaryHybridCF` implementation for the given types and arguments, populating its inputs.
`static <I1,I2,O> BinaryHybridCF<I1,I2,O>`	Hybrids.`binaryCF(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, I1 in1, I2 in2, Object... otherArgs)` Gets the best `BinaryHybridCF` implementation for the given types and arguments, populating its inputs.
`static <I1,I2,O> BinaryHybridCF<I1,I2,O>`	Hybrids.`binaryCF(OpEnvironment ops, Class<? extends Op> opType, O out, I1 in1, I2 in2, Object... otherArgs)` Gets the best `BinaryHybridCF` implementation for the given types and arguments, populating its inputs.
`static <I,O extends I> BinaryHybridCFI<I,O>`	Hybrids.`binaryCFI(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Class<I> inType, Object... otherArgs)` Gets the best `BinaryHybridCFI` implementation for the given types and arguments, populating its inputs.
`static <I,O extends I> BinaryHybridCFI<I,O>`	Hybrids.`binaryCFI(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, I in1, I in2, Object... otherArgs)` Gets the best `BinaryHybridCFI` implementation for the given types and arguments, populating its inputs.
`static <I,O extends I> BinaryHybridCFI<I,O>`	Hybrids.`binaryCFI(OpEnvironment ops, Class<? extends Op> opType, O out, I in1, I in2, Object... otherArgs)` Gets the best `BinaryHybridCFI` implementation for the given types and arguments, populating its inputs.
`static <I1,I2,O extends I1> BinaryHybridCFI1<I1,I2,O>`	Hybrids.`binaryCFI1(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Class<I1> in1Type, Class<I2> in2Type, Object... otherArgs)` Gets the best `BinaryHybridCFI1` implementation for the given types and arguments, populating its inputs.
`static <I1,I2,O extends I1> BinaryHybridCFI1<I1,I2,O>`	Hybrids.`binaryCFI1(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, I1 in1, I2 in2, Object... otherArgs)` Gets the best `BinaryHybridCFI1` implementation for the given types and arguments, populating its inputs.
`static <I1,I2,O extends I1> BinaryHybridCFI1<I1,I2,O>`	Hybrids.`binaryCFI1(OpEnvironment ops, Class<? extends Op> opType, O out, I1 in1, I2 in2, Object... otherArgs)` Gets the best `BinaryHybridCFI1` implementation for the given types and arguments, populating its inputs.
`static <I,O extends I> BinaryHybridCI<I,O>`	Hybrids.`binaryCI(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Class<I> inType, Object... otherArgs)` Gets the best `BinaryHybridCI` implementation for the given types and arguments, populating its inputs.
`static <I,O extends I> BinaryHybridCI<I,O>`	Hybrids.`binaryCI(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, I in1, I in2, Object... otherArgs)` Gets the best `BinaryHybridCI` implementation for the given types and arguments, populating its inputs.
`static <I,O extends I> BinaryHybridCI<I,O>`	Hybrids.`binaryCI(OpEnvironment ops, Class<? extends Op> opType, O out, I in1, I in2, Object... otherArgs)` Gets the best `BinaryHybridCI` implementation for the given types and arguments, populating its inputs.
`static <I1,I2,O extends I1> BinaryHybridCI1<I1,I2,O>`	Hybrids.`binaryCI1(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Class<I1> in1Type, Class<I2> in2Type, Object... otherArgs)` Gets the best `BinaryHybridCI1` implementation for the given types and arguments, populating its inputs.
`static <I1,I2,O extends I1> BinaryHybridCI1<I1,I2,O>`	Hybrids.`binaryCI1(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, I1 in1, I2 in2, Object... otherArgs)` Gets the best `BinaryHybridCI1` implementation for the given types and arguments, populating its inputs.
`static <I1,I2,O extends I1> BinaryHybridCI1<I1,I2,O>`	Hybrids.`binaryCI1(OpEnvironment ops, Class<? extends Op> opType, O out, I1 in1, I2 in2, Object... otherArgs)` Gets the best `BinaryHybridCI1` implementation for the given types and arguments, populating its inputs.
`static <O> NullaryHybridCF<O>`	Hybrids.`nullaryCF(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Object... otherArgs)` Gets the best `NullaryHybridCF` implementation for the given types and arguments, populating its inputs.
`static <O> NullaryHybridCF<O>`	Hybrids.`nullaryCF(OpEnvironment ops, Class<? extends Op> opType, O out, Object... otherArgs)` Gets the best `NullaryHybridCF` implementation for the given types and arguments, populating its inputs.
`static <I,O> UnaryHybridCF<I,O>`	Hybrids.`unaryCF(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Class<I> inType, Object... otherArgs)` Gets the best `UnaryHybridCF` implementation for the given types and arguments, populating its inputs.
`static <I,O> UnaryHybridCF<I,O>`	Hybrids.`unaryCF(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, I in, Object... otherArgs)` Gets the best `UnaryHybridCF` implementation for the given types and arguments, populating its inputs.
`static <I,O> UnaryHybridCF<I,O>`	Hybrids.`unaryCF(OpEnvironment ops, Class<? extends Op> opType, O out, I in, Object... otherArgs)` Gets the best `UnaryHybridCF` implementation for the given types and arguments, populating its inputs.
`static <I,O extends I> UnaryHybridCFI<I,O>`	Hybrids.`unaryCFI(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Class<I> inType, Object... otherArgs)` Gets the best `UnaryHybridCFI` implementation for the given types and arguments, populating its inputs.
`static <I,O extends I> UnaryHybridCFI<I,O>`	Hybrids.`unaryCFI(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, I in, Object... otherArgs)` Gets the best `UnaryHybridCFI` implementation for the given types and arguments, populating its inputs.
`static <I,O extends I> UnaryHybridCFI<I,O>`	Hybrids.`unaryCFI(OpEnvironment ops, Class<? extends Op> opType, O out, I in, Object... otherArgs)` Gets the best `UnaryHybridCFI` implementation for the given types and arguments, populating its inputs.
`static <I,O extends I> UnaryHybridCI<I,O>`	Hybrids.`unaryCI(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, Class<I> inType, Object... otherArgs)` Gets the best `UnaryHybridCI` implementation for the given types and arguments, populating its inputs.
`static <I,O extends I> UnaryHybridCI<I,O>`	Hybrids.`unaryCI(OpEnvironment ops, Class<? extends Op> opType, Class<O> outType, I in, Object... otherArgs)` Gets the best `UnaryHybridCI` implementation for the given types and arguments, populating its inputs.
`static <I,O extends I> UnaryHybridCI<I,O>`	Hybrids.`unaryCI(OpEnvironment ops, Class<? extends Op> opType, O out, I in, Object... otherArgs)` Gets the best `UnaryHybridCI` implementation for the given types and arguments, populating its inputs.

Uses of Op in net.imagej.ops.special.inplace

Subinterfaces of Op in net.imagej.ops.special.inplace
Modifier and Type	Interface and Description
`interface`	`BinaryInplace1OnlyOp<A,I>` A `BinaryInplace1Op` which is not a hybrid.
`interface`	`BinaryInplace1Op<I1,I2,O extends I1>` A binary inplace operation which computes a result from two given arguments, storing it back into the first input (i.e., mutating it).
`interface`	`BinaryInplaceOnlyOp<A>` A `BinaryInplaceOp` which is not a hybrid.
`interface`	`BinaryInplaceOp<I,O extends I>` A binary inplace operation is an op which computes a result from two given arguments, storing it either the first or second argument (i.e., mutating it).
`interface`	`UnaryInplaceOnlyOp<A>` A `UnaryInplaceOp` which is not a hybrid.
`interface`	`UnaryInplaceOp<I,O extends I>` A unary inplace operation is an op which mutates a parameter.

Classes in net.imagej.ops.special.inplace that implement Op
Modifier and Type	Class and Description
`class`	`AbstractBinaryInplace1Op<A,I>` Abstract superclass for `BinaryInplace1OnlyOp` implementations.
`class`	`AbstractBinaryInplaceOp<A>` Abstract superclass for `BinaryInplaceOnlyOp` implementations.
`class`	`AbstractUnaryInplaceOp<A>` Abstract superclass for `UnaryInplaceOnlyOp` implementations.

Method parameters in net.imagej.ops.special.inplace with type arguments of type Op
Modifier and Type	Method and Description
`static <O> BinaryInplaceOp<? super O,O>`	Inplaces.`binary(OpEnvironment ops, Class<? extends Op> opType, Class<O> argType, Object... otherArgs)` Gets the best `BinaryInplaceOp` implementation for the given types and arguments, populating its inputs.
`static <O> BinaryInplaceOp<? super O,O>`	Inplaces.`binary(OpEnvironment ops, Class<? extends Op> opType, O arg1, O arg2, Object... otherArgs)` Gets the best `BinaryInplaceOp` implementation for the given types and arguments, populating its inputs.
`static <I2,O> BinaryInplace1Op<? super O,I2,O>`	Inplaces.`binary1(OpEnvironment ops, Class<? extends Op> opType, Class<O> argType, Class<I2> inType, Object... otherArgs)` Gets the best `BinaryInplace1Op` implementation for the given types and arguments, populating its inputs.
`static <I2,O> BinaryInplace1Op<? super O,I2,O>`	Inplaces.`binary1(OpEnvironment ops, Class<? extends Op> opType, O arg, I2 in, Object... otherArgs)` Gets the best `BinaryInplace1Op` implementation for the given types and arguments, populating its inputs.
`static <O> UnaryInplaceOp<? super O,O>`	Inplaces.`unary(OpEnvironment ops, Class<? extends Op> opType, Class<O> argType, Object... otherArgs)` Gets the best `UnaryInplaceOp` implementation for the given types and arguments, populating its inputs.
`static <O> UnaryInplaceOp<? super O,O>`	Inplaces.`unary(OpEnvironment ops, Class<? extends Op> opType, O arg, Object... otherArgs)` Gets the best `UnaryInplaceOp` implementation for the given types and arguments, populating its inputs.

Uses of Op in net.imagej.ops.stats

Subinterfaces of Op in net.imagej.ops.stats
Modifier and Type	Interface and Description
`interface`	`StatsOp<I,O>` marker interface for statistic ops.

Classes in net.imagej.ops.stats that implement Op
Modifier and Type	Class and Description
`class`	`AbstractStatsOp<I,O extends RealType<O>>` Abstract Statistics Op.
`class`	`DefaultGeometricMean<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.geometricMean` using `stats.size` and `stats.sumOfLogs`.
`class`	`DefaultHarmonicMean<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.harmonicMean` using `stats.size` and `stats.sumOfInverses`.
`class`	`DefaultKurtosis<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.kurtosis` using `stats.stdDev` and `stats.moment4AboutMean`.
`class`	`DefaultMean<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.max` using `stats.sum` and `stats.size`.
`class`	`DefaultMedian<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.median`.
`class`	`DefaultMinMax<I extends RealType<I>>` `Op` to calculate the `stats.minMax`.
`class`	`DefaultMoment1AboutMean<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.moment1AboutMean` using `stats.mean` and `stats.size`.
`class`	`DefaultMoment2AboutMean<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.moment2AboutMean` using `stats.mean` and `stats.size`.
`class`	`DefaultMoment3AboutMean<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.moment3AboutMean` using `stats.mean` and `stats.size`.
`class`	`DefaultMoment4AboutMean<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.moment4AboutMean` using `stats.mean` and `stats.size`.
`class`	`DefaultPercentile<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the n-th `stats.percentile`.
`class`	`DefaultQuantile<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the n-th `stats.percentile`.
`class`	`DefaultSize<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.size`.
`class`	`DefaultSkewness<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.skewness` using `stats.moment3AboutMean` and `stats.stdDev`.
`class`	`DefaultStandardDeviation<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.stdDev` using `stats.variance`.
`class`	`DefaultSum<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.sum`.
`class`	`DefaultSumOfInverses<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.sumOfInverses`.
`class`	`DefaultSumOfLogs<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.sumOfLogs`.
`class`	`DefaultSumOfSquares<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.sumOfSquares`.
`class`	`DefaultVariance<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.variance` using the `stats.stdDev` using the two-pass algorithm.
`class`	`IISize<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.size` directly.
`class`	`IntegralMean<I extends RealType<I>>` `Op` to calculate the `stats.mean` from an integral image using a specialized `Cursor` implementation.
`class`	`IntegralSum<I extends RealType<I>>` `Op` to calculate the `stats.sum` from an integral image using a specialized `Cursor` implementation.
`class`	`IntegralVariance<I extends RealType<I>>` `Op` to calculate the `stats.variance` from an integral image using a specialized `Cursor` implementation.
`class`	`IterableGeometricMean<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.geometricMean` directly.
`class`	`IterableHarmonicMean<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.harmonicMean` directly.
`class`	`IterableMax<T extends RealType<T>>` `Op` to calculate the `stats.max`.
`class`	`IterableMean<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.mean` directly.
`class`	`IterableMin<T extends RealType<T>>` `Op` to calculate the `stats.min`.
`class`	`IterableStandardDeviation<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.stdDev` directly.
`class`	`IterableVariance<I extends RealType<I>,O extends RealType<O>>` `Op` to calculate the `stats.variance` using the online algorithm from Knuth and Welford.

Uses of Op in net.imagej.ops.stats.regression.leastSquares

Classes in net.imagej.ops.stats.regression.leastSquares that implement Op
Modifier and Type	Class and Description
`class`	`Quadric` An op that fits a quadratic surface (quadric) into a set of points.

Uses of Op in net.imagej.ops.thread.chunker

Subinterfaces of Op in net.imagej.ops.thread.chunker
Modifier and Type	Interface and Description
`interface`	`ChunkerOp` A "chunker" operation which executes code across chunks of data using multiple threads.

Classes in net.imagej.ops.thread.chunker that implement Op
Modifier and Type	Class and Description
`class`	`AbstractChunker` Abstract `ChunkerOp`.
`class`	`ChunkerInterleaved` Implementation of a `ChunkerOp` that interleaves the chunks.
`class`	`DefaultChunker` Simple default implementation of a `ChunkerOp`.

Uses of Op in net.imagej.ops.threshold

Subinterfaces of Op in net.imagej.ops.threshold
Modifier and Type	Interface and Description
`interface`	`ApplyThreshold<I,O>` An algorithm for applying a threshold value to an object.
`interface`	`ApplyThresholdIterable<T,I extends Iterable<T>,O>` Interface for `ApplyThreshold` implementations that operate over an iteration.
`interface`	`ComputeThreshold<I,O>` An algorithm for computing a threshold value that divides an object into two classes.
`interface`	`ComputeThresholdHistogram<T extends RealType<T>>` Interface for threshold computation algorithms relying on a histogram.

Classes in net.imagej.ops.threshold that implement Op
Modifier and Type	Class and Description
`class`	`AbstractApplyThresholdImg<T>` Abstract superclass of `ApplyThresholdIterable` implementations that operate on `Img` objects.
`class`	`AbstractApplyThresholdIterable<T,I extends Iterable<T>,O extends Iterable<BitType>>` Abstract superclass of `ApplyThresholdIterable` implementations.
`class`	`AbstractComputeThresholdHistogram<T extends RealType<T>>` Abstract superclass of `ComputeThresholdHistogram` implementations.
`static class`	`ApplyThresholdMethod.Huang<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.IJ1<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.Intermodes<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.IsoData<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.Li<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.MaxEntropy<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.MaxLikelihood<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.Mean<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.MinError<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.Minimum<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.Moments<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.Otsu<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.Percentile<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.RenyiEntropy<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.Rosin<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.Shanbhag<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.Triangle<T extends RealType<T>>`
`static class`	`ApplyThresholdMethod.Yen<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalHuangThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalIJ1Threshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalIntermodesThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalIsoDataThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalLiThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalMaxEntropyThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalMaxLikelihoodThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalMinErrorThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalMinimumThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalMomentsThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalOtsuThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalPercentileThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalRenyiEntropyThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalRosinThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalShanbhagThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalTriangleThreshold<T extends RealType<T>>`
`static class`	`ApplyThresholdMethodLocal.LocalYenThreshold<T extends RealType<T>>`
`class`	`LocalThresholdMethod<T extends RealType<T>>` `AbstractCenterAwareComputerOp` for use in `LocalThreshold`s.
`class`	`LocalThresholdMethodHistogram<T extends RealType<T>,O extends BooleanType<O>>` `AbstractCenterAwareComputerOp` for use in `LocalThreshold`s.

Uses of Op in net.imagej.ops.threshold.apply

Classes in net.imagej.ops.threshold.apply that implement Op
Modifier and Type	Class and Description
`class`	`ApplyConstantThreshold<T extends RealType<T>>` Applies the given threshold value to every element along the given `Iterable` input.
`class`	`ApplyManualThreshold<T extends RealType<T>>` Applies a threshold to an `Img`.
`class`	`ApplyThresholdComparable<T>` Applies a threshold value (the second input) to the given comparable object, producing a `BitType` set to 1 iff the object compares above the threshold.
`class`	`ApplyThresholdComparator<T>` Applies a threshold value (the second input) to the given object using the specified comparator, producing a `BitType` set to 1 iff the object compares above the threshold.
`class`	`LocalThreshold<T extends RealType<T>>` Apply a local thresholding method to an image, optionally using a out of bounds strategy.
`class`	`LocalThresholdIntegral<I extends RealType<I>>` Apply a local thresholding method to an image using integral images for speed up, optionally using a out of bounds strategy.

Uses of Op in net.imagej.ops.threshold.huang

Classes in net.imagej.ops.threshold.huang that implement Op
Modifier and Type	Class and Description
`class`	`ComputeHuangThreshold<T extends RealType<T>>` Implements Huang's threshold method by Huang & Wang.

Uses of Op in net.imagej.ops.threshold.ij1

Classes in net.imagej.ops.threshold.ij1 that implement Op
Modifier and Type	Class and Description
`class`	`ComputeIJ1Threshold<T extends RealType<T>>` Implements the default threshold method from ImageJ 1.x.

Uses of Op in net.imagej.ops.threshold.intermodes

Classes in net.imagej.ops.threshold.intermodes that implement Op
Modifier and Type	Class and Description
`class`	`ComputeIntermodesThreshold<T extends RealType<T>>` Implements an intermodes threshold method by Prewitt & Mendelsohn.

Uses of Op in net.imagej.ops.threshold.isoData

Classes in net.imagej.ops.threshold.isoData that implement Op
Modifier and Type	Class and Description
`class`	`ComputeIsoDataThreshold<T extends RealType<T>>` Implements an IsoData (intermeans) threshold method by Ridler & Calvard.

Uses of Op in net.imagej.ops.threshold.li

Classes in net.imagej.ops.threshold.li that implement Op
Modifier and Type	Class and Description
`class`	`ComputeLiThreshold<T extends RealType<T>>` Implements Li's threshold method by Li & Lee, and Li & Tam, and Sezgin & Sankur.

Uses of Op in net.imagej.ops.threshold.localBernsen

Classes in net.imagej.ops.threshold.localBernsen that implement Op
Modifier and Type	Class and Description
`class`	`LocalBernsenThreshold<T extends RealType<T>>` LocalThresholdMethod which is similar to `LocalMidGreyThreshold`, but uses a constant value rather than the value of the input pixel when the contrast in the neighborhood of that pixel is too small.

Uses of Op in net.imagej.ops.threshold.localContrast

Classes in net.imagej.ops.threshold.localContrast that implement Op
Modifier and Type	Class and Description
`class`	`LocalContrastThreshold<T extends RealType<T>>` LocalThresholdMethod which determines whether a pixel is closer to the maximum or minimum pixel of a neighborhood.

Uses of Op in net.imagej.ops.threshold.localMean

Classes in net.imagej.ops.threshold.localMean that implement Op
Modifier and Type	Class and Description
`class`	`LocalMeanThreshold<T extends RealType<T>>` LocalThresholdMethod that uses the mean and operates directly of RAIs.
`class`	`LocalMeanThresholdIntegral<T extends RealType<T>>` Local threshold method that uses the `IntegralMean` for the threshold computation.

Uses of Op in net.imagej.ops.threshold.localMedian

Classes in net.imagej.ops.threshold.localMedian that implement Op
Modifier and Type	Class and Description
`class`	`LocalMedianThreshold<T extends RealType<T>>` LocalThresholdMethod using median.

Uses of Op in net.imagej.ops.threshold.localMidGrey

Classes in net.imagej.ops.threshold.localMidGrey that implement Op
Modifier and Type	Class and Description
`class`	`LocalMidGreyThreshold<T extends RealType<T>>` LocalThresholdMethod which thresholds against the average of the maximum and minimum pixels of a neighborhood.

Uses of Op in net.imagej.ops.threshold.localNiblack

Classes in net.imagej.ops.threshold.localNiblack that implement Op
Modifier and Type	Class and Description
`class`	`LocalNiblackThreshold<T extends RealType<T>>` LocalThresholdMethod using Niblack's thresholding method.
`class`	`LocalNiblackThresholdIntegral<T extends RealType<T>>` Niblack's local thresholding algorithm.

Uses of Op in net.imagej.ops.threshold.localPhansalkar

Classes in net.imagej.ops.threshold.localPhansalkar that implement Op
Modifier and Type	Class and Description
`class`	`LocalPhansalkarThreshold<T extends RealType<T>>` This is a modification of Sauvola's thresholding method to deal with low contrast images.
`class`	`LocalPhansalkarThresholdIntegral<T extends RealType<T>>` Local thresholding algorithm as proposed by Phansalkar et al.

Uses of Op in net.imagej.ops.threshold.localSauvola

Classes in net.imagej.ops.threshold.localSauvola that implement Op
Modifier and Type	Class and Description
`class`	`LocalSauvolaThreshold<T extends RealType<T>>` This is a modification of Niblack's thresholding method.
`class`	`LocalSauvolaThresholdIntegral<T extends RealType<T>>` Local thresholding algorithm as proposed by Sauvola et al.

Uses of Op in net.imagej.ops.threshold.maxEntropy

Classes in net.imagej.ops.threshold.maxEntropy that implement Op
Modifier and Type	Class and Description
`class`	`ComputeMaxEntropyThreshold<T extends RealType<T>>` Implements Kapur-Sahoo-Wong (Maximum Entropy) thresholding method.

Uses of Op in net.imagej.ops.threshold.maxLikelihood

Classes in net.imagej.ops.threshold.maxLikelihood that implement Op
Modifier and Type	Class and Description
`class`	`ComputeMaxLikelihoodThreshold<T extends RealType<T>>` Implements a maximum likelihood threshold method by Dempster, Laird, & Rubin and Glasbey.

Uses of Op in net.imagej.ops.threshold.mean

Classes in net.imagej.ops.threshold.mean that implement Op
Modifier and Type	Class and Description
`class`	`ComputeMeanThreshold<T extends RealType<T>>` Implements a mean threshold method by Glasbey.

Uses of Op in net.imagej.ops.threshold.minError

Classes in net.imagej.ops.threshold.minError that implement Op
Modifier and Type	Class and Description
`class`	`ComputeMinErrorThreshold<T extends RealType<T>>` Implements a minimum error threshold method by Kittler & Illingworth and Glasbey.

Uses of Op in net.imagej.ops.threshold.minimum

Classes in net.imagej.ops.threshold.minimum that implement Op
Modifier and Type	Class and Description
`class`	`ComputeMinimumThreshold<T extends RealType<T>>` Implements a minimum threshold method by Prewitt & Mendelsohn.

Uses of Op in net.imagej.ops.threshold.moments

Classes in net.imagej.ops.threshold.moments that implement Op
Modifier and Type	Class and Description
`class`	`ComputeMomentsThreshold<T extends RealType<T>>` Implements a moments based threshold method by Tsai.

Uses of Op in net.imagej.ops.threshold.otsu

Classes in net.imagej.ops.threshold.otsu that implement Op
Modifier and Type Class and Description

class ComputeOtsuThreshold<T extends RealType<T>>
Implements Otsu's threshold method.

Uses of Op in net.imagej.ops.threshold.percentile

Classes in net.imagej.ops.threshold.percentile that implement Op
Modifier and Type	Class and Description
`class`	`ComputePercentileThreshold<T extends RealType<T>>` Implements a percentile threshold method by Doyle.

Uses of Op in net.imagej.ops.threshold.renyiEntropy

Classes in net.imagej.ops.threshold.renyiEntropy that implement Op
Modifier and Type	Class and Description
`class`	`ComputeRenyiEntropyThreshold<T extends RealType<T>>` Implements a Renyi entropy based threshold method by Kapur, Sahoo, & Wong.

Uses of Op in net.imagej.ops.threshold.rosin

Classes in net.imagej.ops.threshold.rosin that implement Op
Modifier and Type Class and Description

class ComputeRosinThreshold<T extends RealType<T>>
Implements Rosin's threshold method.

Uses of Op in net.imagej.ops.threshold.shanbhag

Classes in net.imagej.ops.threshold.shanbhag that implement Op
Modifier and Type	Class and Description
`class`	`ComputeShanbhagThreshold<T extends RealType<T>>` Implements Shanbhag's threshold method.

Uses of Op in net.imagej.ops.threshold.triangle

Classes in net.imagej.ops.threshold.triangle that implement Op
Modifier and Type	Class and Description
`class`	`ComputeTriangleThreshold<T extends RealType<T>>` Implements a Triangle algorithm threshold method from Zack, Rogers, & Latt.

Uses of Op in net.imagej.ops.threshold.yen

Classes in net.imagej.ops.threshold.yen that implement Op
Modifier and Type	Class and Description
`class`	`ComputeYenThreshold<T extends RealType<T>>` Implements Yen's threshold method (Yen, Chang, & Chang, and Sezgin & Sankur).

Uses of Op in net.imagej.ops.topology

Classes in net.imagej.ops.topology that implement Op
Modifier and Type	Class and Description
`class`	`BoxCount<B extends BooleanType<B>>` An N-dimensional version of fixed-grid box counting algorithm that can be used to estimate the fractal dimension of an interval

Uses of Op in net.imagej.ops.topology.eulerCharacteristic

Classes in net.imagej.ops.topology.eulerCharacteristic that implement Op
Modifier and Type	Class and Description
`class`	`EulerCharacteristic26N<B extends BooleanType<B>>` An Op which calculates the euler characteristic (χ) of the given 3D binary image. Here Euler characteristic is defined as χ = β_0 - β_1 + β_2, where β_i are so called Betti numbers β_0 = number of separate particles β_1 = number of handles β_2 = number enclosed cavities
`class`	`EulerCharacteristic26NFloating<B extends BooleanType<B>>` An Op which calculates the euler characteristic (χ) of the given binary image.
`class`	`EulerCorrection<B extends BooleanType<B>>` An Op which calculates the correction needed to approximate the contribution of the image to the Euler characteristic χ of the whole image.

Uses of Op in net.imagej.ops.transform.addDimensionView

Classes in net.imagej.ops.transform.addDimensionView that implement Op
Modifier and Type	Class and Description
`class`	`AddDimensionViewMinMax<T>` Wraps the `Views.addDimension(RandomAccessibleInterval, long, long)` method.
`class`	`DefaultAddDimensionView<T>` Wraps the `Views.addDimension(RandomAccessible)` method.

Uses of Op in net.imagej.ops.transform.collapseNumericView

Classes in net.imagej.ops.transform.collapseNumericView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultCollapseNumeric2CompositeIntervalView<T extends NumericType<T>>` Wraps the `Views.collapseNumeric(RandomAccessibleInterval)` method.
`class`	`DefaultCollapseNumeric2CompositeView<T extends NumericType<T>>` Wraps the `Views.collapseNumeric(RandomAccessible, int)` method.

Uses of Op in net.imagej.ops.transform.collapseRealView

Classes in net.imagej.ops.transform.collapseRealView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultCollapseReal2CompositeIntervalView<T extends RealType<T>>` Wraps the `Views.collapseReal(RandomAccessibleInterval)` method.
`class`	`DefaultCollapseReal2CompositeView<T extends RealType<T>>` Wraps the `Views.collapseReal(RandomAccessible, int)` method.

Uses of Op in net.imagej.ops.transform.collapseView

Classes in net.imagej.ops.transform.collapseView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultCollapse2CompositeIntervalView<T>` Wraps the `Views.collapse(RandomAccessibleInterval)` method.
`class`	`DefaultCollapse2CompositeView<T>` Wraps the `Views.collapse(RandomAccessible)` method.

Uses of Op in net.imagej.ops.transform.concatenateView

Classes in net.imagej.ops.transform.concatenateView that implement Op
Modifier and Type	Class and Description
`class`	`ConcatenateViewWithAccessMode<T>` Wraps the `Views#concatenate(int, StackAccessMode, List)` method.
`class`	`DefaultConcatenateView<T>` Wraps the `Views.concatenate(int, List)` method.

Uses of Op in net.imagej.ops.transform.crop

Classes in net.imagej.ops.transform.crop that implement Op
Modifier and Type Class and Description

class CropImgPlus<T extends Type<T>>

class CropRAI<T>

Uses of Op in net.imagej.ops.transform.dropSingletonDimensionsView

Classes in net.imagej.ops.transform.dropSingletonDimensionsView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultDropSingletonDimensionsView<T>` Wraps the `Views.dropSingletonDimensions(RandomAccessibleInterval)` method.

Uses of Op in net.imagej.ops.transform.extendBorderView

Classes in net.imagej.ops.transform.extendBorderView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultExtendBorderView<T,F extends RandomAccessibleInterval<T>>` Wraps the `Views.extendBorder(RandomAccessibleInterval)` method.

Uses of Op in net.imagej.ops.transform.extendMirrorDoubleView

Classes in net.imagej.ops.transform.extendMirrorDoubleView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultExtendMirrorDoubleView<T,F extends RandomAccessibleInterval<T>>` Wraps the `Views.extendMirrorDouble(RandomAccessibleInterval)` method.

Uses of Op in net.imagej.ops.transform.extendMirrorSingleView

Classes in net.imagej.ops.transform.extendMirrorSingleView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultExtendMirrorSingleView<T,F extends RandomAccessibleInterval<T>>` Wraps the `Views.extendMirrorSingle(RandomAccessibleInterval)` method.

Uses of Op in net.imagej.ops.transform.extendPeriodicView

Classes in net.imagej.ops.transform.extendPeriodicView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultExtendPeriodicView<T,F extends RandomAccessibleInterval<T>>` Wraps the `Views.extendPeriodic(RandomAccessibleInterval)` method.

Uses of Op in net.imagej.ops.transform.extendRandomView

Classes in net.imagej.ops.transform.extendRandomView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultExtendRandomView<T extends RealType<T>,F extends RandomAccessibleInterval<T>>` Wraps the `Views.extendRandom(RandomAccessibleInterval, double, double)` method.

Uses of Op in net.imagej.ops.transform.extendValueView

Classes in net.imagej.ops.transform.extendValueView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultExtendValueView<T extends Type<T>,F extends RandomAccessibleInterval<T>>` Wraps the `Views.extendValue(RandomAccessibleInterval, Type)` method.

Uses of Op in net.imagej.ops.transform.extendView

Classes in net.imagej.ops.transform.extendView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultExtendView<T,F extends RandomAccessibleInterval<T>>` Wraps the `Views.extend(RandomAccessibleInterval, OutOfBoundsFactory)` method.

Uses of Op in net.imagej.ops.transform.extendZeroView

Classes in net.imagej.ops.transform.extendZeroView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultExtendZeroView<T extends NumericType<T>,F extends RandomAccessibleInterval<T>>` Wraps the `Views.extendZero(RandomAccessibleInterval)` method.

Uses of Op in net.imagej.ops.transform.flatIterableView

Classes in net.imagej.ops.transform.flatIterableView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultFlatIterableView<T>` Wraps the `Views.flatIterable(RandomAccessibleInterval)` method.

Uses of Op in net.imagej.ops.transform.hyperSliceView

Classes in net.imagej.ops.transform.hyperSliceView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultHyperSliceView<T>` Wraps the `Views.hyperSlice(RandomAccessible, int, long)` method.
`class`	`IntervalHyperSliceView<T>` Wraps the `Views.hyperSlice(RandomAccessibleInterval, int, long)` method.

Uses of Op in net.imagej.ops.transform.interpolateView

Classes in net.imagej.ops.transform.interpolateView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultInterpolateView<I extends EuclideanSpace,T>` Wraps the `Views.interpolate(EuclideanSpace, InterpolatorFactory)` method.

Uses of Op in net.imagej.ops.transform.intervalView

Classes in net.imagej.ops.transform.intervalView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultIntervalView<T>` Wraps the `Views.interval(RandomAccessible, Interval)` method.
`class`	`IntervalViewMinMax<T>` Wraps the `Views.interval(RandomAccessible, long[], long[])` method.

Uses of Op in net.imagej.ops.transform.invertAxisView

Classes in net.imagej.ops.transform.invertAxisView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultInvertAxisView<T>` Wraps the `Views.invertAxis(RandomAccessible, int)` method.
`class`	`IntervalInvertAxisView<T>` Wraps the `Views.invertAxis(RandomAccessible, int)` method while preserving interval bounds.

Uses of Op in net.imagej.ops.transform.offsetView

Classes in net.imagej.ops.transform.offsetView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultOffsetView<T>` Wraps the `Views.offset(RandomAccessible, long[])` method.
`class`	`OffsetViewInterval<T>` Wraps the `Views.offsetInterval(RandomAccessible, Interval)` method.
`class`	`OffsetViewOriginSize<T>` Wraps the `Views.offsetInterval(RandomAccessible, long[], long[])` method.

Uses of Op in net.imagej.ops.transform.permuteCoordinatesInverseView

Classes in net.imagej.ops.transform.permuteCoordinatesInverseView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultPermuteCoordinatesInverseView<T>` Wraps the `Views.permuteCoordinatesInverse(RandomAccessibleInterval, int[])` method.
`class`	`PermuteCoordinateInverseViewOfDimension<T>` Wraps the `Views.permuteCoordinateInverse(RandomAccessibleInterval, int[], int)` method.

Uses of Op in net.imagej.ops.transform.permuteCoordinatesView

Classes in net.imagej.ops.transform.permuteCoordinatesView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultPermuteCoordinatesView<T>` Wraps the `Views.permuteCoordinates(RandomAccessibleInterval, int[])` method.
`class`	`PermuteCoordinatesViewOfDimension<T>` Wraps the `Views.permuteCoordinates(RandomAccessibleInterval, int[], int)` method.

Uses of Op in net.imagej.ops.transform.permuteView

Classes in net.imagej.ops.transform.permuteView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultPermuteView<T>` Wraps the `Views.permute(RandomAccessible, int, int)` method.
`class`	`IntervalPermuteView<T>` Wraps the `Views.permute(RandomAccessible, int, int)` method while preserving interval bounds.

Uses of Op in net.imagej.ops.transform.project

Classes in net.imagej.ops.transform.project that implement Op
Modifier and Type	Class and Description
`class`	`DefaultProjectParallel<T,V>`
`class`	`ProjectRAIToII<T,V>`
`class`	`ProjectRAIToIterableInterval<T,V>`

Uses of Op in net.imagej.ops.transform.rasterView

Classes in net.imagej.ops.transform.rasterView that implement Op
Modifier and Type Class and Description

class DefaultRasterView<T>
Wraps the Views.raster(RealRandomAccessible) method.

Uses of Op in net.imagej.ops.transform.rotateView

Classes in net.imagej.ops.transform.rotateView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultRotateView<T>` Wraps the `Views.rotate(RandomAccessible, int, int)` method.
`class`	`IntervalRotateView<T>` Wraps the `Views.rotate(RandomAccessibleInterval, int, int)` method.

Uses of Op in net.imagej.ops.transform.scaleView

Classes in net.imagej.ops.transform.scaleView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultScaleView<T>` Scales a `RandomAccessibleInterval` in each dimension with the provided scale factors.

Uses of Op in net.imagej.ops.transform.shearView

Classes in net.imagej.ops.transform.shearView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultShearView<T>` Wraps the `Views.shear(RandomAccessible, int, int)` method.
`class`	`ShearViewInterval<T>` Wraps the `Views.shear(RandomAccessible, Interval, int, int)` method.

Uses of Op in net.imagej.ops.transform.stackView

Classes in net.imagej.ops.transform.stackView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultStackView<T>` Wraps the `Views.stack(List)` method.
`class`	`StackViewWithAccessMode<T>` Wraps the `Views#stack(StackAccessMode, List)` method.

Uses of Op in net.imagej.ops.transform.subsampleView

Classes in net.imagej.ops.transform.subsampleView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultSubsampleView<T>` Wraps the `Views.subsample(RandomAccessible, long)` method.
`class`	`IntervalSubsampleView<T>` Wraps the `Views.subsample(RandomAccessible, long)` method while preserving interval bounds.
`class`	`SubsampleIntervalViewStepsForDims<T>` Wraps the `Views.subsample(RandomAccessible, long[])` method while preserving interval bounds.
`class`	`SubsampleViewStepsForDims<T>` Wraps the `Views.subsample(RandomAccessible, long[])` method.

Uses of Op in net.imagej.ops.transform.translateView

Classes in net.imagej.ops.transform.translateView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultTranslateView<T>` Wraps the `Views.translate(RandomAccessible, long[])` method.
`class`	`IntervalTranslateView<T>` Wraps the `Views.translate(RandomAccessible, long[])` method while preserving interval bounds.

Uses of Op in net.imagej.ops.transform.unshearView

Classes in net.imagej.ops.transform.unshearView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultUnshearView<T>` Wraps the `Views.unshear(RandomAccessible, int, int)` method.
`class`	`UnshearViewInterval<T>` Wraps the `Views.unshear(RandomAccessible, Interval, int, int)` method.

Uses of Op in net.imagej.ops.transform.zeroMinView

Classes in net.imagej.ops.transform.zeroMinView that implement Op
Modifier and Type	Class and Description
`class`	`DefaultZeroMinView<T>` Wraps the `Views.zeroMin(RandomAccessibleInterval)` method.

Uses of Interfacenet.imagej.ops.Op

Uses of Op in net.imagej.ops

Uses of Op in net.imagej.ops.cached

Uses of Op in net.imagej.ops.coloc.icq

Uses of Op in net.imagej.ops.coloc.kendallTau

Uses of Op in net.imagej.ops.coloc.maxTKendallTau

Uses of Op in net.imagej.ops.coloc.pearsons

Uses of Op in net.imagej.ops.coloc.pValue

Uses of Op in net.imagej.ops.commands.project

Uses of Op in net.imagej.ops.commands.threshold

Uses of Op in net.imagej.ops.convert

Uses of Op in net.imagej.ops.convert.clip

Uses of Op in net.imagej.ops.convert.copy

Uses of Op in net.imagej.ops.convert.imageType

Uses of Op in net.imagej.ops.convert.normalizeScale

Uses of Op in net.imagej.ops.convert.scale

Uses of Op in net.imagej.ops.copy

Uses of Op in net.imagej.ops.create.img

Uses of Op in net.imagej.ops.create.imgFactory

Uses of Op in net.imagej.ops.create.imgLabeling

Uses of Op in net.imagej.ops.create.imgPlus

Uses of Op in net.imagej.ops.create.integerType

Uses of Op in net.imagej.ops.create.kernel

Uses of Op in net.imagej.ops.create.kernelBiGauss

Uses of Op in net.imagej.ops.create.kernelDiffraction

Uses of Op in net.imagej.ops.create.kernelGabor

Uses of Op in net.imagej.ops.create.kernelGauss

Uses of Op in net.imagej.ops.create.kernelLog

Uses of Op in net.imagej.ops.create.kernelSobel

Uses of Op in net.imagej.ops.create.labelingMapping

Uses of Op in net.imagej.ops.create.nativeType

Uses of Op in net.imagej.ops.create.object

Uses of Op in net.imagej.ops.deconvolve

Uses of Op in net.imagej.ops.deconvolve.accelerate

Uses of Op in net.imagej.ops.eval

Uses of Op in net.imagej.ops.features.haralick

Uses of Op in net.imagej.ops.features.haralick.helper

Uses of Op in net.imagej.ops.features.hog

Uses of Op in net.imagej.ops.features.lbp2d

Uses of Op in net.imagej.ops.features.tamura2d

Uses of Op in net.imagej.ops.features.zernike

Uses of Op in net.imagej.ops.features.zernike.helper

Uses of Op in net.imagej.ops.filter

Uses of Op in net.imagej.ops.filter.addNoise

Uses of Op in net.imagej.ops.filter.addPoissonNoise

Uses of Op in net.imagej.ops.filter.bilateral

Uses of Op in net.imagej.ops.filter.convolve

Uses of Op in net.imagej.ops.filter.correlate

Uses of Op in net.imagej.ops.filter.derivative

Uses of Op in net.imagej.ops.filter.derivativeGauss

Uses of Op in net.imagej.ops.filter.dog

Uses of Op in net.imagej.ops.filter.fft

Uses of Op in net.imagej.ops.filter.fftSize

Uses of Op in net.imagej.ops.filter.gauss

Uses of Op in net.imagej.ops.filter.hessian

Uses of Op in net.imagej.ops.filter.ifft

Uses of Op in net.imagej.ops.filter.max

Uses of Op in net.imagej.ops.filter.mean

Uses of Op in net.imagej.ops.filter.median

Uses of Op in net.imagej.ops.filter.min

Uses of Op in net.imagej.ops.filter.pad

Uses of Op in net.imagej.ops.filter.sigma

Uses of Op in net.imagej.ops.filter.sobel

Uses of Op in net.imagej.ops.filter.tubeness

Uses of Op in net.imagej.ops.filter.variance

Uses of Op in net.imagej.ops.filter.vesselness

Uses of Op in net.imagej.ops.geom

Uses of Op in net.imagej.ops.geom.geom2d

Uses of Op in net.imagej.ops.geom.geom3d

Uses of Op in net.imagej.ops.geom.geom3d.mesh

Uses of Op in net.imagej.ops.help

Uses of Op in net.imagej.ops.identity

Uses of Op in net.imagej.ops.image.ascii

Uses of Op in net.imagej.ops.image.cooccurrenceMatrix

Uses of Op in net.imagej.ops.image.distancetransform

Uses of Op in net.imagej.ops.image.equation

Uses of Op in net.imagej.ops.image.fill

Uses of Op in net.imagej.ops.image.histogram

Uses of Op in net.imagej.ops.image.integral

Uses of Op in net.imagej.ops.image.invert

Uses of Interface
net.imagej.ops.Op