### Install tiffwrite

Source: https://github.com/wimpomp/tiffwrite/blob/main/README.md

Installation commands for the tiffwrite package via pip.

```bash
pip install tiffwrite
```

```bash
pip install tiffwrite@git+https://github.com/wimpomp/tiffwrite
```

--------------------------------

### Rust API: Basic IJTiffFile Usage

Source: https://context7.com/wimpomp/tiffwrite/llms.txt

Demonstrates basic usage of the `IJTiffFile` struct in Rust for creating BioFormats-compatible TIFF files. Includes setting compression, metadata, channel colors, and saving frames.

```rust
use ndarray::Array2;
use tiffwrite::{IJTiffFile, Compression, Tag};

fn main() -> Result<(), tiffwrite::error::Error> {
    // Basic usage - file is closed when f goes out of scope
    {
        let mut f = IJTiffFile::new("output.tif")?;

        // Set compression (default is zstd level 3)
        f.set_compression(Compression::Zstd(10));

        // Set metadata
        f.px_size = Some(0.065);
        f.delta_z = Some(0.2);
        f.time_interval = Some(5.0);
        f.comment = Some(String::from("Rust-generated TIFF"));

        // Set channel colors
        f.set_colors(&["red", "lime", "blue"])?;

        // Save frames in any order
        for c in 0..3 {
            for z in 0..5 {
                for t in 0..10 {
                    let arr = Array2::<u16>::zeros((256, 256));
                    f.save(&arr, c, z, t)?;
                }
            }
        }
    }  // File automatically finalized here

    // Using different data types
    {
        let mut f = IJTiffFile::new("float_data.tif")?;
        let arr = Array2::<f32>::from_elem((512, 512), 0.5);
        f.save(&arr, 0, 0, 0)?;
    }

    Ok(())
}
```

--------------------------------

### Frame-by-Frame Writing with IJTiffFile

Source: https://context7.com/wimpomp/tiffwrite/llms.txt

The `IJTiffFile` class enables memory-efficient incremental writing of individual frames, allowing frames to be saved in any order. The file is finalized upon exiting the context manager. Supports custom colors per channel and colormaps.

```python
from tiffwrite import IJTiffFile
import numpy as np

# Basic frame-by-frame writing with metadata
with IJTiffFile('timelapse.tif', dtype='uint16', pxsize=0.09707, deltaz=0.5, timeinterval=30.0) as tif:
    for t in range(100):  # 100 timepoints
        for z in range(20):  # 20 z-slices
            for c in range(3):  # 3 channels
                # Process and save each frame individually
                frame = np.random.randint(0, 65535, (512, 512), dtype='uint16')
                tif.save(frame, c, z, t)
```

```python
# Writing with custom colors per channel
with IJTiffFile('colored.tif', dtype='uint16', colors=['red', 'lime', 'blue']) as tif:
    for c, color in enumerate(['red', 'lime', 'blue']):
        tif.save(np.random.randint(0, 1000, (256, 256)), c, 0, 0)
```

```python
# Writing with a colormap (e.g., glasbey for segmentation masks)
with IJTiffFile('segmentation.tif', dtype='uint16', colormap='glasbey') as tif:
    mask = np.random.randint(0, 100, (512, 512), dtype='uint16')
    tif.save(mask, 0, 0, 0)
```

--------------------------------

### Configure Metadata with IJTiffFile Properties

Source: https://context7.com/wimpomp/tiffwrite/llms.txt

Configure pixel size, z-spacing, time intervals, channel colors, colormaps, and comments using `IJTiffFile` properties. These settings are embedded in the TIFF metadata for ImageJ/Fiji compatibility. Note that `colors` and `colormap` cannot be used simultaneously.

```python
from tiffwrite import IJTiffFile
import numpy as np

with IJTiffFile('metadata_example.tif', dtype='uint16') as tif:
    # Set pixel size in micrometers
    tif.px_size = 0.065

    # Set z-slice interval in micrometers
    tif.delta_z = 0.2

    # Set time interval between frames in seconds
    tif.time_interval = 5.0

    # Set channel colors using CSS color names or hex codes
    tif.colors = ['#ff0000', 'lime', 'cyan']

    # Or use a colormap instead (cannot use both colors and colormap)
    # tif.colormap = 'viridis'

    # Add a comment to the TIFF metadata
    tif.comment = 'Confocal microscopy, 63x objective, NA 1.4'

    # Save frames
    for c in range(3):
        frame = np.random.randint(0, 4095, (256, 256), dtype='uint16')
        tif.save(frame, c, 0, 0)
```

--------------------------------

### Create Various TIFF Tags in Rust

Source: https://context7.com/wimpomp/tiffwrite/llms.txt

Demonstrates the creation of different TIFF tag types using the `tiffwrite::Tag` enum. Ensure necessary imports for `num::Complex` and `num::Rational32` are present.

```rust
use tiffwrite::Tag;
use num::{Complex, Rational32};

fn create_tags() {
    // ASCII string tag (e.g., Artist tag 315)
    let artist = Tag::ascii(315, "Researcher Name");

    // Byte array tag
    let bytes = Tag::byte(700, &[0x01, 0x02, 0x03, 0x04]);

    // Short (u16) values
    let shorts = Tag::short(701, &[100, 200, 300]);

    // Long (u32) values
    let longs = Tag::long(702, &[100000, 200000]);

    // Rational values (fractions)
    let rationals = Tag::rational(282, &[Rational32::new(1, 10)]);  // X resolution

    // Signed types
    let signed_short = Tag::sshort(703, &[-100, 100]);
    let signed_long = Tag::slong(704, &[-50000, 50000]);

    // Floating point
    let floats = Tag::float(705, &[3.14159, 2.71828]);
    let doubles = Tag::double(706, &[3.141592653589793]);

    // 64-bit integers
    let long8 = Tag::long8(707, &[u64::MAX / 2]);

    // Complex numbers
    let complex_vals = Tag::complex(708, &[Complex::new(1.0f32, 2.0f32)]);

    // Unicode string
    let unicode = Tag::unicode(709, "Unicode text with special chars");
}
```

--------------------------------

### IJTiffFile - Frame-by-Frame Writing

Source: https://context7.com/wimpomp/tiffwrite/llms.txt

The `IJTiffFile` class enables incremental writing of individual frames, allowing memory-efficient processing of large datasets. Frames can be saved in any order, and the file is properly finalized when the context manager exits.

```APIDOC
## IJTiffFile - Frame-by-Frame Writing

### Description
Enables incremental writing of individual TIFF frames, suitable for memory-efficient processing of large datasets. Frames can be saved in any order and the file is finalized upon exiting the context manager.

### Method
`IJTiffFile` class with `save` method.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **filename** (str) - The name of the TIFF file to create.
- **dtype** (str, optional) - Data type of the image frames (e.g., 'uint16').
- **pxsize** (float, optional) - Pixel size in micrometers.
- **deltaz** (float, optional) - Z-slice interval in micrometers.
- **timeinterval** (float, optional) - Time interval between frames in seconds.
- **colors** (list[str], optional) - List of channel colors (CSS names or hex codes).
- **colormap** (str, optional) - Name of the colormap to use (e.g., 'glasbey', 'viridis'). Cannot be used with `colors`.
- **compression** (tuple, optional) - Compression settings, e.g., `('zstd', 19)` for zstd level 19.

### Request Example
```python
from tiffwrite import IJTiffFile
import numpy as np

# Basic frame-by-frame writing with metadata
with IJTiffFile('timelapse.tif', dtype='uint16', pxsize=0.09707, deltaz=0.5, timeinterval=30.0) as tif:
    for t in range(100):  # 100 timepoints
        for z in range(20):  # 20 z-slices
            for c in range(3):  # 3 channels
                # Process and save each frame individually
                frame = np.random.randint(0, 65535, (512, 512), dtype='uint16')
                tif.save(frame, c, z, t)

# Writing with custom colors per channel
with IJTiffFile('colored.tif', dtype='uint16', colors=['red', 'lime', 'blue']) as tif:
    for c, color in enumerate(['red', 'lime', 'blue']):
        tif.save(np.random.randint(0, 1000, (256, 256)), c, 0, 0)

# Writing with a colormap (e.g., glasbey for segmentation masks)
with IJTiffFile('segmentation.tif', dtype='uint16', colormap='glasbey') as tif:
    mask = np.random.randint(0, 100, (512, 512), dtype='uint16')
    tif.save(mask, 0, 0, 0)
```

### Response
#### Success Response (200)
None (file is saved to disk)

#### Response Example
None
```

--------------------------------

### IJTiffFile Class

Source: https://github.com/wimpomp/tiffwrite/blob/main/README.md

The `IJTiffFile` class allows for more granular control, enabling writing individual frames to a TIFF file and managing multiple files simultaneously.

```APIDOC
## IJTiffFile(path, dtype='uint16', colors=None, colormap=None, pxsize=None, deltaz=None,
               timeinterval=None, **extratags)

### Description
Context manager for writing TIFF files frame by frame. It supports various metadata and compression options.

### Parameters
#### Path Parameters
- **path** (string) - Required - Path to the new tiff file.
- **dtype** (string) - Optional - Cast data to dtype before saving. Only (u)int8, (u)int16 and float32 are supported by Fiji. Defaults to 'uint16'.
- **colors** (iterable of strings) - Optional - One color per channel. Valid colors are defined in matplotlib.colors. Without colormap, BioFormats sets colors in order: rgbwcmy. Note: 'green' is dark, use 'lime' for usual green.
- **colormap** (string) - Optional - Choose any colormap from the colorcet module. Colors and colormap cannot be used simultaneously.
- **pxsize** (float) - Optional - Pixel size in um.
- **deltaz** (float) - Optional - Z slice interval in um.
- **timeinterval** (float) - Optional - Time between frames in seconds.
- **compression** (int) - Optional - Zstd compression level: -7 to 22.
- **comment** (str) - Optional - Comment to be saved in tif.
- **extratags** (Sequence[Tag]) - Optional - Other tags to be saved. Example: Tag.ascii(315, 'John Doe') or Tag.ascii(33432, 'Made by me').

### Method: save(frame, c, z, t)
Saves a single frame to the TIFF file.

#### Parameters
- **frame** (numpy array) - Required - 2D numpy array with frame data.
- **c** (int) - Required - Channel coordinate of the frame.
- **z** (int) - Required - Z coordinate of the frame.
- **t** (int) - Required - Time coordinate of the frame.

### Request Example (Python)
```python
from tiffwrite import IJTiffFile
import numpy as np

with IJTiffFile('file.tif', pxsize=0.09707) as tif:
    for c in range(3):
        for z in range(5):
            for t in range(10):
                tif.save(np.random.randint(0, 10, (32, 32)), c, z, t)
```

### Request Example (Rust)
```rust
use ndarray::Array2;
use tiffwrite::IJTiffFile;

{
    let mut f = IJTiffFile::new("file.tif")?;
    for c in 0..3 {
        for z in 0..5 {
            for t in 0..10 {
                let arr = Array2::<u16>::zeros((100, 100));
                f.save(&arr, c, z, t)?;
            }
        }
    }
}
```

### Request Example (Multiple Files)
```python
from tiffwrite import IJTiffFile
import numpy as np

with IJTiffFile('fileA.tif') as tif_a, IJTiffFile('fileB.tif') as tif_b:
    for c in range(3):
        for z in range(5):
            for t in range(10):
                tif_a.save(np.random.randint(0, 10, (32, 32)), c, z, t)
                tif_b.save(np.random.randint(0, 10, (32, 32)), c, z, t)
```
```

--------------------------------

### Configure Compression Settings with IJTiffFile

Source: https://context7.com/wimpomp/tiffwrite/llms.txt

Tiffwrite supports zstd (default) and deflate compression. Zstd compression level ranges from -7 (fastest) to 22 (best compression). Specify compression type and level via the `compression` argument.

```python
from tiffwrite import IJTiffFile
import numpy as np

# Default zstd compression (level 3)
with IJTiffFile('default_compression.tif', dtype='uint16') as tif:
    tif.save(np.zeros((512, 512), dtype='uint16'), 0, 0, 0)
```

```python
# High compression zstd (slower but smaller files)
with IJTiffFile('high_compression.tif', dtype='uint16', compression=('zstd', 19)) as tif:
    tif.save(np.zeros((512, 512), dtype='uint16'), 0, 0, 0)
```

--------------------------------

### Write frames in Rust

Source: https://github.com/wimpomp/tiffwrite/blob/main/README.md

Uses the ndarray crate and IJTiffFile to save frames in a Rust environment.

```rust
use ndarray::Array2;
use tiffwrite::IJTiffFile;

{  // f will be closed when f goes out of scope
    let mut f = IJTiffFile::new("file.tif")?;
    for c in 0..3 {
        for z in 0..5 {
            for t in 0..10 {
                let arr = Array2::<u16>::zeros((100, 100));
                f.save(&arr, c, z, t)?;
            }
        }
    }
}
```

--------------------------------

### IJTiffFile Properties - Metadata Configuration

Source: https://context7.com/wimpomp/tiffwrite/llms.txt

IJTiffFile exposes properties for configuring pixel size, z-spacing, time intervals, colors, colormaps, and comments that are embedded in the TIFF metadata for proper interpretation by ImageJ/Fiji.

```APIDOC
## IJTiffFile Properties - Metadata Configuration

### Description
Configures metadata properties of an `IJTiffFile` instance, including pixel size, z-spacing, time intervals, colors, colormaps, and comments, which are embedded in the TIFF metadata for ImageJ/Fiji compatibility.

### Method
`IJTiffFile` class properties.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **px_size** (float) - Pixel size in micrometers.
- **delta_z** (float) - Z-slice interval in micrometers.
- **time_interval** (float) - Time interval between frames in seconds.
- **colors** (list[str]) - List of channel colors (CSS names or hex codes).
- **colormap** (str) - Name of the colormap to use (e.g., 'viridis'). Cannot be used with `colors`.
- **comment** (str) - A comment string to embed in the TIFF metadata.

### Request Example
```python
from tiffwrite import IJTiffFile
import numpy as np

with IJTiffFile('metadata_example.tif', dtype='uint16') as tif:
    # Set pixel size in micrometers
    tif.px_size = 0.065

    # Set z-slice interval in micrometers
    tif.delta_z = 0.2

    # Set time interval between frames in seconds
    tif.time_interval = 5.0

    # Set channel colors using CSS color names or hex codes
    tif.colors = ['#ff0000', 'lime', 'cyan']

    # Or use a colormap instead (cannot use both colors and colormap)
    # tif.colormap = 'viridis'

    # Add a comment to the TIFF metadata
    tif.comment = 'Confocal microscopy, 63x objective, NA 1.4'

    # Save frames
    for c in range(3):
        frame = np.random.randint(0, 4095, (256, 256), dtype='uint16')
        tif.save(frame, c, 0, 0)
```

### Response
#### Success Response (200)
None (metadata is saved to the TIFF file)

#### Response Example
None
```

--------------------------------

### tiffwrite - Write Complete Image Stack

Source: https://context7.com/wimpomp/tiffwrite/llms.txt

The `tiffwrite` function provides a simple high-level interface to save a complete numpy array as a TIFF file in a single call. It automatically handles dimension ordering and supports 2D to 5D arrays with configurable axis labels.

```APIDOC
## tiffwrite - Write Complete Image Stack

### Description
Saves a complete numpy array as a TIFF file in a single call, handling dimension ordering and supporting 2D to 5D arrays.

### Method
`tiffwrite`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **image_stack** (numpy.ndarray) - The image data to save.
- **axes** (str) - Configurable axis labels (e.g., 'TZCYX').
- **dtype** (str, optional) - Data type of the image (e.g., 'uint16').
- **bar** (bool, optional) - Whether to display a progress bar.
- **pxsize** (float, optional) - Pixel size in micrometers.
- **deltaz** (float, optional) - Z-slice interval in micrometers.

### Request Example
```python
from tiffwrite import tiffwrite
import numpy as np

# Create a 5D image stack: 10 timepoints, 5 z-slices, 3 channels, 256x256 pixels
image_stack = np.random.randint(0, 65535, (10, 5, 3, 256, 256), dtype='uint16')

# Save with default TZCYX axis ordering
tiffwrite('microscopy_data.tif', image_stack, axes='TZCYX')

# Save 4D data with explicit axis specification and progress bar
z_stack = np.random.randint(0, 255, (20, 4, 512, 512), dtype='uint8')
tiffwrite('z_stack.tif', z_stack, axes='ZCYX', dtype='uint16', bar=True)

# Save 3D multichannel image with pixel size metadata
multichannel = np.random.rand(3, 1024, 1024).astype('float32')
tiffwrite('fluorescence.tif', multichannel, axes='CYX', pxsize=0.065, deltaz=0.2)
```

### Response
#### Success Response (200)
None (file is saved to disk)

#### Response Example
None
```

--------------------------------

### Save multiple TIFFs simultaneously in Python

Source: https://github.com/wimpomp/tiffwrite/blob/main/README.md

Opens multiple IJTiffFile instances to write to different files within the same loop.

```python
from tiffwrite import IJTiffFile
import numpy as np

with IJTiffFile('fileA.tif') as tif_a, IJTiffFile('fileB.tif') as tif_b:
    for c in range(3):
        for z in range(5):
            for t in range(10):
                tif_a.save(np.random.randint(0, 10, (32, 32)), c, z, t)
                tif_b.save(np.random.randint(0, 10, (32, 32)), c, z, t)
```

--------------------------------

### Deflate Compression for Compatibility

Source: https://context7.com/wimpomp/tiffwrite/llms.txt

Employ Deflate compression for maximum compatibility with various TIFF readers and software. This is a good default choice when interoperability is a key concern.

```python
from tiffwrite import IJTiffFile
import numpy as np

with IJTiffFile('deflate.tif', dtype='uint16', compression='deflate') as tif:
    tif.save(np.zeros((512, 512), dtype='uint16'), 0, 0, 0)
```

--------------------------------

### tiffwrite Function

Source: https://github.com/wimpomp/tiffwrite/blob/main/README.md

The `tiffwrite` function provides a high-level interface to write an entire image stack to a TIFF file.

```APIDOC
## tiffwrite(file, data, axes='TZCXY', dtype=None, bar=False, *args, **kwargs)

### Description
Writes a 2 to 5D numpy array as a BioFormats/ImageJ compatible TIFF file with zstd compression.

### Parameters
#### Path Parameters
- **file** (string) - Required - Filename of the new tiff file.
- **data** (numpy array) - Required - 2 to 5D numpy array in one of the following datatypes: (u)int8, (u)int16, float32.
- **axes** (string) - Optional - Order of dimensions in data. Defaults to TZCXY for 5D, ZCXY for 4D, CXY for 3D, XY for 2D data.
- **dtype** (string) - Optional - Cast data to dtype before saving. Only (u)int8, (u)int16 and float32 are supported.
- **bar** (bool) - Optional - Whether to show a progress bar. Defaults to False.
- **args, kwargs** - Optional - Arguments to be passed to IJTiffFile.

### Request Example
```python
from tiffwrite import tiffwrite
import numpy as np

image = np.random.randint(0, 255, (5, 3, 64, 64), 'uint16')
tiffwrite('file.tif', image, 'TCXY')
```
```

--------------------------------

### Write Complete Image Stack with tiffwrite

Source: https://context7.com/wimpomp/tiffwrite/llms.txt

Use the `tiffwrite` function for a simple, high-level interface to save a complete numpy array as a TIFF file. It handles dimension ordering and supports 2D to 5D arrays with configurable axis labels and optional progress bars.

```python
from tiffwrite import tiffwrite
import numpy as np

# Create a 5D image stack: 10 timepoints, 5 z-slices, 3 channels, 256x256 pixels
image_stack = np.random.randint(0, 65535, (10, 5, 3, 256, 256), dtype='uint16')

# Save with default TZCYX axis ordering
tiffwrite('microscopy_data.tif', image_stack, axes='TZCYX')
```

```python
# Save 4D data with explicit axis specification and progress bar
z_stack = np.random.randint(0, 255, (20, 4, 512, 512), dtype='uint8')
tiffwrite('z_stack.tif', z_stack, axes='ZCYX', dtype='uint16', bar=True)
```

```python
# Save 3D multichannel image with pixel size metadata
multichannel = np.random.rand(3, 1024, 1024).astype('float32')
tiffwrite('fluorescence.tif', multichannel, axes='CYX', pxsize=0.065, deltaz=0.2)
```

--------------------------------

### Write an image stack in Python

Source: https://github.com/wimpomp/tiffwrite/blob/main/README.md

Writes a multi-dimensional numpy array to a TIFF file using the tiffwrite function.

```python
from tiffwrite import tiffwrite
import numpy as np

image = np.random.randint(0, 255, (5, 3, 64, 64), 'uint16')
tiffwrite('file.tif', image, 'TCXY')
```

--------------------------------

### Write frames individually in Python

Source: https://github.com/wimpomp/tiffwrite/blob/main/README.md

Saves frames one by one using the IJTiffFile context manager, allowing for memory-efficient processing.

```python
from tiffwrite import IJTiffFile
import numpy as np

with IJTiffFile('file.tif', pxsize=0.09707) as tif:
    for c in range(3):
        for z in range(5):
            for t in range(10):
                tif.save(np.random.randint(0, 10, (32, 32)), c, z, t)
```

--------------------------------

### Fast ZSTD Compression (Level -7)

Source: https://context7.com/wimpomp/tiffwrite/llms.txt

Use ZSTD compression with a negative level for faster compression speeds, suitable for large datasets where speed is prioritized over maximum compression ratio.

```python
from tiffwrite import IJTiffFile
import numpy as np

with IJTiffFile('fast_compression.tif', dtype='uint16', compression=('zstd', -7)) as tif:
    tif.save(np.zeros((512, 512), dtype='uint16'), 0, 0, 0)
```

--------------------------------

### Simultaneous Multi-File TIFF Writing

Source: https://context7.com/wimpomp/tiffwrite/llms.txt

Write to multiple TIFF files concurrently using `ExitStack` for efficient management of resources. This is useful for splitting data streams or creating parallel outputs with different data types or processing levels.

```python
from tiffwrite import IJTiffFile
from contextlib import ExitStack
import numpy as np

# Write to multiple files simultaneously
with ExitStack() as stack:
    # Open multiple TIFF files
    tif_raw = stack.enter_context(IJTiffFile('raw_data.tif', dtype='uint16'))
    tif_processed = stack.enter_context(IJTiffFile('processed.tif', dtype='float32'))
    tif_mask = stack.enter_context(IJTiffFile('segmentation.tif', dtype='uint8'))

    for t in range(50):
        for z in range(10):
            # Acquire/generate raw data
            raw_frame = np.random.randint(0, 4095, (512, 512), dtype='uint16')
            tif_raw.save(raw_frame, 0, z, t)

            # Process and save
            processed = (raw_frame.astype('float32') - 100) / 4095.0
            tif_processed.save(processed, 0, z, t)

            # Generate and save mask
            mask = (raw_frame > 2000).astype('uint8') * 255
            tif_mask.save(mask, 0, z, t)
```

```python
# Simple two-file example
with IJTiffFile('fileA.tif') as tif_a, IJTiffFile('fileB.tif') as tif_b:
    for c in range(3):
        for z in range(5):
            for t in range(10):
                frame = np.random.randint(0, 255, (64, 64), dtype='uint16')
                tif_a.save(frame, c, z, t)
                tif_b.save(frame * 2, c, z, t)
```

--------------------------------

### Adding Custom TIFF Tags

Source: https://context7.com/wimpomp/tiffwrite/llms.txt

Utilize the Tag class to add custom TIFF tags, including global tags applied to all frames and frame-specific tags. Supports various data types like ASCII, byte, short, long, rational, float, and double.

```python
from tiffwrite import IJTiffFile, Tag
import numpy as np

with IJTiffFile('custom_tags.tif', dtype='uint16') as tif:
    # Add global extra tags (applied to all frames)
    # Tag 315 is the Artist tag
    artist_tag = Tag.ascii(315, 'John Doe')

    # Tag 33432 is the Copyright tag
    copyright_tag = Tag.ascii(33432, 'CC BY 4.0')

    # Save frame with extra tags
    frame = np.random.randint(0, 1000, (256, 256), dtype='uint16')
    tif.save(frame, 0, 0, 0, extratags=[artist_tag, copyright_tag])

    # Frame-specific tags can be appended
    tif.append_extra_tag(Tag.ascii(270, 'Frame-specific description'), (0, 0, 0))

    # Various tag types available:
    # Tag.byte(code, [bytes])
    # Tag.ascii(code, 'string')
    # Tag.short(code, [uint16 values])
    # Tag.long(code, [uint32 values])
    # Tag.rational(code, [float values as ratios])
    # Tag.float(code, [float32 values])
    # Tag.double(code, [float64 values])
```

--------------------------------

### Compression Settings

Source: https://context7.com/wimpomp/tiffwrite/llms.txt

Tiffwrite supports zstd compression (default, highly efficient) and deflate compression. The compression level for zstd ranges from -7 (fastest) to 22 (best compression).

```APIDOC
## Compression Settings

### Description
Configures compression for TIFF files written by Tiffwrite. Supports zstd (default) and deflate compression, with configurable levels for zstd.

### Method
`IJTiffFile` constructor parameter `compression`.

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **compression** (tuple or str) - Compression settings. Can be:
    - `('zstd', level)`: zstd compression with a level from -7 to 22.
    - `'deflate'`: deflate compression.
    - If not specified, defaults to zstd compression level 3.

### Request Example
```python
from tiffwrite import IJTiffFile
import numpy as np

# Default zstd compression (level 3)
with IJTiffFile('default_compression.tif', dtype='uint16') as tif:
    tif.save(np.zeros((512, 512), dtype='uint16'), 0, 0, 0)

# High compression zstd (slower but smaller files)
with IJTiffFile('high_compression.tif', dtype='uint16', compression=('zstd', 19)) as tif:
    tif.save(np.zeros((512, 512), dtype='uint16'), 0, 0, 0)
```

### Response
#### Success Response (200)
None (file is saved to disk with specified compression)

#### Response Example
None
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.