About
=====
Image inspection and analysis tools for image series, based on the following classes.
*Representation of image sequences:*
- `ImgSeries` (sequence stored in multiple files),
- `ImgStack` (sequence stored in a stack, e.g. tiff or HDF5).
Objects from these classes can also be generated with the `series()` and `stack()` methods, respectively;
*Analysis of image sequences:*
- `GreyLevel`: evolution of average gray level of selected zone(s),
- `ContourTracking`: track objects by contour(s) detection,
- `Front1D`: measure fronts propagating in one direction,
- `Flicker`: analyze image flicker with reference zone(s).
These classes act on `ImgSeries` or `ImgStack` objects.
The package is customizable and designed to easily incorporate modifications and additional, user-defined plugins (e.g. different type of analysis methods); see *Customize_Analysis.ipynb* and *Customize_Images.ipynb* in the `examples` folder.
How to install:
```bash
pip install imgseries
```
The package is under CeCILL license (equivalent to - and compatible with - GNU GPL, see below).
Quick start
===========
Below is some information to use the functions available in **imgseries**.
For more details and examples, please also consult docstrings and the Jupyter notebooks in the `examples` folder: *ImgSeries_Static.ipynb*, *ImgSeries_Interactive.ipynb*, *Analysis_GreyLevel.ipynb* and *Analysis_ContourTracking.ipynb*.
The management of file series, possibly spread out over multiple folders, follows the scheme of `filo.Series`. In particular, image files are attributed a unique `num` identifier that starts at 0 in the first folder. See `filo` documentation for details. The `ImgSeries` thus directly inherits from `filo.Series`.
*Warning*
If running on a Windows machine and using the parallel option in some of the analysis codes, the call of the function must not be run during import of the python file containing the script (e.g. by using a `if __name__ == '__main__'` block). This is because in Windows, multiprocessing imports the main program when setting up processes, which causes recursive problems. The problem does not arise on Linux / MacOS.
`ImgSeries`, `ImgStack`: general image series manipulation
----------------------------------------------------------
See also the notebook with examples and details *ImgSeries.ipynb* in the `examples` folder.
```python
from imgseries import ImgSeries, series
# ----------------------------------------------------------------------------
# ======= WORKING WITH IMAGE SERIES (distinct, individual image files) =======
# ----------------------------------------------------------------------------
# EITHER:
images = ImgSeries(paths=['img1', 'img2']) # implicitly, savepath is current directory
# OR:
images = series(paths=['img1', 'img2'])
# (the series() function is a bit more powerful than the ImgSeries class, as it
# allows the user to select caching options for speed improvements, see below)
# Image dimensions in x and y
images.nx, images.ny
# Access individual images in the series -------------------------------------
images.files[10] # filo.File object of image number num=10
images.files[10].file # actual pathlib.Path file object
images.read(10) # read image number num=10 into numpy array
images.show(10) # show image in a matplotlib graph
# Interactive views of image sequence ----------------------------------------
images.animate() # see image series as a movie (start, end, skip options)
images.inspect() # browse through image series with a slider (same options)
images.profile() # object that also has inspect(), animate() methods etc.
# Define display options (only for grayscale imagee --------------------------
# (see details in notebook)
images.display.define('contrast') # set vmin, vmax in imshow interactively
images.display.define('colormap') # set cmap in imshow() interactively
# Manually: (equivalent: images.display.limits = 0, 255)
images.display.vmin, images.display.vmax = 0, 255
images.display.cmap = 'viridis'
images.save_display() # save rotation and crop parameters in a json file
images.load_display() # load rotation and crop parameters from json file
# Define global transform applied on all images (rotation + crop) ------------
# (see details in notebook)
# Note: the transforms to be considered and the order with which they are
# applied on the images can be modified by passing the argument
# transforms= in ImgSeries. For example:
# images = series(transforms=('rotation', 'crop', 'filter'))
# Interactive:
images.rotation.define()
images.crop.define()
images.filter.define()
images.threshold.define()
# Manual:
images.grayscale.apply = True
images.rotation.angle = -70
images.crop.zone = (2, 25, 400, 600)
images.filter.size = 10
images.subtraction.reference = range(5) # avg first 5 images for subtraction
images.subtraction.relative = True # (I - Iref) / I_ref instead of I - Iref
images.threshold.vmin = 220 # everything below vmin is False, rest True
images.threshold.vmax = 240 # everything below vmax is True, rest False
# Note: threshold.vmin can be combined with threshold.vmax for a bandpass
# Other transform parameters / methods:
images.save_transforms() # save rotation, crop etc. parameters in a json file
images.load_transforms() # load rotation, crop etc. parameters from json file
images.active_transforms # see currently applied transforms on images
images.reset_transforms() # reset all transforms
# Corrections can also be applied to image sequences, e.g. flicker and shaking
# (See also Flicker analysis class, below)
# Contrary to transforms, corrections can be
images.flicker.load()
images.save_corrections()
images.active_corrections # see currently applied corrections on images
images.reset_corrections() # reset all corrections
# Exporting images (with transforms and/or corrections)
images.export() # see examples/Export.ipynb for examples
# Manage image timestamps ----------------------------------------------------
images.info # see correspondence num / file info + automatically extracted image time
images.save_info() # save above info in a csv file
images.load_info() # Load info from previously saved csv data (overwrites images.files)
images.load_time('Time_File.txt') # Keep images.files but update its time information with data from an external csv file.
# ----------------------------------------------------------------------------
# ===================== WORKING WITH A .TIFF IMAGE STACK =====================
# ----------------------------------------------------------------------------
images = ImgSeries(stack='ImgStack.tif')
# All methods/attributes above available, except those associated with timestamps
```
### Caching images for speed improvement
```python
images = series(paths=['img1', 'img2'], cache=True)
images.inspect() # inspection should be significantly faster
```
See *ImgSeries_Caching.ipynb* for examples, details and options (cache size etc.).
By default, caching is disabled because it can lead to significant memory usage for large files.
`GreyLevel`: average grey level analysis in image series
--------------------------------------------------------
Follow the average grey level (brightness) of one or more selected zones (default: whole image) on the image sequence.
The `GreyLevel` class accepts an image sequence (`ImgSeries` type, see above) as an input parameter. See also docstrings and the notebook with examples and details: *Analysis_GreyLevel.ipynb* in the `examples` folder.
```python
from imgseries import GreyLevel, GreyLevelResults
# Create analysis object -----------------------------------------------------
gl = GreyLevel(images)
# Prepare and run analysis ---------------------------------------------------
# NOTE: if no zones are defined, full image is taken as a default
gl.zones.define() # interactively select zones on image
gl.zones.load() # alternative to define() where zones are loaded from saved metadata
# other alternative to load image series and analysis parameters from saved files
gl.regenerate()
gl.run() # run actual analysis (parallel computation available);
gl.results # is an object containing data and metadata of the analysis
gl.results.save()
# Interactive views of results -----------------------------------------------
gl.show() # show result of analysis on a given image (default: first one)
gl.animate() # see results as a movie (start, end, skip options)
gl.inspect() # browse through results with a slider (same options)
# Load analysis results afterwards (need save() to have been called) ---------
results = GreyLevelResults()
results.load() # load analysis results (data + metadata)
results.data, results.metadata # useful attributes
```
`ContourTracking`: object tracking using contours in image series
-----------------------------------------------------------------
Follow contours of iso-grey-level on image sequence. The `GreyLevel` class accepts an image sequence (`ImgSeries` type, see above) as an input parameter. See also docstrings and the notebook with examples and details: *Analysis_ContourTracking.ipynb* in the `examples` folder.
```python
from imgseries import ContourTracking, ContourTrackingResults
# Create analysis object
ct = ContourTracking(images)
# Prepare and run analysis ---------------------------------------------------
ct.threshold.define() # interactively select threshold level
ct.contours.define() # interactively select contours at the above level
ct.contours.load() # alternative to define() where contours are loaded from saved metadata
# other alternative to load image series and analysis parameters from saved files
ct.regenerate()
ct.run() # run actual analysis (no parallel computation available)
ct.results # is an object containing data and metadata of the analysis
ct.results.save() # save results (data + metadata) to files (csv, json)
# Interactive views of results -----------------------------------------------
ct.show() # show result of analysis on a given image (default: first one)
ct.animate() # see results as a movie (start, end, skip options)
ct.inspect() # browse through results with a slider (same options)
# Load analysis results afterwards (need save() to have been called) ---------
results = ContourTrackingResults()
results.load() # load analysis results (data + metadata)
results.data, results.raw_contour_data, results.metadata # useful attributes
```
`Front1D`: Analyze 1D propagating fronts with grey level analysis
-----------------------------------------------------------------
Analyze fronts propagating in one direction (e.g., *x*), by averaging grey levels in the other direction (*y*). The program returns a line of pixel values along *x* as a function of time (i.e., a reslice of the data), where each pixel is an average of all other pixels along *y*. The operation and methods are similar to `GreyLevel` or ``ContourTracking` (see above). See also docstrings and the notebook with examples and details: *Analysis_Front1D.ipynb* in the `examples` folder.
```python
from imgseries import Front1D, Front1DResults
f1d = Front1D(images)
f1d.run()
```
`Flicker`: Get image flicker from grey level variations on a zone
-----------------------------------------------------------------
Analyze flicker on images based on the average gray level variation in a reference zone in the image. The operation and methods are very similar to `GreyLevel`, including reference zone definition (see above). See also docstrings and the notebook with examples and details: *Analysis_Flicker.ipynb* in the `examples` folder.
```python
from imgseries import Flicker, FlickerResults
flick = Flicker(images)
flick.zones.define()
flick.run()
```
The results are stored as a ratio, which is by how much the pixel values in the image have to be divided to remove apparent flicker.
Afterwards, these results can be loaded in the image series to correct flicker automatically (as a *corrections* parameter):
```python
images.flicker.load()
```
# Requirements / dependencies
## Python packages
(installed by pip automatically if necessary)
- skimage (scikit-image)
- matplotlib
- numpy
- importlib-metadata
- tqdm (waitbars)
- filo (file series management) >= 1.1
- gittools (get git commit info) >= 0.5
- imgbasics (basic image processing) >= 0.3.0
- drapo (interactive tools for matplotlib figures) >= 1.2.1
## Python version
- Python >= 3.6 because of f-string formatting
# Author
Olivier Vincent
(ovinc.py@mgmail.com)
# License
This software is under the CeCILL-2.1 license, equivalent to GNU-GPL (see https://cecill.info/)
Copyright Olivier Vincent (2021-2024)
(ovinc.py@gmail.com)
This software is a computer program whose purpose is to provide tools for
inspection and analysis of image sequences
(either as individual files or as stacks).
This software is governed by the CeCILL license under French law and
abiding by the rules of distribution of free software. You can use,
modify and/ or redistribute the software under the terms of the CeCILL
license as circulated by CEA, CNRS and INRIA at the following URL
"http://www.cecill.info".
As a counterpart to the access to the source code and rights to copy,
modify and redistribute granted by the license, users are provided only
with a limited warranty and the software's author, the holder of the
economic rights, and the successive licensors have only limited
liability.
In this respect, the user's attention is drawn to the risks associated
with loading, using, modifying and/or developing or reproducing the
software by the user in light of its specific status of free software,
that may mean that it is complicated to manipulate, and that also
therefore means that it is reserved for developers and experienced
professionals having in-depth computer knowledge. Users are therefore
encouraged to load and test the software's suitability as regards their
requirements in conditions enabling the security of their systems and/or
data to be ensured and, more generally, to use and operate it in the
same conditions as regards security.
The fact that you are presently reading this means that you have had
knowledge of the CeCILL license and that you accept its terms.
Raw data
{
"_id": null,
"home_page": null,
"name": "imgseries",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.6",
"maintainer_email": null,
"keywords": "image, analysis, inspection, series, contour, tracking, grey, level, gray",
"author": null,
"author_email": "Olivier Vincent <ovinc.py@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/20/15/cdc7db45ab7ece9035532fa474caf71f386293adab378704384d057e55ad/imgseries-0.7.4.tar.gz",
"platform": null,
"description": "About\n=====\n\nImage inspection and analysis tools for image series, based on the following classes.\n\n*Representation of image sequences:*\n- `ImgSeries` (sequence stored in multiple files),\n- `ImgStack` (sequence stored in a stack, e.g. tiff or HDF5).\nObjects from these classes can also be generated with the `series()` and `stack()` methods, respectively;\n\n*Analysis of image sequences:*\n- `GreyLevel`: evolution of average gray level of selected zone(s),\n- `ContourTracking`: track objects by contour(s) detection,\n- `Front1D`: measure fronts propagating in one direction,\n- `Flicker`: analyze image flicker with reference zone(s).\nThese classes act on `ImgSeries` or `ImgStack` objects.\n\nThe package is customizable and designed to easily incorporate modifications and additional, user-defined plugins (e.g. different type of analysis methods); see *Customize_Analysis.ipynb* and *Customize_Images.ipynb* in the `examples` folder.\n\nHow to install:\n\n```bash\npip install imgseries\n```\n\nThe package is under CeCILL license (equivalent to - and compatible with - GNU GPL, see below).\n\nQuick start\n===========\n\nBelow is some information to use the functions available in **imgseries**.\nFor more details and examples, please also consult docstrings and the Jupyter notebooks in the `examples` folder: *ImgSeries_Static.ipynb*, *ImgSeries_Interactive.ipynb*, *Analysis_GreyLevel.ipynb* and *Analysis_ContourTracking.ipynb*.\n\n\nThe management of file series, possibly spread out over multiple folders, follows the scheme of `filo.Series`. In particular, image files are attributed a unique `num` identifier that starts at 0 in the first folder. See `filo` documentation for details. The `ImgSeries` thus directly inherits from `filo.Series`.\n\n*Warning*\n\nIf running on a Windows machine and using the parallel option in some of the analysis codes, the call of the function must not be run during import of the python file containing the script (e.g. by using a `if __name__ == '__main__'` block). This is because in Windows, multiprocessing imports the main program when setting up processes, which causes recursive problems. The problem does not arise on Linux / MacOS.\n\n\n`ImgSeries`, `ImgStack`: general image series manipulation\n----------------------------------------------------------\n\nSee also the notebook with examples and details *ImgSeries.ipynb* in the `examples` folder.\n\n```python\nfrom imgseries import ImgSeries, series\n\n# ----------------------------------------------------------------------------\n# ======= WORKING WITH IMAGE SERIES (distinct, individual image files) =======\n# ----------------------------------------------------------------------------\n\n# EITHER:\nimages = ImgSeries(paths=['img1', 'img2']) # implicitly, savepath is current directory\n# OR:\nimages = series(paths=['img1', 'img2'])\n# (the series() function is a bit more powerful than the ImgSeries class, as it\n# allows the user to select caching options for speed improvements, see below)\n\n# Image dimensions in x and y\nimages.nx, images.ny\n\n# Access individual images in the series -------------------------------------\n\nimages.files[10] # filo.File object of image number num=10\nimages.files[10].file # actual pathlib.Path file object\nimages.read(10) # read image number num=10 into numpy array\nimages.show(10) # show image in a matplotlib graph\n\n# Interactive views of image sequence ----------------------------------------\n\nimages.animate() # see image series as a movie (start, end, skip options)\nimages.inspect() # browse through image series with a slider (same options)\nimages.profile() # object that also has inspect(), animate() methods etc.\n\n# Define display options (only for grayscale imagee --------------------------\n# (see details in notebook)\nimages.display.define('contrast') # set vmin, vmax in imshow interactively\nimages.display.define('colormap') # set cmap in imshow() interactively\n\n# Manually: (equivalent: images.display.limits = 0, 255)\nimages.display.vmin, images.display.vmax = 0, 255\nimages.display.cmap = 'viridis'\n\nimages.save_display() # save rotation and crop parameters in a json file\nimages.load_display() # load rotation and crop parameters from json file\n\n# Define global transform applied on all images (rotation + crop) ------------\n# (see details in notebook)\n\n# Note: the transforms to be considered and the order with which they are\n# applied on the images can be modified by passing the argument\n# transforms= in ImgSeries. For example:\n# images = series(transforms=('rotation', 'crop', 'filter'))\n\n# Interactive:\nimages.rotation.define()\nimages.crop.define()\nimages.filter.define()\nimages.threshold.define()\n\n# Manual:\nimages.grayscale.apply = True\nimages.rotation.angle = -70\nimages.crop.zone = (2, 25, 400, 600)\nimages.filter.size = 10\nimages.subtraction.reference = range(5) # avg first 5 images for subtraction\nimages.subtraction.relative = True # (I - Iref) / I_ref instead of I - Iref\nimages.threshold.vmin = 220 # everything below vmin is False, rest True\nimages.threshold.vmax = 240 # everything below vmax is True, rest False\n# Note: threshold.vmin can be combined with threshold.vmax for a bandpass\n\n# Other transform parameters / methods:\nimages.save_transforms() # save rotation, crop etc. parameters in a json file\nimages.load_transforms() # load rotation, crop etc. parameters from json file\nimages.active_transforms # see currently applied transforms on images\nimages.reset_transforms() # reset all transforms\n\n# Corrections can also be applied to image sequences, e.g. flicker and shaking\n# (See also Flicker analysis class, below)\n# Contrary to transforms, corrections can be\nimages.flicker.load()\nimages.save_corrections()\nimages.active_corrections # see currently applied corrections on images\nimages.reset_corrections() # reset all corrections\n\n# Exporting images (with transforms and/or corrections)\nimages.export() # see examples/Export.ipynb for examples\n\n# Manage image timestamps ----------------------------------------------------\nimages.info # see correspondence num / file info + automatically extracted image time\nimages.save_info() # save above info in a csv file\nimages.load_info() # Load info from previously saved csv data (overwrites images.files)\nimages.load_time('Time_File.txt') # Keep images.files but update its time information with data from an external csv file.\n\n# ----------------------------------------------------------------------------\n# ===================== WORKING WITH A .TIFF IMAGE STACK =====================\n# ----------------------------------------------------------------------------\n\nimages = ImgSeries(stack='ImgStack.tif')\n\n# All methods/attributes above available, except those associated with timestamps\n```\n\n### Caching images for speed improvement\n\n```python\nimages = series(paths=['img1', 'img2'], cache=True)\nimages.inspect() # inspection should be significantly faster\n```\nSee *ImgSeries_Caching.ipynb* for examples, details and options (cache size etc.).\nBy default, caching is disabled because it can lead to significant memory usage for large files.\n\n\n`GreyLevel`: average grey level analysis in image series\n--------------------------------------------------------\n\nFollow the average grey level (brightness) of one or more selected zones (default: whole image) on the image sequence.\nThe `GreyLevel` class accepts an image sequence (`ImgSeries` type, see above) as an input parameter. See also docstrings and the notebook with examples and details: *Analysis_GreyLevel.ipynb* in the `examples` folder.\n\n```python\nfrom imgseries import GreyLevel, GreyLevelResults\n\n# Create analysis object -----------------------------------------------------\ngl = GreyLevel(images)\n\n# Prepare and run analysis ---------------------------------------------------\n# NOTE: if no zones are defined, full image is taken as a default\ngl.zones.define() # interactively select zones on image\ngl.zones.load() # alternative to define() where zones are loaded from saved metadata\n\n# other alternative to load image series and analysis parameters from saved files\ngl.regenerate()\n\ngl.run() # run actual analysis (parallel computation available);\ngl.results # is an object containing data and metadata of the analysis\ngl.results.save()\n\n# Interactive views of results -----------------------------------------------\ngl.show() # show result of analysis on a given image (default: first one)\ngl.animate() # see results as a movie (start, end, skip options)\ngl.inspect() # browse through results with a slider (same options)\n\n# Load analysis results afterwards (need save() to have been called) ---------\nresults = GreyLevelResults()\nresults.load() # load analysis results (data + metadata)\nresults.data, results.metadata # useful attributes\n```\n\n\n`ContourTracking`: object tracking using contours in image series\n-----------------------------------------------------------------\n\nFollow contours of iso-grey-level on image sequence. The `GreyLevel` class accepts an image sequence (`ImgSeries` type, see above) as an input parameter. See also docstrings and the notebook with examples and details: *Analysis_ContourTracking.ipynb* in the `examples` folder.\n\n```python\nfrom imgseries import ContourTracking, ContourTrackingResults\n\n# Create analysis object\nct = ContourTracking(images)\n\n# Prepare and run analysis ---------------------------------------------------\nct.threshold.define() # interactively select threshold level\nct.contours.define() # interactively select contours at the above level\nct.contours.load() # alternative to define() where contours are loaded from saved metadata\n\n# other alternative to load image series and analysis parameters from saved files\nct.regenerate()\n\nct.run() # run actual analysis (no parallel computation available)\nct.results # is an object containing data and metadata of the analysis\nct.results.save() # save results (data + metadata) to files (csv, json)\n\n# Interactive views of results -----------------------------------------------\nct.show() # show result of analysis on a given image (default: first one)\nct.animate() # see results as a movie (start, end, skip options)\nct.inspect() # browse through results with a slider (same options)\n\n# Load analysis results afterwards (need save() to have been called) ---------\nresults = ContourTrackingResults()\nresults.load() # load analysis results (data + metadata)\nresults.data, results.raw_contour_data, results.metadata # useful attributes\n```\n\n`Front1D`: Analyze 1D propagating fronts with grey level analysis\n-----------------------------------------------------------------\n\nAnalyze fronts propagating in one direction (e.g., *x*), by averaging grey levels in the other direction (*y*). The program returns a line of pixel values along *x* as a function of time (i.e., a reslice of the data), where each pixel is an average of all other pixels along *y*. The operation and methods are similar to `GreyLevel` or ``ContourTracking` (see above). See also docstrings and the notebook with examples and details: *Analysis_Front1D.ipynb* in the `examples` folder.\n\n```python\nfrom imgseries import Front1D, Front1DResults\nf1d = Front1D(images)\nf1d.run()\n```\n\n\n`Flicker`: Get image flicker from grey level variations on a zone\n-----------------------------------------------------------------\n\nAnalyze flicker on images based on the average gray level variation in a reference zone in the image. The operation and methods are very similar to `GreyLevel`, including reference zone definition (see above). See also docstrings and the notebook with examples and details: *Analysis_Flicker.ipynb* in the `examples` folder.\n\n```python\nfrom imgseries import Flicker, FlickerResults\nflick = Flicker(images)\nflick.zones.define()\nflick.run()\n```\n\nThe results are stored as a ratio, which is by how much the pixel values in the image have to be divided to remove apparent flicker.\n\nAfterwards, these results can be loaded in the image series to correct flicker automatically (as a *corrections* parameter):\n```python\nimages.flicker.load()\n```\n\n\n# Requirements / dependencies\n\n## Python packages\n\n(installed by pip automatically if necessary)\n- skimage (scikit-image)\n- matplotlib\n- numpy\n- importlib-metadata\n- tqdm (waitbars)\n- filo (file series management) >= 1.1\n- gittools (get git commit info) >= 0.5\n- imgbasics (basic image processing) >= 0.3.0\n- drapo (interactive tools for matplotlib figures) >= 1.2.1\n\n\n## Python version\n- Python >= 3.6 because of f-string formatting\n\n# Author\n\nOlivier Vincent\n\n(ovinc.py@mgmail.com)\n\n# License\n\nThis software is under the CeCILL-2.1 license, equivalent to GNU-GPL (see https://cecill.info/)\n\nCopyright Olivier Vincent (2021-2024)\n(ovinc.py@gmail.com)\n\nThis software is a computer program whose purpose is to provide tools for\ninspection and analysis of image sequences\n(either as individual files or as stacks).\n\nThis software is governed by the CeCILL license under French law and\nabiding by the rules of distribution of free software. You can use,\nmodify and/ or redistribute the software under the terms of the CeCILL\nlicense as circulated by CEA, CNRS and INRIA at the following URL\n\"http://www.cecill.info\".\n\nAs a counterpart to the access to the source code and rights to copy,\nmodify and redistribute granted by the license, users are provided only\nwith a limited warranty and the software's author, the holder of the\neconomic rights, and the successive licensors have only limited\nliability.\n\nIn this respect, the user's attention is drawn to the risks associated\nwith loading, using, modifying and/or developing or reproducing the\nsoftware by the user in light of its specific status of free software,\nthat may mean that it is complicated to manipulate, and that also\ntherefore means that it is reserved for developers and experienced\nprofessionals having in-depth computer knowledge. Users are therefore\nencouraged to load and test the software's suitability as regards their\nrequirements in conditions enabling the security of their systems and/or\ndata to be ensured and, more generally, to use and operate it in the\nsame conditions as regards security.\n\nThe fact that you are presently reading this means that you have had\nknowledge of the CeCILL license and that you accept its terms.\n",
"bugtrack_url": null,
"license": "CeCILL-2.1",
"summary": "Image inspection and analysis tools for image series.",
"version": "0.7.4",
"project_urls": {
"Documentation": "https://github.com/ovinc/imgseries/README.md",
"Homepage": "https://github.com/ovinc/imgseries",
"Repository": "https://github.com/ovinc/imgseries.git"
},
"split_keywords": [
"image",
" analysis",
" inspection",
" series",
" contour",
" tracking",
" grey",
" level",
" gray"
],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "864000ffb9ab3190c1841e22103d1bfbe3388841939b4b063a0395ad68371b1a",
"md5": "f8b6ed2cf7d70729af0fc165d63eb74a",
"sha256": "900bc8a40b2fafdec42e3234444c7cb4f4c1ce3543f28e1ebd9749c2abd749d5"
},
"downloads": -1,
"filename": "imgseries-0.7.4-py3-none-any.whl",
"has_sig": false,
"md5_digest": "f8b6ed2cf7d70729af0fc165d63eb74a",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.6",
"size": 19795434,
"upload_time": "2025-01-20T16:30:40",
"upload_time_iso_8601": "2025-01-20T16:30:40.445049Z",
"url": "https://files.pythonhosted.org/packages/86/40/00ffb9ab3190c1841e22103d1bfbe3388841939b4b063a0395ad68371b1a/imgseries-0.7.4-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "2015cdc7db45ab7ece9035532fa474caf71f386293adab378704384d057e55ad",
"md5": "fa95b335ecfd722263988914fcb7b839",
"sha256": "2ce15b58ab69732813c1e8dd5f6500aecb779ca70beb47808e58287afb7fede2"
},
"downloads": -1,
"filename": "imgseries-0.7.4.tar.gz",
"has_sig": false,
"md5_digest": "fa95b335ecfd722263988914fcb7b839",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.6",
"size": 23289532,
"upload_time": "2025-01-20T16:30:56",
"upload_time_iso_8601": "2025-01-20T16:30:56.035871Z",
"url": "https://files.pythonhosted.org/packages/20/15/cdc7db45ab7ece9035532fa474caf71f386293adab378704384d057e55ad/imgseries-0.7.4.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2025-01-20 16:30:56",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "ovinc",
"github_project": "imgseries",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "imgseries"
}
JSON
