| Modifier and Type | Field and Description |
|---|---|
protected Image<FloatType> |
Frangi_.VesselnessCalculator.result |
| Modifier and Type | Method and Description |
|---|---|
Image<FloatType> |
Frangi_.VesselnessCalculator.call() |
Image<FloatType> |
Frangi_.VesselnessCalculator.getResult() |
ArrayList<Image<FloatType>> |
Curvatures_.hessianEigenvalueImages(Image<T> input,
float[] spacing)
Generate an ArrayList of images, each of which contains a
particular eigenvalue of the Hessian matrix at each point
in the image.
|
| Modifier and Type | Method and Description |
|---|---|
static Image<FloatType> |
FourierConvolution.createGaussianKernel(ContainerFactory factory,
double[] sigmas) |
static Image<FloatType> |
FourierConvolution.createGaussianKernel(ContainerFactory factory,
double[] sigmas,
int precision) |
static Image<FloatType> |
FourierConvolution.createGaussianKernel(ContainerFactory factory,
double sigma,
int numDimensions) |
Image<FloatType> |
PhaseCorrelation.getPhaseCorrelationMatrix() |
| Modifier and Type | Method and Description |
|---|---|
protected ArrayList<PhaseCorrelationPeak> |
PhaseCorrelation.extractPhaseCorrelationPeaks(Image<FloatType> invPCM,
int numPeaks,
FourierTransform<?,?> fft1,
FourierTransform<?,?> fft2) |
| Modifier and Type | Method and Description |
|---|---|
Image<FloatType> |
FloydSteinbergDithering.createErrorDiffusionKernel(int numDimensions) |
| Modifier and Type | Field and Description |
|---|---|
protected ImageFactory<FloatType> |
GradientWatershed.floatFactory |
protected Image<FloatType> |
GradientWatershed.floatImage |
| Modifier and Type | Method and Description |
|---|---|
protected ImageFactory<FloatType> |
GradientWatershed.getFloatFactory() |
protected Image<FloatType> |
GradientWatershed.getFloatImage() |
Image<FloatType> |
GradientWatershed.getGradientImage()
Return a difference of gaussian image that measures the gradient
at a scale defined by the two sigmas of the gaussians.
|
| Modifier and Type | Method and Description |
|---|---|
protected boolean |
GradientWatershed.filterPeak(LocalizableByDimCursor<FloatType> imageCursor,
int[] peak,
int[] dimensions,
boolean find_minimum) |
| Modifier and Type | Method and Description |
|---|---|
Image<FloatType> |
NormalizeImageFloat.getResult() |
| Modifier and Type | Method and Description |
|---|---|
static Image<FloatType> |
ImagePlusAdapter.convertFloat(ij.ImagePlus imp) |
protected static <T extends Type<T>> |
ImagePlusAdapter.convertToFloat(Image<T> input) |
static Image<FloatType> |
ImagePlusAdapter.wrapFloat(ij.ImagePlus imp) |
| Modifier and Type | Method and Description |
|---|---|
static Image<FloatType> |
ImageJFunctions.convertFloat(ij.ImagePlus imp) |
static Image<FloatType> |
ImageJFunctions.wrapFloat(ij.ImagePlus imp) |
| Modifier and Type | Method and Description |
|---|---|
Image<FloatType> |
DCTInterpolator.getCoefficients()
A method that provides the DCT coefficients
|
| Modifier and Type | Method and Description |
|---|---|
static Image<FloatType> |
LOCI.openLOCIFloatType(String fileName,
ContainerFactory factory) |
static Image<FloatType> |
LOCI.openLOCIFloatType(String fileName,
ImageFactory<FloatType> factory) |
static Image<FloatType> |
LOCI.openLOCIFloatType(String path,
String fileName,
ContainerFactory factory) |
static Image<FloatType> |
LOCI.openLOCIFloatType(String path,
String fileName,
ContainerFactory factory,
int from,
int to) |
static Image<FloatType> |
LOCI.openLOCIFloatType(String path,
String fileName,
ImageFactory<FloatType> factory) |
static Image<FloatType> |
LOCI.openLOCIFloatType(String path,
String fileName,
ImageFactory<FloatType> factory,
int from,
int to) |
| Modifier and Type | Method and Description |
|---|---|
static Image<FloatType> |
LOCI.openLOCIFloatType(String fileName,
ImageFactory<FloatType> factory) |
static Image<FloatType> |
LOCI.openLOCIFloatType(String path,
String fileName,
ImageFactory<FloatType> factory) |
static Image<FloatType> |
LOCI.openLOCIFloatType(String path,
String fileName,
ImageFactory<FloatType> factory,
int from,
int to) |
| Modifier and Type | Method and Description |
|---|---|
FloatType |
FloatType.copy() |
FloatType[] |
FloatType.createArray1D(int size1) |
FloatType[][] |
FloatType.createArray2D(int size1,
int size2) |
FloatType[][][] |
FloatType.createArray3D(int size1,
int size2,
int size3) |
FloatType |
FloatType.createVariable() |
FloatType |
FloatType.duplicateTypeOnSameDirectAccessContainer() |
| Modifier and Type | Method and Description |
|---|---|
DirectAccessContainer<FloatType,? extends FloatAccess> |
FloatType.createSuitableDirectAccessContainer(DirectAccessContainerFactory storageFactory,
int[] dim) |
| Modifier and Type | Method and Description |
|---|---|
void |
FloatType.add(FloatType c) |
int |
FloatType.compareTo(FloatType c) |
void |
FloatType.div(FloatType c) |
void |
FloatType.mul(FloatType c) |
void |
FloatType.set(FloatType c) |
void |
FloatType.sub(FloatType c) |
| Constructor and Description |
|---|
FloatType(DirectAccessContainer<FloatType,? extends FloatAccess> floatStorage) |
| Modifier and Type | Method and Description |
|---|---|
static Image<FloatType> |
DevUtil.createImageFromArray(float[] data,
int[] dim) |
| Modifier and Type | Method and Description |
|---|---|
static Image<FloatType> |
ImgLib2.wrapArrayFloatToImgLib1(Img<FloatType> img)
|
static Image<FloatType> |
ImgLib2.wrapCellFloatToImgLib1(Img<FloatType> img)
|
static Image<FloatType> |
ImgLib2.wrapFloatToImgLib1(Img<FloatType> img)
|
| Modifier and Type | Method and Description |
|---|---|
static Img<FloatType> |
ImgLib1.wrapArrayFloatToImgLib2(Image<FloatType> image)
|
static Img<FloatType> |
ImgLib1.wrapCellFloatToImgLib2(Image<FloatType> image)
|
static Img<FloatType> |
ImgLib1.wrapFloatToImgLib2(Image<FloatType> image)
|
| Modifier and Type | Method and Description |
|---|---|
static void |
PreDeconvolutionFusionSequential.computeOverlap(Image<FloatType> overlap,
ArrayList<ViewDataBeads> views,
ViewStructure viewStructure,
int cropOffsetX,
int cropOffsetY,
int cropOffsetZ,
int scale,
Point3f min) |
abstract LocalizableByDimCursor<FloatType> |
IsolatedPixelWeightener.getResultIterator(OutOfBoundsStrategyFactory<FloatType> factory) |
LocalizableByDimCursor<FloatType> |
GaussContent.getResultIterator(OutOfBoundsStrategyFactory<FloatType> factory) |
LocalizableByDimCursor<FloatType> |
EntropyFast.getResultIterator(OutOfBoundsStrategyFactory<FloatType> factory) |
LocalizableByDimCursor<FloatType> |
AverageContent.getResultIterator(OutOfBoundsStrategyFactory<FloatType> factory) |
static void |
PreDeconvolutionFusion.subtractBackground(Image<FloatType> img,
float value) |
| Modifier and Type | Field and Description |
|---|---|
Image<FloatType> |
EntropyFloatArray3D.img |
Image<FloatType> |
Entropy.img |
| Modifier and Type | Method and Description |
|---|---|
static Image<FloatType> |
EntropyFloatArray3D.computeEntropy(Image<FloatType> image,
ContainerFactory entropyType,
int histogramBins,
int windowSizeX,
int windowSizeY,
int windowSizeZ) |
static Image<FloatType> |
Entropy.computeEntropy(Image<FloatType> img,
ContainerFactory entropyType,
int histogramBins,
int windowSizeX,
int windowSizeY,
int windowSizeZ) |
| Modifier and Type | Method and Description |
|---|---|
static Image<FloatType> |
EntropyFloatArray3D.computeEntropy(Image<FloatType> image,
ContainerFactory entropyType,
int histogramBins,
int windowSizeX,
int windowSizeY,
int windowSizeZ) |
static Image<FloatType> |
Entropy.computeEntropy(Image<FloatType> img,
ContainerFactory entropyType,
int histogramBins,
int windowSizeX,
int windowSizeY,
int windowSizeZ) |
static EntropyFloatArray3D |
EntropyFloatArray3D.initEntropy(Image<FloatType> img,
int histogramBins,
int windowSizeX,
int windowSizeY,
int windowSizeZ,
int x,
int y,
int z) |
static Entropy |
Entropy.initEntropy(Image<FloatType> img,
int histogramBins,
int windowSizeX,
int windowSizeY,
int windowSizeZ,
int x,
int y,
int z) |
| Constructor and Description |
|---|
Entropy(float stepSize,
Image<FloatType> img,
LocalizableByDimCursor<FloatType> cursor,
int histogramBins,
int windowSizeX,
int windowSizeY,
int windowSizeZ,
int x,
int y,
int z) |
Entropy(float stepSize,
Image<FloatType> img,
LocalizableByDimCursor<FloatType> cursor,
int histogramBins,
int windowSizeX,
int windowSizeY,
int windowSizeZ,
int x,
int y,
int z) |
EntropyFloatArray3D(float stepSize,
Image<FloatType> img,
LocalizableByDimCursor3D<FloatType> cIn,
LocalizableByDimCursor3D<FloatType> cOut,
int histogramBins,
int windowSizeX,
int windowSizeY,
int windowSizeZ,
int x,
int y,
int z) |
EntropyFloatArray3D(float stepSize,
Image<FloatType> img,
LocalizableByDimCursor3D<FloatType> cIn,
LocalizableByDimCursor3D<FloatType> cOut,
int histogramBins,
int windowSizeX,
int windowSizeY,
int windowSizeZ,
int x,
int y,
int z) |
EntropyFloatArray3D(float stepSize,
Image<FloatType> img,
LocalizableByDimCursor3D<FloatType> cIn,
LocalizableByDimCursor3D<FloatType> cOut,
int histogramBins,
int windowSizeX,
int windowSizeY,
int windowSizeZ,
int x,
int y,
int z) |
| Modifier and Type | Field and Description |
|---|---|
InterpolatorFactory<FloatType> |
SPIMConfiguration.interpolatorFactorOutput |
OutOfBoundsStrategyFactory<FloatType> |
SPIMConfiguration.strategyFactoryGauss |
OutOfBoundsStrategyFactory<FloatType> |
SPIMConfiguration.strategyFactoryOutput |
| Modifier and Type | Method and Description |
|---|---|
protected static Image<FloatType> |
ExtractPSF.extractPSF(ViewDataBeads view,
int[] size)
Extracts the PSF by averaging the local neighborhood RANSAC correspondences
|
Image<FloatType> |
ExtractPSF.getAverageOriginalPSF() |
Image<FloatType> |
ExtractPSF.getAveragePSF() |
FourierConvolution<FloatType,FloatType> |
LucyRichardsonFFT.getFFTConvolution() |
FourierConvolution<FloatType,FloatType> |
LucyRichardsonFFT.getFFTConvolution() |
Image<FloatType> |
LucyRichardsonFFT.getImage() |
Image<FloatType> |
LucyRichardsonFFT.getKernel() |
Image<FloatType> |
ExtractPSF.getMaxProjectionAveragePSF()
Get projection along the smallest dimension (which is usually the rotation axis)
|
ArrayList<Image<FloatType>> |
ExtractPSF.getPSFs() |
ArrayList<Image<FloatType>> |
ExtractPSF.getPSFsInInputCalibration() |
Image<FloatType> |
LucyRichardsonFFT.getViewContribution() |
Image<FloatType> |
LucyRichardsonFFT.getWeight() |
static Image<FloatType> |
LucyRichardsonMultiViewDeconvolution.lucyRichardsonMultiView(ArrayList<LucyRichardsonFFT> data,
int minIterations,
int maxIterations,
boolean multiplicative,
double lambda,
int numThreads) |
static Image<FloatType> |
ExtractPSF.makeSameSize(Image<FloatType> img,
int[] sizeIn)
Make image the same size as defined, center it
|
protected static Image<FloatType> |
ExtractPSF.transformPSF(Image<FloatType> psf,
AbstractAffineModel3D<?> model)
Transforms the extracted PSF using the affine transformation of the corresponding view
|
| Modifier and Type | Method and Description |
|---|---|
static Image<FloatType> |
ExtractPSF.makeSameSize(Image<FloatType> img,
int[] sizeIn)
Make image the same size as defined, center it
|
void |
LucyRichardsonFFT.setViewContribution(Image<FloatType> viewContribution) |
protected static Image<FloatType> |
ExtractPSF.transformPSF(Image<FloatType> psf,
AbstractAffineModel3D<?> model)
Transforms the extracted PSF using the affine transformation of the corresponding view
|
| Constructor and Description |
|---|
LucyRichardsonFFT(Image<FloatType> image,
Image<FloatType> weight,
Image<FloatType> kernel,
int cpusPerView) |
LucyRichardsonFFT(Image<FloatType> image,
Image<FloatType> weight,
Image<FloatType> kernel,
int cpusPerView) |
LucyRichardsonFFT(Image<FloatType> image,
Image<FloatType> weight,
Image<FloatType> kernel,
int cpusPerView) |
| Modifier and Type | Method and Description |
|---|---|
static Image<FloatType> |
LRFFT.computeExponentialKernel(Image<FloatType> kernel,
int numViews) |
static Image<FloatType> |
LRFFT.computeInvertedKernel(Image<FloatType> kernel) |
Image<FloatType> |
LRFFT.convolve1(Image<FloatType> image)
convolves the image with kernel1
|
Image<FloatType> |
LRFFT.convolve2(Image<FloatType> image)
convolves the image with kernel2 (inverted kernel1)
|
static Image<FloatType> |
LRFFT.createImageFromArray(float[] data,
int[] dim) |
Image<FloatType> |
LRFFT.getImage() |
Image<FloatType> |
LRFFT.getKernel1() |
Image<FloatType> |
LRFFT.getKernel2() |
Image<FloatType> |
Deconvolver.getPsi() |
Image<FloatType> |
BayesMVDeconvolution.getPsi() |
Image<FloatType> |
LRFFT.getWeight() |
protected static Image<FloatType> |
BayesMVDeconvolution.loadInitialImage(String fileName,
boolean checkNumbers,
float minValue,
int[] dimensions,
ImageFactory<FloatType> imageFactory) |
static Image<FloatType> |
LRFFT.wrap(Img<FloatType> i) |
| Modifier and Type | Method and Description |
|---|---|
static double |
AdjustInput.addGaussianNoise(Image<FloatType> img,
Random rnd,
float sigma,
boolean onlyPositive)
Adds additive gaussian noise: i = i + gauss(x, sigma)
|
static double |
AdjustInput.addGaussianNoiseAddMul(Image<FloatType> img,
Random rnd,
float sigma,
boolean onlyPositive)
Adds additive and multiplicative gaussian noise: i = i*gauss(x,sigma) + gauss(x, sigma)
|
static void |
AdjustInput.adjustImage(Image<FloatType> image,
float minValue,
float targetAverage)
Adjusts an image so that the minimal intensity is minValue and the average is average
|
static Image<FloatType> |
LRFFT.computeExponentialKernel(Image<FloatType> kernel,
int numViews) |
static Image<FloatType> |
LRFFT.computeInvertedKernel(Image<FloatType> kernel) |
Image<FloatType> |
LRFFT.convolve1(Image<FloatType> image)
convolves the image with kernel1
|
protected static void |
LRFFTThreads.convolve1BlockCPU(Block blockStruct,
int i,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
FourierConvolution<FloatType,FloatType> fftConvolution1) |
protected static void |
LRFFTThreads.convolve1BlockCPU(Block blockStruct,
int i,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
FourierConvolution<FloatType,FloatType> fftConvolution1) |
protected static void |
LRFFTThreads.convolve1BlockCPU(Block blockStruct,
int i,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
FourierConvolution<FloatType,FloatType> fftConvolution1) |
protected static void |
LRFFTThreads.convolve1BlockCPU(Block blockStruct,
int i,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
FourierConvolution<FloatType,FloatType> fftConvolution1) |
protected static void |
LRFFTThreads.convolve1BlockCPU(Block blockStruct,
int i,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
FourierConvolution<FloatType,FloatType> fftConvolution1) |
protected static void |
LRFFTThreads.convolve1BlockCUDA(Block blockStruct,
int i,
int deviceId,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
Image<FloatType> kernel1,
int[] blockSize) |
protected static void |
LRFFTThreads.convolve1BlockCUDA(Block blockStruct,
int i,
int deviceId,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
Image<FloatType> kernel1,
int[] blockSize) |
protected static void |
LRFFTThreads.convolve1BlockCUDA(Block blockStruct,
int i,
int deviceId,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
Image<FloatType> kernel1,
int[] blockSize) |
protected static void |
LRFFTThreads.convolve1BlockCUDA(Block blockStruct,
int i,
int deviceId,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
Image<FloatType> kernel1,
int[] blockSize) |
Image<FloatType> |
LRFFT.convolve2(Image<FloatType> image)
convolves the image with kernel2 (inverted kernel1)
|
protected static void |
LRFFTThreads.convolve2BlockCPU(Block blockStruct,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
FourierConvolution<FloatType,FloatType> fftConvolution2) |
protected static void |
LRFFTThreads.convolve2BlockCPU(Block blockStruct,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
FourierConvolution<FloatType,FloatType> fftConvolution2) |
protected static void |
LRFFTThreads.convolve2BlockCPU(Block blockStruct,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
FourierConvolution<FloatType,FloatType> fftConvolution2) |
protected static void |
LRFFTThreads.convolve2BlockCPU(Block blockStruct,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
FourierConvolution<FloatType,FloatType> fftConvolution2) |
protected static void |
LRFFTThreads.convolve2BlockCPU(Block blockStruct,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
FourierConvolution<FloatType,FloatType> fftConvolution2) |
protected static void |
LRFFTThreads.convolve2BlockCUDA(Block blockStruct,
int deviceId,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
Image<FloatType> kernel2,
int[] blockSize) |
protected static void |
LRFFTThreads.convolve2BlockCUDA(Block blockStruct,
int deviceId,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
Image<FloatType> kernel2,
int[] blockSize) |
protected static void |
LRFFTThreads.convolve2BlockCUDA(Block blockStruct,
int deviceId,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
Image<FloatType> kernel2,
int[] blockSize) |
protected static void |
LRFFTThreads.convolve2BlockCUDA(Block blockStruct,
int deviceId,
Image<FloatType> image,
Image<FloatType> result,
Image<FloatType> block,
Image<FloatType> kernel2,
int[] blockSize) |
void |
Block.copyBlock(Image<FloatType> source,
Image<FloatType> block) |
void |
Block.copyBlock(Image<FloatType> source,
Image<FloatType> block) |
protected static Thread |
LRFFTThreads.getCPUThread1(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
FourierConvolution<FloatType,FloatType> fftConvolution1) |
protected static Thread |
LRFFTThreads.getCPUThread1(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
FourierConvolution<FloatType,FloatType> fftConvolution1) |
protected static Thread |
LRFFTThreads.getCPUThread1(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
FourierConvolution<FloatType,FloatType> fftConvolution1) |
protected static Thread |
LRFFTThreads.getCPUThread1(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
FourierConvolution<FloatType,FloatType> fftConvolution1) |
protected static Thread |
LRFFTThreads.getCPUThread1(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
FourierConvolution<FloatType,FloatType> fftConvolution1) |
protected static Thread |
LRFFTThreads.getCPUThread2(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
FourierConvolution<FloatType,FloatType> fftConvolution2) |
protected static Thread |
LRFFTThreads.getCPUThread2(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
FourierConvolution<FloatType,FloatType> fftConvolution2) |
protected static Thread |
LRFFTThreads.getCPUThread2(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
FourierConvolution<FloatType,FloatType> fftConvolution2) |
protected static Thread |
LRFFTThreads.getCPUThread2(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
FourierConvolution<FloatType,FloatType> fftConvolution2) |
protected static Thread |
LRFFTThreads.getCPUThread2(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
FourierConvolution<FloatType,FloatType> fftConvolution2) |
protected static Thread |
LRFFTThreads.getCUDAThread1(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
int deviceId,
Image<FloatType> kernel1) |
protected static Thread |
LRFFTThreads.getCUDAThread1(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
int deviceId,
Image<FloatType> kernel1) |
protected static Thread |
LRFFTThreads.getCUDAThread1(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
int deviceId,
Image<FloatType> kernel1) |
protected static Thread |
LRFFTThreads.getCUDAThread1(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
int deviceId,
Image<FloatType> kernel1) |
protected static Thread |
LRFFTThreads.getCUDAThread2(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
int deviceId,
Image<FloatType> kernel2) |
protected static Thread |
LRFFTThreads.getCUDAThread2(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
int deviceId,
Image<FloatType> kernel2) |
protected static Thread |
LRFFTThreads.getCUDAThread2(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
int deviceId,
Image<FloatType> kernel2) |
protected static Thread |
LRFFTThreads.getCUDAThread2(AtomicInteger ai,
Block[] blocks,
int[] blockSize,
ImageFactory<FloatType> factory,
Image<FloatType> image,
Image<FloatType> result,
int deviceId,
Image<FloatType> kernel2) |
protected static Image<FloatType> |
BayesMVDeconvolution.loadInitialImage(String fileName,
boolean checkNumbers,
float minValue,
int[] dimensions,
ImageFactory<FloatType> imageFactory) |
static void |
AdjustInput.normImage(Image<FloatType> img)
Norms an image so that the sum over all pixels is 1.
|
void |
Block.pasteBlock(Image<FloatType> target,
Image<FloatType> block) |
void |
Block.pasteBlock(Image<FloatType> target,
Image<FloatType> block) |
void |
LRFFT.setImage(Image<FloatType> image) |
void |
LRFFT.setKernel(Image<FloatType> kernel) |
void |
LRFFT.setWeight(Image<FloatType> weight) |
static double |
AdjustInput.sumImage(Image<FloatType> img) |
static void |
AdjustInput.translate(Image<FloatType> img,
float[] vector) |
static Img<FloatType> |
LRFFT.wrap(Image<FloatType> i) |
| Constructor and Description |
|---|
LRFFT(Image<FloatType> image,
Image<FloatType> weight,
Image<FloatType> kernel,
int[] deviceList,
boolean useBlocks,
int[] blockSize) |
LRFFT(Image<FloatType> image,
Image<FloatType> weight,
Image<FloatType> kernel,
int[] deviceList,
boolean useBlocks,
int[] blockSize) |
LRFFT(Image<FloatType> image,
Image<FloatType> weight,
Image<FloatType> kernel,
int[] deviceList,
boolean useBlocks,
int[] blockSize) |
LRFFT(Image<FloatType> image,
Image<FloatType> kernel,
int[] deviceList,
boolean useBlocks,
int[] blockSize) |
LRFFT(Image<FloatType> image,
Image<FloatType> kernel,
int[] deviceList,
boolean useBlocks,
int[] blockSize) |
| Modifier and Type | Field and Description |
|---|---|
protected Image<FloatType> |
ViewDataBeads.downSampledImage
The currently downsampled image cached
|
| Modifier and Type | Method and Description |
|---|---|
Image<FloatType> |
ViewDataBeads.getDownSampledImage(int downSamplingFactor)
Gets a downsampled and normalized [0...1] version of the input image
|
Image<FloatType> |
ViewDataBeads.getDownSampledImage(int downSamplingFactor,
boolean normalize)
Gets a downsampled version of the input image
|
Image<FloatType> |
ViewDataBeads.getImage()
The link to the input image of this view, normalized to [0...1]
|
Image<FloatType> |
ViewDataBeads.getImage(boolean normalize)
The link to the input image of this view
|
Image<FloatType> |
ViewDataBeads.getImage(ContainerFactory imageFactory)
The link to the input image of this view normalized to [0...1]
|
Image<FloatType> |
ViewDataBeads.getImage(ContainerFactory imageFactory,
boolean normalize)
The link to the input image of this view
|
| Modifier and Type | Method and Description |
|---|---|
static float[] |
ViewDataBeads.normalizeImage(Image<FloatType> image)
Normalizes the image to the range [0...1]
|
static float[] |
ViewDataBeads.normalizeImage(Image<FloatType> image,
float[] minmax)
Normalizes the image to the range [0...1]
|
| Modifier and Type | Method and Description |
|---|---|
Image<FloatType> |
BeadSegmentation.getFoundBeads(ViewDataBeads view) |
| Modifier and Type | Method and Description |
|---|---|
static void |
BeadSegmentation.gaussFit(Image<FloatType> image,
ArrayList<Bead> beadList,
double[] typicalSigma) |
| Modifier and Type | Method and Description |
|---|---|
static void |
LaPlaceFunctions.analyzeMaximum(LocalizableByDimCursor3D<FloatType> cursor,
float minPeakValue,
int width,
int height,
int depth,
float sigma,
float identityRadius,
float maximaTolerance,
RejectStatistics rs,
ArrayList<DoGMaximum> localMaxima) |
static double[] |
LaPlaceFunctions.computeDerivativeVector3(LocalizableByDimCursor<FloatType> cursor) |
static double[] |
LaPlaceFunctions.computeHessianMatrix3x3(LocalizableByDimCursor<FloatType> cursor) |
static boolean |
LaPlaceFunctions.isSpecialPointMin(LocalizableByDimCursor3D<FloatType> cursor,
float minInitialPeakValue) |
static void |
LaPlaceFunctions.subtractImagesInPlace(Image<FloatType> img1,
Image<FloatType> img2,
float norm) |
static void |
LaPlaceFunctions.subtractImagesInPlace(Image<FloatType> img1,
Image<FloatType> img2,
float norm) |
| Modifier and Type | Method and Description |
|---|---|
ArrayList<ComponentProperties> |
ConnectedComponent.getBeads(Image<IntType> connectedComponents,
Image<FloatType> img,
int minSize,
int maxSize,
int minBlackBorder,
boolean useCenterOfMass,
double circularityFactor) |
| Modifier and Type | Method and Description |
|---|---|
static Image<FloatType> |
DOM.computeContentBasedGauss(Image<FloatType> img,
int fusionSigma1,
int fusionSigma2,
float zStretching) |
static Image<FloatType> |
DOM.computeContentBasedWeighting(Image<FloatType> img,
int fusionSigma1,
int fusionSigma2,
float zStretching) |
static Image<FloatType> |
InteractiveIntegral.convertToFloat(ij.ImagePlus imp,
int channel,
int timepoint)
Normalize and make a copy of the
ImagePlus into an Image>FloatType< for faster access when copying the slices |
protected Image<FloatType> |
InteractiveDoG.extractImage(FloatImagePlus<FloatType> source,
Rectangle rectangle,
int extraSize)
Extract the current 2d region of interest from the souce image
|
Image<FloatType> |
InteractiveIntegral.getConvertedImage() |
| Modifier and Type | Method and Description |
|---|---|
static void |
DOM.computeMinMax(Image<FloatType> img,
FloatType min,
FloatType max) |
| Modifier and Type | Method and Description |
|---|---|
static Image<LongType> |
IntegralImage3d.compute(Image<FloatType> img) |
static Image<FloatType> |
DOM.computeContentBasedGauss(Image<FloatType> img,
int fusionSigma1,
int fusionSigma2,
float zStretching) |
static Image<FloatType> |
DOM.computeContentBasedWeighting(Image<FloatType> img,
int fusionSigma1,
int fusionSigma2,
float zStretching) |
static void |
DOM.computeDifferencOfMean(Image<LongType> integralImg,
Image<FloatType> domImg,
int sx1,
int sy1,
int sz1,
int sx2,
int sy2,
int sz2,
float min,
float max) |
static void |
DOM.computeDifferencOfMean3d(Image<LongType> integralImg,
Image<FloatType> domImg,
int sx1,
int sy1,
int sz1,
int sx2,
int sy2,
int sz2,
float min,
float max) |
static void |
InteractiveIntegral.computeDifferencOfMeanSlice(Image<LongType> integralImg,
Image<FloatType> sliceImg,
int z,
int sx1,
int sy1,
int sz1,
int sx2,
int sy2,
int sz2,
float min,
float max) |
Image<LongType> |
InteractiveIntegral.computeIntegralImage(Image<FloatType> img) |
static void |
IntegralImage3d.computeIntegralImage(Image<LongType> integralTmp,
Image<FloatType> img) |
static void |
DOM.computeMinMax(Image<FloatType> img,
FloatType min,
FloatType max) |
static ArrayList<SimplePeak> |
InteractiveIntegral.findPeaks(Image<FloatType> laPlace,
float minValue) |
protected static DifferenceOfGaussian.SpecialPoint |
InteractiveIntegral.isSpecialPoint(LocalNeighborhoodCursor<FloatType> neighborhoodCursor,
float centerValue) |
static void |
DOM.mean(Image<LongType> integralImg,
Image<FloatType> domImg,
int sx,
int sy,
int sz) |
static void |
DOM.meanMirror(Image<LongType> integralImg,
Image<FloatType> domImg,
int sx,
int sy,
int sz) |
| Modifier and Type | Method and Description |
|---|---|
static Image<FloatType> |
PairWiseStitchingImgLib.getWrappedImageFloat(ij.ImagePlus imp,
int channel,
int timepoint)
|
| Modifier and Type | Field and Description |
|---|---|
protected DifferenceOfGaussianPeak<FloatType> |
Particle.peak |
| Modifier and Type | Method and Description |
|---|---|
protected static ArrayList<DifferenceOfGaussianPeak<FloatType>> |
Matching.computeDoG(Image<FloatType> image,
float sigma1,
float sigma2,
boolean lookForMaxima,
boolean lookForMinima,
float threshold,
int localization,
int iterations,
double[] sigmaGuess,
int[] region) |
static Image<FloatType> |
Matching.convertToFloat(ij.ImagePlus imp,
int channel,
int timepoint,
float[] minmax)
Normalize and make a copy of the
ImagePlus into an Image of FloatType for faster access when copying the slices |
static ArrayList<DifferenceOfGaussianPeak<FloatType>> |
DetectionSegmentation.extractBeadsLaPlaceImgLib(Image<FloatType> img,
OutOfBoundsStrategyFactory<FloatType> oobsFactory,
float imageSigma,
float sigma1,
float sigma2,
float minPeakValue,
float minInitialPeakValue,
boolean findMax,
boolean findMin,
int localization,
int iterations,
double[] sigma,
int[] region,
int debugLevel) |
static ArrayList<DifferenceOfGaussianPeak<FloatType>> |
Matching.extractCandidates(ij.ImagePlus imp,
int channel,
int timepoint,
DescriptorParameters params,
float[] minmax) |
protected static ArrayList<DifferenceOfGaussianPeak<FloatType>> |
Matching.filterForROI(Roi roi,
ArrayList<DifferenceOfGaussianPeak<FloatType>> peaks) |
protected static ArrayList<DifferenceOfGaussianPeak<FloatType>> |
Matching.filterForROI(Roi roi,
ArrayList<DifferenceOfGaussianPeak<FloatType>> peaks,
Model<?> model) |
DifferenceOfGaussianPeak<FloatType> |
Particle.getPeak() |
| Modifier and Type | Method and Description |
|---|---|
protected static ArrayList<DifferenceOfGaussianPeak<FloatType>> |
Matching.computeDoG(Image<FloatType> image,
float sigma1,
float sigma2,
boolean lookForMaxima,
boolean lookForMinima,
float threshold,
int localization,
int iterations,
double[] sigmaGuess,
int[] region) |
static <T extends RealType<T>> |
OverlayFusion.createOverlay(T targetType,
ArrayList<ij.ImagePlus> images,
ArrayList<InvertibleBoundable> models,
int dimensionality,
int timepoint,
InterpolatorFactory<FloatType> factory) |
static Vector<ComparePair> |
Matching.descriptorMatching(ArrayList<ArrayList<DifferenceOfGaussianPeak<FloatType>>> peaks,
int numImages,
DescriptorParameters params,
float zStretching) |
static ArrayList<DifferenceOfGaussianPeak<FloatType>> |
DetectionSegmentation.extractBeadsLaPlaceImgLib(Image<FloatType> img,
OutOfBoundsStrategyFactory<FloatType> oobsFactory,
float imageSigma,
float sigma1,
float sigma2,
float minPeakValue,
float minInitialPeakValue,
boolean findMax,
boolean findMin,
int localization,
int iterations,
double[] sigma,
int[] region,
int debugLevel) |
static ArrayList<DifferenceOfGaussianPeak<FloatType>> |
DetectionSegmentation.extractBeadsLaPlaceImgLib(Image<FloatType> img,
OutOfBoundsStrategyFactory<FloatType> oobsFactory,
float imageSigma,
float sigma1,
float sigma2,
float minPeakValue,
float minInitialPeakValue,
boolean findMax,
boolean findMin,
int localization,
int iterations,
double[] sigma,
int[] region,
int debugLevel) |
protected static ArrayList<DifferenceOfGaussianPeak<FloatType>> |
Matching.filterForROI(Roi roi,
ArrayList<DifferenceOfGaussianPeak<FloatType>> peaks) |
protected static ArrayList<DifferenceOfGaussianPeak<FloatType>> |
Matching.filterForROI(Roi roi,
ArrayList<DifferenceOfGaussianPeak<FloatType>> peaks,
Model<?> model) |
static <T extends RealType<T>> |
OverlayFusion.fuseChannel(Image<T> output,
Image<FloatType> input,
float[] offset,
InvertibleCoordinateTransform transform,
InterpolatorFactory<FloatType> factory)
Fuse one slice/volume (one channel)
|
static <T extends RealType<T>> |
OverlayFusion.fuseChannel(Image<T> output,
Image<FloatType> input,
float[] offset,
InvertibleCoordinateTransform transform,
InterpolatorFactory<FloatType> factory)
Fuse one slice/volume (one channel)
|
protected static ArrayList<PointMatch> |
Matching.getCorrespondenceCandidates(double nTimesBetter,
Matcher matcher,
ArrayList<DifferenceOfGaussianPeak<FloatType>> peaks1,
ArrayList<DifferenceOfGaussianPeak<FloatType>> peaks2,
Model<?> model,
int dimensionality,
float zStretching1,
float zStretching2,
String explanation) |
protected static ArrayList<PointMatch> |
Matching.getCorrespondenceCandidates(double nTimesBetter,
Matcher matcher,
ArrayList<DifferenceOfGaussianPeak<FloatType>> peaks1,
ArrayList<DifferenceOfGaussianPeak<FloatType>> peaks2,
Model<?> model,
int dimensionality,
float zStretching1,
float zStretching2,
String explanation) |
protected static Model<?> |
Matching.pairwiseMatching(ArrayList<PointMatch> finalInliers,
ArrayList<DifferenceOfGaussianPeak<FloatType>> peaks1,
ArrayList<DifferenceOfGaussianPeak<FloatType>> peaks2,
float zStretching1,
float zStretching2,
DescriptorParameters params,
String explanation) |
protected static Model<?> |
Matching.pairwiseMatching(ArrayList<PointMatch> finalInliers,
ArrayList<DifferenceOfGaussianPeak<FloatType>> peaks1,
ArrayList<DifferenceOfGaussianPeak<FloatType>> peaks2,
float zStretching1,
float zStretching2,
DescriptorParameters params,
String explanation) |
protected static int |
Matching.performIteration(ArrayList<InvertibleBoundable> lastModels,
ArrayList<ArrayList<DifferenceOfGaussianPeak<FloatType>>> peaksComplete,
int numImages,
DescriptorParameters params,
float zStretching)
Computes one iteration and updates the lastModels ArrayList with the new models
|
protected static int[] |
Matching.removeInvalidAndCollectStatistics(ArrayList<DifferenceOfGaussianPeak<FloatType>> peaks) |
| Constructor and Description |
|---|
Particle(int id,
DifferenceOfGaussianPeak<FloatType> peak,
float zStretching) |
PeakSort(DifferenceOfGaussianPeak<FloatType> peak) |
| Modifier and Type | Method and Description |
|---|---|
List<DifferenceOfGaussianPeak<FloatType>> |
DoGPeaks.getPeaks()
Get all peaks as
DifferenceOfGaussianPeak instances. |
| Modifier and Type | Method and Description |
|---|---|
static Image<FloatType> |
Compute.inFloats(IFunction op)
|
static Image<FloatType> |
Compute.inFloats(Image<? extends RealType<?>> img)
|
static Image<FloatType> |
Compute.inFloats(int numThreads,
IFunction op)
|
| Modifier and Type | Method and Description |
|---|---|
Image<FloatType> |
FloatImageOperation.asImage()
Evaluate this operation as an
Image<FloatType>. |
Image<FloatType> |
FloatImageOperation.asImage(int numThreads)
Evaluate this operation as an
Image<FloatType>
using the defined number of parallel threads. |
| Modifier and Type | Method and Description |
|---|---|
ArrayList<DifferenceOfGaussianPeak<FloatType>> |
DifferenceOfGaussianNewPeakFinder.findPeaks(Image<FloatType> laPlace) |
protected OutputAlgorithm<FloatType> |
DifferenceOfGaussianCUDA.getGaussianConvolution(double[] sigma,
int numThreads) |
Image<FloatType> |
DifferenceOfGaussianCUDA.CUDAOutput.getResult() |
| Modifier and Type | Method and Description |
|---|---|
static ArrayList<InterestPoint> |
ProcessDOG.compute(CUDASeparableConvolution cuda,
List<CUDADevice> deviceList,
boolean accurateCUDA,
double percentGPUMem,
Image<FloatType> img,
Img<FloatType> imglib2img,
float sigma,
float threshold,
int localization,
double imageSigmaX,
double imageSigmaY,
double imageSigmaZ,
boolean findMin,
boolean findMax,
double minIntensity,
double maxIntensity,
boolean keepIntensity) |
static ArrayList<InterestPoint> |
ProcessDOM.compute(Image<FloatType> img,
Img<FloatType> imglib2img,
int radius1,
int radius2,
float threshold,
int localization,
double imageSigmaX,
double imageSigmaY,
double imageSigmaZ,
boolean findMin,
boolean findMax,
double minIntensity,
double maxIntensity,
boolean keepIntensity) |
static ArrayList<InterestPoint> |
Localization.computeGaussLocalization(ArrayList<SimplePeak> peaks,
Image<FloatType> domImg,
double sigma,
boolean findMin,
boolean findMax,
float threshold,
boolean keepIntensity) |
static ArrayList<InterestPoint> |
Localization.computeQuadraticLocalization(ArrayList<SimplePeak> peaks,
Image<FloatType> domImg,
boolean findMin,
boolean findMax,
float threshold,
boolean keepIntensity) |
ArrayList<DifferenceOfGaussianPeak<FloatType>> |
DifferenceOfGaussianNewPeakFinder.findPeaks(Image<FloatType> laPlace) |
| Constructor and Description |
|---|
DifferenceOfGaussianCUDA(CUDASeparableConvolution cuda,
double percentGPUMem,
List<CUDADevice> devList,
Image<FloatType> img1,
Img<FloatType> img2,
boolean accurate,
double[] sigma1,
double[] sigma2,
double minPeakValue,
double normalizationFactor) |
DifferenceOfGaussianNewPeakFinder(Image<FloatType> img,
OutOfBoundsStrategyFactory<FloatType> outOfBoundsFactory,
double[] sigma1,
double[] sigma2,
double minPeakValue,
double normalizationFactor) |
DifferenceOfGaussianNewPeakFinder(Image<FloatType> img,
OutOfBoundsStrategyFactory<FloatType> outOfBoundsFactory,
double[] sigma1,
double[] sigma2,
double minPeakValue,
double normalizationFactor) |
Copyright © 2015–2021 Fiji. All rights reserved.