Python modules to work with large multiresolution images.

I tried extracting the patches using your code. However, I received the following error message:

AttributeError: module 'large_image' has no attribute 'getTileSource'

Do you have any idea why this happens? Thank you!

This is still kind of a WIP. For one, I have taken out all of the annotation code. WIth the annotation work from @manthey on GeoJS, I'm not sure it worth going through the effort to update it.

The client test is also failing on travis, and I'm at a loss for why. It passes for me locally, but on travis, there is an error:

ERROR: ReferenceError: Can't find variable: webpackJsonp

The build takes quite a while to complete so it is combersome to debug. It looks like a problem with the webpack bundle, so I'm wondering if @sebastienbarre or @zachmullen have any ideas?

This is to provide the ability to use a custom tile size when iterating through a whole slide image at a desired magnification.

Example usage:

ts = large_image.getTileSource(wsi_path)
for tile in ts.tileIterator(scale={'magnification': 20}, 
                            tile_size=(tile_height, tile_width)):
    pass

Assuming you have the prerequisites, the tilesource can be used without girder. To facilitate importing it from the source tree, when server is imported without girder, it will still work (though, naturally, you can't import server.models or server.rest).

The plugin_tests/girderless_test.py file shows some access of file sources without girder.

Any file that has a TIFF mime type or a file extension that is one of ptif, tif, tiff, svs is checked. If it can be used as a large_image without a conversion job, it is so marked.

This resolves issue #65.

Added a tile iterator. This doesn't depend on Girder. To use, get a tile source, then, for example,

for tile in tilesource.tileIterator(magnification=20, format=TILE_FORMAT_NUMPY):
  Tile = tile['tile'][:, :, :3]  # three components only
  # process the Tile

You can use many criteria for determining which tiles you get from the image (magnification, level, size of pixels, etc.). See the method documentation of tileIterator in tilesource/base.py. Currently, the tiles that you get from the iterator can optionally be scaled.

This should be fully functional (it is used by getRegion), but needs more tests and probably more documentation.

Report magnification and pixel size of images.

Changed init to allow flake8 to process it (mostly).

Here is sample code which is not working:

import girder_large_image
import girder_client
import large_image
import json
gc = girder_client.GirderClient(apiUrl='http://localhost:8080/api/v2')
gc.authenticate(username='admin', password='password')
item = gc.getItem('6204344429b98b9caa33c7ec')
print(item)
ts = girder_large_image.girder_tilesource.GirderTileSource(item)
ts_metadata = ts.getMetadata()
print(json.dumps(ts_metadata, indent=2))
is_wsi = ts_metadata['magnification'] is not None
print("WSI ", is_wsi)
print(ts.getSingleTile())

We used this svs file: https://styx.neurology.emory.edu/girder/#item/60df5a4c68f4fe34fc7e92d2

Here is the printout and error message:

{'_id': '6204344429b98b9caa33c7ec', '_modelType': 'item', 'baseParentId': '61dd35a75ef164ec2f932d35', 'baseParentType': 'collection', 'created': '2022-02-09T21:38:12.879000+00:00', 'creatorId': '61dd3564bd467a0ab2a0244c', 'description': '', 'folderId': '6204340929b98b9caa33c7ea', 'largeImage': {'fileId': '6204344429b98b9caa33c7ed', 'sourceName': 'openslide'}, 'meta': {}, 'name': 'girder-test.svs', 'size': 134394101, 'updated': '2022-02-09T21:38:12.879000+00:00'}

Using python for large_image caching

None

{ "levels": null, "sizeX": null, "sizeY": null, "tileWidth": null, "tileHeight": null, "magnification": null, "mm_x": null, "mm_y": null }

WSI False

Traceback (most recent call last):
  File "/Users/varunverma/Desktop/playground/test.py", line 23, in <module>
    print(ts.getSingleTile())
  File "/usr/local/lib/python3.9/site-packages/large_image/tilesource/base.py", line 2241, in getSingleTile
    return next(self.tileIterator(*args, kwargs), None)
  File "/usr/local/lib/python3.9/site-packages/large_image/tilesource/base.py", line 2202, in tileIterator
    iterInfo = self._tileIteratorInfo(format=iterFormat, resample=resample,
  File "/usr/local/lib/python3.9/site-packages/large_image/tilesource/base.py", line 467, in _tileIteratorInfo
    magLevel = self.getLevelForMagnification(magArgs)
  File "/usr/local/lib/python3.9/site-packages/large_image/tilesource/base.py", line 2010, in getLevelForMagnification
    mag = self.getMagnificationForLevel()
  File "/usr/local/lib/python3.9/site-packages/large_image/tilesource/base.py", line 1982, in getMagnificationForLevel
    if mag.get('level') == self.levels - 1:

TypeError: unsupported operand type(s) for -: 'NoneType' and 'int'

Hi,

I was looking at the annotations documentation here: https://github.com/girder/large_image/blob/master/docs/annotations.md and was wondering if we could create a single polygon or a circle that has a polygon/circle within it. I ask because the nature of the annotations seems that if you put the points into the points array, a line will be drawn connecting the inner circle/polygon to the outer circle/polygon, like this:

From documentation the points are specified like this: "points": [
[5,6,0],
[-17,6,0], [56,-45,6] ] But is there any special way for it to support concentric polygons without a connecting line?

This still requires more documentation, but in principal is a minimum viable feature.

If you want to try it out install Packer and cd to devops/packer/ and run packer build large_image.json this will require that ansible is installed in your environment. It should build a docker image with girder & large_image with stock libtiff on an ubuntu-16.04 image. Once build you should be able to test it out with:

docker run -it --net=host --rm large_image/large_image:latest

You will need a local instance of mongo running. Once girder is up you will have to create a user, assetstore, enable the plugins and rebuild.

I am using large_image with matplotlib to interactively record rectangles that match the size of the highest resolution tile based on a lower resolution tile. However when I use GetRegion at the lower magnification the returned image has blank pixels.

The input format is .svs and I am outputting to numpy for visualization in matplotlib.

im_low_res, er = image.getRegion( scale=image.getMagnificationForLevel(level=2), format=large_image.tilesource.TILE_FORMAT_NUMPY )

Here is a screen shot of what I am seeing

I also plotted just the first three components of RGBA,

When I open in QuPath the metadata says its a rgb file and not cmyk/rgba. could that explain it ? maybe it's not reading it in the proper format?

I was also able to open the image directly with openslide-python and get a thumbnail without the missing values. when converted to numpy in openslide, it returns an rgb array that is correctly populated..

Is there some kind of encoding step that might be missing.

Cache getTile and getThumbnail as well. These caches are per instance of a tile source; they really should be a single cache for all.

Similarly, the tile source class cache should be one cache, not one cache per class.

Switched to Pillow 3.1.2.

Added a change to the geojs viewer to (when geojs is updated) not request tiles we know don't exist in certain circumstances.

TODO:

• [x] Testing
• [x] Use single caches rather than per-instance and per-class caches

The following variables can be adjusted for this test:

possible_axes = {
    'x': [1, 10],
    'y': [1, 10],
    'c': [1, 100],
    'z': [1, 100],
    't': [1, 100],
    'p': [1, 100],
    'q': [1, 100],
    's': [3, 3],
}

include_axes = {
    'c': False,
    'z': False,
    't': False,
    'p': False,
    'q': False,
}

possible_data_ranges = [
    [0, 1],
    [0, 255],
    [0, 65535],
    [-1, 1]
]

max_tile_size = 100
tile_overlap_ratio = 0.5

More axes and higher numbers will take more computation time. The test succeeds if all extra axes (c, z, t, p, q) are disabled. Enabling any fourth axis after x, y, and s breaks the test because the image source is currently implemented with vips. The goal is to add implementation to the image source such that it can accept arbitrary axes and pass this test.

Currently, the vips source adds a new method that, when used with addTile, can take a series of images (PIL or numpy or vips) and output a file in a few formats. The addTile method species where in the single frame image the new data is located and allows for masking the data as it is added.

We want to expand this capability:

• [ ] Support arbitrary data axes to have multiple frames. The base image can have different sample depths (currently L, LA, RGB, RGBA, but it would be nice to support arbitrary hyperspectal sample channels OR indexed data). Frames could be arbitrary OR could have specific axes: C (channel, which should have channel names as optional metadata), Z (vertical Z stack), T (time), XY (also called P or P and Q for physical sample position). We don't currently handle other axes in any source, but having arbitrary axes would make reading things like netcdf more obvious.
• [ ] Support arbitrary numpy dtypes for the data
• [ ] Support a variety of inputs for data and masks: PIL, numpy arrays, vips images
• [ ] Set a variety of metadata: pixel scale, image description, channel names.
• [ ] Support padding or cropping the data to different sizes so that the output is constrained. If padding, we might want to specify a default color for all channels.
• [ ] Add data at different scales (e.g., a lower resolutions from the base). This could do a nearest neighbor mapping to the base resolution, but we might want to eventually add an option for how the data is scaled. The general form of this would be to accept an affine transform.
• [ ] For geospatial data, specify a base projection and corner locations in some manner, and add an optional different projection when adding data.
• [ ] Have entry-point based file output plugins for this.
• [ ] Add associated images
• [ ] Add arbitrary additional metadata.
• [ ] Allow new images to have a optional path so that they could be created over multiple program runs. This would require having a close method (preferably implicit) that saves enough state to resume image creation.

One method of storing this data internally would be a hdf5 file via the h5py module. We could make a new hdf5 source (limited to just files we create) to allow reading the data as it is being created.

We always want the property that the last data added "wins", overwriting any existing data at its location. If the added data has a mask, it should only change the appropriate locations. If it has an alpha channel, this should be applied as it is added. As part of this, we may want to have a default alpha channel that is transparent until any data is added. Note that if data is added to the same location multiple times with alpha values that are 0 < a < 1, we need to make sure that they mix in the expected proportion.

As a starting point, we should create tests that will exercise the existing features and then expand the tests as we add features.

In the Girder interface, for annotation lists in items, it would be convenient to have check boxes on each row and a top-level check box to check/uncheck all and then have the top-level controls (permissions, delete, download) apply only to those annotations that are checked. This would make it easier to delete multiple but not all annotations at a time, which would be useful in some of the guided labelling work.

Fix #898

at the moment this is just to show that I'm moving forward.

I think I still missed some very specific tricks with projections but we are getting there. If you want to have a look be my guest, I still need to test it but that's complicated in my environment.

Note don't trigger the build yet, it's not ready at all

In this section of the gdal tilesource, there is a complex structure to set and unlink tmp files using os. could it be possible to use a with statement instead (https://stackoverflow.com/a/39984066/6734243) ? letting the lib responsible for cleaning.

https://github.com/girder/large_image/blob/d60004b4810efa14c396281bdaf858d97dd87997/sources/gdal/large_image_source_gdal/init.py#L1131