GeoTIFF Writer

https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/
Admin
A Rust library for creating and writing GeoTIFF files with support for Cloud Optimized GeoTIFF (COG)...
Tokens:117,615
Snippets:1,351
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### GeoTiffBuilder Example

Source: https://docs.rs/geotiff-writer

Demonstrates how to use the GeoTiffBuilder to create a GeoTIFF file with specified spatial referencing and data.

```APIDOC
## GeoTiffBuilder::new

### Description
Initializes a new GeoTiffBuilder with the specified width and height for the GeoTIFF image.

### Method
`GeoTiffBuilder::new(width: usize, height: usize)`

### Parameters
- **width** (usize) - Required - The width of the GeoTIFF image in pixels.
- **height** (usize) - Required - The height of the GeoTIFF image in pixels.

### Example Usage
```rust
use geotiff_writer::GeoTiffBuilder;
use ndarray::Array2;

let data = Array2::<f32>::zeros((100, 100));
GeoTiffBuilder::new(100, 100)
    .epsg(4326)
    .pixel_scale(0.01, 0.01)
    .origin(-180.0, 90.0)
    .nodata("-9999")
    .write_2d("output.tif", data.view())
    .unwrap();
```

## GeoTiffBuilder::epsg

### Description
Sets the EPSG (European Petroleum Survey Group) code for the GeoTIFF's coordinate reference system.

### Method
`epsg(epsg_code: u32)`

### Parameters
- **epsg_code** (u32) - Required - The EPSG code to set.

## GeoTiffBuilder::pixel_scale

### Description
Sets the pixel scale (resolution) for the GeoTIFF image.

### Method
`pixel_scale(x_scale: f64, y_scale: f64)`

### Parameters
- **x_scale** (f64) - Required - The scale in the X-axis (e.g., degrees per pixel).
- **y_scale** (f64) - Required - The scale in the Y-axis (e.g., degrees per pixel).

## GeoTiffBuilder::origin

### Description
Sets the origin (top-left corner) coordinates for the GeoTIFF image.

### Method
`origin(x_origin: f64, y_origin: f64)`

### Parameters
- **x_origin** (f64) - Required - The X-coordinate of the origin.
- **y_origin** (f64) - Required - The Y-coordinate of the origin.

## GeoTiffBuilder::nodata

### Description
Sets the nodata value for the GeoTIFF image.

### Method
`nodata(value: &str)`

### Parameters
- **value** (&str) - Required - The string representation of the nodata value.

## GeoTiffBuilder::write_2d

### Description
Writes the 2D image data to a GeoTIFF file.

### Method
`write_2d(path: &str, data: impl ndarray::View1D<'_, f32>) -> Result<()>`

### Parameters
- **path** (&str) - Required - The file path to write the GeoTIFF to.
- **data** (impl ndarray::View1D<'_, f32>) - Required - A view of the 2D image data to write.

### Returns
- `Result<()>` - Ok(()) on success, or an Error on failure.
```

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

### TryInto Implementation Example

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/enum.ExtraSample.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates the generic TryInto implementation, which allows converting between types that support TryFrom.

```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
where U: TryFrom<T>
```

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

### GeoTiffBuilder Example

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/index.html?search=

Demonstrates how to create a GeoTIFF file with specified dimensions, EPSG code, pixel scale, origin, and nodata value using the GeoTiffBuilder.

```APIDOC
## GeoTiffBuilder::new

### Description
Initializes a new GeoTIFF builder with the specified width and height.

### Method
`GeoTiffBuilder::new(width: usize, height: usize)`

### Parameters
- **width** (usize) - Required - The width of the GeoTIFF image.
- **height** (usize) - Required - The height of the GeoTIFF image.

### Example Usage
```rust
use geotiff_writer::GeoTiffBuilder;
use ndarray::Array2;

let data = Array2::<f32>::zeros((100, 100));
GeoTiffBuilder::new(100, 100)
    .epsg(4326)
    .pixel_scale(0.01, 0.01)
    .origin(-180.0, 90.0)
    .nodata("-9999")
    .write_2d("output.tif", data.view())
    .unwrap();
```

## GeoTiffBuilder::epsg

### Description
Sets the EPSG code for the GeoTIFF file.

### Method
`epsg(code: u32)`

### Parameters
- **code** (u32) - Required - The EPSG code.

## GeoTiffBuilder::pixel_scale

### Description
Sets the pixel scale for the GeoTIFF file.

### Method
`pixel_scale(x_scale: f64, y_scale: f64)`

### Parameters
- **x_scale** (f64) - Required - The scale in the x-direction.
- **y_scale** (f64) - Required - The scale in the y-direction.

## GeoTiffBuilder::origin

### Description
Sets the origin (top-left corner) for the GeoTIFF file.

### Method
`origin(x_origin: f64, y_origin: f64)`

### Parameters
- **x_origin** (f64) - Required - The x-coordinate of the origin.
- **y_origin** (f64) - Required - The y-coordinate of the origin.

## GeoTiffBuilder::nodata

### Description
Sets the nodata value for the GeoTIFF file.

### Method
`nodata(value: &str)`

### Parameters
- **value** (&str) - Required - The nodata value as a string.

## GeoTiffBuilder::write_2d

### Description
Writes the 2D GeoTIFF data to a file.

### Method
`write_2d(path: &str, data: impl ndarray::View1D<'_, f32>) -> Result<()>`

### Parameters
- **path** (&str) - Required - The path to the output GeoTIFF file.
- **data** (impl ndarray::View1D<'_, f32>) - Required - The 2D data to write.

### Returns
- `Result<()>` - Ok(()) on success, or an Error on failure.
```

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

### GeoKeyDirectory::new

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/struct.GeoKeyDirectory.html

Creates a new, empty GeoKeyDirectory with the default version (1.1.0). This is a convenient way to start building a GeoKey directory from scratch.

```APIDOC
## GeoKeyDirectory::new

### Description
Creates an empty directory with default version (1.1.0).

### Method
`new()`

### Returns
- `GeoKeyDirectory`: An empty GeoKeyDirectory instance.
```

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

### Result Methods

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html?search=std%3A%3Avec

Provides documentation and examples for various methods available on the `Result` type, enabling common operations like checking status, copying, cloning, transposing, and flattening.

```APIDOC
## Result Methods

### `copied` Method

#### Description

Maps a `Result<&T, E>` to a `Result<T, E>` by copying the contents of the `Ok` part. Requires `T` to implement the `Copy` trait.

#### Signature

```rust
pub const fn copied(self) -> Result<T, E>
where T: Copy
```

#### Example

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x.copied(), Ok(12));
```

### `cloned` Method

#### Description

Maps a `Result<&T, E>` to a `Result<T, E>` by cloning the contents of the `Ok` part. Requires `T` to implement the `Clone` trait.

#### Signature

```rust
pub fn cloned(self) -> Result<T, E>
where T: Clone
```

#### Example

```rust
let val = 12;
let x: Result<&i32, i32> = Ok(&val);
assert_eq!(x.cloned(), Ok(12));
```

### `transpose` Method

#### Description

Transposes a `Result` of an `Option` into an `Option` of a `Result`. `Ok(None)` is mapped to `None`. `Ok(Some(_))` and `Err(_)` are mapped to `Some(Ok(_))` and `Some(Err(_))` respectively.

#### Signature

```rust
pub const fn transpose(self) -> Option<Result<T, E>>
```

#### Example

```rust
#[derive(Debug, Eq, PartialEq)]
struct SomeErr;
let x: Result<Option<i32>, SomeErr> = Ok(Some(5));
let y: Option<Result<i32, SomeErr>> = Some(Ok(5));
assert_eq!(x.transpose(), y);
```

### `flatten` Method

#### Description

Converts from `Result<Result<T, E>, E>` to `Result<T, E>`, removing one level of nesting.

#### Signature

```rust
pub const fn flatten(self) -> Result<T, E>
```

#### Example

```rust
let x: Result<Result<&str, u32>, u32> = Ok(Ok("hello"));
assert_eq!(Ok("hello"), x.flatten());

let x: Result<Result<&str, u32>, u32> = Ok(Err(6));
assert_eq!(Err(6), x.flatten());

let x: Result<Result<&str, u32>, u32> = Err(6);
assert_eq!(Err(6), x.flatten());
```

### `is_ok` Method

#### Description

Returns `true` if the result is `Ok`.

#### Signature

```rust
pub const fn is_ok(&self) -> bool
```

#### Example

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_ok(), true);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_ok(), false);
```

### `is_ok_and` Method

#### Description

Returns `true` if the result is `Ok` and the value inside of it matches a predicate.

#### Signature

```rust
pub fn is_ok_and<F>(self, f: F) -> bool
where F: FnOnce(T) -> bool
```

#### Example

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.is_ok_and(|x| x > 1), true);

let x: Result<u32, &str> = Ok(0);
assert_eq!(x.is_ok_and(|x| x > 1), false);

let x: Result<u32, &str> = Err("hey");
assert_eq!(x.is_ok_and(|x| x > 1), false);
```

### `is_err` Method

#### Description

Returns `true` if the result is `Err`.

#### Signature

```rust
pub const fn is_err(&self) -> bool
```

#### Example

```rust
let x: Result<i32, &str> = Ok(-3);
assert_eq!(x.is_err(), false);

let x: Result<i32, &str> = Err("Some error message");
assert_eq!(x.is_err(), true);
```

### `is_err_and` Method

#### Description

Returns `true` if the result is `Err` and the value inside of it matches a predicate.

#### Signature

```rust
pub fn is_err_and<F>(self, f: F) -> bool
where F: FnOnce(E) -> bool
```


```

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

### Create and Write a 2D GeoTIFF File

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/index.html

Use GeoTiffBuilder to construct a GeoTIFF file with specified spatial reference, pixel scale, origin, and nodata values. This example demonstrates writing a 2D array of f32 data to 'output.tif'. Ensure the 'ndarray' crate is available for data handling.

```rust
use geotiff_writer::GeoTiffBuilder;
use ndarray::Array2;

let data = Array2::<f32>::zeros((100, 100));
GeoTiffBuilder::new(100, 100)
    .epsg(4326)
    .pixel_scale(0.01, 0.01)
    .origin(-180.0, 90.0)
    .nodata("-9999")
    .write_2d("output.tif", data.view())
    .unwrap();
```

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

### Get GeoKey by ID

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/struct.GeoKeyDirectory.html

Retrieves a reference to a GeoKey from the directory using its ID.

```rust
pub fn get(&self, id: u16) -> Option<&GeoKey>
```

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

### Get Compression variant name

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/enum.Compression.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Retrieves the string name of a `Compression` enum variant.

```rust
pub fn name(self) -> &'static str
```

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

### Get ASCII Value for GeoKey

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/struct.GeoKeyDirectory.html

Retrieves the string value associated with a given GeoKey ID.

```rust
pub fn get_ascii(&self, id: u16) -> Option<&str>
```

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

### Enable Tiling

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/builder/struct.GeoTiffBuilder.html?search=

Enable tiling with specified tile dimensions. Tile dimensions must be multiples of 16.

```rust
pub fn tile_size(self, tile_width: u32, tile_height: u32) -> Self
```

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

### Get Double Value(s) for GeoKey

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/struct.GeoKeyDirectory.html

Retrieves a slice of f64 values associated with a given GeoKey ID.

```rust
pub fn get_double(&self, id: u16) -> Option<&[f64]>
```

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

### Get Short Value for GeoKey

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/struct.GeoKeyDirectory.html

Retrieves the short integer value associated with a given GeoKey ID.

```rust
pub fn get_short(&self, id: u16) -> Option<u16>
```

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

### CogBuilder::new

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/cog/struct.CogBuilder.html?search=

Creates a new CogBuilder instance. Tiling is required for COG; if not set, it defaults to 256x256.

```APIDOC
## CogBuilder::new

### Description
Create a COG builder from a GeoTiffBuilder. Tiling is required for COG; if not set, defaults to 256x256.

### Signature
`pub fn new(builder: GeoTiffBuilder) -> Self`
```

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

### CogBuilder::new

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/cog/struct.CogBuilder.html?search=std%3A%3Avec

Creates a new CogBuilder instance. Tiling is required for COG; if not set, defaults to 256x256.

```APIDOC
## CogBuilder::new

### Description
Creates a COG builder from a GeoTiffBuilder. Tiling is required for COG; if not set, defaults to 256x256.

### Method
`new(builder: GeoTiffBuilder) -> Self`

### Parameters
* `builder` (GeoTiffBuilder) - The GeoTiffBuilder to use for creating the COG builder.
```

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

### CogBuilder::new

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/cog/struct.CogBuilder.html?search=u32+-%3E+bool

Creates a new CogBuilder instance. Tiling is required for COG; if not set, defaults to 256x256.

```APIDOC
## CogBuilder::new

### Description
Create a COG builder from a GeoTiffBuilder. Tiling is required for COG; if not set, defaults to 256x256.

### Method
`new`

### Parameters
* `builder` (GeoTiffBuilder) - The GeoTiffBuilder to use for creating the CogBuilder.
```

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

### Unwrap Err value

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html?search=u32+-%3E+bool

Use `unwrap_err()` to get the contained `Err` value. This method panics if the `Result` is an `Ok`.

```rust
let x: Result<u32, &str> = Err("emergency failure");
assert_eq!(x.unwrap_err(), "emergency failure");
```

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

### Unwrap Ok value

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html?search=u32+-%3E+bool

Use `unwrap()` to get the contained `Ok` value. This method panics if the `Result` is an `Err`.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.unwrap(), 2);
```

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

### i64 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html

Provides WriteSample implementation for i64. Sets SAMPLE_FORMAT to 2 (int), BITS_PER_SAMPLE to 64, and BYTES_PER_SAMPLE to 8. Includes methods for encode_slice and lerc_encode_block. Note that lerc_encode_block for i64 returns an error as it's not supported by LERC.

```rust
const SAMPLE_FORMAT: u16 = 2

const BITS_PER_SAMPLE: u16 = 64

const BYTES_PER_SAMPLE: usize = 8

fn encode_slice(samples: &[i64], byte_order: ByteOrder) -> Vec<u8>

fn lerc_encode_block(
    _samples: &[i64],
    _width: u32,
    _height: u32,
    _depth: u32,
    _max_z_error: f64,
    index: usize,
) -> Result<Vec<u8>, Error>
```

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

### i64 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html?search=

Provides WriteSample implementation for i64, setting sample format to int, bits per sample to 64, and bytes per sample to 8. Note that LERC encoding is not supported for i64 and will return an error.

```rust
impl TiffWriteSample for i64 {
    const SAMPLE_FORMAT: u16 = 2;
    const BITS_PER_SAMPLE: u16 = 64;
    const BYTES_PER_SAMPLE: usize = 8;

    fn encode_slice(samples: &[i64], byte_order: ByteOrder) -> Vec<u8>;
    fn lerc_encode_block(
        _samples: &[i64],
        _width: u32,
        _height: u32,
        _depth: u32,
        _max_z_error: f64,
        index: usize,
    ) -> Result<Vec<u8>, Error>;
}
```

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

### Type ID Implementation

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/cog/struct.CogTileWriter.html?search=

Provides the `type_id` method, which gets the `TypeId` of the current instance. This is part of the `Any` trait implementation.

```rust
fn type_id(&self) -> TypeId
```

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

### Create Streaming Tile Writer for File

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/builder/struct.GeoTiffBuilder.html

Creates a streaming tile writer that specifically writes to a file path. Requires the sample type to implement NumericSample.

```rust
pub fn tile_writer_file<T: NumericSample, P: AsRef<Path>>(
    &self,
    path: P,
) -> Result<StreamingTileWriter<T, BufWriter<File>>>
```

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

### Undefined Behavior Example: Unchecked Err Unwrap on Ok

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html?search=std%3A%3Avec

Illustrates the undefined behavior that occurs when `unwrap_err_unchecked` is called on a `Result` that is `Ok`.

```rust
let x: Result<u32, &str> = Ok(2);
unsafe { x.unwrap_err_unchecked() }; // Undefined behavior!
```

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

### Undefined Behavior Example: Unchecked Ok Unwrap on Err

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html?search=std%3A%3Avec

Illustrates the undefined behavior that occurs when `unwrap_unchecked` is called on a `Result` that is `Err`.

```rust
let x: Result<u32, &str> = Err("emergency failure");
unsafe { x.unwrap_unchecked() }; // Undefined behavior!
```

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

### i32 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html

Provides WriteSample implementation for i32. Sets SAMPLE_FORMAT to 2 (int), BITS_PER_SAMPLE to 32, and BYTES_PER_SAMPLE to 4. Includes methods for encode_slice and lerc_encode_block.

```rust
const SAMPLE_FORMAT: u16 = 2

const BITS_PER_SAMPLE: u16 = 32

const BYTES_PER_SAMPLE: usize = 4

fn encode_slice(samples: &[i32], byte_order: ByteOrder) -> Vec<u8>

fn lerc_encode_block(
    samples: &[i32],
    width: u32,
    height: u32,
    depth: u32,
    max_z_error: f64,
    index: usize,
) -> Result<Vec<u8>, Error>
```

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

### Create Disk-Backed CogTileWriter

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/cog/struct.CogBuilder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a disk-backed `CogTileWriter` for incrementally writing COG tiles. This method takes a `Write + Seek` target as the sink.

```rust
pub fn tile_writer<T: NumericSample, W: Write + Seek>( &self, sink: W, ) -> Result<CogTileWriter<T, W>>
```

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

### Set Planar Configuration

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/builder/struct.GeoTiffBuilder.html?search=

Set the planar configuration for multi-band output.

```rust
pub fn planar_configuration( self, planar_configuration: PlanarConfiguration, ) -> Self
```

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

### Create New GeoKeyDirectory

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/struct.GeoKeyDirectory.html

Creates an empty GeoKeyDirectory with the default version (1.1.0).

```rust
pub fn new() -> GeoKeyDirectory
```

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

### Collecting Results from an Iterator (Failure Case)

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html?search=

When an `Err` is encountered during collection, `collect` stops processing and returns that `Err`. This example demonstrates underflow detection during subtraction.

```rust
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));
```

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

### Getting references from Result with as_ref()

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html?search=u32+-%3E+bool

The `as_ref()` method converts a `&Result<T, E>` into a `Result<&T, &E>`, providing references to the contained values without consuming the original Result.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

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

### i32 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implementation of WriteSample for i32, setting sample format to int, bits per sample to 32, and bytes per sample to 4.

```rust
impl TiffWriteSample for i32 {
    const SAMPLE_FORMAT: u16 = 2;
    const BITS_PER_SAMPLE: u16 = 32;
    const BYTES_PER_SAMPLE: usize = 4;

    fn encode_slice(samples: &[i32], byte_order: ByteOrder) -> Vec<u8> {
        // ... implementation details ...
    }

    fn lerc_encode_block(
        samples: &[i32],
        width: u32,
        height: u32,
        depth: u32,
        max_z_error: f64,
        index: usize,
    ) -> Result<Vec<u8>, Error> {
        // ... implementation details ...
    }
}
```

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

### i16 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html

Provides WriteSample implementation for i16. Sets SAMPLE_FORMAT to 2 (int), BITS_PER_SAMPLE to 16, and BYTES_PER_SAMPLE to 2. Includes methods for encode_slice and lerc_encode_block.

```rust
const SAMPLE_FORMAT: u16 = 2

const BITS_PER_SAMPLE: u16 = 16

const BYTES_PER_SAMPLE: usize = 2

fn encode_slice(samples: &[i16], byte_order: ByteOrder) -> Vec<u8>

fn lerc_encode_block(
    samples: &[i16],
    width: u32,
    height: u32,
    depth: u32,
    max_z_error: f64,
    index: usize,
) -> Result<Vec<u8>, Error>
```

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

### Converting Result to Iterator (Err Case)

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html?search=

When `into_iter` is called on an `Err` variant of `Result`, the resulting iterator is empty. This example demonstrates collecting an `Err` into an empty vector.

```rust
let x: Result<u32, &str> = Err("nothing!");
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, []);
```

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

### Getting Metadata with `and_then`

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html?search=u32+-%3E+bool

Demonstrates using `and_then` to chain fallible operations like retrieving file metadata and its modification time. Handles potential errors like 'NotFound'.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

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

### i32 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/trait.WriteSample.html?search=std%3A%3Avec

Provides WriteSample functionality for i32, including TIFF sample format, bits per sample, bytes per sample, and encoding methods.

```rust
const SAMPLE_FORMAT: u16 = 2
const BITS_PER_SAMPLE: u16 = 32
const BYTES_PER_SAMPLE: usize = 4
fn encode_slice(samples: &[i32], byte_order: ByteOrder) -> Vec<u8>
fn lerc_encode_block(
    samples: &[i32],
    width: u32,
    height: u32,
    depth: u32,
    max_z_error: f64,
    index: usize,
) -> Result<Vec<u8>, Error>
```

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

### Initialize GeoTiffBuilder

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/builder/struct.GeoTiffBuilder.html?search=

Create a new builder for a raster with specified width and height.

```rust
pub fn new(width: u32, height: u32) -> Self
```

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

### Get Ok value or default

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html?search=u32+-%3E+bool

Use `unwrap_or_default()` to return the contained `Ok` value or the default value for the type if it's an `Err`. This is useful for converting fallible operations into fallbacks.

```rust
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().unwrap_or_default();
let bad_year = bad_year_from_input.parse().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);
```

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

### Getting mutable references from Result with as_mut()

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html?search=u32+-%3E+bool

The `as_mut()` method converts a `&mut Result<T, E>` into a `Result<&mut T, &mut E>`, providing mutable references to the contained values.

```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

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

### f64 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html

Provides WriteSample implementation for f64. Sets SAMPLE_FORMAT to 3 (float), BITS_PER_SAMPLE to 64, and BYTES_PER_SAMPLE to 8. Includes methods for encode_slice and lerc_encode_block.

```rust
const SAMPLE_FORMAT: u16 = 3

const BITS_PER_SAMPLE: u16 = 64

const BYTES_PER_SAMPLE: usize = 8

fn encode_slice(samples: &[f64], byte_order: ByteOrder) -> Vec<u8>

fn lerc_encode_block(
    samples: &[f64],
    width: u32,
    height: u32,
    depth: u32,
    max_z_error: f64,
    index: usize,
) -> Result<Vec<u8>, Error>
```

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

### GeoTiffBuilder::new

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/builder/struct.GeoTiffBuilder.html?search=u32+-%3E+bool

Initializes a new GeoTiffBuilder with specified width and height for the raster.

```APIDOC
## GeoTiffBuilder::new

### Description
Create a new builder for a raster of the given dimensions.

### Method
`new(width: u32, height: u32) -> Self`

### Parameters
* **width** (u32) - Required - The width of the raster.
* **height** (u32) - Required - The height of the raster.
```

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

### Set Overview Levels

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/cog/struct.CogBuilder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Configures the resolution levels for overviews in the COG file. For example, `vec![2, 4, 8]` specifies overviews at 1/2, 1/4, and 1/8 resolutions.

```rust
pub fn overview_levels(self, levels: Vec<u32>) -> Self
```

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

### f32 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html?search=

Provides WriteSample implementation for f32, setting sample format to float, bits per sample to 32, and bytes per sample to 4. Includes methods for encoding slices and LERC blocks.

```rust
impl TiffWriteSample for f32 {
    const SAMPLE_FORMAT: u16 = 3;
    const BITS_PER_SAMPLE: u16 = 32;
    const BYTES_PER_SAMPLE: usize = 4;

    fn encode_slice(samples: &[f32], byte_order: ByteOrder) -> Vec<u8>;
    fn lerc_encode_block(
        samples: &[f32],
        width: u32,
        height: u32,
        depth: u32,
        max_z_error: f64,
        index: usize,
    ) -> Result<Vec<u8>, Error>;
}
```

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

### f32 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html

Provides WriteSample implementation for f32. Sets SAMPLE_FORMAT to 3 (float), BITS_PER_SAMPLE to 32, and BYTES_PER_SAMPLE to 4. Includes methods for encode_slice and lerc_encode_block.

```rust
const SAMPLE_FORMAT: u16 = 3

const BITS_PER_SAMPLE: u16 = 32

const BYTES_PER_SAMPLE: usize = 4

fn encode_slice(samples: &[f32], byte_order: ByteOrder) -> Vec<u8>

fn lerc_encode_block(
    samples: &[f32],
    width: u32,
    height: u32,
    depth: u32,
    max_z_error: f64,
    index: usize,
) -> Result<Vec<u8>, Error>
```

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

### Collecting Results from an Iterator (Success Case)

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html?search=

Use `collect` to aggregate results from an iterator. If all elements are `Ok`, a container with the unwrapped values is returned. This example checks for integer overflow during addition.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32|
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

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

### Converting Result to Iterator (Ok Case)

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html?search=

The `into_iter` method on `Result` yields the contained value if it's `Ok`, otherwise it yields nothing. This example shows collecting an `Ok` value into a vector.

```rust
let x: Result<u32, &str> = Ok(5);
let v: Vec<u32> = x.into_iter().collect();
assert_eq!(v, [5]);
```

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

### i32 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/trait.WriteSample.html?search=u32+-%3E+bool

Provides WriteSample functionality for i32, including constants and methods for encoding.

```rust
impl TiffWriteSample for i32

    const SAMPLE_FORMAT: u16 = 2
    const BITS_PER_SAMPLE: u16 = 32
    const BYTES_PER_SAMPLE: usize = 4

    fn encode_slice(samples: &[i32], byte_order: ByteOrder) -> Vec<u8>

    fn lerc_encode_block(
        samples: &[i32],
        width: u32,
        height: u32,
        depth: u32,
        max_z_error: f64,
        index: usize,
    ) -> Result<Vec<u8>, Error>
```

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

### Sum of Iterator Items with Result

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html

Calculates the sum of items in an iterator where each item is a Result. If any item is an Err, it's returned immediately. Otherwise, the sum of all Ok values is returned. This example specifically rejects negative numbers.

```rust
let f = |&x: &i32| if x < 0 { Err("Negative element found") } else { Ok(x) };
let v = vec![1, 2];
let res: Result<i32, _> = v.iter().map(f).sum();
assert_eq!(res, Ok(3));
```

```rust
let f = |&x: &i32| if x < 0 { Err("Negative element found") } else { Ok(x) };
let v = vec![1, -2];
let res: Result<i32, _> = v.iter().map(f).sum();
assert_eq!(res, Err("Negative element found"));
```

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

### i16 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implementation of WriteSample for i16, setting sample format to int, bits per sample to 16, and bytes per sample to 2.

```rust
impl TiffWriteSample for i16 {
    const SAMPLE_FORMAT: u16 = 2;
    const BITS_PER_SAMPLE: u16 = 16;
    const BYTES_PER_SAMPLE: usize = 2;

    fn encode_slice(samples: &[i16], byte_order: ByteOrder) -> Vec<u8> {
        // ... implementation details ...
    }

    fn lerc_encode_block(
        samples: &[i16],
        width: u32,
        height: u32,
        depth: u32,
        max_z_error: f64,
        index: usize,
    ) -> Result<Vec<u8>, Error> {
        // ... implementation details ...
    }
}
```

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

### i8 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html

Provides WriteSample implementation for i8. Sets SAMPLE_FORMAT to 2 (int), BITS_PER_SAMPLE to 8, and BYTES_PER_SAMPLE to 1. Includes methods for encode_slice and lerc_encode_block.

```rust
const SAMPLE_FORMAT: u16 = 2

const BITS_PER_SAMPLE: u16 = 8

const BYTES_PER_SAMPLE: usize = 1

fn encode_slice(samples: &[i8], _byte_order: ByteOrder) -> Vec<u8>

fn lerc_encode_block(
    samples: &[i8],
    width: u32,
    height: u32,
    depth: u32,
    max_z_error: f64,
    index: usize,
) -> Result<Vec<u8>, Error>
```

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

### Create Disk-Backed CogTileWriter to File

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/cog/struct.CogBuilder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a disk-backed `CogTileWriter` specifically for writing to a file path. It utilizes a `BufWriter` for efficient file operations.

```rust
pub fn tile_writer_file<T: NumericSample, P: AsRef<Path>>( &self, path: P, ) -> Result<CogTileWriter<T, BufWriter<File>>>
```

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

### i8 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implementation of WriteSample for i8, setting sample format to int, bits per sample to 8, and bytes per sample to 1.

```rust
impl TiffWriteSample for i8 {
    const SAMPLE_FORMAT: u16 = 2;
    const BITS_PER_SAMPLE: u16 = 8;
    const BYTES_PER_SAMPLE: usize = 1;

    fn encode_slice(samples: &[i8], _byte_order: ByteOrder) -> Vec<u8> {
        // ... implementation details ...
    }

    fn lerc_encode_block(
        samples: &[i8],
        width: u32,
        height: u32,
        depth: u32,
        max_z_error: f64,
        index: usize,
    ) -> Result<Vec<u8>, Error> {
        // ... implementation details ...
    }
}
```

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

### u16 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implementation of WriteSample for u16, setting sample format to uint, bits per sample to 16, and bytes per sample to 2.

```rust
impl TiffWriteSample for u16 {
    const SAMPLE_FORMAT: u16 = 1;
    const BITS_PER_SAMPLE: u16 = 16;
    const BYTES_PER_SAMPLE: usize = 2;

    fn encode_slice(samples: &[u16], byte_order: ByteOrder) -> Vec<u8> {
        // ... implementation details ...
    }

    fn lerc_encode_block(
        samples: &[u16],
        width: u32,
        height: u32,
        depth: u32,
        max_z_error: f64,
        index: usize,
    ) -> Result<Vec<u8>, Error> {
        // ... implementation details ...
    }
}
```

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

### Set JPEG Compression Options

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/builder/struct.GeoTiffBuilder.html?search=

Set JPEG compression with specific options. This also sets compression to Jpeg and predictor to None. Multi-band JPEG requires planar configuration.

```rust
pub fn jpeg_options(self, options: JpegOptions) -> Self
```

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

### f64 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implementation of WriteSample for f64, setting sample format to float, bits per sample to 64, and bytes per sample to 8.

```rust
impl TiffWriteSample for f64 {
    const SAMPLE_FORMAT: u16 = 3;
    const BITS_PER_SAMPLE: u16 = 64;
    const BYTES_PER_SAMPLE: usize = 8;

    fn encode_slice(samples: &[f64], byte_order: ByteOrder) -> Vec<u8> {
        // ... implementation details ...
    }

    fn lerc_encode_block(
        samples: &[f64],
        width: u32,
        height: u32,
        depth: u32,
        max_z_error: f64,
        index: usize,
    ) -> Result<Vec<u8>, Error> {
        // ... implementation details ...
    }
}
```

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

### i64 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/trait.WriteSample.html?search=std%3A%3Avec

Provides WriteSample functionality for i64, including TIFF sample format, bits per sample, bytes per sample, and encoding methods. Note that LERC encoding is not supported for i64.

```rust
const SAMPLE_FORMAT: u16 = 2
const BITS_PER_SAMPLE: u16 = 64
const BYTES_PER_SAMPLE: usize = 8
fn encode_slice(samples: &[i64], byte_order: ByteOrder) -> Vec<u8>
fn lerc_encode_block(
    _samples: &[i64],
    _width: u32,
    _height: u32,
    _depth: u32,
    _max_z_error: f64,
    index: usize,
) -> Result<Vec<u8>, Error>
```

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

### f32 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implementation of WriteSample for f32, setting sample format to float, bits per sample to 32, and bytes per sample to 4.

```rust
impl TiffWriteSample for f32 {
    const SAMPLE_FORMAT: u16 = 3;
    const BITS_PER_SAMPLE: u16 = 32;
    const BYTES_PER_SAMPLE: usize = 4;

    fn encode_slice(samples: &[f32], byte_order: ByteOrder) -> Vec<u8> {
        // ... implementation details ...
    }

    fn lerc_encode_block(
        samples: &[f32],
        width: u32,
        height: u32,
        depth: u32,
        max_z_error: f64,
        index: usize,
    ) -> Result<Vec<u8>, Error> {
        // ... implementation details ...
    }
}
```

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

### u16 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html

Provides WriteSample implementation for u16. Sets SAMPLE_FORMAT to 1 (uint), BITS_PER_SAMPLE to 16, and BYTES_PER_SAMPLE to 2. Includes methods for encode_slice and lerc_encode_block.

```rust
const SAMPLE_FORMAT: u16 = 1

const BITS_PER_SAMPLE: u16 = 16

const BYTES_PER_SAMPLE: usize = 2

fn encode_slice(samples: &[u16], byte_order: ByteOrder) -> Vec<u8>

fn lerc_encode_block(
    samples: &[u16],
    width: u32,
    height: u32,
    depth: u32,
    max_z_error: f64,
    index: usize,
) -> Result<Vec<u8>, Error>
```

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

### Create Streaming Tile Writer

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/builder/struct.GeoTiffBuilder.html

Creates a streaming tile writer for incremental writes to a Write+Seek target. Requires the sample type to implement NumericSample.

```rust
pub fn tile_writer<T: NumericSample, W: Write + Seek>(
    &self,
    sink: W,
) -> Result<StreamingTileWriter<T, W>>
```

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

### u8 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Implementation of WriteSample for u8, setting sample format to uint, bits per sample to 8, and bytes per sample to 1.

```rust
impl TiffWriteSample for u8 {
    const SAMPLE_FORMAT: u16 = 1;
    const BITS_PER_SAMPLE: u16 = 8;
    const BYTES_PER_SAMPLE: usize = 1;

    fn encode_slice(samples: &[u8], _byte_order: ByteOrder) -> Vec<u8> {
        // ... implementation details ...
    }

    fn lerc_encode_block(
        samples: &[u8],
        width: u32,
        height: u32,
        depth: u32,
        max_z_error: f64,
        index: usize,
    ) -> Result<Vec<u8>, Error> {
        // ... implementation details ...
    }
}
```

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

### f32 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/trait.WriteSample.html?search=std%3A%3Avec

Provides WriteSample functionality for f32, including TIFF sample format, bits per sample, bytes per sample, and encoding methods.

```rust
const SAMPLE_FORMAT: u16 = 3
const BITS_PER_SAMPLE: u16 = 32
const BYTES_PER_SAMPLE: usize = 4
fn encode_slice(samples: &[f32], byte_order: ByteOrder) -> Vec<u8>
fn lerc_encode_block(
    samples: &[f32],
    width: u32,
    height: u32,
    depth: u32,
    max_z_error: f64,
    index: usize,
) -> Result<Vec<u8>, Error>
```

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

### f64 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/trait.WriteSample.html?search=u32+-%3E+bool

Provides WriteSample functionality for f64, including constants and methods for encoding.

```rust
impl TiffWriteSample for f64

    const SAMPLE_FORMAT: u16 = 3
    const BITS_PER_SAMPLE: u16 = 64
    const BYTES_PER_SAMPLE: usize = 8

    fn encode_slice(samples: &[f64], byte_order: ByteOrder) -> Vec<u8>

    fn lerc_encode_block(
        samples: &[f64],
        width: u32,
        height: u32,
        depth: u32,
        max_z_error: f64,
        index: usize,
    ) -> Result<Vec<u8>, Error>
```

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

### f64 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/trait.WriteSample.html?search=std%3A%3Avec

Provides WriteSample functionality for f64, including TIFF sample format, bits per sample, bytes per sample, and encoding methods.

```rust
const SAMPLE_FORMAT: u16 = 3
const BITS_PER_SAMPLE: u16 = 64
const BYTES_PER_SAMPLE: usize = 8
fn encode_slice(samples: &[f64], byte_order: ByteOrder) -> Vec<u8>
fn lerc_encode_block(
    samples: &[f64],
    width: u32,
    height: u32,
    depth: u32,
    max_z_error: f64,
    index: usize,
) -> Result<Vec<u8>, Error>
```

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

### f32 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/trait.WriteSample.html?search=u32+-%3E+bool

Provides WriteSample functionality for f32, including constants and methods for encoding.

```rust
impl TiffWriteSample for f32

    const SAMPLE_FORMAT: u16 = 3
    const BITS_PER_SAMPLE: u16 = 32
    const BYTES_PER_SAMPLE: usize = 4

    fn encode_slice(samples: &[f32], byte_order: ByteOrder) -> Vec<u8>

    fn lerc_encode_block(
        samples: &[f32],
        width: u32,
        height: u32,
        depth: u32,
        max_z_error: f64,
        index: usize,
    ) -> Result<Vec<u8>, Error>
```

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

### i16 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/trait.WriteSample.html?search=std%3A%3Avec

Provides WriteSample functionality for i16, including TIFF sample format, bits per sample, bytes per sample, and encoding methods.

```rust
const SAMPLE_FORMAT: u16 = 2
const BITS_PER_SAMPLE: u16 = 16
const BYTES_PER_SAMPLE: usize = 2
fn encode_slice(samples: &[i16], byte_order: ByteOrder) -> Vec<u8>
fn lerc_encode_block(
    samples: &[i16],
    width: u32,
    height: u32,
    depth: u32,
    max_z_error: f64,
    index: usize,
) -> Result<Vec<u8>, Error>
```

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

### u8 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/sample/trait.WriteSample.html?search=

Provides WriteSample implementation for u8, setting sample format to uint, bits per sample to 8, and bytes per sample to 1. Includes methods for encoding slices and LERC blocks.

```rust
impl TiffWriteSample for u8 {
    const SAMPLE_FORMAT: u16 = 1;
    const BITS_PER_SAMPLE: u16 = 8;
    const BYTES_PER_SAMPLE: usize = 1;

    fn encode_slice(samples: &[u8], _byte_order: ByteOrder) -> Vec<u8>;
    fn lerc_encode_block(
        samples: &[u8],
        width: u32,
        height: u32,
        depth: u32,
        max_z_error: f64,
        index: usize,
    ) -> Result<Vec<u8>, Error>;
}
```

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

### i8 Implementation for WriteSample

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/trait.WriteSample.html?search=std%3A%3Avec

Provides WriteSample functionality for i8, including TIFF sample format, bits per sample, bytes per sample, and encoding methods.

```rust
const SAMPLE_FORMAT: u16 = 2
const BITS_PER_SAMPLE: u16 = 8
const BYTES_PER_SAMPLE: usize = 1
fn encode_slice(samples: &[i8], _byte_order: ByteOrder) -> Vec<u8>
fn lerc_encode_block(
    samples: &[i8],
    width: u32,
    height: u32,
    depth: u32,
    max_z_error: f64,
    index: usize,
) -> Result<Vec<u8>, Error>
```

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

### into_ok

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/error/type.Result.html?search=u32+-%3E+bool

Returns the contained `Ok` value, but never panics. This is an experimental API.

```APIDOC
## into_ok

### Description
Returns the contained `Ok` value, but never panics. This is an experimental API.

### Method
`into_ok`

### Parameters
None

### Response
- `T`: The contained `Ok` value.

### Examples
```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```
```

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

### Set Overview Storage Method

Source: https://docs.rs/geotiff-writer/0.5.0/geotiff_writer/cog/struct.CogBuilder.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Determines how the overview Image File Directories (IFDs) are referenced within the COG file.

```rust
pub fn overview_storage(self, storage: OverviewStorage) -> Self
```
Tokens:
Raw