Class SimpleITK

java.lang.Object
org.itk.simple.SimpleITK
All Implemented Interfaces:
SimpleITKConstants

public class SimpleITK extends Object implements SimpleITKConstants
  • Constructor Details

    • SimpleITK

      public SimpleITK()
  • Method Details

    • getPixelIDValueAsString

      public static String getPixelIDValueAsString(int type)
      const std::string SITKCommon_EXPORT itk::simple::GetPixelIDValueAsString(PixelIDValueType type)
    • getPixelIDValueAsString

      public static String getPixelIDValueAsString(PixelIDValueEnum type)
      const std::string SITKCommon_EXPORT itk::simple::GetPixelIDValueAsString(PixelIDValueType type)
    • getPixelIDValueFromString

      public static int getPixelIDValueFromString(String enumString)
      PixelIDValueType SITKCommon_EXPORT itk::simple::GetPixelIDValueFromString(const std::string &enumString) Function mapping enumeration names in std::string to values. This function is intended for use by the R bindings. R stores the enumeration values using the names : "sitkUnknown", "sitkUInt8", etc from PixelIDValueEnum above. This function is used to provide the integer values using calls like: val = GetPixelIDValueFromString("sitkInt32") If the pixel type has not been instantiated then the sitkUnknown value (-1) will be returned. If the pixel type string is not recognized (i.e. is not in the set of tested names) then the return value is -99. The idea is to provide a warning (via the R package) if this function needs to be updated to match changes to PixelIDValueEnum - i.e. if a new pixel type is added.
    • readTransform

      public static Transform readTransform(String filename)
      SITKCommon_EXPORT Transform itk::simple::ReadTransform(const std::string &filename)
    • writeTransform

      public static void writeTransform(Transform transform, String filename)
      SITKCommon_EXPORT void itk::simple::WriteTransform(const Transform &transform, const std::string &filename)
    • show

      public static void show(Image image, String title, boolean debugOn)
      void SITKIO_EXPORT itk::simple::Show(const Image &image, const std::string &title="", const bool debugOn=ProcessObject::GetGlobalDefaultDebug()) Display an image in an external viewer (Fiji by default) This function directly calls the execute method of ImageViewer in order to support a procedural API
    • show

      public static void show(Image image, String title)
      void SITKIO_EXPORT itk::simple::Show(const Image &image, const std::string &title="", const bool debugOn=ProcessObject::GetGlobalDefaultDebug()) Display an image in an external viewer (Fiji by default) This function directly calls the execute method of ImageViewer in order to support a procedural API
    • show

      public static void show(Image image)
      void SITKIO_EXPORT itk::simple::Show(const Image &image, const std::string &title="", const bool debugOn=ProcessObject::GetGlobalDefaultDebug()) Display an image in an external viewer (Fiji by default) This function directly calls the execute method of ImageViewer in order to support a procedural API
    • writeImage

      public static void writeImage(Image image, String fileName, boolean useCompression, int compressionLevel)
      SITKIO_EXPORT void itk::simple::WriteImage(const Image &image, const std::vector< std::string > &fileNames, bool useCompression=false, int compressionLevel=-1) WriteImage is a procedural interface to the ImageSeriesWriter. class which is convenient for many image writing tasks. Parameters: image: the input image to be written fileNames: a vector of filenames of length equal to the number of slices in the image. useCompression: request to compress the written file compressionLevel: a hint for the amount of compression to be applied during writing. See: itk::simple::ImageFileWriter for writing a single file.
    • writeImage

      public static void writeImage(Image image, String fileName, boolean useCompression)
      SITKIO_EXPORT void itk::simple::WriteImage(const Image &image, const std::vector< std::string > &fileNames, bool useCompression=false, int compressionLevel=-1) WriteImage is a procedural interface to the ImageSeriesWriter. class which is convenient for many image writing tasks. Parameters: image: the input image to be written fileNames: a vector of filenames of length equal to the number of slices in the image. useCompression: request to compress the written file compressionLevel: a hint for the amount of compression to be applied during writing. See: itk::simple::ImageFileWriter for writing a single file.
    • writeImage

      public static void writeImage(Image image, String fileName)
      SITKIO_EXPORT void itk::simple::WriteImage(const Image &image, const std::vector< std::string > &fileNames, bool useCompression=false, int compressionLevel=-1) WriteImage is a procedural interface to the ImageSeriesWriter. class which is convenient for many image writing tasks. Parameters: image: the input image to be written fileNames: a vector of filenames of length equal to the number of slices in the image. useCompression: request to compress the written file compressionLevel: a hint for the amount of compression to be applied during writing. See: itk::simple::ImageFileWriter for writing a single file.
    • writeImage

      public static void writeImage(Image image, VectorString fileNames, boolean useCompression, int compressionLevel)
      SITKIO_EXPORT void itk::simple::WriteImage(const Image &image, const std::vector< std::string > &fileNames, bool useCompression=false, int compressionLevel=-1) WriteImage is a procedural interface to the ImageSeriesWriter. class which is convenient for many image writing tasks. Parameters: image: the input image to be written fileNames: a vector of filenames of length equal to the number of slices in the image. useCompression: request to compress the written file compressionLevel: a hint for the amount of compression to be applied during writing. See: itk::simple::ImageFileWriter for writing a single file.
    • writeImage

      public static void writeImage(Image image, VectorString fileNames, boolean useCompression)
      SITKIO_EXPORT void itk::simple::WriteImage(const Image &image, const std::vector< std::string > &fileNames, bool useCompression=false, int compressionLevel=-1) WriteImage is a procedural interface to the ImageSeriesWriter. class which is convenient for many image writing tasks. Parameters: image: the input image to be written fileNames: a vector of filenames of length equal to the number of slices in the image. useCompression: request to compress the written file compressionLevel: a hint for the amount of compression to be applied during writing. See: itk::simple::ImageFileWriter for writing a single file.
    • writeImage

      public static void writeImage(Image image, VectorString fileNames)
      SITKIO_EXPORT void itk::simple::WriteImage(const Image &image, const std::vector< std::string > &fileNames, bool useCompression=false, int compressionLevel=-1) WriteImage is a procedural interface to the ImageSeriesWriter. class which is convenient for many image writing tasks. Parameters: image: the input image to be written fileNames: a vector of filenames of length equal to the number of slices in the image. useCompression: request to compress the written file compressionLevel: a hint for the amount of compression to be applied during writing. See: itk::simple::ImageFileWriter for writing a single file.
    • readImage

      public static Image readImage(VectorString fileNames, PixelIDValueEnum outputPixelType, String imageIO)
      SITKIO_EXPORT Image itk::simple::ReadImage(const std::vector< std::string > &fileNames, PixelIDValueEnum outputPixelType=sitkUnknown, const std::string &imageIO="") ReadImage is a procedural interface to the ImageSeriesReader class which is convenient for most image reading tasks. Parameters: fileNames: a vector of file names outputPixelType: see ImageReaderBase::SetOutputPixelType imageIO: see ImageReaderBase::SetImageIO When reading a series of images that have meta-data associated with them (e.g. a DICOM series) the resulting image will have an empty meta-data dictionary. If you need the meta-data dictionaries associated with each slice then you should use the ImageSeriesReader class. If the pixel type for the returned image is not specified it is deduced from the first image in the series. This approach is computationally efficient and assumes that all images in a series have the same pixel type. If this is not the case, explicitly specify the widest pixel type in the series as the outputPixelType. See: itk::simple::ImageFileReader for reading a single file. itk::simple::ImageSeriesReader for reading a series and meta-data dictionaries.
    • readImage

      public static Image readImage(VectorString fileNames, PixelIDValueEnum outputPixelType)
      SITKIO_EXPORT Image itk::simple::ReadImage(const std::vector< std::string > &fileNames, PixelIDValueEnum outputPixelType=sitkUnknown, const std::string &imageIO="") ReadImage is a procedural interface to the ImageSeriesReader class which is convenient for most image reading tasks. Parameters: fileNames: a vector of file names outputPixelType: see ImageReaderBase::SetOutputPixelType imageIO: see ImageReaderBase::SetImageIO When reading a series of images that have meta-data associated with them (e.g. a DICOM series) the resulting image will have an empty meta-data dictionary. If you need the meta-data dictionaries associated with each slice then you should use the ImageSeriesReader class. If the pixel type for the returned image is not specified it is deduced from the first image in the series. This approach is computationally efficient and assumes that all images in a series have the same pixel type. If this is not the case, explicitly specify the widest pixel type in the series as the outputPixelType. See: itk::simple::ImageFileReader for reading a single file. itk::simple::ImageSeriesReader for reading a series and meta-data dictionaries.
    • readImage

      public static Image readImage(VectorString fileNames)
      SITKIO_EXPORT Image itk::simple::ReadImage(const std::vector< std::string > &fileNames, PixelIDValueEnum outputPixelType=sitkUnknown, const std::string &imageIO="") ReadImage is a procedural interface to the ImageSeriesReader class which is convenient for most image reading tasks. Parameters: fileNames: a vector of file names outputPixelType: see ImageReaderBase::SetOutputPixelType imageIO: see ImageReaderBase::SetImageIO When reading a series of images that have meta-data associated with them (e.g. a DICOM series) the resulting image will have an empty meta-data dictionary. If you need the meta-data dictionaries associated with each slice then you should use the ImageSeriesReader class. If the pixel type for the returned image is not specified it is deduced from the first image in the series. This approach is computationally efficient and assumes that all images in a series have the same pixel type. If this is not the case, explicitly specify the widest pixel type in the series as the outputPixelType. See: itk::simple::ImageFileReader for reading a single file. itk::simple::ImageSeriesReader for reading a series and meta-data dictionaries.
    • readImage

      public static Image readImage(String filename, PixelIDValueEnum outputPixelType, String imageIO)
      SITKIO_EXPORT Image itk::simple::ReadImage(const std::vector< std::string > &fileNames, PixelIDValueEnum outputPixelType=sitkUnknown, const std::string &imageIO="") ReadImage is a procedural interface to the ImageSeriesReader class which is convenient for most image reading tasks. Parameters: fileNames: a vector of file names outputPixelType: see ImageReaderBase::SetOutputPixelType imageIO: see ImageReaderBase::SetImageIO When reading a series of images that have meta-data associated with them (e.g. a DICOM series) the resulting image will have an empty meta-data dictionary. If you need the meta-data dictionaries associated with each slice then you should use the ImageSeriesReader class. If the pixel type for the returned image is not specified it is deduced from the first image in the series. This approach is computationally efficient and assumes that all images in a series have the same pixel type. If this is not the case, explicitly specify the widest pixel type in the series as the outputPixelType. See: itk::simple::ImageFileReader for reading a single file. itk::simple::ImageSeriesReader for reading a series and meta-data dictionaries.
    • readImage

      public static Image readImage(String filename, PixelIDValueEnum outputPixelType)
      SITKIO_EXPORT Image itk::simple::ReadImage(const std::vector< std::string > &fileNames, PixelIDValueEnum outputPixelType=sitkUnknown, const std::string &imageIO="") ReadImage is a procedural interface to the ImageSeriesReader class which is convenient for most image reading tasks. Parameters: fileNames: a vector of file names outputPixelType: see ImageReaderBase::SetOutputPixelType imageIO: see ImageReaderBase::SetImageIO When reading a series of images that have meta-data associated with them (e.g. a DICOM series) the resulting image will have an empty meta-data dictionary. If you need the meta-data dictionaries associated with each slice then you should use the ImageSeriesReader class. If the pixel type for the returned image is not specified it is deduced from the first image in the series. This approach is computationally efficient and assumes that all images in a series have the same pixel type. If this is not the case, explicitly specify the widest pixel type in the series as the outputPixelType. See: itk::simple::ImageFileReader for reading a single file. itk::simple::ImageSeriesReader for reading a series and meta-data dictionaries.
    • readImage

      public static Image readImage(String filename)
      SITKIO_EXPORT Image itk::simple::ReadImage(const std::vector< std::string > &fileNames, PixelIDValueEnum outputPixelType=sitkUnknown, const std::string &imageIO="") ReadImage is a procedural interface to the ImageSeriesReader class which is convenient for most image reading tasks. Parameters: fileNames: a vector of file names outputPixelType: see ImageReaderBase::SetOutputPixelType imageIO: see ImageReaderBase::SetImageIO When reading a series of images that have meta-data associated with them (e.g. a DICOM series) the resulting image will have an empty meta-data dictionary. If you need the meta-data dictionaries associated with each slice then you should use the ImageSeriesReader class. If the pixel type for the returned image is not specified it is deduced from the first image in the series. This approach is computationally efficient and assumes that all images in a series have the same pixel type. If this is not the case, explicitly specify the widest pixel type in the series as the outputPixelType. See: itk::simple::ImageFileReader for reading a single file. itk::simple::ImageSeriesReader for reading a series and meta-data dictionaries.
    • hash

      public static String hash(Image image, HashImageFilter.HashFunction function)
      std::string itk::simple::Hash(const Image &image, HashImageFilter::HashFunction function=HashImageFilter::SHA1)
    • hash

      public static String hash(Image image)
      std::string itk::simple::Hash(const Image &image, HashImageFilter::HashFunction function=HashImageFilter::SHA1)
    • bSplineTransformInitializer

      public static BSplineTransform bSplineTransformInitializer(Image image1, VectorUInt32 transformDomainMeshSize, long order)
      BSplineTransform itk::simple::BSplineTransformInitializer(const Image &image1, const std::vector< uint32_t > &transformDomainMeshSize=std::vector< uint32_t >(3, 1u), unsigned int order=3u) BSplineTransformInitializerFilter is a helper class intended to initialize the control point grid such that it has a physically consistent definition. It sets the transform domain origin, physical dimensions and direction from information obtained from the image. It also sets the mesh size if asked to do so by calling SetTransformDomainMeshSize()before calling InitializeTransform(). This function directly calls the execute method of BSplineTransformInitializerFilter in order to support a procedural API See: itk::simple::BSplineTransformInitializerFilter for the object oriented interface
    • bSplineTransformInitializer

      public static BSplineTransform bSplineTransformInitializer(Image image1, VectorUInt32 transformDomainMeshSize)
      BSplineTransform itk::simple::BSplineTransformInitializer(const Image &image1, const std::vector< uint32_t > &transformDomainMeshSize=std::vector< uint32_t >(3, 1u), unsigned int order=3u) BSplineTransformInitializerFilter is a helper class intended to initialize the control point grid such that it has a physically consistent definition. It sets the transform domain origin, physical dimensions and direction from information obtained from the image. It also sets the mesh size if asked to do so by calling SetTransformDomainMeshSize()before calling InitializeTransform(). This function directly calls the execute method of BSplineTransformInitializerFilter in order to support a procedural API See: itk::simple::BSplineTransformInitializerFilter for the object oriented interface
    • bSplineTransformInitializer

      public static BSplineTransform bSplineTransformInitializer(Image image1)
      BSplineTransform itk::simple::BSplineTransformInitializer(const Image &image1, const std::vector< uint32_t > &transformDomainMeshSize=std::vector< uint32_t >(3, 1u), unsigned int order=3u) BSplineTransformInitializerFilter is a helper class intended to initialize the control point grid such that it has a physically consistent definition. It sets the transform domain origin, physical dimensions and direction from information obtained from the image. It also sets the mesh size if asked to do so by calling SetTransformDomainMeshSize()before calling InitializeTransform(). This function directly calls the execute method of BSplineTransformInitializerFilter in order to support a procedural API See: itk::simple::BSplineTransformInitializerFilter for the object oriented interface
    • centeredTransformInitializer

      public static Transform centeredTransformInitializer(Image fixedImage, Image movingImage, Transform transform, CenteredTransformInitializerFilter.OperationModeType operationMode)
      Transform itk::simple::CenteredTransformInitializer(const Image &fixedImage, const Image &movingImage, const Transform &transform, CenteredTransformInitializerFilter::OperationModeType operationMode=it k::simple::CenteredTransformInitializerFilter::MOMENTS) CenteredTransformInitializer is a helper class intended to initialize the center of rotation and the translation of Transforms having the center of rotation among their parameters. This function directly calls the execute method of CenteredTransformInitializerFilter in order to support a procedural API See: itk::simple::CenteredTransformInitializerFilter for the object oriented interface
    • centeredTransformInitializer

      public static Transform centeredTransformInitializer(Image fixedImage, Image movingImage, Transform transform)
      Transform itk::simple::CenteredTransformInitializer(const Image &fixedImage, const Image &movingImage, const Transform &transform, CenteredTransformInitializerFilter::OperationModeType operationMode=it k::simple::CenteredTransformInitializerFilter::MOMENTS) CenteredTransformInitializer is a helper class intended to initialize the center of rotation and the translation of Transforms having the center of rotation among their parameters. This function directly calls the execute method of CenteredTransformInitializerFilter in order to support a procedural API See: itk::simple::CenteredTransformInitializerFilter for the object oriented interface
    • centeredVersorTransformInitializer

      public static Transform centeredVersorTransformInitializer(Image fixedImage, Image movingImage, Transform transform, boolean computeRotation)
      Transform itk::simple::CenteredVersorTransformInitializer(const Image &fixedImage, const Image &movingImage, const Transform &transform, bool computeRotation=false) CenteredVersorTransformInitializer is a helper class intended to initialize the center of rotation, versor, and translation of the VersorRigid3DTransform. This function directly calls the execute method of CenteredVectorTransformInitializerFilter in order to support a procedural API. See: itk::simple::CenteredVersorTransformInitializerFilter for the object oriented interface
    • centeredVersorTransformInitializer

      public static Transform centeredVersorTransformInitializer(Image fixedImage, Image movingImage, Transform transform)
      Transform itk::simple::CenteredVersorTransformInitializer(const Image &fixedImage, const Image &movingImage, const Transform &transform, bool computeRotation=false) CenteredVersorTransformInitializer is a helper class intended to initialize the center of rotation, versor, and translation of the VersorRigid3DTransform. This function directly calls the execute method of CenteredVectorTransformInitializerFilter in order to support a procedural API. See: itk::simple::CenteredVersorTransformInitializerFilter for the object oriented interface
    • landmarkBasedTransformInitializer

      public static Transform landmarkBasedTransformInitializer(Transform transform, VectorDouble fixedLandmarks, VectorDouble movingLandmarks, VectorDouble landmarkWeight, Image referenceImage, long numberOfControlPoints)
      Transform itk::simple::LandmarkBasedTransformInitializer(const Transform &transform, const std::vector< double > &fixedLandmarks=std::vector< double >(), const std::vector< double > &movingLandmarks=std::vector< double >(), const std::vector< double > &landmarkWeight=std::vector< double >(), const Image &referenceImage=Image(), unsigned int numberOfControlPoints=4u) itk::simple::LandmarkBasedTransformInitializerFilter Procedural Interface This function directly calls the execute method of LandmarkBasedTransformInitializerFilter in order to support a procedural API See: itk::simple::LandmarkBasedTransformInitializerFilter for the object oriented interface
    • landmarkBasedTransformInitializer

      public static Transform landmarkBasedTransformInitializer(Transform transform, VectorDouble fixedLandmarks, VectorDouble movingLandmarks, VectorDouble landmarkWeight, Image referenceImage)
      Transform itk::simple::LandmarkBasedTransformInitializer(const Transform &transform, const std::vector< double > &fixedLandmarks=std::vector< double >(), const std::vector< double > &movingLandmarks=std::vector< double >(), const std::vector< double > &landmarkWeight=std::vector< double >(), const Image &referenceImage=Image(), unsigned int numberOfControlPoints=4u) itk::simple::LandmarkBasedTransformInitializerFilter Procedural Interface This function directly calls the execute method of LandmarkBasedTransformInitializerFilter in order to support a procedural API See: itk::simple::LandmarkBasedTransformInitializerFilter for the object oriented interface
    • landmarkBasedTransformInitializer

      public static Transform landmarkBasedTransformInitializer(Transform transform, VectorDouble fixedLandmarks, VectorDouble movingLandmarks, VectorDouble landmarkWeight)
      Transform itk::simple::LandmarkBasedTransformInitializer(const Transform &transform, const std::vector< double > &fixedLandmarks=std::vector< double >(), const std::vector< double > &movingLandmarks=std::vector< double >(), const std::vector< double > &landmarkWeight=std::vector< double >(), const Image &referenceImage=Image(), unsigned int numberOfControlPoints=4u) itk::simple::LandmarkBasedTransformInitializerFilter Procedural Interface This function directly calls the execute method of LandmarkBasedTransformInitializerFilter in order to support a procedural API See: itk::simple::LandmarkBasedTransformInitializerFilter for the object oriented interface
    • landmarkBasedTransformInitializer

      public static Transform landmarkBasedTransformInitializer(Transform transform, VectorDouble fixedLandmarks, VectorDouble movingLandmarks)
      Transform itk::simple::LandmarkBasedTransformInitializer(const Transform &transform, const std::vector< double > &fixedLandmarks=std::vector< double >(), const std::vector< double > &movingLandmarks=std::vector< double >(), const std::vector< double > &landmarkWeight=std::vector< double >(), const Image &referenceImage=Image(), unsigned int numberOfControlPoints=4u) itk::simple::LandmarkBasedTransformInitializerFilter Procedural Interface This function directly calls the execute method of LandmarkBasedTransformInitializerFilter in order to support a procedural API See: itk::simple::LandmarkBasedTransformInitializerFilter for the object oriented interface
    • landmarkBasedTransformInitializer

      public static Transform landmarkBasedTransformInitializer(Transform transform, VectorDouble fixedLandmarks)
      Transform itk::simple::LandmarkBasedTransformInitializer(const Transform &transform, const std::vector< double > &fixedLandmarks=std::vector< double >(), const std::vector< double > &movingLandmarks=std::vector< double >(), const std::vector< double > &landmarkWeight=std::vector< double >(), const Image &referenceImage=Image(), unsigned int numberOfControlPoints=4u) itk::simple::LandmarkBasedTransformInitializerFilter Procedural Interface This function directly calls the execute method of LandmarkBasedTransformInitializerFilter in order to support a procedural API See: itk::simple::LandmarkBasedTransformInitializerFilter for the object oriented interface
    • landmarkBasedTransformInitializer

      public static Transform landmarkBasedTransformInitializer(Transform transform)
      Transform itk::simple::LandmarkBasedTransformInitializer(const Transform &transform, const std::vector< double > &fixedLandmarks=std::vector< double >(), const std::vector< double > &movingLandmarks=std::vector< double >(), const std::vector< double > &landmarkWeight=std::vector< double >(), const Image &referenceImage=Image(), unsigned int numberOfControlPoints=4u) itk::simple::LandmarkBasedTransformInitializerFilter Procedural Interface This function directly calls the execute method of LandmarkBasedTransformInitializerFilter in order to support a procedural API See: itk::simple::LandmarkBasedTransformInitializerFilter for the object oriented interface
    • cast

      public static Image cast(Image image, PixelIDValueEnum pixelID)
      Image itk::simple::Cast(const Image &image, PixelIDValueEnum pixelID)
    • extract

      public static Image extract(Image image1, VectorUInt32 size, VectorInt32 index, ExtractImageFilter.DirectionCollapseToStrategyType directionCollapseToStrategy)
    • extract

      public static Image extract(Image image1, VectorUInt32 size, VectorInt32 index)
    • extract

      public static Image extract(Image image1, VectorUInt32 size)
    • extract

      public static Image extract(Image image1)
    • paste

      public static Image paste(Image destinationImage, Image sourceImage, VectorUInt32 sourceSize, VectorInt32 sourceIndex, VectorInt32 destinationIndex, VectorBool DestinationSkipAxes)
    • paste

      public static Image paste(Image destinationImage, Image sourceImage, VectorUInt32 sourceSize, VectorInt32 sourceIndex, VectorInt32 destinationIndex)
    • paste

      public static Image paste(Image destinationImage, Image sourceImage, VectorUInt32 sourceSize, VectorInt32 sourceIndex)
    • paste

      public static Image paste(Image destinationImage, Image sourceImage, VectorUInt32 sourceSize)
    • paste

      public static Image paste(Image destinationImage, Image sourceImage)
    • resample

      public static Image resample(Image image1, Transform transform, InterpolatorEnum interpolator, double defaultPixelValue, PixelIDValueEnum outputPixelType, boolean useNearestNeighborExtrapolator)
    • resample

      public static Image resample(Image image1, Transform transform, InterpolatorEnum interpolator, double defaultPixelValue, PixelIDValueEnum outputPixelType)
    • resample

      public static Image resample(Image image1, Transform transform, InterpolatorEnum interpolator, double defaultPixelValue)
    • resample

      public static Image resample(Image image1, Transform transform, InterpolatorEnum interpolator)
    • resample

      public static Image resample(Image image1, Transform transform)
    • resample

      public static Image resample(Image image1)
    • resample

      public static Image resample(Image image1, Image referenceImage, Transform transform, InterpolatorEnum interpolator, double defaultPixelValue, PixelIDValueEnum outputPixelType, boolean useNearestNeighborExtrapolator)
    • resample

      public static Image resample(Image image1, Image referenceImage, Transform transform, InterpolatorEnum interpolator, double defaultPixelValue, PixelIDValueEnum outputPixelType)
    • resample

      public static Image resample(Image image1, Image referenceImage, Transform transform, InterpolatorEnum interpolator, double defaultPixelValue)
    • resample

      public static Image resample(Image image1, Image referenceImage, Transform transform, InterpolatorEnum interpolator)
    • resample

      public static Image resample(Image image1, Image referenceImage, Transform transform)
    • resample

      public static Image resample(Image image1, Image referenceImage)
    • resample

      public static Image resample(Image image1, VectorUInt32 size, Transform transform, InterpolatorEnum interpolator, VectorDouble outputOrigin, VectorDouble outputSpacing, VectorDouble outputDirection, double defaultPixelValue, PixelIDValueEnum outputPixelType, boolean useNearestNeighborExtrapolator)
    • resample

      public static Image resample(Image image1, VectorUInt32 size, Transform transform, InterpolatorEnum interpolator, VectorDouble outputOrigin, VectorDouble outputSpacing, VectorDouble outputDirection, double defaultPixelValue, PixelIDValueEnum outputPixelType)
    • resample

      public static Image resample(Image image1, VectorUInt32 size, Transform transform, InterpolatorEnum interpolator, VectorDouble outputOrigin, VectorDouble outputSpacing, VectorDouble outputDirection, double defaultPixelValue)
    • resample

      public static Image resample(Image image1, VectorUInt32 size, Transform transform, InterpolatorEnum interpolator, VectorDouble outputOrigin, VectorDouble outputSpacing, VectorDouble outputDirection)
    • resample

      public static Image resample(Image image1, VectorUInt32 size, Transform transform, InterpolatorEnum interpolator, VectorDouble outputOrigin, VectorDouble outputSpacing)
    • resample

      public static Image resample(Image image1, VectorUInt32 size, Transform transform, InterpolatorEnum interpolator, VectorDouble outputOrigin)
    • resample

      public static Image resample(Image image1, VectorUInt32 size, Transform transform, InterpolatorEnum interpolator)
    • resample

      public static Image resample(Image image1, VectorUInt32 size, Transform transform)
    • resample

      public static Image resample(Image image1, VectorUInt32 size)
    • patchBasedDenoising

      public static Image patchBasedDenoising(Image image1, PatchBasedDenoisingImageFilter.NoiseModelType noiseModel, double kernelBandwidthSigma, long patchRadius, long numberOfIterations, long numberOfSamplePatches, double sampleVariance, double noiseSigma, double noiseModelFidelityWeight)
      Image itk::simple::PatchBasedDenoising(const Image &image1, itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4u, uint32_t numberOfIterations=1u, uint32_t numberOfSamplePatches=200u, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) itk::simple::PatchBasedDenoisingImageFilter Procedural Interface This function directly calls the execute method of PatchBasedDenoisingImageFilter in order to support a procedural API See: itk::simple::PatchBasedDenoisingImageFilter for the object oriented interface
    • patchBasedDenoising

      public static Image patchBasedDenoising(Image image1, PatchBasedDenoisingImageFilter.NoiseModelType noiseModel, double kernelBandwidthSigma, long patchRadius, long numberOfIterations, long numberOfSamplePatches, double sampleVariance, double noiseSigma)
      Image itk::simple::PatchBasedDenoising(const Image &image1, itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4u, uint32_t numberOfIterations=1u, uint32_t numberOfSamplePatches=200u, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) itk::simple::PatchBasedDenoisingImageFilter Procedural Interface This function directly calls the execute method of PatchBasedDenoisingImageFilter in order to support a procedural API See: itk::simple::PatchBasedDenoisingImageFilter for the object oriented interface
    • patchBasedDenoising

      public static Image patchBasedDenoising(Image image1, PatchBasedDenoisingImageFilter.NoiseModelType noiseModel, double kernelBandwidthSigma, long patchRadius, long numberOfIterations, long numberOfSamplePatches, double sampleVariance)
      Image itk::simple::PatchBasedDenoising(const Image &image1, itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4u, uint32_t numberOfIterations=1u, uint32_t numberOfSamplePatches=200u, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) itk::simple::PatchBasedDenoisingImageFilter Procedural Interface This function directly calls the execute method of PatchBasedDenoisingImageFilter in order to support a procedural API See: itk::simple::PatchBasedDenoisingImageFilter for the object oriented interface
    • patchBasedDenoising

      public static Image patchBasedDenoising(Image image1, PatchBasedDenoisingImageFilter.NoiseModelType noiseModel, double kernelBandwidthSigma, long patchRadius, long numberOfIterations, long numberOfSamplePatches)
      Image itk::simple::PatchBasedDenoising(const Image &image1, itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4u, uint32_t numberOfIterations=1u, uint32_t numberOfSamplePatches=200u, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) itk::simple::PatchBasedDenoisingImageFilter Procedural Interface This function directly calls the execute method of PatchBasedDenoisingImageFilter in order to support a procedural API See: itk::simple::PatchBasedDenoisingImageFilter for the object oriented interface
    • patchBasedDenoising

      public static Image patchBasedDenoising(Image image1, PatchBasedDenoisingImageFilter.NoiseModelType noiseModel, double kernelBandwidthSigma, long patchRadius, long numberOfIterations)
      Image itk::simple::PatchBasedDenoising(const Image &image1, itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4u, uint32_t numberOfIterations=1u, uint32_t numberOfSamplePatches=200u, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) itk::simple::PatchBasedDenoisingImageFilter Procedural Interface This function directly calls the execute method of PatchBasedDenoisingImageFilter in order to support a procedural API See: itk::simple::PatchBasedDenoisingImageFilter for the object oriented interface
    • patchBasedDenoising

      public static Image patchBasedDenoising(Image image1, PatchBasedDenoisingImageFilter.NoiseModelType noiseModel, double kernelBandwidthSigma, long patchRadius)
      Image itk::simple::PatchBasedDenoising(const Image &image1, itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4u, uint32_t numberOfIterations=1u, uint32_t numberOfSamplePatches=200u, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) itk::simple::PatchBasedDenoisingImageFilter Procedural Interface This function directly calls the execute method of PatchBasedDenoisingImageFilter in order to support a procedural API See: itk::simple::PatchBasedDenoisingImageFilter for the object oriented interface
    • patchBasedDenoising

      public static Image patchBasedDenoising(Image image1, PatchBasedDenoisingImageFilter.NoiseModelType noiseModel, double kernelBandwidthSigma)
      Image itk::simple::PatchBasedDenoising(const Image &image1, itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4u, uint32_t numberOfIterations=1u, uint32_t numberOfSamplePatches=200u, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) itk::simple::PatchBasedDenoisingImageFilter Procedural Interface This function directly calls the execute method of PatchBasedDenoisingImageFilter in order to support a procedural API See: itk::simple::PatchBasedDenoisingImageFilter for the object oriented interface
    • patchBasedDenoising

      public static Image patchBasedDenoising(Image image1, PatchBasedDenoisingImageFilter.NoiseModelType noiseModel)
      Image itk::simple::PatchBasedDenoising(const Image &image1, itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4u, uint32_t numberOfIterations=1u, uint32_t numberOfSamplePatches=200u, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) itk::simple::PatchBasedDenoisingImageFilter Procedural Interface This function directly calls the execute method of PatchBasedDenoisingImageFilter in order to support a procedural API See: itk::simple::PatchBasedDenoisingImageFilter for the object oriented interface
    • patchBasedDenoising

      public static Image patchBasedDenoising(Image image1, double kernelBandwidthSigma, long patchRadius, long numberOfIterations, long numberOfSamplePatches, double sampleVariance)
      Image itk::simple::PatchBasedDenoising(const Image &image1, itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4u, uint32_t numberOfIterations=1u, uint32_t numberOfSamplePatches=200u, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) itk::simple::PatchBasedDenoisingImageFilter Procedural Interface This function directly calls the execute method of PatchBasedDenoisingImageFilter in order to support a procedural API See: itk::simple::PatchBasedDenoisingImageFilter for the object oriented interface
    • patchBasedDenoising

      public static Image patchBasedDenoising(Image image1, double kernelBandwidthSigma, long patchRadius, long numberOfIterations, long numberOfSamplePatches)
      Image itk::simple::PatchBasedDenoising(const Image &image1, itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4u, uint32_t numberOfIterations=1u, uint32_t numberOfSamplePatches=200u, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) itk::simple::PatchBasedDenoisingImageFilter Procedural Interface This function directly calls the execute method of PatchBasedDenoisingImageFilter in order to support a procedural API See: itk::simple::PatchBasedDenoisingImageFilter for the object oriented interface
    • patchBasedDenoising

      public static Image patchBasedDenoising(Image image1, double kernelBandwidthSigma, long patchRadius, long numberOfIterations)
      Image itk::simple::PatchBasedDenoising(const Image &image1, itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4u, uint32_t numberOfIterations=1u, uint32_t numberOfSamplePatches=200u, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) itk::simple::PatchBasedDenoisingImageFilter Procedural Interface This function directly calls the execute method of PatchBasedDenoisingImageFilter in order to support a procedural API See: itk::simple::PatchBasedDenoisingImageFilter for the object oriented interface
    • patchBasedDenoising

      public static Image patchBasedDenoising(Image image1, double kernelBandwidthSigma, long patchRadius)
      Image itk::simple::PatchBasedDenoising(const Image &image1, itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4u, uint32_t numberOfIterations=1u, uint32_t numberOfSamplePatches=200u, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) itk::simple::PatchBasedDenoisingImageFilter Procedural Interface This function directly calls the execute method of PatchBasedDenoisingImageFilter in order to support a procedural API See: itk::simple::PatchBasedDenoisingImageFilter for the object oriented interface
    • patchBasedDenoising

      public static Image patchBasedDenoising(Image image1, double kernelBandwidthSigma)
      Image itk::simple::PatchBasedDenoising(const Image &image1, itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4u, uint32_t numberOfIterations=1u, uint32_t numberOfSamplePatches=200u, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) itk::simple::PatchBasedDenoisingImageFilter Procedural Interface This function directly calls the execute method of PatchBasedDenoisingImageFilter in order to support a procedural API See: itk::simple::PatchBasedDenoisingImageFilter for the object oriented interface
    • patchBasedDenoising

      public static Image patchBasedDenoising(Image image1)
      Image itk::simple::PatchBasedDenoising(const Image &image1, itk::simple::PatchBasedDenoisingImageFilter::NoiseModelType noiseModel, double kernelBandwidthSigma=400.0, uint32_t patchRadius=4u, uint32_t numberOfIterations=1u, uint32_t numberOfSamplePatches=200u, double sampleVariance=400.0, double noiseSigma=0.0, double noiseModelFidelityWeight=0.0) itk::simple::PatchBasedDenoisingImageFilter Procedural Interface This function directly calls the execute method of PatchBasedDenoisingImageFilter in order to support a procedural API See: itk::simple::PatchBasedDenoisingImageFilter for the object oriented interface
    • discreteGaussian

      public static Image discreteGaussian(Image image1, double variance, long maximumKernelWidth, double maximumError, boolean useImageSpacing)
      Image itk::simple::DiscreteGaussian(const Image &image1, double variance, unsigned int maximumKernelWidth=32u, double maximumError=0.01, bool useImageSpacing=true) Blurs an image by separable convolution with discrete gaussian kernels. This filter performs Gaussian blurring by separable convolution of an image and a discrete Gaussian operator (kernel). This function directly calls the execute method of DiscreteGaussianImageFilter in order to support a procedural API See: itk::simple::DiscreteGaussianImageFilter for the object oriented interface
    • discreteGaussian

      public static Image discreteGaussian(Image image1, double variance, long maximumKernelWidth, double maximumError)
      Image itk::simple::DiscreteGaussian(const Image &image1, double variance, unsigned int maximumKernelWidth=32u, double maximumError=0.01, bool useImageSpacing=true) Blurs an image by separable convolution with discrete gaussian kernels. This filter performs Gaussian blurring by separable convolution of an image and a discrete Gaussian operator (kernel). This function directly calls the execute method of DiscreteGaussianImageFilter in order to support a procedural API See: itk::simple::DiscreteGaussianImageFilter for the object oriented interface
    • discreteGaussian

      public static Image discreteGaussian(Image image1, double variance, long maximumKernelWidth)
      Image itk::simple::DiscreteGaussian(const Image &image1, double variance, unsigned int maximumKernelWidth=32u, double maximumError=0.01, bool useImageSpacing=true) Blurs an image by separable convolution with discrete gaussian kernels. This filter performs Gaussian blurring by separable convolution of an image and a discrete Gaussian operator (kernel). This function directly calls the execute method of DiscreteGaussianImageFilter in order to support a procedural API See: itk::simple::DiscreteGaussianImageFilter for the object oriented interface
    • discreteGaussian

      public static Image discreteGaussian(Image image1, double variance)
      Image itk::simple::DiscreteGaussian(const Image &image1, double variance, unsigned int maximumKernelWidth=32u, double maximumError=0.01, bool useImageSpacing=true) Blurs an image by separable convolution with discrete gaussian kernels. This filter performs Gaussian blurring by separable convolution of an image and a discrete Gaussian operator (kernel). This function directly calls the execute method of DiscreteGaussianImageFilter in order to support a procedural API See: itk::simple::DiscreteGaussianImageFilter for the object oriented interface
    • smoothingRecursiveGaussian

      public static Image smoothingRecursiveGaussian(Image image1, double sigma, boolean normalizeAcrossScale)
      Image itk::simple::SmoothingRecursiveGaussian(const Image &image1, double sigma, bool normalizeAcrossScale=false) Computes the smoothing of an image by convolution with the Gaussian kernels implemented as IIR filters. This function directly calls the execute method of SmoothingRecursiveGaussianImageFilter in order to support a procedural API See: itk::simple::SmoothingRecursiveGaussianImageFilter for the object oriented interface
    • smoothingRecursiveGaussian

      public static Image smoothingRecursiveGaussian(Image image1, double sigma)
      Image itk::simple::SmoothingRecursiveGaussian(const Image &image1, double sigma, bool normalizeAcrossScale=false) Computes the smoothing of an image by convolution with the Gaussian kernels implemented as IIR filters. This function directly calls the execute method of SmoothingRecursiveGaussianImageFilter in order to support a procedural API See: itk::simple::SmoothingRecursiveGaussianImageFilter for the object oriented interface
    • abs

      public static Image abs(Image image1)
    • absoluteValueDifference

      public static Image absoluteValueDifference(Image image1, Image image2)
      Image itk::simple::AbsoluteValueDifference(Image &&image1, double constant)
    • absoluteValueDifference

      public static Image absoluteValueDifference(Image image1, double constant)
      Image itk::simple::AbsoluteValueDifference(Image &&image1, double constant)
    • absoluteValueDifference

      public static Image absoluteValueDifference(double constant, Image image2)
      Image itk::simple::AbsoluteValueDifference(Image &&image1, double constant)
    • acos

      public static Image acos(Image image1)
    • adaptiveHistogramEqualization

      public static Image adaptiveHistogramEqualization(Image image1, VectorUInt32 radius, float alpha, float beta)
    • adaptiveHistogramEqualization

      public static Image adaptiveHistogramEqualization(Image image1, VectorUInt32 radius, float alpha)
    • adaptiveHistogramEqualization

      public static Image adaptiveHistogramEqualization(Image image1, VectorUInt32 radius)
    • adaptiveHistogramEqualization

      public static Image adaptiveHistogramEqualization(Image image1)
    • add

      public static Image add(Image image1, Image image2)
      Image itk::simple::Add(Image &&image1, double constant)
    • add

      public static Image add(Image image1, double constant)
      Image itk::simple::Add(Image &&image1, double constant)
    • add

      public static Image add(double constant, Image image2)
      Image itk::simple::Add(Image &&image1, double constant)
    • additiveGaussianNoise

      public static Image additiveGaussianNoise(Image image1, double standardDeviation, double mean, long seed)
    • additiveGaussianNoise

      public static Image additiveGaussianNoise(Image image1, double standardDeviation, double mean)
    • additiveGaussianNoise

      public static Image additiveGaussianNoise(Image image1, double standardDeviation)
    • additiveGaussianNoise

      public static Image additiveGaussianNoise(Image image1)
    • aggregateLabelMap

      public static Image aggregateLabelMap(Image image1)
    • and

      public static Image and(Image image1, Image image2)
      Image itk::simple::And(int constant, const Image &image2)
    • and

      public static Image and(Image image1, int constant)
      Image itk::simple::And(int constant, const Image &image2)
    • and

      public static Image and(int constant, Image image2)
      Image itk::simple::And(int constant, const Image &image2)
    • antiAliasBinary

      public static Image antiAliasBinary(Image image1, double maximumRMSError, long numberOfIterations)
    • antiAliasBinary

      public static Image antiAliasBinary(Image image1, double maximumRMSError)
    • antiAliasBinary

      public static Image antiAliasBinary(Image image1)
    • approximateSignedDistanceMap

      public static Image approximateSignedDistanceMap(Image image1, double insideValue, double outsideValue)
    • approximateSignedDistanceMap

      public static Image approximateSignedDistanceMap(Image image1, double insideValue)
    • approximateSignedDistanceMap

      public static Image approximateSignedDistanceMap(Image image1)
    • areaClosing

      public static Image areaClosing(Image image1, double lambda, boolean useImageSpacing, boolean fullyConnected)
    • areaClosing

      public static Image areaClosing(Image image1, double lambda, boolean useImageSpacing)
    • areaClosing

      public static Image areaClosing(Image image1, double lambda)
    • areaClosing

      public static Image areaClosing(Image image1)
    • areaOpening

      public static Image areaOpening(Image image1, double lambda, boolean useImageSpacing, boolean fullyConnected)
    • areaOpening

      public static Image areaOpening(Image image1, double lambda, boolean useImageSpacing)
    • areaOpening

      public static Image areaOpening(Image image1, double lambda)
    • areaOpening

      public static Image areaOpening(Image image1)
    • asin

      public static Image asin(Image image1)
    • atan2

      public static Image atan2(Image image1, Image image2)
      Image itk::simple::Atan2(Image &&image1, double constant)
    • atan2

      public static Image atan2(Image image1, double constant)
      Image itk::simple::Atan2(Image &&image1, double constant)
    • atan2

      public static Image atan2(double constant, Image image2)
      Image itk::simple::Atan2(Image &&image1, double constant)
    • atan

      public static Image atan(Image image1)
    • bSplineDecomposition

      public static Image bSplineDecomposition(Image image1, long splineOrder)
    • bSplineDecomposition

      public static Image bSplineDecomposition(Image image1)
    • bilateral

      public static Image bilateral(Image image1, double domainSigma, double rangeSigma, long numberOfRangeGaussianSamples)
    • bilateral

      public static Image bilateral(Image image1, double domainSigma, double rangeSigma)
    • bilateral

      public static Image bilateral(Image image1, double domainSigma)
    • bilateral

      public static Image bilateral(Image image1)
    • binShrink

      public static Image binShrink(Image image1, VectorUInt32 shrinkFactors)
    • binShrink

      public static Image binShrink(Image image1)
    • binaryClosingByReconstruction

      public static Image binaryClosingByReconstruction(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double foregroundValue, boolean fullyConnected)
    • binaryClosingByReconstruction

      public static Image binaryClosingByReconstruction(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double foregroundValue)
    • binaryClosingByReconstruction

      public static Image binaryClosingByReconstruction(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • binaryClosingByReconstruction

      public static Image binaryClosingByReconstruction(Image image1, VectorUInt32 kernelRadius)
    • binaryClosingByReconstruction

      public static Image binaryClosingByReconstruction(Image image1)
    • binaryContour

      public static Image binaryContour(Image image1, boolean fullyConnected, double backgroundValue, double foregroundValue)
    • binaryContour

      public static Image binaryContour(Image image1, boolean fullyConnected, double backgroundValue)
    • binaryContour

      public static Image binaryContour(Image image1, boolean fullyConnected)
    • binaryContour

      public static Image binaryContour(Image image1)
    • binaryDilate

      public static Image binaryDilate(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double backgroundValue, double foregroundValue, boolean boundaryToForeground)
    • binaryDilate

      public static Image binaryDilate(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double backgroundValue, double foregroundValue)
    • binaryDilate

      public static Image binaryDilate(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double backgroundValue)
    • binaryDilate

      public static Image binaryDilate(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • binaryDilate

      public static Image binaryDilate(Image image1, VectorUInt32 kernelRadius)
    • binaryDilate

      public static Image binaryDilate(Image image1)
    • binaryErode

      public static Image binaryErode(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double backgroundValue, double foregroundValue, boolean boundaryToForeground)
    • binaryErode

      public static Image binaryErode(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double backgroundValue, double foregroundValue)
    • binaryErode

      public static Image binaryErode(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double backgroundValue)
    • binaryErode

      public static Image binaryErode(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • binaryErode

      public static Image binaryErode(Image image1, VectorUInt32 kernelRadius)
    • binaryErode

      public static Image binaryErode(Image image1)
    • binaryFillhole

      public static Image binaryFillhole(Image image1, boolean fullyConnected, double foregroundValue)
    • binaryFillhole

      public static Image binaryFillhole(Image image1, boolean fullyConnected)
    • binaryFillhole

      public static Image binaryFillhole(Image image1)
    • binaryGrindPeak

      public static Image binaryGrindPeak(Image image1, boolean fullyConnected, double foregroundValue, double backgroundValue)
    • binaryGrindPeak

      public static Image binaryGrindPeak(Image image1, boolean fullyConnected, double foregroundValue)
    • binaryGrindPeak

      public static Image binaryGrindPeak(Image image1, boolean fullyConnected)
    • binaryGrindPeak

      public static Image binaryGrindPeak(Image image1)
    • binaryImageToLabelMap

      public static Image binaryImageToLabelMap(Image image1, boolean fullyConnected, double inputForegroundValue, double outputBackgroundValue)
    • binaryImageToLabelMap

      public static Image binaryImageToLabelMap(Image image1, boolean fullyConnected, double inputForegroundValue)
    • binaryImageToLabelMap

      public static Image binaryImageToLabelMap(Image image1, boolean fullyConnected)
    • binaryImageToLabelMap

      public static Image binaryImageToLabelMap(Image image1)
    • binaryMagnitude

      public static Image binaryMagnitude(Image image1, Image image2)
    • binaryMedian

      public static Image binaryMedian(Image image1, VectorUInt32 radius, double foregroundValue, double backgroundValue)
    • binaryMedian

      public static Image binaryMedian(Image image1, VectorUInt32 radius, double foregroundValue)
    • binaryMedian

      public static Image binaryMedian(Image image1, VectorUInt32 radius)
    • binaryMedian

      public static Image binaryMedian(Image image1)
    • binaryMinMaxCurvatureFlow

      public static Image binaryMinMaxCurvatureFlow(Image image1, double timeStep, long numberOfIterations, int stencilRadius, double threshold)
    • binaryMinMaxCurvatureFlow

      public static Image binaryMinMaxCurvatureFlow(Image image1, double timeStep, long numberOfIterations, int stencilRadius)
    • binaryMinMaxCurvatureFlow

      public static Image binaryMinMaxCurvatureFlow(Image image1, double timeStep, long numberOfIterations)
    • binaryMinMaxCurvatureFlow

      public static Image binaryMinMaxCurvatureFlow(Image image1, double timeStep)
    • binaryMinMaxCurvatureFlow

      public static Image binaryMinMaxCurvatureFlow(Image image1)
    • binaryMorphologicalClosing

      public static Image binaryMorphologicalClosing(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double foregroundValue, boolean safeBorder)
    • binaryMorphologicalClosing

      public static Image binaryMorphologicalClosing(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double foregroundValue)
    • binaryMorphologicalClosing

      public static Image binaryMorphologicalClosing(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • binaryMorphologicalClosing

      public static Image binaryMorphologicalClosing(Image image1, VectorUInt32 kernelRadius)
    • binaryMorphologicalClosing

      public static Image binaryMorphologicalClosing(Image image1)
    • binaryMorphologicalOpening

      public static Image binaryMorphologicalOpening(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double backgroundValue, double foregroundValue)
    • binaryMorphologicalOpening

      public static Image binaryMorphologicalOpening(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double backgroundValue)
    • binaryMorphologicalOpening

      public static Image binaryMorphologicalOpening(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • binaryMorphologicalOpening

      public static Image binaryMorphologicalOpening(Image image1, VectorUInt32 kernelRadius)
    • binaryMorphologicalOpening

      public static Image binaryMorphologicalOpening(Image image1)
    • binaryNot

      public static Image binaryNot(Image image1, double foregroundValue, double backgroundValue)
    • binaryNot

      public static Image binaryNot(Image image1, double foregroundValue)
    • binaryNot

      public static Image binaryNot(Image image1)
    • binaryOpeningByReconstruction

      public static Image binaryOpeningByReconstruction(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double foregroundValue, double backgroundValue, boolean fullyConnected)
    • binaryOpeningByReconstruction

      public static Image binaryOpeningByReconstruction(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double foregroundValue, double backgroundValue)
    • binaryOpeningByReconstruction

      public static Image binaryOpeningByReconstruction(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double foregroundValue)
    • binaryOpeningByReconstruction

      public static Image binaryOpeningByReconstruction(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • binaryOpeningByReconstruction

      public static Image binaryOpeningByReconstruction(Image image1, VectorUInt32 kernelRadius)
    • binaryOpeningByReconstruction

      public static Image binaryOpeningByReconstruction(Image image1)
    • binaryProjection

      public static Image binaryProjection(Image image1, long projectionDimension, double foregroundValue, double backgroundValue)
    • binaryProjection

      public static Image binaryProjection(Image image1, long projectionDimension, double foregroundValue)
    • binaryProjection

      public static Image binaryProjection(Image image1, long projectionDimension)
    • binaryProjection

      public static Image binaryProjection(Image image1)
    • binaryPruning

      public static Image binaryPruning(Image image1, long iteration)
    • binaryPruning

      public static Image binaryPruning(Image image1)
    • binaryReconstructionByDilation

      public static Image binaryReconstructionByDilation(Image markerImage, Image maskImage, double backgroundValue, double foregroundValue, boolean fullyConnected)
    • binaryReconstructionByDilation

      public static Image binaryReconstructionByDilation(Image markerImage, Image maskImage, double backgroundValue, double foregroundValue)
    • binaryReconstructionByDilation

      public static Image binaryReconstructionByDilation(Image markerImage, Image maskImage, double backgroundValue)
    • binaryReconstructionByDilation

      public static Image binaryReconstructionByDilation(Image markerImage, Image maskImage)
    • binaryReconstructionByErosion

      public static Image binaryReconstructionByErosion(Image markerImage, Image maskImage, double backgroundValue, double foregroundValue, boolean fullyConnected)
    • binaryReconstructionByErosion

      public static Image binaryReconstructionByErosion(Image markerImage, Image maskImage, double backgroundValue, double foregroundValue)
    • binaryReconstructionByErosion

      public static Image binaryReconstructionByErosion(Image markerImage, Image maskImage, double backgroundValue)
    • binaryReconstructionByErosion

      public static Image binaryReconstructionByErosion(Image markerImage, Image maskImage)
    • binaryThinning

      public static Image binaryThinning(Image image1)
    • binaryThreshold

      public static Image binaryThreshold(Image image1, double lowerThreshold, double upperThreshold, short insideValue, short outsideValue)
    • binaryThreshold

      public static Image binaryThreshold(Image image1, double lowerThreshold, double upperThreshold, short insideValue)
    • binaryThreshold

      public static Image binaryThreshold(Image image1, double lowerThreshold, double upperThreshold)
    • binaryThreshold

      public static Image binaryThreshold(Image image1, double lowerThreshold)
    • binaryThreshold

      public static Image binaryThreshold(Image image1)
    • binaryThresholdProjection

      public static Image binaryThresholdProjection(Image image1, long projectionDimension, double thresholdValue, short foregroundValue, short backgroundValue)
    • binaryThresholdProjection

      public static Image binaryThresholdProjection(Image image1, long projectionDimension, double thresholdValue, short foregroundValue)
    • binaryThresholdProjection

      public static Image binaryThresholdProjection(Image image1, long projectionDimension, double thresholdValue)
    • binaryThresholdProjection

      public static Image binaryThresholdProjection(Image image1, long projectionDimension)
    • binaryThresholdProjection

      public static Image binaryThresholdProjection(Image image1)
    • binomialBlur

      public static Image binomialBlur(Image image1, long repetitions)
    • binomialBlur

      public static Image binomialBlur(Image image1)
    • bitwiseNot

      public static Image bitwiseNot(Image image1)
    • blackTopHat

      public static Image blackTopHat(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, boolean safeBorder)
    • blackTopHat

      public static Image blackTopHat(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • blackTopHat

      public static Image blackTopHat(Image image1, VectorUInt32 kernelRadius)
    • blackTopHat

      public static Image blackTopHat(Image image1)
    • boundedReciprocal

      public static Image boundedReciprocal(Image image1)
    • boxMean

      public static Image boxMean(Image image1, VectorUInt32 radius)
    • boxMean

      public static Image boxMean(Image image1)
    • boxSigma

      public static Image boxSigma(Image image1, VectorUInt32 radius)
    • boxSigma

      public static Image boxSigma(Image image1)
    • cannyEdgeDetection

      public static Image cannyEdgeDetection(Image image1, double lowerThreshold, double upperThreshold, VectorDouble variance, VectorDouble maximumError)
    • cannyEdgeDetection

      public static Image cannyEdgeDetection(Image image1, double lowerThreshold, double upperThreshold, VectorDouble variance)
    • cannyEdgeDetection

      public static Image cannyEdgeDetection(Image image1, double lowerThreshold, double upperThreshold)
    • cannyEdgeDetection

      public static Image cannyEdgeDetection(Image image1, double lowerThreshold)
    • cannyEdgeDetection

      public static Image cannyEdgeDetection(Image image1)
    • cannySegmentationLevelSet

      public static Image cannySegmentationLevelSet(Image initialImage, Image featureImage, double threshold, double variance, double maximumRMSError, double propagationScaling, double curvatureScaling, double advectionScaling, long numberOfIterations, boolean reverseExpansionDirection, double isoSurfaceValue)
    • cannySegmentationLevelSet

      public static Image cannySegmentationLevelSet(Image initialImage, Image featureImage, double threshold, double variance, double maximumRMSError, double propagationScaling, double curvatureScaling, double advectionScaling, long numberOfIterations, boolean reverseExpansionDirection)
    • cannySegmentationLevelSet

      public static Image cannySegmentationLevelSet(Image initialImage, Image featureImage, double threshold, double variance, double maximumRMSError, double propagationScaling, double curvatureScaling, double advectionScaling, long numberOfIterations)
    • cannySegmentationLevelSet

      public static Image cannySegmentationLevelSet(Image initialImage, Image featureImage, double threshold, double variance, double maximumRMSError, double propagationScaling, double curvatureScaling, double advectionScaling)
    • cannySegmentationLevelSet

      public static Image cannySegmentationLevelSet(Image initialImage, Image featureImage, double threshold, double variance, double maximumRMSError, double propagationScaling, double curvatureScaling)
    • cannySegmentationLevelSet

      public static Image cannySegmentationLevelSet(Image initialImage, Image featureImage, double threshold, double variance, double maximumRMSError, double propagationScaling)
    • cannySegmentationLevelSet

      public static Image cannySegmentationLevelSet(Image initialImage, Image featureImage, double threshold, double variance, double maximumRMSError)
    • cannySegmentationLevelSet

      public static Image cannySegmentationLevelSet(Image initialImage, Image featureImage, double threshold, double variance)
    • cannySegmentationLevelSet

      public static Image cannySegmentationLevelSet(Image initialImage, Image featureImage, double threshold)
    • cannySegmentationLevelSet

      public static Image cannySegmentationLevelSet(Image initialImage, Image featureImage)
    • changeLabel

      public static Image changeLabel(Image image1, DoubleDoubleMap changeMap)
    • changeLabel

      public static Image changeLabel(Image image1)
    • changeLabelLabelMap

      public static Image changeLabelLabelMap(Image image1, DoubleDoubleMap changeMap)
    • changeLabelLabelMap

      public static Image changeLabelLabelMap(Image image1)
    • checkerBoard

      public static Image checkerBoard(Image image1, Image image2, VectorUInt32 checkerPattern)
    • checkerBoard

      public static Image checkerBoard(Image image1, Image image2)
    • clamp

      public static Image clamp(Image image1, PixelIDValueEnum outputPixelType, double lowerBound, double upperBound)
    • clamp

      public static Image clamp(Image image1, PixelIDValueEnum outputPixelType, double lowerBound)
    • clamp

      public static Image clamp(Image image1, PixelIDValueEnum outputPixelType)
    • clamp

      public static Image clamp(Image image1)
    • closingByReconstruction

      public static Image closingByReconstruction(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, boolean fullyConnected, boolean preserveIntensities)
    • closingByReconstruction

      public static Image closingByReconstruction(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, boolean fullyConnected)
    • closingByReconstruction

      public static Image closingByReconstruction(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • closingByReconstruction

      public static Image closingByReconstruction(Image image1, VectorUInt32 kernelRadius)
    • closingByReconstruction

      public static Image closingByReconstruction(Image image1)
    • collidingFronts

      public static Image collidingFronts(Image image1, VectorUIntList seedPoints1, VectorUIntList seedPoints2, boolean applyConnectivity, double negativeEpsilon, boolean stopOnTargets)
    • collidingFronts

      public static Image collidingFronts(Image image1, VectorUIntList seedPoints1, VectorUIntList seedPoints2, boolean applyConnectivity, double negativeEpsilon)
    • collidingFronts

      public static Image collidingFronts(Image image1, VectorUIntList seedPoints1, VectorUIntList seedPoints2, boolean applyConnectivity)
    • collidingFronts

      public static Image collidingFronts(Image image1, VectorUIntList seedPoints1, VectorUIntList seedPoints2)
    • collidingFronts

      public static Image collidingFronts(Image image1, VectorUIntList seedPoints1)
    • collidingFronts

      public static Image collidingFronts(Image image1)
    • complexToImaginary

      public static Image complexToImaginary(Image image1)
    • complexToModulus

      public static Image complexToModulus(Image image1)
    • complexToPhase

      public static Image complexToPhase(Image image1)
    • complexToReal

      public static Image complexToReal(Image image1)
    • compose

      public static Image compose(VectorOfImage images)
    • compose

      public static Image compose(Image image1)
    • compose

      public static Image compose(Image image1, Image image2)
    • compose

      public static Image compose(Image image1, Image image2, Image image3)
    • compose

      public static Image compose(Image image1, Image image2, Image image3, Image image4)
    • compose

      public static Image compose(Image image1, Image image2, Image image3, Image image4, Image image5)
    • confidenceConnected

      public static Image confidenceConnected(Image image1, VectorUIntList seedList, long numberOfIterations, double multiplier, long initialNeighborhoodRadius, short replaceValue)
    • confidenceConnected

      public static Image confidenceConnected(Image image1, VectorUIntList seedList, long numberOfIterations, double multiplier, long initialNeighborhoodRadius)
    • confidenceConnected

      public static Image confidenceConnected(Image image1, VectorUIntList seedList, long numberOfIterations, double multiplier)
    • confidenceConnected

      public static Image confidenceConnected(Image image1, VectorUIntList seedList, long numberOfIterations)
    • confidenceConnected

      public static Image confidenceConnected(Image image1, VectorUIntList seedList)
    • confidenceConnected

      public static Image confidenceConnected(Image image1)
    • connectedComponent

      public static Image connectedComponent(Image image, Image maskImage, boolean fullyConnected)
    • connectedComponent

      public static Image connectedComponent(Image image, Image maskImage)
    • connectedComponent

      public static Image connectedComponent(Image image, boolean fullyConnected)
    • connectedComponent

      public static Image connectedComponent(Image image)
    • connectedThreshold

      public static Image connectedThreshold(Image image1, VectorUIntList seedList, double lower, double upper, short replaceValue, ConnectedThresholdImageFilter.ConnectivityType connectivity)
    • connectedThreshold

      public static Image connectedThreshold(Image image1, VectorUIntList seedList, double lower, double upper, short replaceValue)
    • connectedThreshold

      public static Image connectedThreshold(Image image1, VectorUIntList seedList, double lower, double upper)
    • connectedThreshold

      public static Image connectedThreshold(Image image1, VectorUIntList seedList, double lower)
    • connectedThreshold

      public static Image connectedThreshold(Image image1, VectorUIntList seedList)
    • connectedThreshold

      public static Image connectedThreshold(Image image1)
    • constantPad

      public static Image constantPad(Image image1, VectorUInt32 padLowerBound, VectorUInt32 padUpperBound, double constant)
    • constantPad

      public static Image constantPad(Image image1, VectorUInt32 padLowerBound, VectorUInt32 padUpperBound)
    • constantPad

      public static Image constantPad(Image image1, VectorUInt32 padLowerBound)
    • constantPad

      public static Image constantPad(Image image1)
    • convolution

      public static Image convolution(Image image, Image kernelImage, boolean normalize, ConvolutionImageFilter.BoundaryConditionType boundaryCondition, ConvolutionImageFilter.OutputRegionModeType outputRegionMode)
    • convolution

      public static Image convolution(Image image, Image kernelImage, boolean normalize, ConvolutionImageFilter.BoundaryConditionType boundaryCondition)
    • convolution

      public static Image convolution(Image image, Image kernelImage, boolean normalize)
    • convolution

      public static Image convolution(Image image, Image kernelImage)
    • cos

      public static Image cos(Image image1)
    • crop

      public static Image crop(Image image1, VectorUInt32 lowerBoundaryCropSize, VectorUInt32 upperBoundaryCropSize)
    • crop

      public static Image crop(Image image1, VectorUInt32 lowerBoundaryCropSize)
    • crop

      public static Image crop(Image image1)
    • curvatureAnisotropicDiffusion

      public static Image curvatureAnisotropicDiffusion(Image image1, double timeStep, double conductanceParameter, long conductanceScalingUpdateInterval, long numberOfIterations)
    • curvatureAnisotropicDiffusion

      public static Image curvatureAnisotropicDiffusion(Image image1, double timeStep, double conductanceParameter, long conductanceScalingUpdateInterval)
    • curvatureAnisotropicDiffusion

      public static Image curvatureAnisotropicDiffusion(Image image1, double timeStep, double conductanceParameter)
    • curvatureAnisotropicDiffusion

      public static Image curvatureAnisotropicDiffusion(Image image1, double timeStep)
    • curvatureAnisotropicDiffusion

      public static Image curvatureAnisotropicDiffusion(Image image1)
    • curvatureFlow

      public static Image curvatureFlow(Image image1, double timeStep, long numberOfIterations)
    • curvatureFlow

      public static Image curvatureFlow(Image image1, double timeStep)
    • curvatureFlow

      public static Image curvatureFlow(Image image1)
    • cyclicShift

      public static Image cyclicShift(Image image1, VectorInt32 shift)
    • cyclicShift

      public static Image cyclicShift(Image image1)
    • dICOMOrient

      public static Image dICOMOrient(Image image1, String desiredCoordinateOrientation)
    • dICOMOrient

      public static Image dICOMOrient(Image image1)
    • danielssonDistanceMap

      public static Image danielssonDistanceMap(Image image1, boolean inputIsBinary, boolean squaredDistance, boolean useImageSpacing)
    • danielssonDistanceMap

      public static Image danielssonDistanceMap(Image image1, boolean inputIsBinary, boolean squaredDistance)
    • danielssonDistanceMap

      public static Image danielssonDistanceMap(Image image1, boolean inputIsBinary)
    • danielssonDistanceMap

      public static Image danielssonDistanceMap(Image image1)
    • derivative

      public static Image derivative(Image image1, long direction, long order, boolean useImageSpacing)
    • derivative

      public static Image derivative(Image image1, long direction, long order)
    • derivative

      public static Image derivative(Image image1, long direction)
    • derivative

      public static Image derivative(Image image1)
    • dilateObjectMorphology

      public static Image dilateObjectMorphology(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double objectValue)
    • dilateObjectMorphology

      public static Image dilateObjectMorphology(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • dilateObjectMorphology

      public static Image dilateObjectMorphology(Image image1, VectorUInt32 kernelRadius)
    • dilateObjectMorphology

      public static Image dilateObjectMorphology(Image image1)
    • discreteGaussianDerivative

      public static Image discreteGaussianDerivative(Image image1, VectorDouble variance, VectorUInt32 order, long maximumKernelWidth, double maximumError, boolean useImageSpacing, boolean normalizeAcrossScale)
    • discreteGaussianDerivative

      public static Image discreteGaussianDerivative(Image image1, VectorDouble variance, VectorUInt32 order, long maximumKernelWidth, double maximumError, boolean useImageSpacing)
    • discreteGaussianDerivative

      public static Image discreteGaussianDerivative(Image image1, VectorDouble variance, VectorUInt32 order, long maximumKernelWidth, double maximumError)
    • discreteGaussianDerivative

      public static Image discreteGaussianDerivative(Image image1, VectorDouble variance, VectorUInt32 order, long maximumKernelWidth)
    • discreteGaussianDerivative

      public static Image discreteGaussianDerivative(Image image1, VectorDouble variance, VectorUInt32 order)
    • discreteGaussianDerivative

      public static Image discreteGaussianDerivative(Image image1, VectorDouble variance)
    • discreteGaussianDerivative

      public static Image discreteGaussianDerivative(Image image1)
    • discreteGaussian

      public static Image discreteGaussian(Image image1, VectorDouble variance, long maximumKernelWidth, VectorDouble maximumError, boolean useImageSpacing)
      Image itk::simple::DiscreteGaussian(const Image &image1, double variance, unsigned int maximumKernelWidth=32u, double maximumError=0.01, bool useImageSpacing=true) Blurs an image by separable convolution with discrete gaussian kernels. This filter performs Gaussian blurring by separable convolution of an image and a discrete Gaussian operator (kernel). This function directly calls the execute method of DiscreteGaussianImageFilter in order to support a procedural API See: itk::simple::DiscreteGaussianImageFilter for the object oriented interface
    • discreteGaussian

      public static Image discreteGaussian(Image image1, VectorDouble variance, long maximumKernelWidth, VectorDouble maximumError)
      Image itk::simple::DiscreteGaussian(const Image &image1, double variance, unsigned int maximumKernelWidth=32u, double maximumError=0.01, bool useImageSpacing=true) Blurs an image by separable convolution with discrete gaussian kernels. This filter performs Gaussian blurring by separable convolution of an image and a discrete Gaussian operator (kernel). This function directly calls the execute method of DiscreteGaussianImageFilter in order to support a procedural API See: itk::simple::DiscreteGaussianImageFilter for the object oriented interface
    • discreteGaussian

      public static Image discreteGaussian(Image image1, VectorDouble variance, long maximumKernelWidth)
      Image itk::simple::DiscreteGaussian(const Image &image1, double variance, unsigned int maximumKernelWidth=32u, double maximumError=0.01, bool useImageSpacing=true) Blurs an image by separable convolution with discrete gaussian kernels. This filter performs Gaussian blurring by separable convolution of an image and a discrete Gaussian operator (kernel). This function directly calls the execute method of DiscreteGaussianImageFilter in order to support a procedural API See: itk::simple::DiscreteGaussianImageFilter for the object oriented interface
    • discreteGaussian

      public static Image discreteGaussian(Image image1, VectorDouble variance)
      Image itk::simple::DiscreteGaussian(const Image &image1, double variance, unsigned int maximumKernelWidth=32u, double maximumError=0.01, bool useImageSpacing=true) Blurs an image by separable convolution with discrete gaussian kernels. This filter performs Gaussian blurring by separable convolution of an image and a discrete Gaussian operator (kernel). This function directly calls the execute method of DiscreteGaussianImageFilter in order to support a procedural API See: itk::simple::DiscreteGaussianImageFilter for the object oriented interface
    • discreteGaussian

      public static Image discreteGaussian(Image image1)
      Image itk::simple::DiscreteGaussian(const Image &image1, double variance, unsigned int maximumKernelWidth=32u, double maximumError=0.01, bool useImageSpacing=true) Blurs an image by separable convolution with discrete gaussian kernels. This filter performs Gaussian blurring by separable convolution of an image and a discrete Gaussian operator (kernel). This function directly calls the execute method of DiscreteGaussianImageFilter in order to support a procedural API See: itk::simple::DiscreteGaussianImageFilter for the object oriented interface
    • displacementFieldJacobianDeterminant

      public static Image displacementFieldJacobianDeterminant(Image image1, boolean useImageSpacing, VectorDouble derivativeWeights)
    • displacementFieldJacobianDeterminant

      public static Image displacementFieldJacobianDeterminant(Image image1, boolean useImageSpacing)
    • displacementFieldJacobianDeterminant

      public static Image displacementFieldJacobianDeterminant(Image image1)
    • divideFloor

      public static Image divideFloor(Image image1, Image image2)
      Image itk::simple::DivideFloor(Image &&image1, double constant)
    • divideFloor

      public static Image divideFloor(Image image1, double constant)
      Image itk::simple::DivideFloor(Image &&image1, double constant)
    • divideFloor

      public static Image divideFloor(double constant, Image image2)
      Image itk::simple::DivideFloor(Image &&image1, double constant)
    • divide

      public static Image divide(Image image1, Image image2)
      Image itk::simple::Divide(Image &&image1, double constant)
    • divide

      public static Image divide(Image image1, double constant)
      Image itk::simple::Divide(Image &&image1, double constant)
    • divide

      public static Image divide(double constant, Image image2)
      Image itk::simple::Divide(Image &&image1, double constant)
    • divideReal

      public static Image divideReal(Image image1, Image image2)
      Image itk::simple::DivideReal(Image &&image1, double constant)
    • divideReal

      public static Image divideReal(Image image1, double constant)
      Image itk::simple::DivideReal(Image &&image1, double constant)
    • divideReal

      public static Image divideReal(double constant, Image image2)
      Image itk::simple::DivideReal(Image &&image1, double constant)
    • doubleThreshold

      public static Image doubleThreshold(Image image1, double threshold1, double threshold2, double threshold3, double threshold4, short insideValue, short outsideValue, boolean fullyConnected)
    • doubleThreshold

      public static Image doubleThreshold(Image image1, double threshold1, double threshold2, double threshold3, double threshold4, short insideValue, short outsideValue)
    • doubleThreshold

      public static Image doubleThreshold(Image image1, double threshold1, double threshold2, double threshold3, double threshold4, short insideValue)
    • doubleThreshold

      public static Image doubleThreshold(Image image1, double threshold1, double threshold2, double threshold3, double threshold4)
    • doubleThreshold

      public static Image doubleThreshold(Image image1, double threshold1, double threshold2, double threshold3)
    • doubleThreshold

      public static Image doubleThreshold(Image image1, double threshold1, double threshold2)
    • doubleThreshold

      public static Image doubleThreshold(Image image1, double threshold1)
    • doubleThreshold

      public static Image doubleThreshold(Image image1)
    • edgePotential

      public static Image edgePotential(Image image1)
    • equal

      public static Image equal(Image image1, Image image2, short backgroundValue, short foregroundValue)
      Image itk::simple::Equal(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • equal

      public static Image equal(Image image1, Image image2, short backgroundValue)
      Image itk::simple::Equal(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • equal

      public static Image equal(Image image1, Image image2)
      Image itk::simple::Equal(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • equal

      public static Image equal(Image image1, double constant, short backgroundValue, short foregroundValue)
      Image itk::simple::Equal(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • equal

      public static Image equal(Image image1, double constant, short backgroundValue)
      Image itk::simple::Equal(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • equal

      public static Image equal(Image image1, double constant)
      Image itk::simple::Equal(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • equal

      public static Image equal(double constant, Image image2, short backgroundValue, short foregroundValue)
      Image itk::simple::Equal(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • equal

      public static Image equal(double constant, Image image2, short backgroundValue)
      Image itk::simple::Equal(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • equal

      public static Image equal(double constant, Image image2)
      Image itk::simple::Equal(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • erodeObjectMorphology

      public static Image erodeObjectMorphology(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double objectValue, double backgroundValue)
    • erodeObjectMorphology

      public static Image erodeObjectMorphology(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, double objectValue)
    • erodeObjectMorphology

      public static Image erodeObjectMorphology(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • erodeObjectMorphology

      public static Image erodeObjectMorphology(Image image1, VectorUInt32 kernelRadius)
    • erodeObjectMorphology

      public static Image erodeObjectMorphology(Image image1)
    • exp

      public static Image exp(Image image1)
    • expNegative

      public static Image expNegative(Image image1)
    • expand

      public static Image expand(Image image1, VectorUInt32 expandFactors, InterpolatorEnum interpolator)
    • expand

      public static Image expand(Image image1, VectorUInt32 expandFactors)
    • expand

      public static Image expand(Image image1)
    • fFTConvolution

      public static Image fFTConvolution(Image image, Image kernelImage, boolean normalize, FFTConvolutionImageFilter.BoundaryConditionType boundaryCondition, FFTConvolutionImageFilter.OutputRegionModeType outputRegionMode)
    • fFTConvolution

      public static Image fFTConvolution(Image image, Image kernelImage, boolean normalize, FFTConvolutionImageFilter.BoundaryConditionType boundaryCondition)
    • fFTConvolution

      public static Image fFTConvolution(Image image, Image kernelImage, boolean normalize)
    • fFTConvolution

      public static Image fFTConvolution(Image image, Image kernelImage)
    • fFTNormalizedCorrelation

      public static Image fFTNormalizedCorrelation(Image fixedImage, Image movingImage, long requiredNumberOfOverlappingPixels, double requiredFractionOfOverlappingPixels)
    • fFTNormalizedCorrelation

      public static Image fFTNormalizedCorrelation(Image fixedImage, Image movingImage, long requiredNumberOfOverlappingPixels)
    • fFTNormalizedCorrelation

      public static Image fFTNormalizedCorrelation(Image fixedImage, Image movingImage)
    • fFTPad

      public static Image fFTPad(Image image1, FFTPadImageFilter.BoundaryConditionType boundaryCondition, int sizeGreatestPrimeFactor)
    • fFTPad

      public static Image fFTPad(Image image1, FFTPadImageFilter.BoundaryConditionType boundaryCondition)
    • fFTPad

      public static Image fFTPad(Image image1)
    • fFTShift

      public static Image fFTShift(Image image1, boolean inverse)
    • fFTShift

      public static Image fFTShift(Image image1)
    • fastApproximateRank

      public static Image fastApproximateRank(Image image1, double rank, VectorUInt32 radius)
    • fastApproximateRank

      public static Image fastApproximateRank(Image image1, double rank)
    • fastApproximateRank

      public static Image fastApproximateRank(Image image1)
    • fastMarchingBase

      public static Image fastMarchingBase(Image image1, VectorUIntList trialPoints, double normalizationFactor, double stoppingValue, FastMarchingBaseImageFilter.TopologyCheckType topologyCheck, VectorDouble initialTrialValues)
    • fastMarchingBase

      public static Image fastMarchingBase(Image image1, VectorUIntList trialPoints, double normalizationFactor, double stoppingValue, FastMarchingBaseImageFilter.TopologyCheckType topologyCheck)
    • fastMarchingBase

      public static Image fastMarchingBase(Image image1, VectorUIntList trialPoints, double normalizationFactor, double stoppingValue)
    • fastMarchingBase

      public static Image fastMarchingBase(Image image1, VectorUIntList trialPoints, double normalizationFactor)
    • fastMarchingBase

      public static Image fastMarchingBase(Image image1, VectorUIntList trialPoints)
    • fastMarchingBase

      public static Image fastMarchingBase(Image image1)
    • fastMarching

      public static Image fastMarching(Image image1, VectorUIntList trialPoints, double normalizationFactor, double stoppingValue, VectorDouble initialTrialValues)
    • fastMarching

      public static Image fastMarching(Image image1, VectorUIntList trialPoints, double normalizationFactor, double stoppingValue)
    • fastMarching

      public static Image fastMarching(Image image1, VectorUIntList trialPoints, double normalizationFactor)
    • fastMarching

      public static Image fastMarching(Image image1, VectorUIntList trialPoints)
    • fastMarching

      public static Image fastMarching(Image image1)
    • fastMarchingUpwindGradient

      public static Image fastMarchingUpwindGradient(Image image1, VectorUIntList trialPoints, long numberOfTargets, VectorUIntList targetPoints, double targetOffset, double normalizationFactor, VectorDouble initialTrialValues)
    • fastMarchingUpwindGradient

      public static Image fastMarchingUpwindGradient(Image image1, VectorUIntList trialPoints, long numberOfTargets, VectorUIntList targetPoints, double targetOffset, double normalizationFactor)
    • fastMarchingUpwindGradient

      public static Image fastMarchingUpwindGradient(Image image1, VectorUIntList trialPoints, long numberOfTargets, VectorUIntList targetPoints, double targetOffset)
    • fastMarchingUpwindGradient

      public static Image fastMarchingUpwindGradient(Image image1, VectorUIntList trialPoints, long numberOfTargets, VectorUIntList targetPoints)
    • fastMarchingUpwindGradient

      public static Image fastMarchingUpwindGradient(Image image1, VectorUIntList trialPoints, long numberOfTargets)
    • fastMarchingUpwindGradient

      public static Image fastMarchingUpwindGradient(Image image1, VectorUIntList trialPoints)
    • fastMarchingUpwindGradient

      public static Image fastMarchingUpwindGradient(Image image1)
    • flip

      public static Image flip(Image image1, VectorBool flipAxes, boolean flipAboutOrigin)
    • flip

      public static Image flip(Image image1, VectorBool flipAxes)
    • flip

      public static Image flip(Image image1)
    • forwardFFT

      public static Image forwardFFT(Image image1)
    • gaborSource

      public static Image gaborSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble mean, double frequency, VectorDouble origin, VectorDouble spacing, VectorDouble direction)
      Image itk::simple::GaborSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double frequency=0.4, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an n-dimensional image of a Gabor filter. This function directly calls the execute method of GaborImageSource in order to support a procedural API See: itk::simple::GaborImageSource for the object oriented interface
    • gaborSource

      public static Image gaborSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble mean, double frequency, VectorDouble origin, VectorDouble spacing)
      Image itk::simple::GaborSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double frequency=0.4, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an n-dimensional image of a Gabor filter. This function directly calls the execute method of GaborImageSource in order to support a procedural API See: itk::simple::GaborImageSource for the object oriented interface
    • gaborSource

      public static Image gaborSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble mean, double frequency, VectorDouble origin)
      Image itk::simple::GaborSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double frequency=0.4, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an n-dimensional image of a Gabor filter. This function directly calls the execute method of GaborImageSource in order to support a procedural API See: itk::simple::GaborImageSource for the object oriented interface
    • gaborSource

      public static Image gaborSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble mean, double frequency)
      Image itk::simple::GaborSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double frequency=0.4, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an n-dimensional image of a Gabor filter. This function directly calls the execute method of GaborImageSource in order to support a procedural API See: itk::simple::GaborImageSource for the object oriented interface
    • gaborSource

      public static Image gaborSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble mean)
      Image itk::simple::GaborSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double frequency=0.4, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an n-dimensional image of a Gabor filter. This function directly calls the execute method of GaborImageSource in order to support a procedural API See: itk::simple::GaborImageSource for the object oriented interface
    • gaborSource

      public static Image gaborSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma)
      Image itk::simple::GaborSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double frequency=0.4, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an n-dimensional image of a Gabor filter. This function directly calls the execute method of GaborImageSource in order to support a procedural API See: itk::simple::GaborImageSource for the object oriented interface
    • gaborSource

      public static Image gaborSource(PixelIDValueEnum outputPixelType, VectorUInt32 size)
      Image itk::simple::GaborSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double frequency=0.4, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an n-dimensional image of a Gabor filter. This function directly calls the execute method of GaborImageSource in order to support a procedural API See: itk::simple::GaborImageSource for the object oriented interface
    • gaborSource

      public static Image gaborSource(PixelIDValueEnum outputPixelType)
      Image itk::simple::GaborSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double frequency=0.4, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an n-dimensional image of a Gabor filter. This function directly calls the execute method of GaborImageSource in order to support a procedural API See: itk::simple::GaborImageSource for the object oriented interface
    • gaborSource

      public static Image gaborSource()
      Image itk::simple::GaborSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double frequency=0.4, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an n-dimensional image of a Gabor filter. This function directly calls the execute method of GaborImageSource in order to support a procedural API See: itk::simple::GaborImageSource for the object oriented interface
    • gaussianSource

      public static Image gaussianSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble mean, double scale, VectorDouble origin, VectorDouble spacing, VectorDouble direction, boolean normalized)
      Image itk::simple::GaussianSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double scale=255, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), bool normalized=false) Generate an n-dimensional image of a Gaussian. This function directly calls the execute method of GaussianImageSource in order to support a procedural API See: itk::simple::GaussianImageSource for the object oriented interface
    • gaussianSource

      public static Image gaussianSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble mean, double scale, VectorDouble origin, VectorDouble spacing, VectorDouble direction)
      Image itk::simple::GaussianSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double scale=255, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), bool normalized=false) Generate an n-dimensional image of a Gaussian. This function directly calls the execute method of GaussianImageSource in order to support a procedural API See: itk::simple::GaussianImageSource for the object oriented interface
    • gaussianSource

      public static Image gaussianSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble mean, double scale, VectorDouble origin, VectorDouble spacing)
      Image itk::simple::GaussianSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double scale=255, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), bool normalized=false) Generate an n-dimensional image of a Gaussian. This function directly calls the execute method of GaussianImageSource in order to support a procedural API See: itk::simple::GaussianImageSource for the object oriented interface
    • gaussianSource

      public static Image gaussianSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble mean, double scale, VectorDouble origin)
      Image itk::simple::GaussianSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double scale=255, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), bool normalized=false) Generate an n-dimensional image of a Gaussian. This function directly calls the execute method of GaussianImageSource in order to support a procedural API See: itk::simple::GaussianImageSource for the object oriented interface
    • gaussianSource

      public static Image gaussianSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble mean, double scale)
      Image itk::simple::GaussianSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double scale=255, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), bool normalized=false) Generate an n-dimensional image of a Gaussian. This function directly calls the execute method of GaussianImageSource in order to support a procedural API See: itk::simple::GaussianImageSource for the object oriented interface
    • gaussianSource

      public static Image gaussianSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble mean)
      Image itk::simple::GaussianSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double scale=255, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), bool normalized=false) Generate an n-dimensional image of a Gaussian. This function directly calls the execute method of GaussianImageSource in order to support a procedural API See: itk::simple::GaussianImageSource for the object oriented interface
    • gaussianSource

      public static Image gaussianSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma)
      Image itk::simple::GaussianSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double scale=255, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), bool normalized=false) Generate an n-dimensional image of a Gaussian. This function directly calls the execute method of GaussianImageSource in order to support a procedural API See: itk::simple::GaussianImageSource for the object oriented interface
    • gaussianSource

      public static Image gaussianSource(PixelIDValueEnum outputPixelType, VectorUInt32 size)
      Image itk::simple::GaussianSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double scale=255, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), bool normalized=false) Generate an n-dimensional image of a Gaussian. This function directly calls the execute method of GaussianImageSource in order to support a procedural API See: itk::simple::GaussianImageSource for the object oriented interface
    • gaussianSource

      public static Image gaussianSource(PixelIDValueEnum outputPixelType)
      Image itk::simple::GaussianSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double scale=255, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), bool normalized=false) Generate an n-dimensional image of a Gaussian. This function directly calls the execute method of GaussianImageSource in order to support a procedural API See: itk::simple::GaussianImageSource for the object oriented interface
    • gaussianSource

      public static Image gaussianSource()
      Image itk::simple::GaussianSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 16.0), std::vector< double > mean=std::vector< double >(3, 32.0), double scale=255, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), bool normalized=false) Generate an n-dimensional image of a Gaussian. This function directly calls the execute method of GaussianImageSource in order to support a procedural API See: itk::simple::GaussianImageSource for the object oriented interface
    • geodesicActiveContourLevelSet

      public static Image geodesicActiveContourLevelSet(Image initialImage, Image featureImage, double maximumRMSError, double propagationScaling, double curvatureScaling, double advectionScaling, long numberOfIterations, boolean reverseExpansionDirection)
    • geodesicActiveContourLevelSet

      public static Image geodesicActiveContourLevelSet(Image initialImage, Image featureImage, double maximumRMSError, double propagationScaling, double curvatureScaling, double advectionScaling, long numberOfIterations)
    • geodesicActiveContourLevelSet

      public static Image geodesicActiveContourLevelSet(Image initialImage, Image featureImage, double maximumRMSError, double propagationScaling, double curvatureScaling, double advectionScaling)
    • geodesicActiveContourLevelSet

      public static Image geodesicActiveContourLevelSet(Image initialImage, Image featureImage, double maximumRMSError, double propagationScaling, double curvatureScaling)
    • geodesicActiveContourLevelSet

      public static Image geodesicActiveContourLevelSet(Image initialImage, Image featureImage, double maximumRMSError, double propagationScaling)
    • geodesicActiveContourLevelSet

      public static Image geodesicActiveContourLevelSet(Image initialImage, Image featureImage, double maximumRMSError)
    • geodesicActiveContourLevelSet

      public static Image geodesicActiveContourLevelSet(Image initialImage, Image featureImage)
    • gradientAnisotropicDiffusion

      public static Image gradientAnisotropicDiffusion(Image image1, double timeStep, double conductanceParameter, long conductanceScalingUpdateInterval, long numberOfIterations)
    • gradientAnisotropicDiffusion

      public static Image gradientAnisotropicDiffusion(Image image1, double timeStep, double conductanceParameter, long conductanceScalingUpdateInterval)
    • gradientAnisotropicDiffusion

      public static Image gradientAnisotropicDiffusion(Image image1, double timeStep, double conductanceParameter)
    • gradientAnisotropicDiffusion

      public static Image gradientAnisotropicDiffusion(Image image1, double timeStep)
    • gradientAnisotropicDiffusion

      public static Image gradientAnisotropicDiffusion(Image image1)
    • gradient

      public static Image gradient(Image image1, boolean useImageSpacing, boolean useImageDirection)
    • gradient

      public static Image gradient(Image image1, boolean useImageSpacing)
    • gradient

      public static Image gradient(Image image1)
    • gradientMagnitude

      public static Image gradientMagnitude(Image image1, boolean useImageSpacing)
    • gradientMagnitude

      public static Image gradientMagnitude(Image image1)
    • gradientMagnitudeRecursiveGaussian

      public static Image gradientMagnitudeRecursiveGaussian(Image image1, double sigma, boolean normalizeAcrossScale)
    • gradientMagnitudeRecursiveGaussian

      public static Image gradientMagnitudeRecursiveGaussian(Image image1, double sigma)
    • gradientMagnitudeRecursiveGaussian

      public static Image gradientMagnitudeRecursiveGaussian(Image image1)
    • gradientRecursiveGaussian

      public static Image gradientRecursiveGaussian(Image image1, double sigma, boolean normalizeAcrossScale, boolean useImageDirection)
    • gradientRecursiveGaussian

      public static Image gradientRecursiveGaussian(Image image1, double sigma, boolean normalizeAcrossScale)
    • gradientRecursiveGaussian

      public static Image gradientRecursiveGaussian(Image image1, double sigma)
    • gradientRecursiveGaussian

      public static Image gradientRecursiveGaussian(Image image1)
    • grayscaleConnectedClosing

      public static Image grayscaleConnectedClosing(Image image1, VectorUInt32 seed, boolean fullyConnected)
    • grayscaleConnectedClosing

      public static Image grayscaleConnectedClosing(Image image1, VectorUInt32 seed)
    • grayscaleConnectedClosing

      public static Image grayscaleConnectedClosing(Image image1)
    • grayscaleConnectedOpening

      public static Image grayscaleConnectedOpening(Image image1, VectorUInt32 seed, boolean fullyConnected)
    • grayscaleConnectedOpening

      public static Image grayscaleConnectedOpening(Image image1, VectorUInt32 seed)
    • grayscaleConnectedOpening

      public static Image grayscaleConnectedOpening(Image image1)
    • grayscaleDilate

      public static Image grayscaleDilate(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • grayscaleDilate

      public static Image grayscaleDilate(Image image1, VectorUInt32 kernelRadius)
    • grayscaleDilate

      public static Image grayscaleDilate(Image image1)
    • grayscaleErode

      public static Image grayscaleErode(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • grayscaleErode

      public static Image grayscaleErode(Image image1, VectorUInt32 kernelRadius)
    • grayscaleErode

      public static Image grayscaleErode(Image image1)
    • grayscaleFillhole

      public static Image grayscaleFillhole(Image image1, boolean fullyConnected)
    • grayscaleFillhole

      public static Image grayscaleFillhole(Image image1)
    • grayscaleGeodesicDilate

      public static Image grayscaleGeodesicDilate(Image image1, Image image2, boolean runOneIteration, boolean fullyConnected)
    • grayscaleGeodesicDilate

      public static Image grayscaleGeodesicDilate(Image image1, Image image2, boolean runOneIteration)
    • grayscaleGeodesicDilate

      public static Image grayscaleGeodesicDilate(Image image1, Image image2)
    • grayscaleGeodesicErode

      public static Image grayscaleGeodesicErode(Image image1, Image image2, boolean runOneIteration, boolean fullyConnected)
    • grayscaleGeodesicErode

      public static Image grayscaleGeodesicErode(Image image1, Image image2, boolean runOneIteration)
    • grayscaleGeodesicErode

      public static Image grayscaleGeodesicErode(Image image1, Image image2)
    • grayscaleGrindPeak

      public static Image grayscaleGrindPeak(Image image1, boolean fullyConnected)
    • grayscaleGrindPeak

      public static Image grayscaleGrindPeak(Image image1)
    • grayscaleMorphologicalClosing

      public static Image grayscaleMorphologicalClosing(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, boolean safeBorder)
    • grayscaleMorphologicalClosing

      public static Image grayscaleMorphologicalClosing(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • grayscaleMorphologicalClosing

      public static Image grayscaleMorphologicalClosing(Image image1, VectorUInt32 kernelRadius)
    • grayscaleMorphologicalClosing

      public static Image grayscaleMorphologicalClosing(Image image1)
    • grayscaleMorphologicalOpening

      public static Image grayscaleMorphologicalOpening(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, boolean safeBorder)
    • grayscaleMorphologicalOpening

      public static Image grayscaleMorphologicalOpening(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • grayscaleMorphologicalOpening

      public static Image grayscaleMorphologicalOpening(Image image1, VectorUInt32 kernelRadius)
    • grayscaleMorphologicalOpening

      public static Image grayscaleMorphologicalOpening(Image image1)
    • greaterEqual

      public static Image greaterEqual(Image image1, Image image2, short backgroundValue, short foregroundValue)
      Image itk::simple::GreaterEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greaterEqual

      public static Image greaterEqual(Image image1, Image image2, short backgroundValue)
      Image itk::simple::GreaterEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greaterEqual

      public static Image greaterEqual(Image image1, Image image2)
      Image itk::simple::GreaterEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greaterEqual

      public static Image greaterEqual(Image image1, double constant, short backgroundValue, short foregroundValue)
      Image itk::simple::GreaterEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greaterEqual

      public static Image greaterEqual(Image image1, double constant, short backgroundValue)
      Image itk::simple::GreaterEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greaterEqual

      public static Image greaterEqual(Image image1, double constant)
      Image itk::simple::GreaterEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greaterEqual

      public static Image greaterEqual(double constant, Image image2, short backgroundValue, short foregroundValue)
      Image itk::simple::GreaterEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greaterEqual

      public static Image greaterEqual(double constant, Image image2, short backgroundValue)
      Image itk::simple::GreaterEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greaterEqual

      public static Image greaterEqual(double constant, Image image2)
      Image itk::simple::GreaterEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greater

      public static Image greater(Image image1, Image image2, short backgroundValue, short foregroundValue)
      Image itk::simple::Greater(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greater

      public static Image greater(Image image1, Image image2, short backgroundValue)
      Image itk::simple::Greater(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greater

      public static Image greater(Image image1, Image image2)
      Image itk::simple::Greater(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greater

      public static Image greater(Image image1, double constant, short backgroundValue, short foregroundValue)
      Image itk::simple::Greater(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greater

      public static Image greater(Image image1, double constant, short backgroundValue)
      Image itk::simple::Greater(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greater

      public static Image greater(Image image1, double constant)
      Image itk::simple::Greater(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greater

      public static Image greater(double constant, Image image2, short backgroundValue, short foregroundValue)
      Image itk::simple::Greater(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greater

      public static Image greater(double constant, Image image2, short backgroundValue)
      Image itk::simple::Greater(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • greater

      public static Image greater(double constant, Image image2)
      Image itk::simple::Greater(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • gridSource

      public static Image gridSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble gridSpacing, VectorDouble gridOffset, double scale, VectorDouble origin, VectorDouble spacing, VectorDouble direction, VectorBool whichDimensions)
      Image itk::simple::GridSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 0.5), std::vector< double > gridSpacing=std::vector< double >(3, 4.0), std::vector< double > gridOffset=std::vector< double >(3, 0.0), double scale=255.0, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), std::vector< bool > whichDimensions=std::vector< bool >(3, true)) Generate an n-dimensional image of a grid. This function directly calls the execute method of GridImageSource in order to support a procedural API See: itk::simple::GridImageSource for the object oriented interface
    • gridSource

      public static Image gridSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble gridSpacing, VectorDouble gridOffset, double scale, VectorDouble origin, VectorDouble spacing, VectorDouble direction)
      Image itk::simple::GridSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 0.5), std::vector< double > gridSpacing=std::vector< double >(3, 4.0), std::vector< double > gridOffset=std::vector< double >(3, 0.0), double scale=255.0, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), std::vector< bool > whichDimensions=std::vector< bool >(3, true)) Generate an n-dimensional image of a grid. This function directly calls the execute method of GridImageSource in order to support a procedural API See: itk::simple::GridImageSource for the object oriented interface
    • gridSource

      public static Image gridSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble gridSpacing, VectorDouble gridOffset, double scale, VectorDouble origin, VectorDouble spacing)
      Image itk::simple::GridSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 0.5), std::vector< double > gridSpacing=std::vector< double >(3, 4.0), std::vector< double > gridOffset=std::vector< double >(3, 0.0), double scale=255.0, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), std::vector< bool > whichDimensions=std::vector< bool >(3, true)) Generate an n-dimensional image of a grid. This function directly calls the execute method of GridImageSource in order to support a procedural API See: itk::simple::GridImageSource for the object oriented interface
    • gridSource

      public static Image gridSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble gridSpacing, VectorDouble gridOffset, double scale, VectorDouble origin)
      Image itk::simple::GridSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 0.5), std::vector< double > gridSpacing=std::vector< double >(3, 4.0), std::vector< double > gridOffset=std::vector< double >(3, 0.0), double scale=255.0, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), std::vector< bool > whichDimensions=std::vector< bool >(3, true)) Generate an n-dimensional image of a grid. This function directly calls the execute method of GridImageSource in order to support a procedural API See: itk::simple::GridImageSource for the object oriented interface
    • gridSource

      public static Image gridSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble gridSpacing, VectorDouble gridOffset, double scale)
      Image itk::simple::GridSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 0.5), std::vector< double > gridSpacing=std::vector< double >(3, 4.0), std::vector< double > gridOffset=std::vector< double >(3, 0.0), double scale=255.0, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), std::vector< bool > whichDimensions=std::vector< bool >(3, true)) Generate an n-dimensional image of a grid. This function directly calls the execute method of GridImageSource in order to support a procedural API See: itk::simple::GridImageSource for the object oriented interface
    • gridSource

      public static Image gridSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble gridSpacing, VectorDouble gridOffset)
      Image itk::simple::GridSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 0.5), std::vector< double > gridSpacing=std::vector< double >(3, 4.0), std::vector< double > gridOffset=std::vector< double >(3, 0.0), double scale=255.0, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), std::vector< bool > whichDimensions=std::vector< bool >(3, true)) Generate an n-dimensional image of a grid. This function directly calls the execute method of GridImageSource in order to support a procedural API See: itk::simple::GridImageSource for the object oriented interface
    • gridSource

      public static Image gridSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma, VectorDouble gridSpacing)
      Image itk::simple::GridSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 0.5), std::vector< double > gridSpacing=std::vector< double >(3, 4.0), std::vector< double > gridOffset=std::vector< double >(3, 0.0), double scale=255.0, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), std::vector< bool > whichDimensions=std::vector< bool >(3, true)) Generate an n-dimensional image of a grid. This function directly calls the execute method of GridImageSource in order to support a procedural API See: itk::simple::GridImageSource for the object oriented interface
    • gridSource

      public static Image gridSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble sigma)
      Image itk::simple::GridSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 0.5), std::vector< double > gridSpacing=std::vector< double >(3, 4.0), std::vector< double > gridOffset=std::vector< double >(3, 0.0), double scale=255.0, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), std::vector< bool > whichDimensions=std::vector< bool >(3, true)) Generate an n-dimensional image of a grid. This function directly calls the execute method of GridImageSource in order to support a procedural API See: itk::simple::GridImageSource for the object oriented interface
    • gridSource

      public static Image gridSource(PixelIDValueEnum outputPixelType, VectorUInt32 size)
      Image itk::simple::GridSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 0.5), std::vector< double > gridSpacing=std::vector< double >(3, 4.0), std::vector< double > gridOffset=std::vector< double >(3, 0.0), double scale=255.0, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), std::vector< bool > whichDimensions=std::vector< bool >(3, true)) Generate an n-dimensional image of a grid. This function directly calls the execute method of GridImageSource in order to support a procedural API See: itk::simple::GridImageSource for the object oriented interface
    • gridSource

      public static Image gridSource(PixelIDValueEnum outputPixelType)
      Image itk::simple::GridSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 0.5), std::vector< double > gridSpacing=std::vector< double >(3, 4.0), std::vector< double > gridOffset=std::vector< double >(3, 0.0), double scale=255.0, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), std::vector< bool > whichDimensions=std::vector< bool >(3, true)) Generate an n-dimensional image of a grid. This function directly calls the execute method of GridImageSource in order to support a procedural API See: itk::simple::GridImageSource for the object oriented interface
    • gridSource

      public static Image gridSource()
      Image itk::simple::GridSource(PixelIDValueEnum outputPixelType=itk::simple::sitkFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > sigma=std::vector< double >(3, 0.5), std::vector< double > gridSpacing=std::vector< double >(3, 4.0), std::vector< double > gridOffset=std::vector< double >(3, 0.0), double scale=255.0, std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >(), std::vector< bool > whichDimensions=std::vector< bool >(3, true)) Generate an n-dimensional image of a grid. This function directly calls the execute method of GridImageSource in order to support a procedural API See: itk::simple::GridImageSource for the object oriented interface
    • hConcave

      public static Image hConcave(Image image1, double height, boolean fullyConnected)
    • hConcave

      public static Image hConcave(Image image1, double height)
    • hConcave

      public static Image hConcave(Image image1)
    • hConvex

      public static Image hConvex(Image image1, double height, boolean fullyConnected)
    • hConvex

      public static Image hConvex(Image image1, double height)
    • hConvex

      public static Image hConvex(Image image1)
    • hMaxima

      public static Image hMaxima(Image image1, double height)
    • hMaxima

      public static Image hMaxima(Image image1)
    • hMinima

      public static Image hMinima(Image image1, double height, boolean fullyConnected)
    • hMinima

      public static Image hMinima(Image image1, double height)
    • hMinima

      public static Image hMinima(Image image1)
    • halfHermitianToRealInverseFFT

      public static Image halfHermitianToRealInverseFFT(Image image1, boolean actualXDimensionIsOdd)
    • halfHermitianToRealInverseFFT

      public static Image halfHermitianToRealInverseFFT(Image image1)
    • histogramMatching

      public static Image histogramMatching(Image image, Image referenceImage, long numberOfHistogramLevels, long numberOfMatchPoints, boolean thresholdAtMeanIntensity)
    • histogramMatching

      public static Image histogramMatching(Image image, Image referenceImage, long numberOfHistogramLevels, long numberOfMatchPoints)
    • histogramMatching

      public static Image histogramMatching(Image image, Image referenceImage, long numberOfHistogramLevels)
    • histogramMatching

      public static Image histogramMatching(Image image, Image referenceImage)
    • huangThreshold

      public static Image huangThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • huangThreshold

      public static Image huangThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • huangThreshold

      public static Image huangThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins)
    • huangThreshold

      public static Image huangThreshold(Image image, Image maskImage, short insideValue, short outsideValue)
    • huangThreshold

      public static Image huangThreshold(Image image, Image maskImage, short insideValue)
    • huangThreshold

      public static Image huangThreshold(Image image, Image maskImage)
    • huangThreshold

      public static Image huangThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • huangThreshold

      public static Image huangThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • huangThreshold

      public static Image huangThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins)
    • huangThreshold

      public static Image huangThreshold(Image image, short insideValue, short outsideValue)
    • huangThreshold

      public static Image huangThreshold(Image image, short insideValue)
    • huangThreshold

      public static Image huangThreshold(Image image)
    • intensityWindowing

      public static Image intensityWindowing(Image image1, double windowMinimum, double windowMaximum, double outputMinimum, double outputMaximum)
    • intensityWindowing

      public static Image intensityWindowing(Image image1, double windowMinimum, double windowMaximum, double outputMinimum)
    • intensityWindowing

      public static Image intensityWindowing(Image image1, double windowMinimum, double windowMaximum)
    • intensityWindowing

      public static Image intensityWindowing(Image image1, double windowMinimum)
    • intensityWindowing

      public static Image intensityWindowing(Image image1)
    • intermodesThreshold

      public static Image intermodesThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • intermodesThreshold

      public static Image intermodesThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • intermodesThreshold

      public static Image intermodesThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins)
    • intermodesThreshold

      public static Image intermodesThreshold(Image image, Image maskImage, short insideValue, short outsideValue)
    • intermodesThreshold

      public static Image intermodesThreshold(Image image, Image maskImage, short insideValue)
    • intermodesThreshold

      public static Image intermodesThreshold(Image image, Image maskImage)
    • intermodesThreshold

      public static Image intermodesThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • intermodesThreshold

      public static Image intermodesThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • intermodesThreshold

      public static Image intermodesThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins)
    • intermodesThreshold

      public static Image intermodesThreshold(Image image, short insideValue, short outsideValue)
    • intermodesThreshold

      public static Image intermodesThreshold(Image image, short insideValue)
    • intermodesThreshold

      public static Image intermodesThreshold(Image image)
    • inverseDeconvolution

      public static Image inverseDeconvolution(Image image1, Image image2, double kernelZeroMagnitudeThreshold, boolean normalize, InverseDeconvolutionImageFilter.BoundaryConditionType boundaryCondition, InverseDeconvolutionImageFilter.OutputRegionModeType outputRegionMode)
    • inverseDeconvolution

      public static Image inverseDeconvolution(Image image1, Image image2, double kernelZeroMagnitudeThreshold, boolean normalize, InverseDeconvolutionImageFilter.BoundaryConditionType boundaryCondition)
    • inverseDeconvolution

      public static Image inverseDeconvolution(Image image1, Image image2, double kernelZeroMagnitudeThreshold, boolean normalize)
    • inverseDeconvolution

      public static Image inverseDeconvolution(Image image1, Image image2, double kernelZeroMagnitudeThreshold)
    • inverseDeconvolution

      public static Image inverseDeconvolution(Image image1, Image image2)
    • inverseDisplacementField

      public static Image inverseDisplacementField(Image image1, VectorUInt32 size, VectorDouble outputOrigin, VectorDouble outputSpacing, long subsamplingFactor)
    • inverseDisplacementField

      public static Image inverseDisplacementField(Image image1, VectorUInt32 size, VectorDouble outputOrigin, VectorDouble outputSpacing)
    • inverseDisplacementField

      public static Image inverseDisplacementField(Image image1, VectorUInt32 size, VectorDouble outputOrigin)
    • inverseDisplacementField

      public static Image inverseDisplacementField(Image image1, VectorUInt32 size)
    • inverseDisplacementField

      public static Image inverseDisplacementField(Image image1)
    • inverseFFT

      public static Image inverseFFT(Image image1)
    • invertDisplacementField

      public static Image invertDisplacementField(Image image1, long maximumNumberOfIterations, double maxErrorToleranceThreshold, double meanErrorToleranceThreshold, boolean enforceBoundaryCondition)
    • invertDisplacementField

      public static Image invertDisplacementField(Image image1, long maximumNumberOfIterations, double maxErrorToleranceThreshold, double meanErrorToleranceThreshold)
    • invertDisplacementField

      public static Image invertDisplacementField(Image image1, long maximumNumberOfIterations, double maxErrorToleranceThreshold)
    • invertDisplacementField

      public static Image invertDisplacementField(Image image1, long maximumNumberOfIterations)
    • invertDisplacementField

      public static Image invertDisplacementField(Image image1)
    • invertIntensity

      public static Image invertIntensity(Image image1, double maximum)
    • invertIntensity

      public static Image invertIntensity(Image image1)
    • isoContourDistance

      public static Image isoContourDistance(Image image1, double levelSetValue, double farValue)
    • isoContourDistance

      public static Image isoContourDistance(Image image1, double levelSetValue)
    • isoContourDistance

      public static Image isoContourDistance(Image image1)
    • isoDataThreshold

      public static Image isoDataThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • isoDataThreshold

      public static Image isoDataThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • isoDataThreshold

      public static Image isoDataThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins)
    • isoDataThreshold

      public static Image isoDataThreshold(Image image, Image maskImage, short insideValue, short outsideValue)
    • isoDataThreshold

      public static Image isoDataThreshold(Image image, Image maskImage, short insideValue)
    • isoDataThreshold

      public static Image isoDataThreshold(Image image, Image maskImage)
    • isoDataThreshold

      public static Image isoDataThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • isoDataThreshold

      public static Image isoDataThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • isoDataThreshold

      public static Image isoDataThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins)
    • isoDataThreshold

      public static Image isoDataThreshold(Image image, short insideValue, short outsideValue)
    • isoDataThreshold

      public static Image isoDataThreshold(Image image, short insideValue)
    • isoDataThreshold

      public static Image isoDataThreshold(Image image)
    • isolatedConnected

      public static Image isolatedConnected(Image image1, VectorUInt32 seed1, VectorUInt32 seed2, double lower, double upper, short replaceValue, double isolatedValueTolerance, boolean findUpperThreshold)
    • isolatedConnected

      public static Image isolatedConnected(Image image1, VectorUInt32 seed1, VectorUInt32 seed2, double lower, double upper, short replaceValue, double isolatedValueTolerance)
    • isolatedConnected

      public static Image isolatedConnected(Image image1, VectorUInt32 seed1, VectorUInt32 seed2, double lower, double upper, short replaceValue)
    • isolatedConnected

      public static Image isolatedConnected(Image image1, VectorUInt32 seed1, VectorUInt32 seed2, double lower, double upper)
    • isolatedConnected

      public static Image isolatedConnected(Image image1, VectorUInt32 seed1, VectorUInt32 seed2, double lower)
    • isolatedConnected

      public static Image isolatedConnected(Image image1, VectorUInt32 seed1, VectorUInt32 seed2)
    • isolatedConnected

      public static Image isolatedConnected(Image image1, VectorUInt32 seed1)
    • isolatedConnected

      public static Image isolatedConnected(Image image1)
    • isolatedWatershed

      public static Image isolatedWatershed(Image image1, VectorUInt32 seed1, VectorUInt32 seed2, double threshold, double upperValueLimit, double isolatedValueTolerance, short replaceValue1, short replaceValue2)
    • isolatedWatershed

      public static Image isolatedWatershed(Image image1, VectorUInt32 seed1, VectorUInt32 seed2, double threshold, double upperValueLimit, double isolatedValueTolerance, short replaceValue1)
    • isolatedWatershed

      public static Image isolatedWatershed(Image image1, VectorUInt32 seed1, VectorUInt32 seed2, double threshold, double upperValueLimit, double isolatedValueTolerance)
    • isolatedWatershed

      public static Image isolatedWatershed(Image image1, VectorUInt32 seed1, VectorUInt32 seed2, double threshold, double upperValueLimit)
    • isolatedWatershed

      public static Image isolatedWatershed(Image image1, VectorUInt32 seed1, VectorUInt32 seed2, double threshold)
    • isolatedWatershed

      public static Image isolatedWatershed(Image image1, VectorUInt32 seed1, VectorUInt32 seed2)
    • isolatedWatershed

      public static Image isolatedWatershed(Image image1, VectorUInt32 seed1)
    • isolatedWatershed

      public static Image isolatedWatershed(Image image1)
    • iterativeInverseDisplacementField

      public static Image iterativeInverseDisplacementField(Image image1, long numberOfIterations, double stopValue)
    • iterativeInverseDisplacementField

      public static Image iterativeInverseDisplacementField(Image image1, long numberOfIterations)
    • iterativeInverseDisplacementField

      public static Image iterativeInverseDisplacementField(Image image1)
    • joinSeries

      public static Image joinSeries(VectorOfImage images, double origin, double spacing)
    • joinSeries

      public static Image joinSeries(VectorOfImage images, double origin)
    • joinSeries

      public static Image joinSeries(VectorOfImage images)
    • joinSeries

      public static Image joinSeries(Image image1, double origin, double spacing)
    • joinSeries

      public static Image joinSeries(Image image1, double origin)
    • joinSeries

      public static Image joinSeries(Image image1)
    • joinSeries

      public static Image joinSeries(Image image1, Image image2, double origin, double spacing)
    • joinSeries

      public static Image joinSeries(Image image1, Image image2, double origin)
    • joinSeries

      public static Image joinSeries(Image image1, Image image2)
    • joinSeries

      public static Image joinSeries(Image image1, Image image2, Image image3, double origin, double spacing)
    • joinSeries

      public static Image joinSeries(Image image1, Image image2, Image image3, double origin)
    • joinSeries

      public static Image joinSeries(Image image1, Image image2, Image image3)
    • joinSeries

      public static Image joinSeries(Image image1, Image image2, Image image3, Image image4, double origin, double spacing)
    • joinSeries

      public static Image joinSeries(Image image1, Image image2, Image image3, Image image4, double origin)
    • joinSeries

      public static Image joinSeries(Image image1, Image image2, Image image3, Image image4)
    • joinSeries

      public static Image joinSeries(Image image1, Image image2, Image image3, Image image4, Image image5, double origin, double spacing)
    • joinSeries

      public static Image joinSeries(Image image1, Image image2, Image image3, Image image4, Image image5, double origin)
    • joinSeries

      public static Image joinSeries(Image image1, Image image2, Image image3, Image image4, Image image5)
    • kittlerIllingworthThreshold

      public static Image kittlerIllingworthThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • kittlerIllingworthThreshold

      public static Image kittlerIllingworthThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • kittlerIllingworthThreshold

      public static Image kittlerIllingworthThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins)
    • kittlerIllingworthThreshold

      public static Image kittlerIllingworthThreshold(Image image, Image maskImage, short insideValue, short outsideValue)
    • kittlerIllingworthThreshold

      public static Image kittlerIllingworthThreshold(Image image, Image maskImage, short insideValue)
    • kittlerIllingworthThreshold

      public static Image kittlerIllingworthThreshold(Image image, Image maskImage)
    • kittlerIllingworthThreshold

      public static Image kittlerIllingworthThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • kittlerIllingworthThreshold

      public static Image kittlerIllingworthThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • kittlerIllingworthThreshold

      public static Image kittlerIllingworthThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins)
    • kittlerIllingworthThreshold

      public static Image kittlerIllingworthThreshold(Image image, short insideValue, short outsideValue)
    • kittlerIllingworthThreshold

      public static Image kittlerIllingworthThreshold(Image image, short insideValue)
    • kittlerIllingworthThreshold

      public static Image kittlerIllingworthThreshold(Image image)
    • labelContour

      public static Image labelContour(Image image1, boolean fullyConnected, double backgroundValue)
    • labelContour

      public static Image labelContour(Image image1, boolean fullyConnected)
    • labelContour

      public static Image labelContour(Image image1)
    • labelImageToLabelMap

      public static Image labelImageToLabelMap(Image image1, double backgroundValue)
    • labelImageToLabelMap

      public static Image labelImageToLabelMap(Image image1)
    • labelMapContourOverlay

      public static Image labelMapContourOverlay(Image labelMapImage, Image featureImage, double opacity, VectorUInt32 dilationRadius, VectorUInt32 contourThickness, long sliceDimension, LabelMapContourOverlayImageFilter.ContourTypeType contourType, LabelMapContourOverlayImageFilter.PriorityType priority, VectorUInt8 colormap)
    • labelMapContourOverlay

      public static Image labelMapContourOverlay(Image labelMapImage, Image featureImage, double opacity, VectorUInt32 dilationRadius, VectorUInt32 contourThickness, long sliceDimension, LabelMapContourOverlayImageFilter.ContourTypeType contourType, LabelMapContourOverlayImageFilter.PriorityType priority)
    • labelMapContourOverlay

      public static Image labelMapContourOverlay(Image labelMapImage, Image featureImage, double opacity, VectorUInt32 dilationRadius, VectorUInt32 contourThickness, long sliceDimension, LabelMapContourOverlayImageFilter.ContourTypeType contourType)
    • labelMapContourOverlay

      public static Image labelMapContourOverlay(Image labelMapImage, Image featureImage, double opacity, VectorUInt32 dilationRadius, VectorUInt32 contourThickness, long sliceDimension)
    • labelMapContourOverlay

      public static Image labelMapContourOverlay(Image labelMapImage, Image featureImage, double opacity, VectorUInt32 dilationRadius, VectorUInt32 contourThickness)
    • labelMapContourOverlay

      public static Image labelMapContourOverlay(Image labelMapImage, Image featureImage, double opacity, VectorUInt32 dilationRadius)
    • labelMapContourOverlay

      public static Image labelMapContourOverlay(Image labelMapImage, Image featureImage, double opacity)
    • labelMapContourOverlay

      public static Image labelMapContourOverlay(Image labelMapImage, Image featureImage)
    • labelMapMask

      public static Image labelMapMask(Image labelMapImage, Image featureImage, long label, double backgroundValue, boolean negated, boolean crop, VectorUInt32 cropBorder)
    • labelMapMask

      public static Image labelMapMask(Image labelMapImage, Image featureImage, long label, double backgroundValue, boolean negated, boolean crop)
    • labelMapMask

      public static Image labelMapMask(Image labelMapImage, Image featureImage, long label, double backgroundValue, boolean negated)
    • labelMapMask

      public static Image labelMapMask(Image labelMapImage, Image featureImage, long label, double backgroundValue)
    • labelMapMask

      public static Image labelMapMask(Image labelMapImage, Image featureImage, long label)
    • labelMapMask

      public static Image labelMapMask(Image labelMapImage, Image featureImage)
    • labelMapOverlay

      public static Image labelMapOverlay(Image labelMapImage, Image featureImage, double opacity, VectorUInt8 colormap)
    • labelMapOverlay

      public static Image labelMapOverlay(Image labelMapImage, Image featureImage, double opacity)
    • labelMapOverlay

      public static Image labelMapOverlay(Image labelMapImage, Image featureImage)
    • labelMapToBinary

      public static Image labelMapToBinary(Image image1, double backgroundValue, double foregroundValue)
    • labelMapToBinary

      public static Image labelMapToBinary(Image image1, double backgroundValue)
    • labelMapToBinary

      public static Image labelMapToBinary(Image image1)
    • labelMapToLabel

      public static Image labelMapToLabel(Image image1)
    • labelMapToRGB

      public static Image labelMapToRGB(Image image1, VectorUInt8 colormap)
    • labelMapToRGB

      public static Image labelMapToRGB(Image image1)
    • labelOverlay

      public static Image labelOverlay(Image image, Image labelImage, double opacity, double backgroundValue, VectorUInt8 colormap)
    • labelOverlay

      public static Image labelOverlay(Image image, Image labelImage, double opacity, double backgroundValue)
    • labelOverlay

      public static Image labelOverlay(Image image, Image labelImage, double opacity)
    • labelOverlay

      public static Image labelOverlay(Image image, Image labelImage)
    • labelToRGB

      public static Image labelToRGB(Image image1, double backgroundValue, VectorUInt8 colormap)
    • labelToRGB

      public static Image labelToRGB(Image image1, double backgroundValue)
    • labelToRGB

      public static Image labelToRGB(Image image1)
    • labelUniqueLabelMap

      public static Image labelUniqueLabelMap(Image image1, boolean reverseOrdering)
    • labelUniqueLabelMap

      public static Image labelUniqueLabelMap(Image image1)
    • labelVoting

      public static Image labelVoting(VectorOfImage images, long labelForUndecidedPixels)
    • labelVoting

      public static Image labelVoting(VectorOfImage images)
    • labelVoting

      public static Image labelVoting(Image image1, long labelForUndecidedPixels)
    • labelVoting

      public static Image labelVoting(Image image1)
    • labelVoting

      public static Image labelVoting(Image image1, Image image2, long labelForUndecidedPixels)
    • labelVoting

      public static Image labelVoting(Image image1, Image image2)
    • labelVoting

      public static Image labelVoting(Image image1, Image image2, Image image3, long labelForUndecidedPixels)
    • labelVoting

      public static Image labelVoting(Image image1, Image image2, Image image3)
    • labelVoting

      public static Image labelVoting(Image image1, Image image2, Image image3, Image image4, long labelForUndecidedPixels)
    • labelVoting

      public static Image labelVoting(Image image1, Image image2, Image image3, Image image4)
    • labelVoting

      public static Image labelVoting(Image image1, Image image2, Image image3, Image image4, Image image5, long labelForUndecidedPixels)
    • labelVoting

      public static Image labelVoting(Image image1, Image image2, Image image3, Image image4, Image image5)
    • landweberDeconvolution

      public static Image landweberDeconvolution(Image image1, Image image2, double alpha, int numberOfIterations, boolean normalize, LandweberDeconvolutionImageFilter.BoundaryConditionType boundaryCondition, LandweberDeconvolutionImageFilter.OutputRegionModeType outputRegionMode)
    • landweberDeconvolution

      public static Image landweberDeconvolution(Image image1, Image image2, double alpha, int numberOfIterations, boolean normalize, LandweberDeconvolutionImageFilter.BoundaryConditionType boundaryCondition)
    • landweberDeconvolution

      public static Image landweberDeconvolution(Image image1, Image image2, double alpha, int numberOfIterations, boolean normalize)
    • landweberDeconvolution

      public static Image landweberDeconvolution(Image image1, Image image2, double alpha, int numberOfIterations)
    • landweberDeconvolution

      public static Image landweberDeconvolution(Image image1, Image image2, double alpha)
    • landweberDeconvolution

      public static Image landweberDeconvolution(Image image1, Image image2)
    • laplacian

      public static Image laplacian(Image image1, boolean useImageSpacing)
    • laplacian

      public static Image laplacian(Image image1)
    • laplacianRecursiveGaussian

      public static Image laplacianRecursiveGaussian(Image image1, double sigma, boolean normalizeAcrossScale)
    • laplacianRecursiveGaussian

      public static Image laplacianRecursiveGaussian(Image image1, double sigma)
    • laplacianRecursiveGaussian

      public static Image laplacianRecursiveGaussian(Image image1)
    • laplacianSegmentationLevelSet

      public static Image laplacianSegmentationLevelSet(Image initialImage, Image featureImage, double maximumRMSError, double propagationScaling, double curvatureScaling, long numberOfIterations, boolean reverseExpansionDirection)
    • laplacianSegmentationLevelSet

      public static Image laplacianSegmentationLevelSet(Image initialImage, Image featureImage, double maximumRMSError, double propagationScaling, double curvatureScaling, long numberOfIterations)
    • laplacianSegmentationLevelSet

      public static Image laplacianSegmentationLevelSet(Image initialImage, Image featureImage, double maximumRMSError, double propagationScaling, double curvatureScaling)
    • laplacianSegmentationLevelSet

      public static Image laplacianSegmentationLevelSet(Image initialImage, Image featureImage, double maximumRMSError, double propagationScaling)
    • laplacianSegmentationLevelSet

      public static Image laplacianSegmentationLevelSet(Image initialImage, Image featureImage, double maximumRMSError)
    • laplacianSegmentationLevelSet

      public static Image laplacianSegmentationLevelSet(Image initialImage, Image featureImage)
    • laplacianSharpening

      public static Image laplacianSharpening(Image image1, boolean useImageSpacing)
    • laplacianSharpening

      public static Image laplacianSharpening(Image image1)
    • lessEqual

      public static Image lessEqual(Image image1, Image image2, short backgroundValue, short foregroundValue)
      Image itk::simple::LessEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • lessEqual

      public static Image lessEqual(Image image1, Image image2, short backgroundValue)
      Image itk::simple::LessEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • lessEqual

      public static Image lessEqual(Image image1, Image image2)
      Image itk::simple::LessEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • lessEqual

      public static Image lessEqual(Image image1, double constant, short backgroundValue, short foregroundValue)
      Image itk::simple::LessEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • lessEqual

      public static Image lessEqual(Image image1, double constant, short backgroundValue)
      Image itk::simple::LessEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • lessEqual

      public static Image lessEqual(Image image1, double constant)
      Image itk::simple::LessEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • lessEqual

      public static Image lessEqual(double constant, Image image2, short backgroundValue, short foregroundValue)
      Image itk::simple::LessEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • lessEqual

      public static Image lessEqual(double constant, Image image2, short backgroundValue)
      Image itk::simple::LessEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • lessEqual

      public static Image lessEqual(double constant, Image image2)
      Image itk::simple::LessEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • less

      public static Image less(Image image1, Image image2, short backgroundValue, short foregroundValue)
      Image itk::simple::Less(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • less

      public static Image less(Image image1, Image image2, short backgroundValue)
      Image itk::simple::Less(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • less

      public static Image less(Image image1, Image image2)
      Image itk::simple::Less(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • less

      public static Image less(Image image1, double constant, short backgroundValue, short foregroundValue)
      Image itk::simple::Less(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • less

      public static Image less(Image image1, double constant, short backgroundValue)
      Image itk::simple::Less(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • less

      public static Image less(Image image1, double constant)
      Image itk::simple::Less(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • less

      public static Image less(double constant, Image image2, short backgroundValue, short foregroundValue)
      Image itk::simple::Less(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • less

      public static Image less(double constant, Image image2, short backgroundValue)
      Image itk::simple::Less(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • less

      public static Image less(double constant, Image image2)
      Image itk::simple::Less(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • liThreshold

      public static Image liThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • liThreshold

      public static Image liThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • liThreshold

      public static Image liThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins)
    • liThreshold

      public static Image liThreshold(Image image, Image maskImage, short insideValue, short outsideValue)
    • liThreshold

      public static Image liThreshold(Image image, Image maskImage, short insideValue)
    • liThreshold

      public static Image liThreshold(Image image, Image maskImage)
    • liThreshold

      public static Image liThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • liThreshold

      public static Image liThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • liThreshold

      public static Image liThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins)
    • liThreshold

      public static Image liThreshold(Image image, short insideValue, short outsideValue)
    • liThreshold

      public static Image liThreshold(Image image, short insideValue)
    • liThreshold

      public static Image liThreshold(Image image)
    • log10

      public static Image log10(Image image1)
    • log

      public static Image log(Image image1)
    • magnitudeAndPhaseToComplex

      public static Image magnitudeAndPhaseToComplex(Image image1, Image image2)
      Image itk::simple::MagnitudeAndPhaseToComplex(Image &&image1, double constant)
    • magnitudeAndPhaseToComplex

      public static Image magnitudeAndPhaseToComplex(Image image1, double constant)
      Image itk::simple::MagnitudeAndPhaseToComplex(Image &&image1, double constant)
    • magnitudeAndPhaseToComplex

      public static Image magnitudeAndPhaseToComplex(double constant, Image image2)
      Image itk::simple::MagnitudeAndPhaseToComplex(Image &&image1, double constant)
    • mask

      public static Image mask(Image image, Image maskImage, double outsideValue, double maskingValue)
    • mask

      public static Image mask(Image image, Image maskImage, double outsideValue)
    • mask

      public static Image mask(Image image, Image maskImage)
    • maskNegated

      public static Image maskNegated(Image image, Image maskImage, double outsideValue, double maskingValue)
    • maskNegated

      public static Image maskNegated(Image image, Image maskImage, double outsideValue)
    • maskNegated

      public static Image maskNegated(Image image, Image maskImage)
    • maskedAssign

      public static Image maskedAssign(Image image, Image maskImage, Image assignImage, double assignConstant)
    • maskedAssign

      public static Image maskedAssign(Image image, Image maskImage, Image assignImage)
    • maskedAssign

      public static Image maskedAssign(Image image, Image maskImage, double assignConstant)
    • maskedAssign

      public static Image maskedAssign(Image image, Image maskImage)
    • maskedFFTNormalizedCorrelation

      public static Image maskedFFTNormalizedCorrelation(Image fixedImage, Image movingImage, Image fixedImageMask, Image movingImageMask, long requiredNumberOfOverlappingPixels, float requiredFractionOfOverlappingPixels)
    • maskedFFTNormalizedCorrelation

      public static Image maskedFFTNormalizedCorrelation(Image fixedImage, Image movingImage, Image fixedImageMask, Image movingImageMask, long requiredNumberOfOverlappingPixels)
    • maskedFFTNormalizedCorrelation

      public static Image maskedFFTNormalizedCorrelation(Image fixedImage, Image movingImage, Image fixedImageMask, Image movingImageMask)
    • maximumEntropyThreshold

      public static Image maximumEntropyThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • maximumEntropyThreshold

      public static Image maximumEntropyThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • maximumEntropyThreshold

      public static Image maximumEntropyThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins)
    • maximumEntropyThreshold

      public static Image maximumEntropyThreshold(Image image, Image maskImage, short insideValue, short outsideValue)
    • maximumEntropyThreshold

      public static Image maximumEntropyThreshold(Image image, Image maskImage, short insideValue)
    • maximumEntropyThreshold

      public static Image maximumEntropyThreshold(Image image, Image maskImage)
    • maximumEntropyThreshold

      public static Image maximumEntropyThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • maximumEntropyThreshold

      public static Image maximumEntropyThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • maximumEntropyThreshold

      public static Image maximumEntropyThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins)
    • maximumEntropyThreshold

      public static Image maximumEntropyThreshold(Image image, short insideValue, short outsideValue)
    • maximumEntropyThreshold

      public static Image maximumEntropyThreshold(Image image, short insideValue)
    • maximumEntropyThreshold

      public static Image maximumEntropyThreshold(Image image)
    • maximum

      public static Image maximum(Image image1, Image image2)
      Image itk::simple::Maximum(Image &&image1, double constant)
    • maximum

      public static Image maximum(Image image1, double constant)
      Image itk::simple::Maximum(Image &&image1, double constant)
    • maximum

      public static Image maximum(double constant, Image image2)
      Image itk::simple::Maximum(Image &&image1, double constant)
    • maximumProjection

      public static Image maximumProjection(Image image1, long projectionDimension)
    • maximumProjection

      public static Image maximumProjection(Image image1)
    • mean

      public static Image mean(Image image1, VectorUInt32 radius)
    • mean

      public static Image mean(Image image1)
    • meanProjection

      public static Image meanProjection(Image image1, long projectionDimension)
    • meanProjection

      public static Image meanProjection(Image image1)
    • median

      public static Image median(Image image1, VectorUInt32 radius)
    • median

      public static Image median(Image image1)
    • medianProjection

      public static Image medianProjection(Image image1, long projectionDimension)
    • medianProjection

      public static Image medianProjection(Image image1)
    • mergeLabelMap

      public static Image mergeLabelMap(VectorOfImage images, MergeLabelMapFilter.MethodType method)
    • mergeLabelMap

      public static Image mergeLabelMap(VectorOfImage images)
    • mergeLabelMap

      public static Image mergeLabelMap(Image image1, MergeLabelMapFilter.MethodType method)
    • mergeLabelMap

      public static Image mergeLabelMap(Image image1)
    • mergeLabelMap

      public static Image mergeLabelMap(Image image1, Image image2, MergeLabelMapFilter.MethodType method)
    • mergeLabelMap

      public static Image mergeLabelMap(Image image1, Image image2)
    • mergeLabelMap

      public static Image mergeLabelMap(Image image1, Image image2, Image image3, MergeLabelMapFilter.MethodType method)
    • mergeLabelMap

      public static Image mergeLabelMap(Image image1, Image image2, Image image3)
    • mergeLabelMap

      public static Image mergeLabelMap(Image image1, Image image2, Image image3, Image image4, MergeLabelMapFilter.MethodType method)
    • mergeLabelMap

      public static Image mergeLabelMap(Image image1, Image image2, Image image3, Image image4)
    • mergeLabelMap

      public static Image mergeLabelMap(Image image1, Image image2, Image image3, Image image4, Image image5, MergeLabelMapFilter.MethodType method)
    • mergeLabelMap

      public static Image mergeLabelMap(Image image1, Image image2, Image image3, Image image4, Image image5)
    • minMaxCurvatureFlow

      public static Image minMaxCurvatureFlow(Image image1, double timeStep, long numberOfIterations, int stencilRadius)
    • minMaxCurvatureFlow

      public static Image minMaxCurvatureFlow(Image image1, double timeStep, long numberOfIterations)
    • minMaxCurvatureFlow

      public static Image minMaxCurvatureFlow(Image image1, double timeStep)
    • minMaxCurvatureFlow

      public static Image minMaxCurvatureFlow(Image image1)
    • minimum

      public static Image minimum(Image image1, Image image2)
      Image itk::simple::Minimum(Image &&image1, double constant)
    • minimum

      public static Image minimum(Image image1, double constant)
      Image itk::simple::Minimum(Image &&image1, double constant)
    • minimum

      public static Image minimum(double constant, Image image2)
      Image itk::simple::Minimum(Image &&image1, double constant)
    • minimumProjection

      public static Image minimumProjection(Image image1, long projectionDimension)
    • minimumProjection

      public static Image minimumProjection(Image image1)
    • mirrorPad

      public static Image mirrorPad(Image image1, VectorUInt32 padLowerBound, VectorUInt32 padUpperBound, double decayBase)
    • mirrorPad

      public static Image mirrorPad(Image image1, VectorUInt32 padLowerBound, VectorUInt32 padUpperBound)
    • mirrorPad

      public static Image mirrorPad(Image image1, VectorUInt32 padLowerBound)
    • mirrorPad

      public static Image mirrorPad(Image image1)
    • modulus

      public static Image modulus(Image image1, Image image2)
      Image itk::simple::Modulus(uint32_t constant, const Image &image2)
    • modulus

      public static Image modulus(Image image1, long constant)
      Image itk::simple::Modulus(uint32_t constant, const Image &image2)
    • modulus

      public static Image modulus(long constant, Image image2)
      Image itk::simple::Modulus(uint32_t constant, const Image &image2)
    • momentsThreshold

      public static Image momentsThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • momentsThreshold

      public static Image momentsThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • momentsThreshold

      public static Image momentsThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins)
    • momentsThreshold

      public static Image momentsThreshold(Image image, Image maskImage, short insideValue, short outsideValue)
    • momentsThreshold

      public static Image momentsThreshold(Image image, Image maskImage, short insideValue)
    • momentsThreshold

      public static Image momentsThreshold(Image image, Image maskImage)
    • momentsThreshold

      public static Image momentsThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • momentsThreshold

      public static Image momentsThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • momentsThreshold

      public static Image momentsThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins)
    • momentsThreshold

      public static Image momentsThreshold(Image image, short insideValue, short outsideValue)
    • momentsThreshold

      public static Image momentsThreshold(Image image, short insideValue)
    • momentsThreshold

      public static Image momentsThreshold(Image image)
    • morphologicalGradient

      public static Image morphologicalGradient(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • morphologicalGradient

      public static Image morphologicalGradient(Image image1, VectorUInt32 kernelRadius)
    • morphologicalGradient

      public static Image morphologicalGradient(Image image1)
    • morphologicalWatershedFromMarkers

      public static Image morphologicalWatershedFromMarkers(Image image, Image markerImage, boolean markWatershedLine, boolean fullyConnected)
    • morphologicalWatershedFromMarkers

      public static Image morphologicalWatershedFromMarkers(Image image, Image markerImage, boolean markWatershedLine)
    • morphologicalWatershedFromMarkers

      public static Image morphologicalWatershedFromMarkers(Image image, Image markerImage)
    • morphologicalWatershed

      public static Image morphologicalWatershed(Image image1, double level, boolean markWatershedLine, boolean fullyConnected)
    • morphologicalWatershed

      public static Image morphologicalWatershed(Image image1, double level, boolean markWatershedLine)
    • morphologicalWatershed

      public static Image morphologicalWatershed(Image image1, double level)
    • morphologicalWatershed

      public static Image morphologicalWatershed(Image image1)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(VectorOfImage images, long labelForUndecidedPixels, float terminationUpdateThreshold, long maximumNumberOfIterations, VectorFloat priorProbabilities)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(VectorOfImage images, long labelForUndecidedPixels, float terminationUpdateThreshold, long maximumNumberOfIterations)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(VectorOfImage images, long labelForUndecidedPixels, float terminationUpdateThreshold)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(VectorOfImage images, long labelForUndecidedPixels)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(VectorOfImage images)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, long labelForUndecidedPixels, float terminationUpdateThreshold, long maximumNumberOfIterations, VectorFloat priorProbabilities)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, long labelForUndecidedPixels, float terminationUpdateThreshold, long maximumNumberOfIterations)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, long labelForUndecidedPixels, float terminationUpdateThreshold)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, long labelForUndecidedPixels)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, long labelForUndecidedPixels, float terminationUpdateThreshold, long maximumNumberOfIterations, VectorFloat priorProbabilities)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, long labelForUndecidedPixels, float terminationUpdateThreshold, long maximumNumberOfIterations)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, long labelForUndecidedPixels, float terminationUpdateThreshold)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, long labelForUndecidedPixels)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3, long labelForUndecidedPixels, float terminationUpdateThreshold, long maximumNumberOfIterations, VectorFloat priorProbabilities)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3, long labelForUndecidedPixels, float terminationUpdateThreshold, long maximumNumberOfIterations)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3, long labelForUndecidedPixels, float terminationUpdateThreshold)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3, long labelForUndecidedPixels)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3, Image image4, long labelForUndecidedPixels, float terminationUpdateThreshold, long maximumNumberOfIterations, VectorFloat priorProbabilities)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3, Image image4, long labelForUndecidedPixels, float terminationUpdateThreshold, long maximumNumberOfIterations)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3, Image image4, long labelForUndecidedPixels, float terminationUpdateThreshold)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3, Image image4, long labelForUndecidedPixels)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3, Image image4)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3, Image image4, Image image5, long labelForUndecidedPixels, float terminationUpdateThreshold, long maximumNumberOfIterations, VectorFloat priorProbabilities)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3, Image image4, Image image5, long labelForUndecidedPixels, float terminationUpdateThreshold, long maximumNumberOfIterations)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3, Image image4, Image image5, long labelForUndecidedPixels, float terminationUpdateThreshold)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3, Image image4, Image image5, long labelForUndecidedPixels)
    • multiLabelSTAPLE

      public static Image multiLabelSTAPLE(Image image1, Image image2, Image image3, Image image4, Image image5)
    • multiply

      public static Image multiply(Image image1, Image image2)
      Image itk::simple::Multiply(Image &&image1, double constant)
    • multiply

      public static Image multiply(Image image1, double constant)
      Image itk::simple::Multiply(Image &&image1, double constant)
    • multiply

      public static Image multiply(double constant, Image image2)
      Image itk::simple::Multiply(Image &&image1, double constant)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, Image maskImage, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations, double biasFieldFullWidthAtHalfMaximum, double wienerFilterNoise, long numberOfHistogramBins, VectorUInt32 numberOfControlPoints, long splineOrder, boolean useMaskLabel, short maskLabel)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, Image maskImage, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations, double biasFieldFullWidthAtHalfMaximum, double wienerFilterNoise, long numberOfHistogramBins, VectorUInt32 numberOfControlPoints, long splineOrder, boolean useMaskLabel)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, Image maskImage, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations, double biasFieldFullWidthAtHalfMaximum, double wienerFilterNoise, long numberOfHistogramBins, VectorUInt32 numberOfControlPoints, long splineOrder)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, Image maskImage, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations, double biasFieldFullWidthAtHalfMaximum, double wienerFilterNoise, long numberOfHistogramBins, VectorUInt32 numberOfControlPoints)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, Image maskImage, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations, double biasFieldFullWidthAtHalfMaximum, double wienerFilterNoise, long numberOfHistogramBins)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, Image maskImage, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations, double biasFieldFullWidthAtHalfMaximum, double wienerFilterNoise)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, Image maskImage, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations, double biasFieldFullWidthAtHalfMaximum)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, Image maskImage, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, Image maskImage, double convergenceThreshold)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, Image maskImage)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations, double biasFieldFullWidthAtHalfMaximum, double wienerFilterNoise, long numberOfHistogramBins, VectorUInt32 numberOfControlPoints, long splineOrder, boolean useMaskLabel, short maskLabel)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations, double biasFieldFullWidthAtHalfMaximum, double wienerFilterNoise, long numberOfHistogramBins, VectorUInt32 numberOfControlPoints, long splineOrder, boolean useMaskLabel)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations, double biasFieldFullWidthAtHalfMaximum, double wienerFilterNoise, long numberOfHistogramBins, VectorUInt32 numberOfControlPoints, long splineOrder)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations, double biasFieldFullWidthAtHalfMaximum, double wienerFilterNoise, long numberOfHistogramBins, VectorUInt32 numberOfControlPoints)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations, double biasFieldFullWidthAtHalfMaximum, double wienerFilterNoise, long numberOfHistogramBins)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations, double biasFieldFullWidthAtHalfMaximum, double wienerFilterNoise)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations, double biasFieldFullWidthAtHalfMaximum)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, double convergenceThreshold, VectorUInt32 maximumNumberOfIterations)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image, double convergenceThreshold)
    • n4BiasFieldCorrection

      public static Image n4BiasFieldCorrection(Image image)
    • naryAdd

      public static Image naryAdd(VectorOfImage images)
    • naryAdd

      public static Image naryAdd(Image image1)
    • naryAdd

      public static Image naryAdd(Image image1, Image image2)
    • naryAdd

      public static Image naryAdd(Image image1, Image image2, Image image3)
    • naryAdd

      public static Image naryAdd(Image image1, Image image2, Image image3, Image image4)
    • naryAdd

      public static Image naryAdd(Image image1, Image image2, Image image3, Image image4, Image image5)
    • naryMaximum

      public static Image naryMaximum(VectorOfImage images)
    • naryMaximum

      public static Image naryMaximum(Image image1)
    • naryMaximum

      public static Image naryMaximum(Image image1, Image image2)
    • naryMaximum

      public static Image naryMaximum(Image image1, Image image2, Image image3)
    • naryMaximum

      public static Image naryMaximum(Image image1, Image image2, Image image3, Image image4)
    • naryMaximum

      public static Image naryMaximum(Image image1, Image image2, Image image3, Image image4, Image image5)
    • neighborhoodConnected

      public static Image neighborhoodConnected(Image image1, VectorUIntList seedList, double lower, double upper, VectorUInt32 radius, double replaceValue)
    • neighborhoodConnected

      public static Image neighborhoodConnected(Image image1, VectorUIntList seedList, double lower, double upper, VectorUInt32 radius)
    • neighborhoodConnected

      public static Image neighborhoodConnected(Image image1, VectorUIntList seedList, double lower, double upper)
    • neighborhoodConnected

      public static Image neighborhoodConnected(Image image1, VectorUIntList seedList, double lower)
    • neighborhoodConnected

      public static Image neighborhoodConnected(Image image1, VectorUIntList seedList)
    • neighborhoodConnected

      public static Image neighborhoodConnected(Image image1)
    • noise

      public static Image noise(Image image1, VectorUInt32 radius)
    • noise

      public static Image noise(Image image1)
    • normalize

      public static Image normalize(Image image1)
    • normalizeToConstant

      public static Image normalizeToConstant(Image image1, double constant)
    • normalizeToConstant

      public static Image normalizeToConstant(Image image1)
    • normalizedCorrelation

      public static Image normalizedCorrelation(Image image, Image maskImage, Image templateImage)
    • notEqual

      public static Image notEqual(Image image1, Image image2, short backgroundValue, short foregroundValue)
      Image itk::simple::NotEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • notEqual

      public static Image notEqual(Image image1, Image image2, short backgroundValue)
      Image itk::simple::NotEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • notEqual

      public static Image notEqual(Image image1, Image image2)
      Image itk::simple::NotEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • notEqual

      public static Image notEqual(Image image1, double constant, short backgroundValue, short foregroundValue)
      Image itk::simple::NotEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • notEqual

      public static Image notEqual(Image image1, double constant, short backgroundValue)
      Image itk::simple::NotEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • notEqual

      public static Image notEqual(Image image1, double constant)
      Image itk::simple::NotEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • notEqual

      public static Image notEqual(double constant, Image image2, short backgroundValue, short foregroundValue)
      Image itk::simple::NotEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • notEqual

      public static Image notEqual(double constant, Image image2, short backgroundValue)
      Image itk::simple::NotEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • notEqual

      public static Image notEqual(double constant, Image image2)
      Image itk::simple::NotEqual(Image &&image1, double constant, uint8_t backgroundValue=0u, uint8_t foregroundValue=1u)
    • not

      public static Image not(Image image1)
    • objectnessMeasure

      public static Image objectnessMeasure(Image image1, double alpha, double beta, double gamma, boolean scaleObjectnessMeasure, long objectDimension, boolean brightObject)
    • objectnessMeasure

      public static Image objectnessMeasure(Image image1, double alpha, double beta, double gamma, boolean scaleObjectnessMeasure, long objectDimension)
    • objectnessMeasure

      public static Image objectnessMeasure(Image image1, double alpha, double beta, double gamma, boolean scaleObjectnessMeasure)
    • objectnessMeasure

      public static Image objectnessMeasure(Image image1, double alpha, double beta, double gamma)
    • objectnessMeasure

      public static Image objectnessMeasure(Image image1, double alpha, double beta)
    • objectnessMeasure

      public static Image objectnessMeasure(Image image1, double alpha)
    • objectnessMeasure

      public static Image objectnessMeasure(Image image1)
    • openingByReconstruction

      public static Image openingByReconstruction(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, boolean fullyConnected, boolean preserveIntensities)
    • openingByReconstruction

      public static Image openingByReconstruction(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, boolean fullyConnected)
    • openingByReconstruction

      public static Image openingByReconstruction(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • openingByReconstruction

      public static Image openingByReconstruction(Image image1, VectorUInt32 kernelRadius)
    • openingByReconstruction

      public static Image openingByReconstruction(Image image1)
    • or

      public static Image or(Image image1, Image image2)
      Image itk::simple::Or(int constant, const Image &image2)
    • or

      public static Image or(Image image1, int constant)
      Image itk::simple::Or(int constant, const Image &image2)
    • or

      public static Image or(int constant, Image image2)
      Image itk::simple::Or(int constant, const Image &image2)
    • otsuMultipleThresholds

      public static Image otsuMultipleThresholds(Image image1, short numberOfThresholds, short labelOffset, long numberOfHistogramBins, boolean valleyEmphasis, boolean returnBinMidpoint)
    • otsuMultipleThresholds

      public static Image otsuMultipleThresholds(Image image1, short numberOfThresholds, short labelOffset, long numberOfHistogramBins, boolean valleyEmphasis)
    • otsuMultipleThresholds

      public static Image otsuMultipleThresholds(Image image1, short numberOfThresholds, short labelOffset, long numberOfHistogramBins)
    • otsuMultipleThresholds

      public static Image otsuMultipleThresholds(Image image1, short numberOfThresholds, short labelOffset)
    • otsuMultipleThresholds

      public static Image otsuMultipleThresholds(Image image1, short numberOfThresholds)
    • otsuMultipleThresholds

      public static Image otsuMultipleThresholds(Image image1)
    • otsuThreshold

      public static Image otsuThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue, boolean returnBinMidpoint)
    • otsuThreshold

      public static Image otsuThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • otsuThreshold

      public static Image otsuThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • otsuThreshold

      public static Image otsuThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins)
    • otsuThreshold

      public static Image otsuThreshold(Image image, Image maskImage, short insideValue, short outsideValue)
    • otsuThreshold

      public static Image otsuThreshold(Image image, Image maskImage, short insideValue)
    • otsuThreshold

      public static Image otsuThreshold(Image image, Image maskImage)
    • otsuThreshold

      public static Image otsuThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue, boolean returnBinMidpoint)
    • otsuThreshold

      public static Image otsuThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • otsuThreshold

      public static Image otsuThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • otsuThreshold

      public static Image otsuThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins)
    • otsuThreshold

      public static Image otsuThreshold(Image image, short insideValue, short outsideValue)
    • otsuThreshold

      public static Image otsuThreshold(Image image, short insideValue)
    • otsuThreshold

      public static Image otsuThreshold(Image image)
    • permuteAxes

      public static Image permuteAxes(Image image1, VectorUInt32 order)
    • permuteAxes

      public static Image permuteAxes(Image image1)
    • physicalPointSource

      public static Image physicalPointSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble origin, VectorDouble spacing, VectorDouble direction)
      Image itk::simple::PhysicalPointSource(PixelIDValueEnum outputPixelType=itk::simple::sitkVectorFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an image of the physical locations of each pixel. This function directly calls the execute method of PhysicalPointImageSource in order to support a procedural API See: itk::simple::PhysicalPointImageSource for the object oriented interface
    • physicalPointSource

      public static Image physicalPointSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble origin, VectorDouble spacing)
      Image itk::simple::PhysicalPointSource(PixelIDValueEnum outputPixelType=itk::simple::sitkVectorFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an image of the physical locations of each pixel. This function directly calls the execute method of PhysicalPointImageSource in order to support a procedural API See: itk::simple::PhysicalPointImageSource for the object oriented interface
    • physicalPointSource

      public static Image physicalPointSource(PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble origin)
      Image itk::simple::PhysicalPointSource(PixelIDValueEnum outputPixelType=itk::simple::sitkVectorFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an image of the physical locations of each pixel. This function directly calls the execute method of PhysicalPointImageSource in order to support a procedural API See: itk::simple::PhysicalPointImageSource for the object oriented interface
    • physicalPointSource

      public static Image physicalPointSource(PixelIDValueEnum outputPixelType, VectorUInt32 size)
      Image itk::simple::PhysicalPointSource(PixelIDValueEnum outputPixelType=itk::simple::sitkVectorFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an image of the physical locations of each pixel. This function directly calls the execute method of PhysicalPointImageSource in order to support a procedural API See: itk::simple::PhysicalPointImageSource for the object oriented interface
    • physicalPointSource

      public static Image physicalPointSource(PixelIDValueEnum outputPixelType)
      Image itk::simple::PhysicalPointSource(PixelIDValueEnum outputPixelType=itk::simple::sitkVectorFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an image of the physical locations of each pixel. This function directly calls the execute method of PhysicalPointImageSource in order to support a procedural API See: itk::simple::PhysicalPointImageSource for the object oriented interface
    • physicalPointSource

      public static Image physicalPointSource()
      Image itk::simple::PhysicalPointSource(PixelIDValueEnum outputPixelType=itk::simple::sitkVectorFloat32, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > origin=std::vector< double >(3, 0.0), std::vector< double > spacing=std::vector< double >(3, 1.0), std::vector< double > direction=std::vector< double >()) Generate an image of the physical locations of each pixel. This function directly calls the execute method of PhysicalPointImageSource in order to support a procedural API See: itk::simple::PhysicalPointImageSource for the object oriented interface
    • pow

      public static Image pow(Image image1, Image image2)
      Image itk::simple::Pow(Image &&image1, double constant)
    • pow

      public static Image pow(Image image1, double constant)
      Image itk::simple::Pow(Image &&image1, double constant)
    • pow

      public static Image pow(double constant, Image image2)
      Image itk::simple::Pow(Image &&image1, double constant)
    • projectedLandweberDeconvolution

      public static Image projectedLandweberDeconvolution(Image image1, Image image2, double alpha, int numberOfIterations, boolean normalize, ProjectedLandweberDeconvolutionImageFilter.BoundaryConditionType boundaryCondition, ProjectedLandweberDeconvolutionImageFilter.OutputRegionModeType outputRegionMode)
    • projectedLandweberDeconvolution

      public static Image projectedLandweberDeconvolution(Image image1, Image image2, double alpha, int numberOfIterations, boolean normalize, ProjectedLandweberDeconvolutionImageFilter.BoundaryConditionType boundaryCondition)
    • projectedLandweberDeconvolution

      public static Image projectedLandweberDeconvolution(Image image1, Image image2, double alpha, int numberOfIterations, boolean normalize)
    • projectedLandweberDeconvolution

      public static Image projectedLandweberDeconvolution(Image image1, Image image2, double alpha, int numberOfIterations)
    • projectedLandweberDeconvolution

      public static Image projectedLandweberDeconvolution(Image image1, Image image2, double alpha)
    • projectedLandweberDeconvolution

      public static Image projectedLandweberDeconvolution(Image image1, Image image2)
    • rank

      public static Image rank(Image image1, double rank, VectorUInt32 radius, KernelEnum kernelType)
    • rank

      public static Image rank(Image image1, double rank, VectorUInt32 radius)
    • rank

      public static Image rank(Image image1, double rank)
    • rank

      public static Image rank(Image image1)
    • realAndImaginaryToComplex

      public static Image realAndImaginaryToComplex(Image image1, Image image2)
    • realToHalfHermitianForwardFFT

      public static Image realToHalfHermitianForwardFFT(Image image1)
    • reconstructionByDilation

      public static Image reconstructionByDilation(Image markerImage, Image maskImage, boolean fullyConnected, boolean useInternalCopy)
    • reconstructionByDilation

      public static Image reconstructionByDilation(Image markerImage, Image maskImage, boolean fullyConnected)
    • reconstructionByDilation

      public static Image reconstructionByDilation(Image markerImage, Image maskImage)
    • reconstructionByErosion

      public static Image reconstructionByErosion(Image markerImage, Image maskImage, boolean fullyConnected, boolean useInternalCopy)
    • reconstructionByErosion

      public static Image reconstructionByErosion(Image markerImage, Image maskImage, boolean fullyConnected)
    • reconstructionByErosion

      public static Image reconstructionByErosion(Image markerImage, Image maskImage)
    • recursiveGaussian

      public static Image recursiveGaussian(Image image1, double sigma, boolean normalizeAcrossScale, RecursiveGaussianImageFilter.OrderType order, long direction)
    • recursiveGaussian

      public static Image recursiveGaussian(Image image1, double sigma, boolean normalizeAcrossScale, RecursiveGaussianImageFilter.OrderType order)
    • recursiveGaussian

      public static Image recursiveGaussian(Image image1, double sigma, boolean normalizeAcrossScale)
    • recursiveGaussian

      public static Image recursiveGaussian(Image image1, double sigma)
    • recursiveGaussian

      public static Image recursiveGaussian(Image image1)
    • regionOfInterest

      public static Image regionOfInterest(Image image1, VectorUInt32 size, VectorInt32 index)
    • regionOfInterest

      public static Image regionOfInterest(Image image1, VectorUInt32 size)
    • regionOfInterest

      public static Image regionOfInterest(Image image1)
    • regionalMaxima

      public static Image regionalMaxima(Image image1, double backgroundValue, double foregroundValue, boolean fullyConnected, boolean flatIsMaxima)
    • regionalMaxima

      public static Image regionalMaxima(Image image1, double backgroundValue, double foregroundValue, boolean fullyConnected)
    • regionalMaxima

      public static Image regionalMaxima(Image image1, double backgroundValue, double foregroundValue)
    • regionalMaxima

      public static Image regionalMaxima(Image image1, double backgroundValue)
    • regionalMaxima

      public static Image regionalMaxima(Image image1)
    • regionalMinima

      public static Image regionalMinima(Image image1, double backgroundValue, double foregroundValue, boolean fullyConnected, boolean flatIsMinima)
    • regionalMinima

      public static Image regionalMinima(Image image1, double backgroundValue, double foregroundValue, boolean fullyConnected)
    • regionalMinima

      public static Image regionalMinima(Image image1, double backgroundValue, double foregroundValue)
    • regionalMinima

      public static Image regionalMinima(Image image1, double backgroundValue)
    • regionalMinima

      public static Image regionalMinima(Image image1)
    • relabelComponent

      public static Image relabelComponent(Image image1, long minimumObjectSize, boolean sortByObjectSize)
    • relabelComponent

      public static Image relabelComponent(Image image1, long minimumObjectSize)
    • relabelComponent

      public static Image relabelComponent(Image image1)
    • relabelLabelMap

      public static Image relabelLabelMap(Image image1, boolean reverseOrdering)
    • relabelLabelMap

      public static Image relabelLabelMap(Image image1)
    • renyiEntropyThreshold

      public static Image renyiEntropyThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • renyiEntropyThreshold

      public static Image renyiEntropyThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • renyiEntropyThreshold

      public static Image renyiEntropyThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins)
    • renyiEntropyThreshold

      public static Image renyiEntropyThreshold(Image image, Image maskImage, short insideValue, short outsideValue)
    • renyiEntropyThreshold

      public static Image renyiEntropyThreshold(Image image, Image maskImage, short insideValue)
    • renyiEntropyThreshold

      public static Image renyiEntropyThreshold(Image image, Image maskImage)
    • renyiEntropyThreshold

      public static Image renyiEntropyThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • renyiEntropyThreshold

      public static Image renyiEntropyThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • renyiEntropyThreshold

      public static Image renyiEntropyThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins)
    • renyiEntropyThreshold

      public static Image renyiEntropyThreshold(Image image, short insideValue, short outsideValue)
    • renyiEntropyThreshold

      public static Image renyiEntropyThreshold(Image image, short insideValue)
    • renyiEntropyThreshold

      public static Image renyiEntropyThreshold(Image image)
    • rescaleIntensity

      public static Image rescaleIntensity(Image image1, double outputMinimum, double outputMaximum)
    • rescaleIntensity

      public static Image rescaleIntensity(Image image1, double outputMinimum)
    • rescaleIntensity

      public static Image rescaleIntensity(Image image1)
    • richardsonLucyDeconvolution

      public static Image richardsonLucyDeconvolution(Image image1, Image image2, int numberOfIterations, boolean normalize, RichardsonLucyDeconvolutionImageFilter.BoundaryConditionType boundaryCondition, RichardsonLucyDeconvolutionImageFilter.OutputRegionModeType outputRegionMode)
    • richardsonLucyDeconvolution

      public static Image richardsonLucyDeconvolution(Image image1, Image image2, int numberOfIterations, boolean normalize, RichardsonLucyDeconvolutionImageFilter.BoundaryConditionType boundaryCondition)
    • richardsonLucyDeconvolution

      public static Image richardsonLucyDeconvolution(Image image1, Image image2, int numberOfIterations, boolean normalize)
    • richardsonLucyDeconvolution

      public static Image richardsonLucyDeconvolution(Image image1, Image image2, int numberOfIterations)
    • richardsonLucyDeconvolution

      public static Image richardsonLucyDeconvolution(Image image1, Image image2)
    • round

      public static Image round(Image image1)
    • sLIC

      public static Image sLIC(Image image1, VectorUInt32 superGridSize, double spatialProximityWeight, long maximumNumberOfIterations, boolean enforceConnectivity, boolean initializationPerturbation)
    • sLIC

      public static Image sLIC(Image image1, VectorUInt32 superGridSize, double spatialProximityWeight, long maximumNumberOfIterations, boolean enforceConnectivity)
    • sLIC

      public static Image sLIC(Image image1, VectorUInt32 superGridSize, double spatialProximityWeight, long maximumNumberOfIterations)
    • sLIC

      public static Image sLIC(Image image1, VectorUInt32 superGridSize, double spatialProximityWeight)
    • sLIC

      public static Image sLIC(Image image1, VectorUInt32 superGridSize)
    • sLIC

      public static Image sLIC(Image image1)
    • sTAPLE

      public static Image sTAPLE(VectorOfImage images, double confidenceWeight, double foregroundValue, long maximumIterations)
    • sTAPLE

      public static Image sTAPLE(VectorOfImage images, double confidenceWeight, double foregroundValue)
    • sTAPLE

      public static Image sTAPLE(VectorOfImage images, double confidenceWeight)
    • sTAPLE

      public static Image sTAPLE(VectorOfImage images)
    • sTAPLE

      public static Image sTAPLE(Image image1, double confidenceWeight, double foregroundValue, long maximumIterations)
    • sTAPLE

      public static Image sTAPLE(Image image1, double confidenceWeight, double foregroundValue)
    • sTAPLE

      public static Image sTAPLE(Image image1, double confidenceWeight)
    • sTAPLE

      public static Image sTAPLE(Image image1)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, double confidenceWeight, double foregroundValue, long maximumIterations)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, double confidenceWeight, double foregroundValue)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, double confidenceWeight)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, Image image3, double confidenceWeight, double foregroundValue, long maximumIterations)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, Image image3, double confidenceWeight, double foregroundValue)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, Image image3, double confidenceWeight)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, Image image3)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, Image image3, Image image4, double confidenceWeight, double foregroundValue, long maximumIterations)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, Image image3, Image image4, double confidenceWeight, double foregroundValue)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, Image image3, Image image4, double confidenceWeight)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, Image image3, Image image4)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, Image image3, Image image4, Image image5, double confidenceWeight, double foregroundValue, long maximumIterations)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, Image image3, Image image4, Image image5, double confidenceWeight, double foregroundValue)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, Image image3, Image image4, Image image5, double confidenceWeight)
    • sTAPLE

      public static Image sTAPLE(Image image1, Image image2, Image image3, Image image4, Image image5)
    • saltAndPepperNoise

      public static Image saltAndPepperNoise(Image image1, double probability, long seed)
    • saltAndPepperNoise

      public static Image saltAndPepperNoise(Image image1, double probability)
    • saltAndPepperNoise

      public static Image saltAndPepperNoise(Image image1)
    • scalarChanAndVeseDenseLevelSet

      public static Image scalarChanAndVeseDenseLevelSet(Image initialImage, Image featureImage, double maximumRMSError, long numberOfIterations, double lambda1, double lambda2, double epsilon, double curvatureWeight, double areaWeight, double reinitializationSmoothingWeight, double volume, double volumeMatchingWeight, ScalarChanAndVeseDenseLevelSetImageFilter.HeavisideStepFunctionType heavisideStepFunction, boolean useImageSpacing)
    • scalarChanAndVeseDenseLevelSet

      public static Image scalarChanAndVeseDenseLevelSet(Image initialImage, Image featureImage, double maximumRMSError, long numberOfIterations, double lambda1, double lambda2, double epsilon, double curvatureWeight, double areaWeight, double reinitializationSmoothingWeight, double volume, double volumeMatchingWeight, ScalarChanAndVeseDenseLevelSetImageFilter.HeavisideStepFunctionType heavisideStepFunction)
    • scalarChanAndVeseDenseLevelSet

      public static Image scalarChanAndVeseDenseLevelSet(Image initialImage, Image featureImage, double maximumRMSError, long numberOfIterations, double lambda1, double lambda2, double epsilon, double curvatureWeight, double areaWeight, double reinitializationSmoothingWeight, double volume, double volumeMatchingWeight)
    • scalarChanAndVeseDenseLevelSet

      public static Image scalarChanAndVeseDenseLevelSet(Image initialImage, Image featureImage, double maximumRMSError, long numberOfIterations, double lambda1, double lambda2, double epsilon, double curvatureWeight, double areaWeight, double reinitializationSmoothingWeight, double volume)
    • scalarChanAndVeseDenseLevelSet

      public static Image scalarChanAndVeseDenseLevelSet(Image initialImage, Image featureImage, double maximumRMSError, long numberOfIterations, double lambda1, double lambda2, double epsilon, double curvatureWeight, double areaWeight, double reinitializationSmoothingWeight)
    • scalarChanAndVeseDenseLevelSet

      public static Image scalarChanAndVeseDenseLevelSet(Image initialImage, Image featureImage, double maximumRMSError, long numberOfIterations, double lambda1, double lambda2, double epsilon, double curvatureWeight, double areaWeight)
    • scalarChanAndVeseDenseLevelSet

      public static Image scalarChanAndVeseDenseLevelSet(Image initialImage, Image featureImage, double maximumRMSError, long numberOfIterations, double lambda1, double lambda2, double epsilon, double curvatureWeight)
    • scalarChanAndVeseDenseLevelSet

      public static Image scalarChanAndVeseDenseLevelSet(Image initialImage, Image featureImage, double maximumRMSError, long numberOfIterations, double lambda1, double lambda2, double epsilon)
    • scalarChanAndVeseDenseLevelSet

      public static Image scalarChanAndVeseDenseLevelSet(Image initialImage, Image featureImage, double maximumRMSError, long numberOfIterations, double lambda1, double lambda2)
    • scalarChanAndVeseDenseLevelSet

      public static Image scalarChanAndVeseDenseLevelSet(Image initialImage, Image featureImage, double maximumRMSError, long numberOfIterations, double lambda1)
    • scalarChanAndVeseDenseLevelSet

      public static Image scalarChanAndVeseDenseLevelSet(Image initialImage, Image featureImage, double maximumRMSError, long numberOfIterations)
    • scalarChanAndVeseDenseLevelSet

      public static Image scalarChanAndVeseDenseLevelSet(Image initialImage, Image featureImage, double maximumRMSError)
    • scalarChanAndVeseDenseLevelSet

      public static Image scalarChanAndVeseDenseLevelSet(Image initialImage, Image featureImage)
    • scalarConnectedComponent

      public static Image scalarConnectedComponent(Image image, Image maskImage, double distanceThreshold, boolean fullyConnected)
    • scalarConnectedComponent

      public static Image scalarConnectedComponent(Image image, Image maskImage, double distanceThreshold)
    • scalarConnectedComponent

      public static Image scalarConnectedComponent(Image image, Image maskImage)
    • scalarConnectedComponent

      public static Image scalarConnectedComponent(Image image, double distanceThreshold, boolean fullyConnected)
    • scalarConnectedComponent

      public static Image scalarConnectedComponent(Image image, double distanceThreshold)
    • scalarConnectedComponent

      public static Image scalarConnectedComponent(Image image)
    • scalarImageKmeans

      public static Image scalarImageKmeans(Image image1, VectorDouble classWithInitialMean, boolean useNonContiguousLabels)
    • scalarImageKmeans

      public static Image scalarImageKmeans(Image image1, VectorDouble classWithInitialMean)
    • scalarImageKmeans

      public static Image scalarImageKmeans(Image image1)
    • scalarToRGBColormap

      public static Image scalarToRGBColormap(Image image1, ScalarToRGBColormapImageFilter.ColormapType colormap, boolean useInputImageExtremaForScaling)
    • scalarToRGBColormap

      public static Image scalarToRGBColormap(Image image1, ScalarToRGBColormapImageFilter.ColormapType colormap)
    • scalarToRGBColormap

      public static Image scalarToRGBColormap(Image image1)
    • shanbhagThreshold

      public static Image shanbhagThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • shanbhagThreshold

      public static Image shanbhagThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • shanbhagThreshold

      public static Image shanbhagThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins)
    • shanbhagThreshold

      public static Image shanbhagThreshold(Image image, Image maskImage, short insideValue, short outsideValue)
    • shanbhagThreshold

      public static Image shanbhagThreshold(Image image, Image maskImage, short insideValue)
    • shanbhagThreshold

      public static Image shanbhagThreshold(Image image, Image maskImage)
    • shanbhagThreshold

      public static Image shanbhagThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • shanbhagThreshold

      public static Image shanbhagThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • shanbhagThreshold

      public static Image shanbhagThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins)
    • shanbhagThreshold

      public static Image shanbhagThreshold(Image image, short insideValue, short outsideValue)
    • shanbhagThreshold

      public static Image shanbhagThreshold(Image image, short insideValue)
    • shanbhagThreshold

      public static Image shanbhagThreshold(Image image)
    • shapeDetectionLevelSet

      public static Image shapeDetectionLevelSet(Image initialImage, Image featureImage, double maximumRMSError, double propagationScaling, double curvatureScaling, long numberOfIterations, boolean reverseExpansionDirection)
    • shapeDetectionLevelSet

      public static Image shapeDetectionLevelSet(Image initialImage, Image featureImage, double maximumRMSError, double propagationScaling, double curvatureScaling, long numberOfIterations)
    • shapeDetectionLevelSet

      public static Image shapeDetectionLevelSet(Image initialImage, Image featureImage, double maximumRMSError, double propagationScaling, double curvatureScaling)
    • shapeDetectionLevelSet

      public static Image shapeDetectionLevelSet(Image initialImage, Image featureImage, double maximumRMSError, double propagationScaling)
    • shapeDetectionLevelSet

      public static Image shapeDetectionLevelSet(Image initialImage, Image featureImage, double maximumRMSError)
    • shapeDetectionLevelSet

      public static Image shapeDetectionLevelSet(Image initialImage, Image featureImage)
    • shiftScale

      public static Image shiftScale(Image image1, double shift, double scale, PixelIDValueEnum outputPixelType)
    • shiftScale

      public static Image shiftScale(Image image1, double shift, double scale)
    • shiftScale

      public static Image shiftScale(Image image1, double shift)
    • shiftScale

      public static Image shiftScale(Image image1)
    • shotNoise

      public static Image shotNoise(Image image1, double scale, long seed)
    • shotNoise

      public static Image shotNoise(Image image1, double scale)
    • shotNoise

      public static Image shotNoise(Image image1)
    • shrink

      public static Image shrink(Image image1, VectorUInt32 shrinkFactors)
    • shrink

      public static Image shrink(Image image1)
    • sigmoid

      public static Image sigmoid(Image image1, double alpha, double beta, double outputMaximum, double outputMinimum)
    • sigmoid

      public static Image sigmoid(Image image1, double alpha, double beta, double outputMaximum)
    • sigmoid

      public static Image sigmoid(Image image1, double alpha, double beta)
    • sigmoid

      public static Image sigmoid(Image image1, double alpha)
    • sigmoid

      public static Image sigmoid(Image image1)
    • signedDanielssonDistanceMap

      public static Image signedDanielssonDistanceMap(Image image1, boolean insideIsPositive, boolean squaredDistance, boolean useImageSpacing)
    • signedDanielssonDistanceMap

      public static Image signedDanielssonDistanceMap(Image image1, boolean insideIsPositive, boolean squaredDistance)
    • signedDanielssonDistanceMap

      public static Image signedDanielssonDistanceMap(Image image1, boolean insideIsPositive)
    • signedDanielssonDistanceMap

      public static Image signedDanielssonDistanceMap(Image image1)
    • signedMaurerDistanceMap

      public static Image signedMaurerDistanceMap(Image image1, boolean insideIsPositive, boolean squaredDistance, boolean useImageSpacing, double backgroundValue)
    • signedMaurerDistanceMap

      public static Image signedMaurerDistanceMap(Image image1, boolean insideIsPositive, boolean squaredDistance, boolean useImageSpacing)
    • signedMaurerDistanceMap

      public static Image signedMaurerDistanceMap(Image image1, boolean insideIsPositive, boolean squaredDistance)
    • signedMaurerDistanceMap

      public static Image signedMaurerDistanceMap(Image image1, boolean insideIsPositive)
    • signedMaurerDistanceMap

      public static Image signedMaurerDistanceMap(Image image1)
    • simpleContourExtractor

      public static Image simpleContourExtractor(Image image1, double inputForegroundValue, double inputBackgroundValue, VectorUInt32 radius, double outputForegroundValue, double outputBackgroundValue)
    • simpleContourExtractor

      public static Image simpleContourExtractor(Image image1, double inputForegroundValue, double inputBackgroundValue, VectorUInt32 radius, double outputForegroundValue)
    • simpleContourExtractor

      public static Image simpleContourExtractor(Image image1, double inputForegroundValue, double inputBackgroundValue, VectorUInt32 radius)
    • simpleContourExtractor

      public static Image simpleContourExtractor(Image image1, double inputForegroundValue, double inputBackgroundValue)
    • simpleContourExtractor

      public static Image simpleContourExtractor(Image image1, double inputForegroundValue)
    • simpleContourExtractor

      public static Image simpleContourExtractor(Image image1)
    • sin

      public static Image sin(Image image1)
    • slice

      public static Image slice(Image image1, VectorInt32 start, VectorInt32 stop, VectorInt32 step)
    • slice

      public static Image slice(Image image1, VectorInt32 start, VectorInt32 stop)
    • slice

      public static Image slice(Image image1, VectorInt32 start)
    • slice

      public static Image slice(Image image1)
    • smoothingRecursiveGaussian

      public static Image smoothingRecursiveGaussian(Image image1, VectorDouble sigma, boolean normalizeAcrossScale)
      Image itk::simple::SmoothingRecursiveGaussian(const Image &image1, double sigma, bool normalizeAcrossScale=false) Computes the smoothing of an image by convolution with the Gaussian kernels implemented as IIR filters. This function directly calls the execute method of SmoothingRecursiveGaussianImageFilter in order to support a procedural API See: itk::simple::SmoothingRecursiveGaussianImageFilter for the object oriented interface
    • smoothingRecursiveGaussian

      public static Image smoothingRecursiveGaussian(Image image1, VectorDouble sigma)
      Image itk::simple::SmoothingRecursiveGaussian(const Image &image1, double sigma, bool normalizeAcrossScale=false) Computes the smoothing of an image by convolution with the Gaussian kernels implemented as IIR filters. This function directly calls the execute method of SmoothingRecursiveGaussianImageFilter in order to support a procedural API See: itk::simple::SmoothingRecursiveGaussianImageFilter for the object oriented interface
    • smoothingRecursiveGaussian

      public static Image smoothingRecursiveGaussian(Image image1)
      Image itk::simple::SmoothingRecursiveGaussian(const Image &image1, double sigma, bool normalizeAcrossScale=false) Computes the smoothing of an image by convolution with the Gaussian kernels implemented as IIR filters. This function directly calls the execute method of SmoothingRecursiveGaussianImageFilter in order to support a procedural API See: itk::simple::SmoothingRecursiveGaussianImageFilter for the object oriented interface
    • sobelEdgeDetection

      public static Image sobelEdgeDetection(Image image1)
    • speckleNoise

      public static Image speckleNoise(Image image1, double standardDeviation, long seed)
    • speckleNoise

      public static Image speckleNoise(Image image1, double standardDeviation)
    • speckleNoise

      public static Image speckleNoise(Image image1)
    • sqrt

      public static Image sqrt(Image image1)
    • square

      public static Image square(Image image1)
    • squaredDifference

      public static Image squaredDifference(Image image1, Image image2)
      Image itk::simple::SquaredDifference(Image &&image1, double constant)
    • squaredDifference

      public static Image squaredDifference(Image image1, double constant)
      Image itk::simple::SquaredDifference(Image &&image1, double constant)
    • squaredDifference

      public static Image squaredDifference(double constant, Image image2)
      Image itk::simple::SquaredDifference(Image &&image1, double constant)
    • standardDeviationProjection

      public static Image standardDeviationProjection(Image image1, long projectionDimension)
    • standardDeviationProjection

      public static Image standardDeviationProjection(Image image1)
    • stochasticFractalDimension

      public static Image stochasticFractalDimension(Image image, Image maskImage, VectorUInt32 neighborhoodRadius)
    • stochasticFractalDimension

      public static Image stochasticFractalDimension(Image image, Image maskImage)
    • stochasticFractalDimension

      public static Image stochasticFractalDimension(Image image, VectorUInt32 neighborhoodRadius)
    • stochasticFractalDimension

      public static Image stochasticFractalDimension(Image image)
    • subtract

      public static Image subtract(Image image1, Image image2)
      Image itk::simple::Subtract(Image &&image1, double constant)
    • subtract

      public static Image subtract(Image image1, double constant)
      Image itk::simple::Subtract(Image &&image1, double constant)
    • subtract

      public static Image subtract(double constant, Image image2)
      Image itk::simple::Subtract(Image &&image1, double constant)
    • sumProjection

      public static Image sumProjection(Image image1, long projectionDimension)
    • sumProjection

      public static Image sumProjection(Image image1)
    • tan

      public static Image tan(Image image1)
    • ternaryAdd

      public static Image ternaryAdd(Image image1, Image image2, Image image3)
    • ternaryMagnitude

      public static Image ternaryMagnitude(Image image1, Image image2, Image image3)
    • ternaryMagnitudeSquared

      public static Image ternaryMagnitudeSquared(Image image1, Image image2, Image image3)
    • threshold

      public static Image threshold(Image image1, double lower, double upper, double outsideValue)
    • threshold

      public static Image threshold(Image image1, double lower, double upper)
    • threshold

      public static Image threshold(Image image1, double lower)
    • threshold

      public static Image threshold(Image image1)
    • thresholdMaximumConnectedComponents

      public static Image thresholdMaximumConnectedComponents(Image image1, long minimumObjectSizeInPixels, double upperBoundary, short insideValue, short outsideValue)
    • thresholdMaximumConnectedComponents

      public static Image thresholdMaximumConnectedComponents(Image image1, long minimumObjectSizeInPixels, double upperBoundary, short insideValue)
    • thresholdMaximumConnectedComponents

      public static Image thresholdMaximumConnectedComponents(Image image1, long minimumObjectSizeInPixels, double upperBoundary)
    • thresholdMaximumConnectedComponents

      public static Image thresholdMaximumConnectedComponents(Image image1, long minimumObjectSizeInPixels)
    • thresholdMaximumConnectedComponents

      public static Image thresholdMaximumConnectedComponents(Image image1)
    • thresholdSegmentationLevelSet

      public static Image thresholdSegmentationLevelSet(Image initialImage, Image featureImage, double lowerThreshold, double upperThreshold, double maximumRMSError, double propagationScaling, double curvatureScaling, long numberOfIterations, boolean reverseExpansionDirection)
    • thresholdSegmentationLevelSet

      public static Image thresholdSegmentationLevelSet(Image initialImage, Image featureImage, double lowerThreshold, double upperThreshold, double maximumRMSError, double propagationScaling, double curvatureScaling, long numberOfIterations)
    • thresholdSegmentationLevelSet

      public static Image thresholdSegmentationLevelSet(Image initialImage, Image featureImage, double lowerThreshold, double upperThreshold, double maximumRMSError, double propagationScaling, double curvatureScaling)
    • thresholdSegmentationLevelSet

      public static Image thresholdSegmentationLevelSet(Image initialImage, Image featureImage, double lowerThreshold, double upperThreshold, double maximumRMSError, double propagationScaling)
    • thresholdSegmentationLevelSet

      public static Image thresholdSegmentationLevelSet(Image initialImage, Image featureImage, double lowerThreshold, double upperThreshold, double maximumRMSError)
    • thresholdSegmentationLevelSet

      public static Image thresholdSegmentationLevelSet(Image initialImage, Image featureImage, double lowerThreshold, double upperThreshold)
    • thresholdSegmentationLevelSet

      public static Image thresholdSegmentationLevelSet(Image initialImage, Image featureImage, double lowerThreshold)
    • thresholdSegmentationLevelSet

      public static Image thresholdSegmentationLevelSet(Image initialImage, Image featureImage)
    • tikhonovDeconvolution

      public static Image tikhonovDeconvolution(Image image1, Image image2, double regularizationConstant, boolean normalize, TikhonovDeconvolutionImageFilter.BoundaryConditionType boundaryCondition, TikhonovDeconvolutionImageFilter.OutputRegionModeType outputRegionMode)
    • tikhonovDeconvolution

      public static Image tikhonovDeconvolution(Image image1, Image image2, double regularizationConstant, boolean normalize, TikhonovDeconvolutionImageFilter.BoundaryConditionType boundaryCondition)
    • tikhonovDeconvolution

      public static Image tikhonovDeconvolution(Image image1, Image image2, double regularizationConstant, boolean normalize)
    • tikhonovDeconvolution

      public static Image tikhonovDeconvolution(Image image1, Image image2, double regularizationConstant)
    • tikhonovDeconvolution

      public static Image tikhonovDeconvolution(Image image1, Image image2)
    • tile

      public static Image tile(VectorOfImage images, VectorUInt32 layout, double defaultPixelValue)
    • tile

      public static Image tile(VectorOfImage images, VectorUInt32 layout)
    • tile

      public static Image tile(VectorOfImage images)
    • tile

      public static Image tile(Image image1, VectorUInt32 layout, double defaultPixelValue)
    • tile

      public static Image tile(Image image1, VectorUInt32 layout)
    • tile

      public static Image tile(Image image1)
    • tile

      public static Image tile(Image image1, Image image2, VectorUInt32 layout, double defaultPixelValue)
    • tile

      public static Image tile(Image image1, Image image2, VectorUInt32 layout)
    • tile

      public static Image tile(Image image1, Image image2)
    • tile

      public static Image tile(Image image1, Image image2, Image image3, VectorUInt32 layout, double defaultPixelValue)
    • tile

      public static Image tile(Image image1, Image image2, Image image3, VectorUInt32 layout)
    • tile

      public static Image tile(Image image1, Image image2, Image image3)
    • tile

      public static Image tile(Image image1, Image image2, Image image3, Image image4, VectorUInt32 layout, double defaultPixelValue)
    • tile

      public static Image tile(Image image1, Image image2, Image image3, Image image4, VectorUInt32 layout)
    • tile

      public static Image tile(Image image1, Image image2, Image image3, Image image4)
    • tile

      public static Image tile(Image image1, Image image2, Image image3, Image image4, Image image5, VectorUInt32 layout, double defaultPixelValue)
    • tile

      public static Image tile(Image image1, Image image2, Image image3, Image image4, Image image5, VectorUInt32 layout)
    • tile

      public static Image tile(Image image1, Image image2, Image image3, Image image4, Image image5)
    • toboggan

      public static Image toboggan(Image image1)
    • transformGeometry

      public static Image transformGeometry(Image image, Transform transform)
    • transformToDisplacementField

      public static Image transformToDisplacementField(Transform transform, PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble outputOrigin, VectorDouble outputSpacing, VectorDouble outputDirection)
      Image itk::simple::TransformToDisplacementField(const Transform &transform, PixelIDValueEnum outputPixelType=itk::simple::sitkVectorFloat64, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > outputOrigin=std::vector< double >(3, 0.0), std::vector< double > outputSpacing=std::vector< double >(3, 1.0), std::vector< double > outputDirection=std::vector< double >()) Generate a displacement field from a coordinate transform. This function directly calls the execute method of TransformToDisplacementFieldFilter in order to support a procedural API See: itk::simple::TransformToDisplacementFieldFilter for the object oriented interface
    • transformToDisplacementField

      public static Image transformToDisplacementField(Transform transform, PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble outputOrigin, VectorDouble outputSpacing)
      Image itk::simple::TransformToDisplacementField(const Transform &transform, PixelIDValueEnum outputPixelType=itk::simple::sitkVectorFloat64, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > outputOrigin=std::vector< double >(3, 0.0), std::vector< double > outputSpacing=std::vector< double >(3, 1.0), std::vector< double > outputDirection=std::vector< double >()) Generate a displacement field from a coordinate transform. This function directly calls the execute method of TransformToDisplacementFieldFilter in order to support a procedural API See: itk::simple::TransformToDisplacementFieldFilter for the object oriented interface
    • transformToDisplacementField

      public static Image transformToDisplacementField(Transform transform, PixelIDValueEnum outputPixelType, VectorUInt32 size, VectorDouble outputOrigin)
      Image itk::simple::TransformToDisplacementField(const Transform &transform, PixelIDValueEnum outputPixelType=itk::simple::sitkVectorFloat64, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > outputOrigin=std::vector< double >(3, 0.0), std::vector< double > outputSpacing=std::vector< double >(3, 1.0), std::vector< double > outputDirection=std::vector< double >()) Generate a displacement field from a coordinate transform. This function directly calls the execute method of TransformToDisplacementFieldFilter in order to support a procedural API See: itk::simple::TransformToDisplacementFieldFilter for the object oriented interface
    • transformToDisplacementField

      public static Image transformToDisplacementField(Transform transform, PixelIDValueEnum outputPixelType, VectorUInt32 size)
      Image itk::simple::TransformToDisplacementField(const Transform &transform, PixelIDValueEnum outputPixelType=itk::simple::sitkVectorFloat64, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > outputOrigin=std::vector< double >(3, 0.0), std::vector< double > outputSpacing=std::vector< double >(3, 1.0), std::vector< double > outputDirection=std::vector< double >()) Generate a displacement field from a coordinate transform. This function directly calls the execute method of TransformToDisplacementFieldFilter in order to support a procedural API See: itk::simple::TransformToDisplacementFieldFilter for the object oriented interface
    • transformToDisplacementField

      public static Image transformToDisplacementField(Transform transform, PixelIDValueEnum outputPixelType)
      Image itk::simple::TransformToDisplacementField(const Transform &transform, PixelIDValueEnum outputPixelType=itk::simple::sitkVectorFloat64, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > outputOrigin=std::vector< double >(3, 0.0), std::vector< double > outputSpacing=std::vector< double >(3, 1.0), std::vector< double > outputDirection=std::vector< double >()) Generate a displacement field from a coordinate transform. This function directly calls the execute method of TransformToDisplacementFieldFilter in order to support a procedural API See: itk::simple::TransformToDisplacementFieldFilter for the object oriented interface
    • transformToDisplacementField

      public static Image transformToDisplacementField(Transform transform)
      Image itk::simple::TransformToDisplacementField(const Transform &transform, PixelIDValueEnum outputPixelType=itk::simple::sitkVectorFloat64, std::vector< unsigned int > size=std::vector< unsigned int >(3, 64), std::vector< double > outputOrigin=std::vector< double >(3, 0.0), std::vector< double > outputSpacing=std::vector< double >(3, 1.0), std::vector< double > outputDirection=std::vector< double >()) Generate a displacement field from a coordinate transform. This function directly calls the execute method of TransformToDisplacementFieldFilter in order to support a procedural API See: itk::simple::TransformToDisplacementFieldFilter for the object oriented interface
    • triangleThreshold

      public static Image triangleThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • triangleThreshold

      public static Image triangleThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • triangleThreshold

      public static Image triangleThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins)
    • triangleThreshold

      public static Image triangleThreshold(Image image, Image maskImage, short insideValue, short outsideValue)
    • triangleThreshold

      public static Image triangleThreshold(Image image, Image maskImage, short insideValue)
    • triangleThreshold

      public static Image triangleThreshold(Image image, Image maskImage)
    • triangleThreshold

      public static Image triangleThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • triangleThreshold

      public static Image triangleThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • triangleThreshold

      public static Image triangleThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins)
    • triangleThreshold

      public static Image triangleThreshold(Image image, short insideValue, short outsideValue)
    • triangleThreshold

      public static Image triangleThreshold(Image image, short insideValue)
    • triangleThreshold

      public static Image triangleThreshold(Image image)
    • unaryMinus

      public static Image unaryMinus(Image image1)
    • unsharpMask

      public static Image unsharpMask(Image image1, VectorDouble sigmas, double amount, double threshold, boolean clamp)
    • unsharpMask

      public static Image unsharpMask(Image image1, VectorDouble sigmas, double amount, double threshold)
    • unsharpMask

      public static Image unsharpMask(Image image1, VectorDouble sigmas, double amount)
    • unsharpMask

      public static Image unsharpMask(Image image1, VectorDouble sigmas)
    • unsharpMask

      public static Image unsharpMask(Image image1)
    • valuedRegionalMaxima

      public static Image valuedRegionalMaxima(Image image1, boolean fullyConnected)
    • valuedRegionalMaxima

      public static Image valuedRegionalMaxima(Image image1)
    • valuedRegionalMinima

      public static Image valuedRegionalMinima(Image image1, boolean fullyConnected)
    • valuedRegionalMinima

      public static Image valuedRegionalMinima(Image image1)
    • vectorConfidenceConnected

      public static Image vectorConfidenceConnected(Image image1, VectorUIntList seedList, long numberOfIterations, double multiplier, long initialNeighborhoodRadius, short replaceValue)
    • vectorConfidenceConnected

      public static Image vectorConfidenceConnected(Image image1, VectorUIntList seedList, long numberOfIterations, double multiplier, long initialNeighborhoodRadius)
    • vectorConfidenceConnected

      public static Image vectorConfidenceConnected(Image image1, VectorUIntList seedList, long numberOfIterations, double multiplier)
    • vectorConfidenceConnected

      public static Image vectorConfidenceConnected(Image image1, VectorUIntList seedList, long numberOfIterations)
    • vectorConfidenceConnected

      public static Image vectorConfidenceConnected(Image image1, VectorUIntList seedList)
    • vectorConfidenceConnected

      public static Image vectorConfidenceConnected(Image image1)
    • vectorConnectedComponent

      public static Image vectorConnectedComponent(Image image1, double distanceThreshold, boolean fullyConnected)
    • vectorConnectedComponent

      public static Image vectorConnectedComponent(Image image1, double distanceThreshold)
    • vectorConnectedComponent

      public static Image vectorConnectedComponent(Image image1)
    • vectorIndexSelectionCast

      public static Image vectorIndexSelectionCast(Image image1, long index, PixelIDValueEnum outputPixelType)
    • vectorIndexSelectionCast

      public static Image vectorIndexSelectionCast(Image image1, long index)
    • vectorIndexSelectionCast

      public static Image vectorIndexSelectionCast(Image image1)
    • vectorMagnitude

      public static Image vectorMagnitude(Image image1)
    • votingBinaryHoleFilling

      public static Image votingBinaryHoleFilling(Image image1, VectorUInt32 radius, long majorityThreshold, double foregroundValue, double backgroundValue)
    • votingBinaryHoleFilling

      public static Image votingBinaryHoleFilling(Image image1, VectorUInt32 radius, long majorityThreshold, double foregroundValue)
    • votingBinaryHoleFilling

      public static Image votingBinaryHoleFilling(Image image1, VectorUInt32 radius, long majorityThreshold)
    • votingBinaryHoleFilling

      public static Image votingBinaryHoleFilling(Image image1, VectorUInt32 radius)
    • votingBinaryHoleFilling

      public static Image votingBinaryHoleFilling(Image image1)
    • votingBinary

      public static Image votingBinary(Image image1, VectorUInt32 radius, long birthThreshold, long survivalThreshold, double foregroundValue, double backgroundValue)
    • votingBinary

      public static Image votingBinary(Image image1, VectorUInt32 radius, long birthThreshold, long survivalThreshold, double foregroundValue)
    • votingBinary

      public static Image votingBinary(Image image1, VectorUInt32 radius, long birthThreshold, long survivalThreshold)
    • votingBinary

      public static Image votingBinary(Image image1, VectorUInt32 radius, long birthThreshold)
    • votingBinary

      public static Image votingBinary(Image image1, VectorUInt32 radius)
    • votingBinary

      public static Image votingBinary(Image image1)
    • votingBinaryIterativeHoleFilling

      public static Image votingBinaryIterativeHoleFilling(Image image1, VectorUInt32 radius, long maximumNumberOfIterations, long majorityThreshold, double foregroundValue, double backgroundValue)
    • votingBinaryIterativeHoleFilling

      public static Image votingBinaryIterativeHoleFilling(Image image1, VectorUInt32 radius, long maximumNumberOfIterations, long majorityThreshold, double foregroundValue)
    • votingBinaryIterativeHoleFilling

      public static Image votingBinaryIterativeHoleFilling(Image image1, VectorUInt32 radius, long maximumNumberOfIterations, long majorityThreshold)
    • votingBinaryIterativeHoleFilling

      public static Image votingBinaryIterativeHoleFilling(Image image1, VectorUInt32 radius, long maximumNumberOfIterations)
    • votingBinaryIterativeHoleFilling

      public static Image votingBinaryIterativeHoleFilling(Image image1, VectorUInt32 radius)
    • votingBinaryIterativeHoleFilling

      public static Image votingBinaryIterativeHoleFilling(Image image1)
    • warp

      public static Image warp(Image image, Image displacementField, InterpolatorEnum interpolator, VectorUInt32 outputSize, VectorDouble outputOrigin, VectorDouble outputSpacing, VectorDouble outputDirection, double edgePaddingValue)
    • warp

      public static Image warp(Image image, Image displacementField, InterpolatorEnum interpolator, VectorUInt32 outputSize, VectorDouble outputOrigin, VectorDouble outputSpacing, VectorDouble outputDirection)
    • warp

      public static Image warp(Image image, Image displacementField, InterpolatorEnum interpolator, VectorUInt32 outputSize, VectorDouble outputOrigin, VectorDouble outputSpacing)
    • warp

      public static Image warp(Image image, Image displacementField, InterpolatorEnum interpolator, VectorUInt32 outputSize, VectorDouble outputOrigin)
    • warp

      public static Image warp(Image image, Image displacementField, InterpolatorEnum interpolator, VectorUInt32 outputSize)
    • warp

      public static Image warp(Image image, Image displacementField, InterpolatorEnum interpolator)
    • warp

      public static Image warp(Image image, Image displacementField)
    • whiteTopHat

      public static Image whiteTopHat(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType, boolean safeBorder)
    • whiteTopHat

      public static Image whiteTopHat(Image image1, VectorUInt32 kernelRadius, KernelEnum kernelType)
    • whiteTopHat

      public static Image whiteTopHat(Image image1, VectorUInt32 kernelRadius)
    • whiteTopHat

      public static Image whiteTopHat(Image image1)
    • wienerDeconvolution

      public static Image wienerDeconvolution(Image image1, Image image2, double noiseVariance, boolean normalize, WienerDeconvolutionImageFilter.BoundaryConditionType boundaryCondition, WienerDeconvolutionImageFilter.OutputRegionModeType outputRegionMode)
    • wienerDeconvolution

      public static Image wienerDeconvolution(Image image1, Image image2, double noiseVariance, boolean normalize, WienerDeconvolutionImageFilter.BoundaryConditionType boundaryCondition)
    • wienerDeconvolution

      public static Image wienerDeconvolution(Image image1, Image image2, double noiseVariance, boolean normalize)
    • wienerDeconvolution

      public static Image wienerDeconvolution(Image image1, Image image2, double noiseVariance)
    • wienerDeconvolution

      public static Image wienerDeconvolution(Image image1, Image image2)
    • wrapPad

      public static Image wrapPad(Image image1, VectorUInt32 padLowerBound, VectorUInt32 padUpperBound)
    • wrapPad

      public static Image wrapPad(Image image1, VectorUInt32 padLowerBound)
    • wrapPad

      public static Image wrapPad(Image image1)
    • xor

      public static Image xor(Image image1, Image image2)
      Image itk::simple::Xor(int constant, const Image &image2)
    • xor

      public static Image xor(Image image1, int constant)
      Image itk::simple::Xor(int constant, const Image &image2)
    • xor

      public static Image xor(int constant, Image image2)
      Image itk::simple::Xor(int constant, const Image &image2)
    • yenThreshold

      public static Image yenThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • yenThreshold

      public static Image yenThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • yenThreshold

      public static Image yenThreshold(Image image, Image maskImage, short insideValue, short outsideValue, long numberOfHistogramBins)
    • yenThreshold

      public static Image yenThreshold(Image image, Image maskImage, short insideValue, short outsideValue)
    • yenThreshold

      public static Image yenThreshold(Image image, Image maskImage, short insideValue)
    • yenThreshold

      public static Image yenThreshold(Image image, Image maskImage)
    • yenThreshold

      public static Image yenThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput, short maskValue)
    • yenThreshold

      public static Image yenThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins, boolean maskOutput)
    • yenThreshold

      public static Image yenThreshold(Image image, short insideValue, short outsideValue, long numberOfHistogramBins)
    • yenThreshold

      public static Image yenThreshold(Image image, short insideValue, short outsideValue)
    • yenThreshold

      public static Image yenThreshold(Image image, short insideValue)
    • yenThreshold

      public static Image yenThreshold(Image image)
    • zeroCrossingBasedEdgeDetection

      public static Image zeroCrossingBasedEdgeDetection(Image image1, double variance, short foregroundValue, short backgroundValue, double maximumError)
    • zeroCrossingBasedEdgeDetection

      public static Image zeroCrossingBasedEdgeDetection(Image image1, double variance, short foregroundValue, short backgroundValue)
    • zeroCrossingBasedEdgeDetection

      public static Image zeroCrossingBasedEdgeDetection(Image image1, double variance, short foregroundValue)
    • zeroCrossingBasedEdgeDetection

      public static Image zeroCrossingBasedEdgeDetection(Image image1, double variance)
    • zeroCrossingBasedEdgeDetection

      public static Image zeroCrossingBasedEdgeDetection(Image image1)
    • zeroCrossing

      public static Image zeroCrossing(Image image1, short foregroundValue, short backgroundValue)
    • zeroCrossing

      public static Image zeroCrossing(Image image1, short foregroundValue)
    • zeroCrossing

      public static Image zeroCrossing(Image image1)
    • zeroFluxNeumannPad

      public static Image zeroFluxNeumannPad(Image image1, VectorUInt32 padLowerBound, VectorUInt32 padUpperBound)
    • zeroFluxNeumannPad

      public static Image zeroFluxNeumannPad(Image image1, VectorUInt32 padLowerBound)
    • zeroFluxNeumannPad

      public static Image zeroFluxNeumannPad(Image image1)