| IOFormat Python 1.8.0

Loading...
Searching...
No Matches
Fundamentals

# Open an Image

## Initialization

IOFormat does not necessarily need to be initialized, but it is a way to force plugins to be loaded at start-up, to avoid some latency during the first opening at runtime.

ioformat.init()

## Retrieve view from a file path

IOFormat provides methods to directly retrieve a view from a path. The filename extension will determine the format, and thus the extractor to instantiate. Theoretically, IOFormat can handle any kind of format, so this method cannot directly return an `ImageView`. You will have to check first the type of view returned, and then transform it.

An important note, when opening a resource with `openView`, only a handle to the resource is kept, the data of the view is not copied in memory, or will be reduced to a minimum.

Concerning images, IOFormat can return three kinds of view:

- `ImageView` (Readable at minimum)
- `MultiImageView` (Readable at minimum)
- `LodImageView` (Readable at minimum)

If a problem happened during the opening, an error will be raised.

view = ioformat.open_view("tmp/image.tiff")
if iolink.ImageViewProvider.is_image(view):
imgView = iolink.ImageViewProvider.to_image(view)
# process image
elif iolink.MultiImageViewProvider.is_multi_image(view):
imgView = iolink.MultiImageViewProvider.to_multi_image(view)
# process multi image

## Load in memory from a file path

Users can decide to directly load in memory the full content of the loaded image. That way, the view is directly created in memory, through a specific method.

For now, this functionality is only for singles-frame images. If the given file contains more than one frame, the method will rise an exception.

image = ioformat.read_image("tmp/image.bmp")

## Get a view from an URI

You have the possibility to load a view from a URI. This allows to load an image with a network protocol for example.

Remark: In the case of HTTP, the server must support HTTP range requests.

Two methods are available for two distinct cases:

- URI allows to retrieve remote file extension, and thus its supposed format
- URI does not allow to identify file format. Format must be specified at method call.

uri = iolink.Uri("https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png")
view = ioformat.open_view(uri)

If the file format cannot be identified with its URI, its format must be specified:

# for example, a PHP request can point toward an image, but nothing in the request indicates file format
uri = iolink.Uri("http://google.com?id=1&name=wayne")
view = ioformat.open_view(uri, "PNG")

## Get a view from any accessor

For any other cases, you can use an accessor as a container for your image to decode. You can have a look into the 'accessor concept' section in IOLink user-guide for more details.

Once you have an accessor to your content, IOFormat provides a method to create a view onto this accessor. On the other hand, you have to specify the format of your data.

Remark: IOLink provides a factory to create a view onto an accessor, but with raw data only (not encoded). This one is different, since data are encoded in the accessor, and only IOFormat has capacities to decode them.

# you have an accessor onto an encoded image (whatever it comes from)
accessor = ....
# you know your data represent a PNG image
view = ioformat.open_view(accessor, "PNG")

# Open a stack of files

## Using a pattern

The `StackReader` factory can be used to aggregate files which names follow a pattern into an `ImageView`. Methods from this factory usually take a pattern and the interpretation of the stacking dimension. The pattern format is quite simple: variable parts of the path are indicated with a wildcard "*". The wildcard must only be in the last segment of the pattern. For example `some/dir/img_*.png` is valid, where `some/dir_*/img_*.png` is invalid.

- `openImageFromPattern` will not load anything in memory, so it is useful for out-of-core mechanics.
- `readImageFromPattern` will stack the files and then load the resulting view in memory for better performance.

img = ioformat.StackReader.open_image_from_pattern("some/dir/img_*.png", iolink.ImageDimension_SLICE)

## Using a file list

A file list is a file where each line is a path to an image, `StackReader::openListFile` will open such a file list and create a stacked image using the listed images in order. The `StackReader::loadListFile` variant do all the same, and then load the stacked image in memory.

Example of an image list:

some/path/to/file.ext
some/other/path/to/file.ext

Code example to load a list file:

img = ioformat.StackReader.open_image_from_list_file("some/dir/stack.lst", iolink.ImageDimension_SLICE)

# Write as a stack of files

It is possible to export a multiImageView or a multi-dimensional image (> 3D) as a stack of files, identified with the same name followed by an unique index.

e.g. a volume (3D) can be written as a list of 2D images numbered (the last dimension is used to unstack) a MultiImageView containing 50 2D-frames can be written as a list of 50 of 2D images numbered.

Here is an example of how to export a volume into a list of files:

# a volume
volume = iolink.ImageViewFactory.allocate(iolink.VectorXu64(20, 30, 40), iolink.DataTypeId.UINT8)
# export the volume as a list of TIFF files
ioformat.StackWriter.write_from_pattern(volume, "stack%%%.tif") # 40 TIFF files are generated: stack001.tif, stack002.tif, stack003.tif...
# same thing with a different naming
ioformat.StackWriter.write_from_pattern(volume, "stack%.tif") # 40 TIFF files are generated: stack1.tif, stack2.tif, stack3.tif...

# Export to a format

Exporting a view into a specific format means encoding your view content into this format. But each format has its own specificities, limitations, and can request some parameters (compression, color, etc.). Hence, each format needs a specific writer.

## Generic method

If you need to export your view content into a file or stream, the easiest way is to use the dedicated method. The appropriate writer plugin will be used internally. Default options of writers will be used for encoding.

This is a simple code example:

image = iolink.ImageViewFactory.allocate(iolink.VectorXu64(64, 64), iolink.DataTypeId.UINT8)
# image is encoded in PNG in the given file (extension of the file path determines the format)
ioformat.write_view(image, "tmp/image.png")
output_stream = iolink.StreamAccessFactory.open_file("tmp/image.raw")
ioformat.write_view(image, outputStream, "PNG"); # image is encoded in PNG and stored in the given stream
ioformat.write_view(image, outputStream, "MRC"); # image is encoded in MRC and stored in the given stream

## Advanced method

You can use advanced API methods to automatically let IOFormat choose the appropriate writer according to the desired output format or the plugin to use directly. All these methods return a writer which could then be used for advanced configuration.

Important remark: a writer can only be used for one writing. If you need to write your data a second time, another writer shall be created.

Following methods are provided in IOFormat API:

# to retrieve a writer able to write the given view into the given file path
def open_writer(view, pathFile)
# to retrieve a writer able to write the given view into the given stream, and
# encoded with given format
def open_writer(view, dst, format)
# to retrieve a writer able to write the given view into the given stream, encoded
# with given format, with given plugin (identified by its name)
def open_writer(view, dst, format, pluginName)

Finally, you can use your created writer as following:

# here you have an ImageView that you want to export into a specific format
image = iolink.ImageViewFactory.allocate(iolink.VectorXu64(64, 64), iolink.DataTypeId.UINT8)
# in this case, we only need to retrieve any writer for a Jpeg compression to
# export data into a "toto.jpeg" file
writer = ioformat.open_writer(image, "tmp/toto.jpeg")
if writer is not None:
# using writers allow you to configure the encoding
# compression quality is set here
writer.set_option("quality", 70)
# data are encoded
writer.write_all()
# destroy writer, else it keeps an handle on created file
writer = None

With the `Writer` object, you have possibility to set options for the writing step. In the previous example, the "quality" of compression can be customized.

# Helpers

IOFormat API provides some helpers.

## Using formats

Some IOFormat APIs require to provide the format to encode or decode a data through a stream. This format is given as a characters string and should textually match with one of the formats supported by the internal plugins.

Example: To encode a view into a stream with JPEG format, you have to specify "JPEG" as format.

A helper exists to easily convert an extension (i.e "jpg" or "png") into a format recognized by IOFormat APIs.

The following example shows how to encode your view into a specific extension which format you don't know:

# here you have an ImageView that you want to export into an extension (.ali)
image = iolink.ImageViewFactory.allocate(iolink.VectorXu64(64, 64), iolink.DataTypeId.UINT8)
# output stream previously created
output_stream = iolink.StreamAccessFactory.open_file("tmp/image.raw")
# you need to know the format associated to this extension
# if extension is not handled, an exception is raised
format = ioformat.format_from_extension("ali")
# you can now retrieve a writer for this format
writer = ioformat.open_writer(imageView, output_stream, format)

# Configuration

## Logger

IOFormat can log messages with different level of criticity:

- `LOG_OFF`: No logging at all
- `LOG_CRITICAL`: Severe errors that cause premature termination.
- `LOG_ERR`: runtime errors or unexpected conditions.
- `LOG_WARNING`: Use of deprecated APIs, poor use of API, "almost" errors, other runtime situations that are undesirable or unexpected, but not necessarily "wrong".
- `LOG_INFO`: Interesting runtime events (startup/shutdown).
- `LOG_DEBUG`: Detailed information on the flow through the system.
- `LOG_TRACE`: Only for "tracing" the code and trying to find one part of a function specifically

User is free to select the level of messages which he's interested to display at runtime.

By default, IOFormat log level is initialized with IOLink log level. Its level can only be specified by initializing a `Logger` object. before any other IOFormat API call.

iolink.Logger.init(iolink.LogLevel_LOG_INFO)
ioformat.Logger.init(iolink.LogLevel_LOG_ERR)
view = ioformat.open_view("car.png")

In the previous example, the IOLink log level is set at `INFO` level, and the IOFormat log level is set at the `ERROR` level.

iolink.Logger.init(iolink.LogLevel_LOG_INFO)
view = ioformat.open_view("car.png")

In this other example, only the IOLink log level is set. The IOFormat log level is internally initialized at the same level as IOLink.

view = ioformat.open_view("car.png")
ioformat.Logger.init(iolink.LogLevel_LOG_INFO)

In this last example, the IOFormat log level is set after an IOFormat API call. This last line has no effect.