Method Detail

• imgByte

  public static Img<ByteType> imgByte(org.tensorflow.Tensor<org.tensorflow.types.UInt8> image)

  Creates an image of type ByteType containing the data of a TensorFlow Tensor with the data type DataType.UINT8.

  Note that this does _not_ adjust any dimensions. This means that the resulting image will have dimensions corresponding to the reversed shape of the Tensor. See imgByteDirect(Tensor) and imgByte(Tensor, int[]) if you want to handle dimensions differently.

  Note also that no exception is thrown if the data type is not DataType.UINT8 but it will give unexpected results.

  Parameters:

  image - The TensorFlow Tensor.

  Returns:

  An image containing the data of the Tensor.

• imgDouble

  public static Img<DoubleType> imgDouble(org.tensorflow.Tensor<Double> image)

  Creates an image of type DoubleType containing the data of a TensorFlow Tensor with the data type DataType.DOUBLE.

  Note that this does _not_ adjust any dimensions. This means that the resulting image will have dimensions corresponding to the reversed shape of the Tensor. See imgByteDirect(Tensor) and imgByte(Tensor, int[]) if you want to handle dimensions differently.

  Parameters:

  image - The TensorFlow Tensor.

  Returns:

  An image containing the data of the Tensor.

  Throws:

  IllegalArgumentException - if Tensor data type is not double.

• imgFloat

  public static Img<FloatType> imgFloat(org.tensorflow.Tensor<Float> image)

  Creates an image of type FloatType containing the data of a TensorFlow Tensor with the data type DataType.FLOAT.

  Note that this does _not_ adjust any dimensions. This means that the resulting image will have dimensions corresponding to the reversed shape of the Tensor. See imgByteDirect(Tensor) and imgByte(Tensor, int[]) if you want to handle dimensions differently.

  Parameters:

  image - The TensorFlow Tensor.

  Returns:

  An image containing the data of the Tensor.

  Throws:

  IllegalArgumentException - if Tensor data type is not float.

• imgInt

  public static Img<IntType> imgInt(org.tensorflow.Tensor<Integer> image)

  Creates an image of type IntType containing the data of a TensorFlow Tensor with the data type DataType.INT32.

  Note that this does _not_ adjust any dimensions. This means that the resulting image will have dimensions corresponding to the reversed shape of the Tensor. See imgByteDirect(Tensor) and imgByte(Tensor, int[]) if you want to handle dimensions differently.

  Parameters:

  image - The TensorFlow Tensor.

  Returns:

  An image containing the data of the Tensor.

  Throws:

  IllegalArgumentException - if Tensor data type is not int.

• imgLong

  public static Img<LongType> imgLong(org.tensorflow.Tensor<Long> image)

  Creates an image of type LongType containing the data of a TensorFlow Tensor with the data type DataType.INT64.

  Note that this does _not_ adjust any dimensions. This means that the resulting image will have dimensions corresponding to the reversed shape of the Tensor. See imgByteDirect(Tensor) and imgByte(Tensor, int[]) if you want to handle dimensions differently.

  Parameters:

  image - The TensorFlow Tensor.

  Returns:

  An image containing the data of the Tensor.

  Throws:

  IllegalArgumentException - if Tensor data type is not long.

• imgByte

  public static Img<ByteType> imgByte(org.tensorflow.Tensor<org.tensorflow.types.UInt8> image,
                                      int[] dimOrder)

  Creates an image of type ByteType containing the data of a TensorFlow Tensor with the data type DataType.UINT8.

  Note that no exception is thrown if the data type is not DataType.UINT8 but it will give unexpected results.

  Parameters:

  image - The TensorFlow Tensor.

  dimOrder - Defines the mapping of the dimensions between the image and the Tensor where the index corresponds to the dimension in the image and the value corresponds to the dimension in the Tensor. TODO Example?

  Returns:

  An image containing the data of the Tensor.

• imgDouble

  public static Img<DoubleType> imgDouble(org.tensorflow.Tensor<Double> image,
                                          int[] dimOrder)

  Creates an image of type DoubleType containing the data of a TensorFlow Tensor with the data type DataType.DOUBLE.

  Parameters:

  image - The TensorFlow Tensor.

  dimOrder - Defines the mapping of the dimensions between the image and the Tensor where the index corresponds to the dimension in the image and the value corresponds to the dimension in the Tensor.

  Returns:

  An image containing the data of the Tensor.

  Throws:

  IllegalArgumentException - if Tensor data type is not double.

• imgFloat

  public static Img<FloatType> imgFloat(org.tensorflow.Tensor<Float> image,
                                        int[] dimOrder)

  Creates an image of type FloatType containing the data of a TensorFlow Tensor with the data type DataType.FLOAT.

  Parameters:

  image - The TensorFlow Tensor.

  dimOrder - Defines the mapping of the dimensions between the image and the Tensor where the index corresponds to the dimension in the image and the value corresponds to the dimension in the Tensor.

  Returns:

  An image containing the data of the Tensor.

  Throws:

  IllegalArgumentException - if Tensor data type is not float.

• imgInt

  public static Img<IntType> imgInt(org.tensorflow.Tensor<Integer> image,
                                    int[] dimOrder)

  Creates an image of type IntType containing the data of a TensorFlow Tensor with the data type DataType.INT32.

  Parameters:

  image - The TensorFlow Tensor.

  dimOrder - Defines the mapping of the dimensions between the image and the Tensor where the index corresponds to the dimension in the image and the value corresponds to the dimension in the Tensor.

  Returns:

  An image containing the data of the Tensor.

  Throws:

  IllegalArgumentException - if Tensor data type is not int.

• imgLong

  public static Img<LongType> imgLong(org.tensorflow.Tensor<Long> image,
                                      int[] dimOrder)

  Creates an image of type LongType containing the data of a TensorFlow Tensor with the data type DataType.INT64.

  Parameters:

  image - The TensorFlow Tensor.

  dimOrder - Defines the mapping of the dimensions between the image and the Tensor where the index corresponds to the dimension in the image and the value corresponds to the dimension in the Tensor.

  Returns:

  An image containing the data of the Tensor.

  Throws:

  IllegalArgumentException - if Tensor data type is not long.

• imgByteDirect

  public static Img<ByteType> imgByteDirect(org.tensorflow.Tensor<org.tensorflow.types.UInt8> image)

  Creates an image of type ByteType containing the data of a TensorFlow Tensor with the data type DataType.UINT8.

  Note that this _does_ adjust the dimensions. This means that the resulting image will have dimensions directly corresponding to the shape of the Tensor. See imgByte(Tensor) and imgByte(Tensor, int[]) if you want to handle dimensions differently.

  Note also that no exception is thrown if the data type is not DataType.UINT8 but it will give unexpected results.

  Parameters:

  image - The TensorFlow Tensor.

  Returns:

  An image containing the data of the Tensor.

• imgDoubleDirect

  public static Img<DoubleType> imgDoubleDirect(org.tensorflow.Tensor<Double> image)

  Creates an image of type DoubleType containing the data of a TensorFlow Tensor with the data type DataType.DOUBLE.

  Note that this _does_ adjust the dimensions. This means that the resulting image will have dimensions directly corresponding to the shape of the Tensor. See imgDouble(Tensor) and imgDouble(Tensor, int[]) if you want to handle dimensions differently.

  Parameters:

  image - The TensorFlow Tensor.

  Returns:

  An image containing the data of the Tensor.

  Throws:

  IllegalArgumentException - if Tensor data type is not double.

• imgFloatDirect

  public static Img<FloatType> imgFloatDirect(org.tensorflow.Tensor<Float> image)

  Creates an image of type FloatType containing the data of a TensorFlow Tensor with the data type DataType.FLOAT.

  Note that this _does_ adjust the dimensions. This means that the resulting image will have dimensions directly corresponding to the shape of the Tensor. See imgFloat(Tensor) and imgFloat(Tensor, int[]) if you want to handle dimensions differently.

  Parameters:

  image - The TensorFlow Tensor.

  Returns:

  An image containing the data of the Tensor.

  Throws:

  IllegalArgumentException - if Tensor data type is not float.

• imgIntDirect

  public static Img<IntType> imgIntDirect(org.tensorflow.Tensor<Integer> image)

  Creates an image of type IntType containing the data of a TensorFlow Tensor with the data type DataType.INT32.

  Note that this _does_ adjust the dimensions. This means that the resulting image will have dimensions directly corresponding to the shape of the Tensor. See imgInt(Tensor) and imgInt(Tensor, int[]) if you want to handle dimensions differently.

  Parameters:

  image - The TensorFlow Tensor.

  Returns:

  An image containing the data of the Tensor.

  Throws:

  IllegalArgumentException - if Tensor data type is not int.

• imgLongDirect

  public static Img<LongType> imgLongDirect(org.tensorflow.Tensor<Long> image)

  Creates an image of type LongType containing the data of a TensorFlow Tensor with the data type DataType.INT64.

  Note that this _does_ adjust the dimensions. This means that the resulting image will have dimensions directly corresponding to the shape of the Tensor. See imgLong(Tensor) and imgLong(Tensor, int[]) if you want to handle dimensions differently.

  Parameters:

  image - The TensorFlow Tensor.

  Returns:

  An image containing the data of the Tensor.

  Throws:

  IllegalArgumentException - if Tensor data type is not long.

• tensor

  public static <T extends RealType<T>> org.tensorflow.Tensor<?> tensor(RandomAccessibleInterval<T> image)

  Creates a TensorFlow Tensor containing data from the given image.

  Note that this does _not_ adjust any dimensions. This means that the resulting Tensor will have a shape corresponding to the reversed dimensions of the image. This is probably what you want because TensorFlow uses the dimension order CYX while ImageJ uses XYC. See tensorDirect(RandomAccessibleInterval) and tensor(RandomAccessibleInterval, int[]) if you want to handle dimensions differently.

  Also note that this will use the backing RAI's primitive array when one is available. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  Returns:

  A Tensor containing the data of the image.

  Throws:

  IllegalArgumentException - if the type of the image is not supported. Supported types are ByteType, DoubleType, FloatType, IntType and LongType.

• tensor

  public static <T extends RealType<T>> org.tensorflow.Tensor<?> tensor(RandomAccessibleInterval<T> image,
                                                                        int[] dimOrder)

  Creates a TensorFlow Tensor containing data from the given image.

  Note that this will use the backing RAI's primitive array when one is available and no dimensions where swapped. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  dimOrder - Defines the mapping of the dimensions between the image and the Tensor where the index corresponds to the dimension in the image and the value corresponds to the dimension in the Tensor. TODO Example?

  Returns:

  A Tensor containing the data of the image.

  Throws:

  IllegalArgumentException - if the type of the image is not supported. Supported types are ByteType, DoubleType, FloatType, IntType and LongType.

• tensorDirect

  public static <T extends RealType<T>> org.tensorflow.Tensor<?> tensorDirect(RandomAccessibleInterval<T> image)

  Creates a TensorFlow Tensor containing data from the given image.

  Note that this _does_ adjust the dimensions. This means that the resulting Tensor will have a shape directly corresponding to the dimensions of the image. Make sure the dimensions are as you want them in TensorFlow. See tensor(RandomAccessibleInterval) and tensor(RandomAccessibleInterval, int[]) if you want to handle dimensions differently.

  Also note that this will use the backing RAI's primitive array when one is available. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  Returns:

  A Tensor containing the data of the image.

  Throws:

  IllegalArgumentException - if the type of the image is not supported. Supported types are ByteType, DoubleType, FloatType, IntType and LongType.

• tensorByte

  public static org.tensorflow.Tensor<org.tensorflow.types.UInt8> tensorByte(RandomAccessibleInterval<ByteType> image)

  Creates a TensorFlow Tensor containing data from the given byte image.

  Note that this does _not_ adjust any dimensions. This means that the resulting Tensor will have a shape corresponding to the reversed dimensions of the image.

  Also note that this will use the backing RAI's primitive array when one is available. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  Returns:

  A Tensor containing the data of the image.

• tensorDouble

  public static org.tensorflow.Tensor<Double> tensorDouble(RandomAccessibleInterval<DoubleType> image)

  Creates a TensorFlow Tensor containing data from the given double image.

  Note that this does _not_ adjust any dimensions. This means that the resulting Tensor will have a shape corresponding to the reversed dimensions of the image.

  Also note that this will use the backing RAI's primitive array when one is available. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  Returns:

  A Tensor containing the data of the image.

• tensorFloat

  public static org.tensorflow.Tensor<Float> tensorFloat(RandomAccessibleInterval<FloatType> image)

  Creates a TensorFlow Tensor containing data from the given float image.

  Note that this does _not_ adjust any dimensions. This means that the resulting Tensor will have a shape corresponding to the reversed dimensions of the image.

  Also note that this will use the backing RAI's primitive array when one is available. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  Returns:

  A Tensor containing the data of the image.

• tensorInt

  public static org.tensorflow.Tensor<Integer> tensorInt(RandomAccessibleInterval<IntType> image)

  Creates a TensorFlow Tensor containing data from the given int image.

  Note that this does _not_ adjust any dimensions. This means that the resulting Tensor will have a shape corresponding to the reversed dimensions of the image.

  Also note that this will use the backing RAI's primitive array when one is available. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  Returns:

  A Tensor containing the data of the image.

• tensorLong

  public static org.tensorflow.Tensor<Long> tensorLong(RandomAccessibleInterval<LongType> image)

  Creates a TensorFlow Tensor containing data from the given long image.

  Note that this does _not_ adjust any dimensions. This means that the resulting Tensor will have a shape corresponding to the reversed dimensions of the image.

  Also note that this will use the backing RAI's primitive array when one is available. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  Returns:

  A Tensor containing the data of the image.

• tensorByte

  public static org.tensorflow.Tensor<org.tensorflow.types.UInt8> tensorByte(RandomAccessibleInterval<ByteType> image,
                                                                             int[] dimOrder)

  Creates a TensorFlow Tensor containing data from the given byte image.

  Note that this will use the backing RAI's primitive array when one is available and no dimensions where swapped. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  dimOrder - Defines the mapping of the dimensions between the image and the Tensor where the index corresponds to the dimension in the image and the value corresponds to the dimension in the Tensor. TODO Example?

  Returns:

  A Tensor containing the data of the image.

• tensorDouble

  public static org.tensorflow.Tensor<Double> tensorDouble(RandomAccessibleInterval<DoubleType> image,
                                                           int[] dimOrder)

  Creates a TensorFlow Tensor containing data from the given double image.

  Note that this will use the backing RAI's primitive array when one is available and no dimensions where swapped. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  dimOrder - Defines the mapping of the dimensions between the image and the Tensor where the index corresponds to the dimension in the image and the value corresponds to the dimension in the Tensor. TODO Example?

  Returns:

  A Tensor containing the data of the image.

• tensorFloat

  public static org.tensorflow.Tensor<Float> tensorFloat(RandomAccessibleInterval<FloatType> image,
                                                         int[] dimOrder)

  Creates a TensorFlow Tensor containing data from the given float image.

  Note that this will use the backing RAI's primitive array when one is available and no dimensions where swapped. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  dimOrder - Defines the mapping of the dimensions between the image and the Tensor where the index corresponds to the dimension in the image and the value corresponds to the dimension in the Tensor. TODO Example?

  Returns:

  A Tensor containing the data of the image.

• tensorInt

  public static org.tensorflow.Tensor<Integer> tensorInt(RandomAccessibleInterval<IntType> image,
                                                         int[] dimOrder)

  Creates a TensorFlow Tensor containing data from the given int image.

  Note that this will use the backing RAI's primitive array when one is available and no dimensions where swapped. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  dimOrder - Defines the mapping of the dimensions between the image and the Tensor where the index corresponds to the dimension in the image and the value corresponds to the dimension in the Tensor. TODO Example?

  Returns:

  A Tensor containing the data of the image.

• tensorLong

  public static org.tensorflow.Tensor<Long> tensorLong(RandomAccessibleInterval<LongType> image,
                                                       int[] dimOrder)

  Creates a TensorFlow Tensor containing data from the given long image.

  Note that this will use the backing RAI's primitive array when one is available and no dimensions where swapped. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  dimOrder - Defines the mapping of the dimensions between the image and the Tensor where the index corresponds to the dimension in the image and the value corresponds to the dimension in the Tensor. TODO Example?

  Returns:

  A Tensor containing the data of the image.

• tensorByteDirect

  public static org.tensorflow.Tensor<org.tensorflow.types.UInt8> tensorByteDirect(RandomAccessibleInterval<ByteType> image)

  Creates a TensorFlow Tensor containing data from the given byte image.

  Note that this _does_ adjust the dimensions. This means that the resulting Tensor will have a shape directly corresponding to the dimensions of the image. Make sure the dimensions are as you want them in TensorFlow. See tensorByte(RandomAccessibleInterval) and tensorByte(RandomAccessibleInterval, int[]) if you want to handle dimensions differently.

  Also note that this will use the backing RAI's primitive array when one is available. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  Returns:

  A Tensor containing the data of the image.

• tensorDoubleDirect

  public static org.tensorflow.Tensor<Double> tensorDoubleDirect(RandomAccessibleInterval<DoubleType> image)

  Creates a TensorFlow Tensor containing data from the given double image.

  Note that this _does_ adjust the dimensions. This means that the resulting Tensor will have a shape directly corresponding to the dimensions of the image. Make sure the dimensions are as you want them in TensorFlow. See tensorDouble(RandomAccessibleInterval) and tensorDouble(RandomAccessibleInterval, int[]) if you want to handle dimensions differently.

  Also note that this will use the backing RAI's primitive array when one is available. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  Returns:

  A Tensor containing the data of the image.

• tensorFloatDirect

  public static org.tensorflow.Tensor<Float> tensorFloatDirect(RandomAccessibleInterval<FloatType> image)

  Creates a TensorFlow Tensor containing data from the given float image.

  Note that this _does_ adjust the dimensions. This means that the resulting Tensor will have a shape directly corresponding to the dimensions of the image. Make sure the dimensions are as you want them in TensorFlow. See tensorFloat(RandomAccessibleInterval) and tensorFloat(RandomAccessibleInterval, int[]) if you want to handle dimensions differently.

  Also note that this will use the backing RAI's primitive array when one is available. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  Returns:

  A Tensor containing the data of the image.

• tensorIntDirect

  public static org.tensorflow.Tensor<Integer> tensorIntDirect(RandomAccessibleInterval<IntType> image)

  Creates a TensorFlow Tensor containing data from the given int image.

  Note that this _does_ adjust the dimensions. This means that the resulting Tensor will have a shape directly corresponding to the dimensions of the image. Make sure the dimensions are as you want them in TensorFlow. See tensorInt(RandomAccessibleInterval) and tensorInt(RandomAccessibleInterval, int[]) if you want to handle dimensions differently.

  Also note that this will use the backing RAI's primitive array when one is available. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  Returns:

  A Tensor containing the data of the image.

• tensorLongDirect

  public static org.tensorflow.Tensor<Long> tensorLongDirect(RandomAccessibleInterval<LongType> image)

  Creates a TensorFlow Tensor containing data from the given long image.

  Note that this _does_ adjust the dimensions. This means that the resulting Tensor will have a shape directly corresponding to the dimensions of the image. Make sure the dimensions are as you want them in TensorFlow. See tensorLong(RandomAccessibleInterval) and tensorLong(RandomAccessibleInterval, int[]) if you want to handle dimensions differently.

  Also note that this will use the backing RAI's primitive array when one is available. Otherwise a copy will be made.

  Parameters:

  image - The image which should be put into the Tensor.

  Returns:

  A Tensor containing the data of the image.

• reverse

  public static <T extends RealType<T>> Img<T> reverse(Img<T> image)

  Flips all dimensions d0,d1,...,dn -> dn,...,d1,d0.

• reverse

  public static <T extends RealType<T>> RandomAccessibleInterval<T> reverse(RandomAccessibleInterval<T> image)

  Flips all dimensions d0,d1,...,dn -> dn,...,d1,d0.