Uses of Class
edu.stanford.rsl.konrad.volume3d.Volume3D

Packages that use Volume3D
edu.stanford.rsl.konrad.cuda Contains classes for hardware-accelerated projection and volume handling using CUDA. 
edu.stanford.rsl.konrad.filtering.multiprojection.anisotropic Contains classes for anisotropic filtering of image data. 
edu.stanford.rsl.konrad.volume3d Contains classes to model 3D volumes. 
edu.stanford.rsl.konrad.volume3d.operations Contains classes for parallel processing of volumes. 
 

Uses of Volume3D in edu.stanford.rsl.konrad.cuda
 

Subclasses of Volume3D in edu.stanford.rsl.konrad.cuda
 class CUDAVolume3D
          CUDAVolume3D models a Volume3D in the CUDA memory.
 

Methods in edu.stanford.rsl.konrad.cuda that return Volume3D
 Volume3D CUDAVolumeOperator.createDirectionalWeights(int dimensions, int[] size, float[] dim, float[] dir, int A, VolumeOperator.FILTER_TYPE t_filt)
           
 Volume3D CUDAVolumeOperator.createExponentialDirectionalHighPassFilter(int dimensions, int[] size, float[] dim, float[] dir, int A, float B, float ri, VolumeOperator.FILTER_TYPE t_filt)
           
 Volume3D CUDAVolumeOperator.createGaussLowPassFilter(int dimensions, int[] size, float[] dim, float alpha)
           
 Volume3D CUDAVolumeOperator.createHighPassFilter(int dimensions, int[] size, float[] dim, int filt_loop, float lp_upper)
           
 Volume3D CUDAVolumeOperator.createLowPassFilter(int dimensions, int[] size, float[] dim, float lp_upper)
           
 Volume3D CUDAVolumeTest.createRandomVolume()
           
 Volume3D CUDAVolumeOperator.createVolume(ij.ImagePlus image, int mirror, int cuty, boolean uneven)
           
 Volume3D CUDAVolumeOperator.createVolume(int[] size, float[] dim, int in_dim)
           
 Volume3D CUDAVolumeOperator.solveMaximumEigenvalue(Volume3D[][] structureTensor)
           
 

Methods in edu.stanford.rsl.konrad.cuda with parameters of type Volume3D
 int CUDAVolumeOperator.abs(Volume3D vol)
           
 int CUDAVolumeOperator.addScalar(Volume3D vol, float realPart, float imagPart)
           
 int CUDAVolumeOperator.addVolume(Volume3D vol1, Volume3D vol2)
           
 int CUDAVolumeOperator.addVolume(Volume3D vol1, Volume3D vol2, double weight)
           
static jcuda.driver.CUdeviceptr CUDAUtil.allocateSpace(Volume3D vol)
          Allocates space on the CUDA device for a Volume3D
 CUDAVolume3D CUDAVolumeTest.createCUDACopy(Volume3D vol)
           
 int CUDAVolumeOperator.divideByVolume(Volume3D vol1, Volume3D vol2)
           
static void CUDAUtil.fetchFromDevice(Volume3D vol, jcuda.driver.CUdeviceptr deviceX)
          Fetches the volume from the device
 int CUDAVolumeOperator.fftShift(Volume3D vol)
           
 void CUDAVolumeOperator.fill(Volume3D vol, float number)
           
 void CUDAFFTVolumeHandle.forwardTransform(Volume3D vol)
           
 int CUDAVolumeOperator.imag(Volume3D vol)
           
 void CUDAFFTVolumeHandle.inverseTransform(Volume3D vol)
           
 void CUDAVolumeOperator.makeComplex(Volume3D vol)
           
 float CUDAVolumeOperator.max(Volume3D vol)
           
 float CUDAVolumeOperator.mean(Volume3D vol)
           
 float CUDAVolumeOperator.min(Volume3D vol)
           
 int CUDAVolumeOperator.minOfTwoVolumes(Volume3D vol1, Volume3D vol2)
           
static void CUDAUtil.moveToDevice(Volume3D vol, jcuda.driver.CUdeviceptr deviceX)
          Moves the volume to the device.
 int CUDAVolumeOperator.multiply(Volume3D vol1, Volume3D vol2)
           
 int CUDAVolumeOperator.multiplyScalar(Volume3D vol, float realPart, float imagPart)
           
 int CUDAVolumeOperator.real(Volume3D vol)
           
 int CUDAVolumeOperator.sigmoid(Volume3D vol, float smoothing, float lowValue, float highValue, float highPassLowerLevel, float highPassUpperLevel)
           
 Volume3D CUDAVolumeOperator.solveMaximumEigenvalue(Volume3D[][] structureTensor)
           
 int CUDAVolumeOperator.sqrt(Volume3D vol)
           
 int CUDAVolumeOperator.upperLimit(Volume3D vol, float max)
           
 

Uses of Volume3D in edu.stanford.rsl.konrad.filtering.multiprojection.anisotropic
 

Methods in edu.stanford.rsl.konrad.filtering.multiprojection.anisotropic that return Volume3D
 Volume3D[] AnisotropicFilterFunction.computeAnisotropicFilteredVolume(Volume3D volume, float low, float high, float hp_lower_level, float hp_upper_level, float smth, int A, float B, float ri, float a, float lpUpper)
           
 Volume3D[][] AnisotropicFilterFunction.computeStructureTensor(Volume3D vol, int A, float B, float ri)
           
 Volume3D AnisotropicFilterFunction.filt_normalize_tensors(Volume3D[][] structureTensor, int eig)
          Normalizes the tensors and computes the tensor nor.
 Volume3D[] AnisotropicFilterFunction.filt_pre_enhance(Volume3D volume, int A, float B, float ri, float a, float lpUpper)
          Computes an array of filtered images.
 

Methods in edu.stanford.rsl.konrad.filtering.multiprojection.anisotropic with parameters of type Volume3D
 Volume3D[] AnisotropicFilterFunction.computeAnisotropicFilteredVolume(Volume3D volume, float low, float high, float hp_lower_level, float hp_upper_level, float smth, int A, float B, float ri, float a, float lpUpper)
           
 Volume3D[][] AnisotropicFilterFunction.computeStructureTensor(Volume3D vol, int A, float B, float ri)
           
 void AnisotropicFilterFunction.filt_gauss_relax_tensors(Volume3D[][] vol, float a)
           
 Volume3D AnisotropicFilterFunction.filt_normalize_tensors(Volume3D[][] structureTensor, int eig)
          Normalizes the tensors and computes the tensor nor.
 Volume3D[] AnisotropicFilterFunction.filt_pre_enhance(Volume3D volume, int A, float B, float ri, float a, float lpUpper)
          Computes an array of filtered images.
 

Uses of Volume3D in edu.stanford.rsl.konrad.volume3d
 

Methods in edu.stanford.rsl.konrad.volume3d that return Volume3D
 Volume3D VolumeOperator.createDirectionalWeights(int dimensions, int[] size, float[] dim, float[] dir, int A, VolumeOperator.FILTER_TYPE t_filt)
          Creates an anisotropic, i.e.
 Volume3D ParallelVolumeOperator.createDirectionalWeights(int dimensions, int[] size, float[] dim, float[] dir, int A, VolumeOperator.FILTER_TYPE t_filt)
           
 Volume3D VolumeOperator.createExponentialDirectionalHighPassFilter(int dimensions, int[] size, float[] dim, float[] dir, int A, float B, float ri, VolumeOperator.FILTER_TYPE t_filt)
          Creates an radially symetric anisotropic quadrature filter according to this definition: %preamble{\\usepackage{amsmath}} \\begin{align*} F(\\mathbf{u}) & = \\left \\{ \\begin{array}{ll} \\left(\\frac{\\displaystyle (\\mathbf{u} \\cdot \\hat{\\mathbf{n}}_k)}{\\displaystyle |\\rho|}\\right)^{2A} \\cdot R(\\rho)& \\text{if}\\qquad\\mathbf{u} \\cdot \\hat{\\mathbf{n}}_k >0 \\\\ 0 & \\text{else} \\end{array} \\right .
 Volume3D ParallelVolumeOperator.createExponentialDirectionalHighPassFilter(int dimensions, int[] size, float[] dim, float[] dir, int A, float B, float ri, VolumeOperator.FILTER_TYPE t_filt)
           
 Volume3D VolumeOperator.createGaussLowPassFilter(int dimensions, int[] size, float[] dim, float alpha)
          Creates an isotropic, i.e.
 Volume3D ParallelVolumeOperator.createGaussLowPassFilter(int dimensions, int[] size, float[] dim, float alpha)
           
 Volume3D VolumeOperator.createHighPassFilter(int dimensions, int[] size, float[] dim, int filt_loop, float lp_upper)
          Creates a directional high pass filter %preamble{\usepackage{amsmath}} $F_{\displaystyle\text{HP}_k}(\mathbf{u}) = 1 - (R_\text{LP}(\rho) \cdot D_k(\mathbf{u}))$.
 Volume3D ParallelVolumeOperator.createHighPassFilter(int dimensions, int[] size, float[] dim, int filt_loop, float lp_upper)
           
 Volume3D VolumeOperator.createLowPassFilter(int dimensions, int[] size, float[] dim, float lp_upper)
          Creates an isotropic low-pass filter, i.e.
 Volume3D ParallelVolumeOperator.createLowPassFilter(int dimensions, int[] size, float[] dim, float lp_upper)
           
 Volume3D VolumeOperator.createVolume(ij.ImagePlus image, int mirror, int cuty, boolean uneven)
          Creates a Volume3D Object from an ImagePlus.
 Volume3D VolumeOperator.createVolume(int[] size, float[] dim, int in_dim)
          Creates a new empty volume according to the parameters.
 Volume3D VolumeOperator.solveMaximumEigenvalue(Volume3D[][] structureTensor)
          Method to compute the maximal eigenvalue %preamble{\usepackage{amsmath}} $\lambda_1$ per volume element for a volume structure tensor.
 Volume3D ParallelVolumeOperator.solveMaximumEigenvalue(Volume3D[][] structureTensor)
           
 

Methods in edu.stanford.rsl.konrad.volume3d with parameters of type Volume3D
 int VolumeOperator.abs(Volume3D vol)
          Determines the absolute volume of the input volume.
If the input volume is real Math.abs() is called for each element.
If the input volume is complex the power spectrum is computed.
 int ParallelVolumeOperator.abs(Volume3D vol)
           
 int VolumeOperator.addScalar(Volume3D vol, float realPart, float imagPart)
          Adds a scalar to the Volume3D.
 int ParallelVolumeOperator.addScalar(Volume3D vol, float re_sc, float im_sc)
           
 int VolumeOperator.addVolume(Volume3D vol1, Volume3D vol2)
          Adds the second volume to the first volume.
 int ParallelVolumeOperator.addVolume(Volume3D vol1, Volume3D vol2)
           
 int VolumeOperator.addVolume(Volume3D vol1, Volume3D vol2, double weight)
          Adds the second volume %preamble{\usepackage{amsmath}} $y_j$ multiplied by the scalar weight %preamble{\usepackage{amsmath}} $s$ to the first volume %preamble{\usepackage{amsmath}} $x_j$.
The first volume is overwritten.
 int ParallelVolumeOperator.addVolume(Volume3D vol1, Volume3D vol2, double weight)
           
 int VolumeOperator.divideByVolume(Volume3D vol1, Volume3D vol2)
          Divides the first volume by the second volume element by element
 int ParallelVolumeOperator.divideByVolume(Volume3D vol1, Volume3D vol2)
           
 int VolumeOperator.divideScalar(Volume3D vol, float realPart, float imagPart)
          Divides the volume by a scalar.
 int VolumeOperator.fftShift(Volume3D vol)
          Performs the shift required for the FFT, i.e.
 int ParallelVolumeOperator.fftShift(Volume3D vol)
           
 void JTransformsFFTVolumeHandle.forwardTransform(Volume3D vol)
           
abstract  void FFTVolumeHandle.forwardTransform(Volume3D vol)
          Performs a forward Fast Fourier Transform of the Volume
 int VolumeOperator.imag(Volume3D vol)
          Maps a complex volume onto its imaginary part.
 int ParallelVolumeOperator.imag(Volume3D vol)
           
 void JTransformsFFTVolumeHandle.inverseTransform(Volume3D vol)
           
abstract  void FFTVolumeHandle.inverseTransform(Volume3D vol)
          Performs a normalized inverse Fast Fourier Transform of the Volume
 void VolumeOperator.makeComplex(Volume3D vol)
          Makes the volume complex, i.e.
 void ParallelVolumeOperator.makeComplex(Volume3D vol)
           
 float VolumeOperator.max(Volume3D vol)
          Determines the maximum intensity of a pixel in the given volume.
 float ParallelVolumeOperator.max(Volume3D vol)
           
 float VolumeOperator.mean(Volume3D vol)
          Determines the arithmetic average %preamble{\usepackage{amsmath}} $\mu$ of all %preamble{\usepackage{amsmath}} $N = \prod_i d_i$ voxels %preamble{\usepackage{amsmath}} $x_j$.
 float ParallelVolumeOperator.mean(Volume3D vol)
           
 float VolumeOperator.min(Volume3D vol)
          Determines the minimum intensity of the volume.
 float ParallelVolumeOperator.min(Volume3D vol)
           
 int VolumeOperator.minOfTwoVolumes(Volume3D vol1, Volume3D vol2)
          Determines the minimal volume element by element.
The output is stored in the first volume.
 int ParallelVolumeOperator.minOfTwoVolumes(Volume3D vol1, Volume3D vol2)
           
 int VolumeOperator.multiply(Volume3D vol1, Volume3D vol2)
          Multiplies two volumes element by element.
 int ParallelVolumeOperator.multiply(Volume3D vol1, Volume3D vol2)
           
 int VolumeOperator.multiplyScalar(Volume3D vol, float realPart, float imagPart)
          Multiplies the volume by a scalar.
 int ParallelVolumeOperator.multiplyScalar(Volume3D vol, float re_sc, float im_sc)
           
 int VolumeOperator.real(Volume3D vol)
          Maps volume onto its real part.
 int ParallelVolumeOperator.real(Volume3D vol)
           
 int VolumeOperator.sigmoid(Volume3D vol, float smoothing, float lowValue, float highValue, float highPassLowerLevel, float highPassUpperLevel)
          Remaps gray values using a sigmoid function.
 Volume3D VolumeOperator.solveMaximumEigenvalue(Volume3D[][] structureTensor)
          Method to compute the maximal eigenvalue %preamble{\usepackage{amsmath}} $\lambda_1$ per volume element for a volume structure tensor.
 Volume3D ParallelVolumeOperator.solveMaximumEigenvalue(Volume3D[][] structureTensor)
           
 int VolumeOperator.sqrt(Volume3D vol)
          Replaces every element in the volume with the output of Math.sqrt(), i.e.
 int ParallelVolumeOperator.sqrt(Volume3D vol)
           
 int VolumeOperator.subtractVolume(Volume3D vol1, Volume3D vol2)
          Subtracts the second volume from the first volume.
 int VolumeOperator.upperLimit(Volume3D vol, float max)
          Iterates the volume and replaces all entries greater than max with max.
 int ParallelVolumeOperator.upperLimit(Volume3D vol, float max)
           
 

Uses of Volume3D in edu.stanford.rsl.konrad.volume3d.operations
 

Methods in edu.stanford.rsl.konrad.volume3d.operations that return Volume3D
 Volume3D ParallelVolumeOperation.getVol()
           
 Volume3D ParallelVolumeOperation.getVol1()
           
 Volume3D ParallelVolumeOperation.getVol2()
           
 

Methods in edu.stanford.rsl.konrad.volume3d.operations with parameters of type Volume3D
 void ParallelVolumeOperation.setVol(Volume3D vol)
           
 void ParallelVolumeOperation.setVol1(Volume3D vol1)
           
 void ParallelVolumeOperation.setVol2(Volume3D vol2)