@itk-wasm/image-io

Input and output for scientific and medical image file formats.

💻 Live API Demo ✨

🕮 Documentation 📚

Installation

npm install @itk-wasm/image-io

Usage

Browser interface

Import:

import {
  readImage,
  writeImage,
  bioRadReadImage,
  bioRadWriteImage,
  bmpReadImage,
  bmpWriteImage,
  fdfReadImage,
  fdfWriteImage,
  gdcmReadImage,
  gdcmWriteImage,
  geAdwReadImage,
  geAdwWriteImage,
  ge4ReadImage,
  ge4WriteImage,
  ge5ReadImage,
  ge5WriteImage,
  giplReadImage,
  giplWriteImage,
  hdf5ReadImage,
  hdf5WriteImage,
  jpegReadImage,
  jpegWriteImage,
  lsmReadImage,
  lsmWriteImage,
  metaReadImage,
  metaWriteImage,
  mghReadImage,
  mghWriteImage,
  mincReadImage,
  mincWriteImage,
  mrcReadImage,
  mrcWriteImage,
  niftiReadImage,
  niftiWriteImage,
  nrrdReadImage,
  nrrdWriteImage,
  pngReadImage,
  pngWriteImage,
  scancoReadImage,
  scancoWriteImage,
  tiffReadImage,
  tiffWriteImage,
  vtkReadImage,
  vtkWriteImage,
  wasmReadImage,
  wasmWriteImage,
  wasmZstdReadImage,
  wasmZstdWriteImage,
  setPipelinesBaseUrl,
  getPipelinesBaseUrl,
} from "@itk-wasm/image-io"

readImage

Read an image file format and convert it to an itk-wasm Image.

async function readImage(
  serializedImage: File | BinaryFile,
  options: ReadImageOptions = {}
) : Promise<ReadImageResult>

ReadImageOptions interface:

ReadImageResult interface:

writeImage

Write an itk-wasm Image converted to an image file format

async function writeImage(
  image: Image,
  serializedImage: string,
  options: WriteImageOptions = {}
) : Promise<WriteImageResult>

WriteImageOptions interface:

WriteImageResult interface:

bioRadReadImage

Read an image file format and convert it to the itk-wasm file format

async function bioRadReadImage(
  serializedImage: File | BinaryFile,
  options: BioRadReadImageOptions = {}
) : Promise<BioRadReadImageResult>

BioRadReadImageOptions interface:

BioRadReadImageResult interface:

bioRadWriteImage

Write an itk-wasm file format converted to an image file format

async function bioRadWriteImage(
  image: Image,
  serializedImage: string,
  options: BioRadWriteImageOptions = {}
) : Promise<BioRadWriteImageResult>

BioRadWriteImageOptions interface:

BioRadWriteImageResult interface:

bmpReadImage

Read an image file format and convert it to the itk-wasm file format

async function bmpReadImage(
  serializedImage: File | BinaryFile,
  options: BmpReadImageOptions = {}
) : Promise<BmpReadImageResult>

BmpReadImageOptions interface:

BmpReadImageResult interface:

bmpWriteImage

Write an itk-wasm file format converted to an image file format

async function bmpWriteImage(
  image: Image,
  serializedImage: string,
  options: BmpWriteImageOptions = {}
) : Promise<BmpWriteImageResult>

BmpWriteImageOptions interface:

BmpWriteImageResult interface:

fdfReadImage

Read an image file format and convert it to the itk-wasm file format

async function fdfReadImage(
  serializedImage: File | BinaryFile,
  options: FdfReadImageOptions = {}
) : Promise<FdfReadImageResult>

FdfReadImageOptions interface:

FdfReadImageResult interface:

fdfWriteImage

Write an itk-wasm file format converted to an image file format

async function fdfWriteImage(
  image: Image,
  serializedImage: string,
  options: FdfWriteImageOptions = {}
) : Promise<FdfWriteImageResult>

FdfWriteImageOptions interface:

FdfWriteImageResult interface:

gdcmReadImage

Read an image file format and convert it to the itk-wasm file format

async function gdcmReadImage(
  serializedImage: File | BinaryFile,
  options: GdcmReadImageOptions = {}
) : Promise<GdcmReadImageResult>

GdcmReadImageOptions interface:

GdcmReadImageResult interface:

gdcmWriteImage

Write an itk-wasm file format converted to an image file format

async function gdcmWriteImage(
  image: Image,
  serializedImage: string,
  options: GdcmWriteImageOptions = {}
) : Promise<GdcmWriteImageResult>

GdcmWriteImageOptions interface:

GdcmWriteImageResult interface:

geAdwReadImage

Read an image file format and convert it to the itk-wasm file format

async function geAdwReadImage(
  serializedImage: File | BinaryFile,
  options: GeAdwReadImageOptions = {}
) : Promise<GeAdwReadImageResult>

GeAdwReadImageOptions interface:

GeAdwReadImageResult interface:

geAdwWriteImage

Write an itk-wasm file format converted to an image file format

async function geAdwWriteImage(
  image: Image,
  serializedImage: string,
  options: GeAdwWriteImageOptions = {}
) : Promise<GeAdwWriteImageResult>

GeAdwWriteImageOptions interface:

GeAdwWriteImageResult interface:

ge4ReadImage

Read an image file format and convert it to the itk-wasm file format

async function ge4ReadImage(
  serializedImage: File | BinaryFile,
  options: Ge4ReadImageOptions = {}
) : Promise<Ge4ReadImageResult>

Ge4ReadImageOptions interface:

Ge4ReadImageResult interface:

ge4WriteImage

Write an itk-wasm file format converted to an image file format

async function ge4WriteImage(
  image: Image,
  serializedImage: string,
  options: Ge4WriteImageOptions = {}
) : Promise<Ge4WriteImageResult>

Ge4WriteImageOptions interface:

Ge4WriteImageResult interface:

ge5ReadImage

Read an image file format and convert it to the itk-wasm file format

async function ge5ReadImage(
  serializedImage: File | BinaryFile,
  options: Ge5ReadImageOptions = {}
) : Promise<Ge5ReadImageResult>

Ge5ReadImageOptions interface:

Ge5ReadImageResult interface:

ge5WriteImage

Write an itk-wasm file format converted to an image file format

async function ge5WriteImage(
  image: Image,
  serializedImage: string,
  options: Ge5WriteImageOptions = {}
) : Promise<Ge5WriteImageResult>

Ge5WriteImageOptions interface:

Ge5WriteImageResult interface:

giplReadImage

Read an image file format and convert it to the itk-wasm file format

async function giplReadImage(
  serializedImage: File | BinaryFile,
  options: GiplReadImageOptions = {}
) : Promise<GiplReadImageResult>

GiplReadImageOptions interface:

GiplReadImageResult interface:

giplWriteImage

Write an itk-wasm file format converted to an image file format

async function giplWriteImage(
  image: Image,
  serializedImage: string,
  options: GiplWriteImageOptions = {}
) : Promise<GiplWriteImageResult>

GiplWriteImageOptions interface:

GiplWriteImageResult interface:

hdf5ReadImage

Read an image file format and convert it to the itk-wasm file format

async function hdf5ReadImage(
  serializedImage: File | BinaryFile,
  options: Hdf5ReadImageOptions = {}
) : Promise<Hdf5ReadImageResult>

Hdf5ReadImageOptions interface:

Hdf5ReadImageResult interface:

hdf5WriteImage

Write an itk-wasm file format converted to an image file format

async function hdf5WriteImage(
  image: Image,
  serializedImage: string,
  options: Hdf5WriteImageOptions = {}
) : Promise<Hdf5WriteImageResult>

Hdf5WriteImageOptions interface:

Hdf5WriteImageResult interface:

jpegReadImage

Read an image file format and convert it to the itk-wasm file format

async function jpegReadImage(
  serializedImage: File | BinaryFile,
  options: JpegReadImageOptions = {}
) : Promise<JpegReadImageResult>

JpegReadImageOptions interface:

JpegReadImageResult interface:

jpegWriteImage

Write an itk-wasm file format converted to an image file format

async function jpegWriteImage(
  image: Image,
  serializedImage: string,
  options: JpegWriteImageOptions = {}
) : Promise<JpegWriteImageResult>

JpegWriteImageOptions interface:

JpegWriteImageResult interface:

lsmReadImage

Read an image file format and convert it to the itk-wasm file format

async function lsmReadImage(
  serializedImage: File | BinaryFile,
  options: LsmReadImageOptions = {}
) : Promise<LsmReadImageResult>

LsmReadImageOptions interface:

LsmReadImageResult interface:

lsmWriteImage

Write an itk-wasm file format converted to an image file format

async function lsmWriteImage(
  image: Image,
  serializedImage: string,
  options: LsmWriteImageOptions = {}
) : Promise<LsmWriteImageResult>

LsmWriteImageOptions interface:

LsmWriteImageResult interface:

metaReadImage

Read an image file format and convert it to the itk-wasm file format

async function metaReadImage(
  serializedImage: File | BinaryFile,
  options: MetaReadImageOptions = {}
) : Promise<MetaReadImageResult>

MetaReadImageOptions interface:

MetaReadImageResult interface:

metaWriteImage

Write an itk-wasm file format converted to an image file format

async function metaWriteImage(
  image: Image,
  serializedImage: string,
  options: MetaWriteImageOptions = {}
) : Promise<MetaWriteImageResult>

MetaWriteImageOptions interface:

MetaWriteImageResult interface:

mghReadImage

Read an image file format and convert it to the itk-wasm file format

async function mghReadImage(
  serializedImage: File | BinaryFile,
  options: MghReadImageOptions = {}
) : Promise<MghReadImageResult>

MghReadImageOptions interface:

MghReadImageResult interface:

mghWriteImage

Write an itk-wasm file format converted to an image file format

async function mghWriteImage(
  image: Image,
  serializedImage: string,
  options: MghWriteImageOptions = {}
) : Promise<MghWriteImageResult>

MghWriteImageOptions interface:

MghWriteImageResult interface: