Saravanan666/pypi-org huggingface dataset:
Package: itk-dev-shared-components
itk-dev-shared-componentsLinksDocumentationPypiInstallationpip install itk-dev-shared-componentsIntroThis python library contains helper modules for RPA development.
It's based on the need ofITK Dev, but it has been
generalized to be useful for others as well.IntegrationsSAP GuiHelper functions for using SAP Gui. A few examples include:Login to SAP.Handling multiple sessions in multiple threads.Convenience functions for gridviews and trees.Microsoft GraphHelper functions for using Microsoft Graph to read emails from shared inboxes.
Some examples are:Authentication using username and password.List and get emails.Get attachment data.Move and delete emails.KMD NovaHelper functions for using the KMD Nova api.
Some examples are:Get cases and documents.Create cases, documents and tasks.
Package: itk-dissolve
ITKDissolveOverviewThis is a module for the Insight Toolkit (ITK) that provides functionality to discard pixels within a masked region. Unlike masking, the pixels in the masked region are replaced (dissolved) by their nearest pixels outside the mask. This can be useful to clean-up label fields, e.g. to remove small islands/holes or remove entire labels, and replace them by the adjacent labels.The module includes a filter called DissolveMaskImageFilter.importitklabels=itk.imread('path/to/labels.mha').astype(itk.US)mask=itk.imread('path/to/mask.mha').astype(itk.UC)ImageType=type(labels)MaskType=type(mask)dissolve=itk.DissolveMaskImageFilter[ImageType,MaskType].New()dissolve.SetInput(labels)dissolve.SetMaskImage(mask)dissolve.Update()modified_labels=dissolve.GetOutput()itk.imwrite(modified_labels,'modified_labels2.mha')Or using the pythonic API:importitklabels=itk.imread('path/to/labels.mha').astype(itk.US)mask=itk.imread('path/to/mask.mha').astype(itk.US)modified_labels=itk.dissolve_mask_image_filter(labels,mask_image=mask)itk.imwrite(modified_labels,'path/to/modified_labels.mha')InstallationTo install the binary Python packages:python-mpipinstallitk-dissolve
Package: itk-fixedpointinversedisplacementfield
itk-fixedpointinversedisplacementfield takes a displacement field as input and computes the displacement field that is its inverse with a simple fixed-point approach.
Please refer to:
M. Luethi, “Inverting deformation fields using a fixed point iteration scheme.”, Insight Journal, July-December 2010,http://hdl.handle.net/10380/3222.
Package: itk-genericlabelinterpolator
itk-genericlabelinterpolator provides a generic interpolator for label images to interpolate each label with an ordinary image interpolator, and return the label with the highest value.
Please refer to:
Schaerer J., Roche F., Belaroussi B., “A generic interpolator for multi-label images.”, Insight Journal, January-December 2014,https://hdl.handle.net/10380/3506.
Package: itk-isotropicwavelets
itk-isotropicwavelets provides a multiresolution analysis (MRA) framework using isotropic and steerable wavelets in the frequency domain.
This framework provides the backbone for state of the art filters for denoising, feature detection or phase analysis in N-dimensions. It focuses on reusability, and highly decoupled modules for easy extension and implementation of new filters.
Please refer to:P. Hernandez-Cerdan, “Isotropic and Steerable Wavelets in N Dimensions.
A multiresolution analysis framework”, Insight Journal, January-December 2016 https://hdl.handle.net/10380/3558.
Package: itk-labelerodedilate
itk-labelerodedilate provides classes for morphological math erode and dilate operations on label images.
Please refer to:
Beare, R. and Jackway, P. “Parallel Algorithms via Scaled Paraboloid Structuring Functions for Spatially-Variant and Label-Set Dilations and Erosions”, 2011 International Conference on Digital Image Computing Techniques and Applications (DICTA). 180–185. 2011. IEEE.
Package: itk-labelpointset
ITKLabelPointSetOverviewThis is a module for the Insight Toolkit (ITK). The module includes a filter to extract a PointSet from a labeled image.
Additional filters and IO classes may be added in future versions to support pointset registration workflows.importitklabels=itk.imread('path/to/labelmap.mha').astype(itk.US)D=labels.ndimImageType=type(labels)PointSetType=itk.PointSet[itk.US,D]extractor=itk.LabelToPointSetFilter[ImageType,PointSetType].New()extractor.SetInput(labels)extractor.Update()point_set=extractor.GetOutput()data=point_set.GetPointData()foriinrange(point_set.GetNumberOfPoints()):print(f"{i}:{point_set.GetPoint(i)},{data.GetElement(i)}")InstallationTo install the binary Python packages:python-mpipinstallitk-labelpointset
Package: itk-morphologicalcontourinterpolation
itk-morphologicalcontourinterpolation provides classes to perform image morphological contour interpolation.
Please refer to:
Zukić Dž., Vicory J., McCormick M., Wisse L., Gerig G., Yushkevich P., Aylward S. “nD Morphological Contour Interpolation”, Insight Journal, January-December 2016,https://hdl.handle.net/10380/3563.
Package: itk_napari_conversion
itk-napari-conversionConvert betweenitkandnaparidata structures.Installationpip install itk-napari-conversionUsageConvert anitk.Imageto annapari.layers.Image:from itk_napari_conversion import image_layer_from_image

image_layer = image_layer_from_image(image)Convert to annapari.layers.Imageto anitk.Image:from itk_napari_conversion import image_from_image_layer

image = image_from_image_layer(image_layer)HackingContributions are welcome!To test locally:git clone https://github.com/InsightSoftwareConsortium/itk-napari-conversion.git
cd itk-napari-conversation
pip install flit pytest
flit install --symlink
pytest test.pyFollow theitk contributing
guidelinesand theitk code of
conduct.
Package: itk-phasesymmetry
itk-phasesymmetry provides multi-scale steerable filters for computing phase symmetry (PS) in the image Fourier transform domain.
Please refer to:
C. Hatt, “Multi-scale Steerable Phase-Symmetry Filters for ITK.”, Insight Journal, July-December 2011,http://hdl.handle.net/10380/3330.
Package: itkpix-efuse-codec
ITkPix E-fuse CodecUtilities for encoding and decoding the data stored in the ITkPix ASIC e-fusesInstallationCppTheitkpix-efuse-codecC++ library is header-only.
Simply add thesingle_include/itkpix_efuse_codec/directory to your project's include path and you should be able to#include "itkpix_efuse_codec.h.Pythonitkpix-efuse-codecis available onPyPi.
Simply run the following command to install:pipinstallitkpix-efuse-codecUsagePythonCommand-line Utilitypipinstallingitkpix-efuse-codecgivers you theefusecommand-line utility, which has theencodeanddecodesub-commands.encodeefuse -v encode BONN 0x146cb
Input:
   probe_location name  : BONN
   chip serial number   : 83659 (bin: 0b10100011011001011, hex: 0x146cb)
Encoded:
   encoded e-fuse (bin) : 00010001010001101100101100011111 (32 bits)
                  (hex) : 0x1146cb1fdecodeefuse -v decode 0x1146cb1f
Input:
    e-fuse data   (bin): 0b100010100011011001011
                  (hex): 0x1146cb
Decoded:
    chip serial number : 0x146cb
    probe location     : BONN (id: 0x1)As a moduleYou can import theitkpix_efuse_codecmodule in your existing Python scripts. For example,
to generate the 32-bit encoded E-fuse data you would do:importitkpix_efuse_codecprobe_location_name:str="BONN"# must be a valid namechip_sn:int=0x12345;efuse_binary_string=itkpix_efuse_codec.encode(probe_location_name,chip_sn)# returns binary stringefuse_data=int(efuse_binary_string,2)# parse the binary string into an integerTo decode 32-bit E-fuse data retreived from the ITkPix ASIC, you would do:importitkpix_efuse_codecfromitkpix_efuse_codecimportEfuseDataretrieved_efuse_data:int=...decoded_efuse_data=int(itkpix_efuse_codec.decode(retrieved_efuse_data),2)# parse the binary string into an integerefuse_data=EfuseData(decoded_efuse_data)# EfuseData class has useful getterschip_sn=efuse_data.chip_sn()probe_location_name=efuse_data.probe_location_name()probe_location_id=efuse_data.probe_location_id()
Package: itk-pocus
ITKPOCUS (ITK Point-of-Care Ultrasound) Python LibraryITK Point-of-Care Ultrasound (ITKPOCUS) is an open source (Apache 2.0) collection of software libraries for the preprocessing and streaming of point-of-care ultrasound (POCUS) devices in order to support image processing and AI.  It currently has levels of support for Clarius, Butterfly, Sonivate, Sonoque, and Interson probes.TheitkpocusPython package supports removing overlays, automatic cropping, and determining the physical dimensions of ultrasound video and images.See theITKPOCUSGithub repo for source code, examples of streaming ultrasound video (Clarius, Interson, Sonivate) using OpenIGTLink, and our Roadmap.ITKPOCUS is developed byKitware, Inc.in collaboration with Duke University.  This effort was sponsored by the U.S. Government under Other Transactions Number W81XWH-15-9-0001/W81XWH-19-9-0015 (MTEC 19-08-MuLTI-0079).Documentationhttps://itkpocus.readthedocs.io/en/latest/UsageThe scripts provided convert manufacturer image and video files to ITK Image objects.  They may also remove overlays from the ultrasound image and set the physical dimension of the image by processing the overlay ruler (when applicable).importitkimportmatplotlib.pyplotaspltimportitkpocus.sonoqueassonoqueimportnumpyasnpfp='../tests/data/sonoque_axial-lateral-resolution-2020.dcm'orig_img=itk.imread(fp)new_img,meta=sonoque.load_and_preprocess_image(fp)InstallationInstallhttps://www.ffmpeg.org/Add ffmpeg binary directory to your PATHNote: errors in this step will result in exceptions fromskvideoActivate your virtual environmentpip install itk-pocus
Package: itk-principalcomponentsanalysis
itk-principalcomponentsanalysis provides an implementation of standard principal components analysis algorithms for use on scalar or vector data sets.
Please refer to:
M. Bowers and L. Younes, “Principal Components Analysis of Scalar, Vector, and Mesh Vertex Data.”, Insight Journal, January-December 2012,http://hdl.handle.net/10380/3386
Package: itk-smoothingrecursiveyvvgaussianfilter
itk-smoothingrecursiveyvvgaussianfilter provides a GPU (OpenCL) and CPU implementation of the computationally efficient forward and backward IIR Young & Van Vliet recursive Gaussian smoothing filter.
Please refer to:
Vidal-Migallon I., Commowick O., Pennec X., Dauguet J., Vercauteren T.,”GPU and CPU implementation of Young - Van Vliet’s Recursive Gaussian Smoothing Filter”, Insight Journal, January-December 2013,http://hdl.handle.net/10380/3425.
Package: itksn
itksn v0.1.0Helper utility for parsing ITk Serial NumbersCI/CDDocsPackageMetaUsingFrom the command line, you can parse serial numbers. If there is an error in
parsing, it will loudly complain (sometimes).$ itksn parse 20UPGMC2291234
Container:
    atlas_project = (enum) atlas_detector b'20'
    system_code = (enum) phaseII_upgrade b'U'
    project_code = (enum) pixel_general b'PG'
    subproject_code = (enum) Module_carrier b'MC'
    identifier = Container:
        module_type = (enum) Linear_triplet_module_carrier b'2'
        module_version = (enum) Quad_v2p1 b'2'
        manufacturer = b'9' (total 1)
        number = b'1234' (total 4)

$ itksn parse 20UPGR40012345
Container:
    atlas_project = (enum) atlas_detector b'20'
    system_code = (enum) phaseII_upgrade b'U'
    project_code = (enum) pixel_general b'PG'
    subproject_code = (enum) Digital_quad_module b'R4'
    identifier = Container:
        FE_chip_version = (enum) RD53A b'0'
        reserved = b'0' (total 1)
        number = b'12345' (total 5)

$ itksn parse 20UPGPD0012345
Container:
    atlas_project = (enum) atlas_detector b'20'
    system_code = (enum) phaseII_upgrade b'U'
    project_code = (enum) pixel_general b'PG'
    subproject_code = (enum) Dual_PCB b'PD'
    identifier = Container:
        FE_chip_version = (enum) RD53A b'0'
        reserved = b'0' (total 1)
        number = b'12345' (total 5)

$ itksn parse 20UPGFW2123456
Container:
    atlas_project = (enum) atlas_detector b'20'
    system_code = (enum) phaseII_upgrade b'U'
    project_code = (enum) pixel_general b'PG'
    subproject_code = (enum) FE_chip_wafer b'FW'
    identifier = Container:
        batch_number = (enum) CROC b'2'
        number = b'123456' (total 6)InstallationIn a fresh virtual environment, you can install fromPyPI:$ python -m pip install itksnor from the main branch of the GitHub repository:$ python -m pip install "git+https://github.com/kratsg/itksn.git"The above is actually cloning and installing directly from the Git repository.However, if you want to, you can of course also install it directly from the Git
repository "locally" by first cloning the repo and then from the top level of it
running$ python -m pip install .ContributingAs this library is experimental contributions of all forms are welcome.If you have ideas on how to improve the API or fix a bug please open an Issue.You are of course also most welcome and encouraged to open PRs.DevelopingTo develop, use a virtual environment.Once the environment is activated, clone the repo from GitHubgit clone git@github.com:kratsg/itksn.gitand you can use hatch for running tests/development, e.g.hatch run +py=3.7 dev:test(Optional) Then setup the Git pre-commit hooks by runningpre-commit installAcknowledgements@matthefeickert'sheputilitiesrepository for a
quick startReferencesSerial Number Specification for ITk pixel modulesProposal for numbering scheme in the ITk, ATU-SYS-AM-0001
Package: itk-splitcomponents
itk-splitcomponents provides a class that takes an image with multi-component pixels and outputs a scalar image for each component. This can be useful when examining images of vectors, tensors, etc.
Please refer to:
M. McCormick, “An ITK Class that Splits Multi-Component Images.”, Insight Journal, July-December 2010,https://hdl.handle.net/10380/3230
Package: itk-strain
itk-strain provides N-dimensional computational framework of strain tensor images in the Insight Toolkit. The filters provided can compute a strain tensor image from a displacement field image and a strain tensor image from a general spatial transform. In both cases, infinitesimal, Green-Lagrangian, or Eulerian-Almansi strain can be generated.
Please refer to:
M. McCormick, “N-Dimensional Computation of Strain Tensor Images in the Insight Toolkit.”, Insight Journal, January-December 2017,https://hdl.handle.net/10380/3573
Package: itk-topologycontrol
ITKTopologyControlOverviewThis is a module for the Insight Toolkit (ITK). The module includes a filter calledFixTopologyCarveOutsidewhich works like morphological closing, except that in the "erode" phase topological constraints are enforced to avoid re-opening holes. It is able to close holes in thin layers (e.g. skull) with a minimal thickness.importitkskull_mask=itk.imread('path/to/skull_with_holes.mha').astype(itk.US)ImageType=type(skull_mask)MaskType=itk.Image[itk.UC,3]top_control=itk.FixTopologyCarveOutside[ImageType,ImageType,MaskType].New()top_control.SetInput(skull_mask)top_control.SetRadius(5)top_control.Update()skull_mask_closed=top_control.GetOutput()itk.imwrite(skull_mask_closed,'skull_mask_closed.mha')Or using a custom mask (e.g. a sphere around a hole):importitkcustom_mask=itk.imread('path/to/custom_mask.mha').astype(itk.UC)skull_mask=itk.imread('path/to/skull_with_holes.mha').astype(itk.US)skull_mask_closed=itk.fix_topology_carve_outside(skull_mask,MaskImage=custom_mask,Radius=5)itk.imwrite(skull_mask_closed,'skull_mask_closed.mha')InstallationTo install the binary Python packages:python-mpipinstallitk-topologycontrol
Package: itk-tubetk
ITKTubeTK: Tubular Object Extraction, Registration, and AnalysisAvailable in C++ and Python for Linux, Windows, and MacOS.OverviewTubeTK is an open-source toolkit for the segmentation, registration, and analysis of tubes and surfaces in images, developed byKitware, Inc.Tubes and surfaces, as generalized 1D and 2D manifolds in N-dimensional images, are essential components in a variety of image analysis tasks. Instances of tubular structures in images include blood vessels in magnetic resonance angiograms and b-mode ultrasound images, wires in microscopy images of integrated circuits, roads in aerial photographs, and nerves in confocal microscopy.A guiding premise of TubeTK is that by focusing on 1D and 2D manifolds we can devise methods that are insensitive to the modality, noise, contrast, and scale of the images being analyzed and to the arrangement and deformations of the objects in them. In particular, we propose that TubeTK's manifold methods offer improved performance for many applications, compared to methods involving the analysis of independent geometric measures (e.g., edges and corners) or requiring complete shape models.TubeTK offers various interface layers:TubeTK/src: This is the algorithms library.   It is the lowest level of access to the methods of TubeTK.  It is only available via C++, and it requires considerable expertise to effectively combine and call its methods to do anything useful.   Interfacing directly with these algorithms is not recommended and is not well supported. Unit-level testing is performed continuously on these methods.TubeTK/include: This is the ITK interface to select methods inTubeTK/src.  This level of interface is intended for ITK users and Python scripts writers.  The methods exposed represent a level of modularization that invites experimentation, integration with other toolkits (e.g., Scikit-Learn), and development of processing pipelines that accomplish significant image analysis goals.  The interface is available as an ITK Extension and thereby available via Python using Wrapped ITK.TubeTK/examples/Applications: These are optional command-line interface applications.  These applications are mostly also available via the TubeTK/include interface, and thereby are available via python.  Expansion of ITK will focus on the TubeTK/include directory, and new applications will only rarely be added.  These applications are built when the cmake options BUILD_EXAMPLES is enabled.  These applications also require SlicerExecutionModel, seehttps://github.com/Slicer/SlicerExecutionModel.Using TubeTKMinimal
$ python -c "from itk import TubeTK"Recommended
$ python -c "from itk import TubeTK as ttk"AcknowledgementsIf you find TubeTK to be useful for your work, please cite the following publication when publishing your work:S. R. Aylward and E. Bullitt, "Initialization, noise, singularities, and scale in height ridge traversal for tubular object centerline extraction," Medical Imaging, IEEE Transactions on, vol. 21, no. 2, pp. 61-75, 2002.
Package: itk-twoprojectionregistration
itk-twoprojectionregistration provides an implementation of intensity-based 2D/3D rigid image registration for patient setup assessment in external beam radiotherapy.
Please refer to:
J. Wu, “ITK-Based Implementation of Two-Projection 2D/3D Registration Method with an Application in Patient Setup for External Beam Radiotherapy”, Insight Journal, July-December 2010,http://hdl.handle.net/10380/3245.
Package: itkwasm
itkwasmPython interface toitk-wasmWebAssembly modules.For more information, see theproject documentation.DevelopmentThank you for contributing a pull request!Welcome to the ITK community!We are glad you are here and appreciate your contribution. Please keep in mind ourcommunity participation guidelines.git clone https://github.com/InsightSoftwareConsortium/itk-wasm
cd itk-wasm/packages/core/python/itkwasm
pip install hatch
hatch run download-pyodide
hatch run test
Package: itkwasm-compare-images-emscripten
itkwasm-compare-images-emscriptenCompare images with a tolerance for regression testing. Emscripten implementation.This package provides the Emscripten WebAssembly implementation. It is usually not called directly. Please use theitkwasm-compare-imagesinstead.Installationimportmicropip
awaitmicropip.install('itkwasm-compare-images-emscripten')Developmentpipinstallhatch
hatchrundownload-pyodide
hatchruntest
Package: itkwasm-compare-images-wasi
itkwasm-compare-images-wasiCompare images with a tolerance for regression testing. WASI implementation.This package provides the WASI WebAssembly implementation. It is usually not called directly. Please useitkwasm-compare-imagesinstead.Installationpipinstallitkwasm-compare-images-wasiDevelopmentpipinstallpytestitk-webassemblyinterface>=1.0b127
pipinstall-e.
pytest# orpipinstallhatch
hatchruntest
Package: itkwasm-compress-stringify-emscripten
itkwasm-compress-stringify-emscriptenZstandard compression and decompression and base64 encoding and decoding in WebAssembly. Emscripten implementation.This package provides the Emscripten WebAssembly implementation. It is usually not called directly. Please useitkwasm-compress-stringifyinstead.Installationpipinstallitkwasm-compress-stringify-emscripten
Package: itkwasm-compress-stringify-wasi
itkwasm-compress-stringify-wasiZstandard compression and decompression and base64 encoding and decoding in WebAssembly. WASI implementation.This package provides the WASI WebAssembly implementation. It is usually not called directly. Please useitkwasm-compress-stringifyinstead.Installationpipinstallitkwasm-compress-stringify-wasi
Package: itkwasm-dicom-emscripten
itkwasm-dicom-emscriptenRead files and images related to DICOM file format. Emscripten implementation.This package provides the Emscripten WebAssembly implementation. It is usually not called directly. Please useitkwasm-dicominstead.Installationimportmicropip
awaitmicropip.install('itkwasm-dicom-emscripten')Development# Download test datacd../../../..
npmci
npmrunbuild:testDatacd-

pipinstallhatch
hatchrundownload-pyodide
hatchruntest
Package: itkwasm-dicom-wasi
itkwasm-dicom-wasiRead files and images related to DICOM file format. WASI implementation.This package provides the WASI WebAssembly implementation. It is usually not called directly. Please useitkwasm-dicominstead.Installationpipinstallitkwasm-dicom-wasiDevelopment# Download test datacd../../../..
npmci
npmrunbuild:testDatacd-

pipinstallpytest
pipinstallpillow
pipinstall-e.
pytest# orpipinstallhatch
hatchruntest
Package: itkwasm-downsample-cucim
itkwasm-downsample-cucimPipelines for downsampling images.cucimimplementation.This package provides the NVIDIA RAPIDS cuCIM CUDA-accelerated implementation. It is usually not called directly. Please useitkwasm-downsampleinstead.InstallationInstall cuCIM, thenpipinstallitkwasm-downsample-cucimDevelopmentpipinstallpytestitkwasm-image-ioitkwasm-compare-images
pipinstall-e.
pytest# orpipinstallhatch
hatchruntest
Package: itkwasm-downsample-emscripten
itkwasm-downsample-emscriptenPipelines for downsampling images. Emscripten implementation.This package provides the Emscripten WebAssembly implementation. It is usually not called directly. Please use theitkwasm-downsampleinstead.Installationimportmicropip
awaitmicropip.install('itkwasm-downsample-emscripten')Developmentpipinstallhatch
hatchrundownload-pyodide
hatchruntest
Package: itkwasm-downsample-wasi
itkwasm-downsample-wasiPipelines for downsampling images. WASI implementation.This package provides the WASI WebAssembly implementation. It is usually not called directly. Please useitkwasm-downsampleinstead.Installationpipinstallitkwasm-downsample-wasiDevelopmentpipinstallpytestitkwasm-image-ioitkwasm-compare-images
pipinstall-e.
pytest# orpipinstallhatch
hatchruntest
Package: itkwasm-elastix-emscripten
itkwasm-elastix-emscriptenA toolbox for rigid and nonrigid registration of images. Emscripten implementation.This package provides the Emscripten WebAssembly implementation. It is usually not called directly. Please use theitkwasm-elastixinstead.Installationimportmicropip
awaitmicropip.install('itkwasm-elastix-emscripten')Developmentpipinstallhatch
hatchrundownload-pyodide
hatchruntest
Package: itkwasm-elastix-wasi
itkwasm-elastix-wasiA toolbox for rigid and nonrigid registration of images. WASI implementation.This package provides the WASI WebAssembly implementation. It is usually not called directly. Please useitkwasm-elastixinstead.Installationpipinstallitkwasm-elastix-wasiDevelopmentpipinstallpytestitkwasm-compare-imagesitk-io
pipinstall-e.
pytest# orpipinstallhatch
hatchruntest