Struct Raster 

pub struct Raster {
    pub endian: Endian,
    pub version: u16,
    pub scale_x: f64,
    pub scale_y: f64,
    pub ip_x: f64,
    pub ip_y: f64,
    pub skew_x: f64,
    pub skew_y: f64,
    pub srid: i32,
    pub width: u16,
    pub height: u16,
    pub bands: Vec<RasterBand>,
}

Raster data

Fields

endian: Endian

Endinanness, 1:ndr/little endian, 0:xdr/big endian

version: u16

format version (0 for this structure)

scale_x: f64

pixel width in geographical units

scale_y: f64

pixel height in geographical units

ip_x: f64

X ordinate of upper-left pixel’s upper-left corner in geographical units

ip_y: f64

Y ordinate of upper-left pixel’s upper-left corner in geographical units

skew_x: f64

rotation about Y-axis

skew_y: f64

rotation about X-axis

srid: i32

Spatial reference id

width: u16

Number of pixel columns

height: u16

Number of pixel rows

bands: Vec<RasterBand>

Bands data

Implementations

impl Raster

pub fn to_wkb_string(self) -> String

Outputs the raster as a Well-Known-Binary string, ready to be used in SQL statements

Examples found in repository

examples/test_runner.rs (line 23)

fn run_encode_test_inner(endian: Endian, input: InMemoryRasterData, width: u16, height: u16) {
    let setup = Raster {
        endian,
        version: 0,
        scale_x: 500.0,
        scale_y: 1.0,
        ip_x: 0.0,
        ip_y: 0.0,
        skew_x: 0.0,
        skew_y: 0.0,
        srid: 4326,
        width,
        height,
        bands: vec![RasterBand {
            is_nodata_value: false,
            data: RasterDataSource::InMemory(input),
        }],
    };

    let encoded = setup.clone().to_wkb_string();
    let decoded = Raster::from_wkb_string(&encoded.as_bytes()).unwrap();
    if decoded != setup {
        use std::process::exit;
        println!("expected: {:#?}\n\ngot:{:#?}", setup, decoded);
        exit(1);
    }
}

examples/write.rs (line 33)

fn main() {
    // 2x2 image bytes, u8 format
    let bytes = vec![
        vec![34, 40],
        vec![56, 0],
    ];

    let raster = Raster {
        endian: Endian::Big,    // note: currently Endian::Little is not supported in PostGIS
        version: 0,             // always set to 0
        scale_x: 500.0,           // pixel width in degrees
        scale_y: 1.0,           // pixel height in degrees
        ip_x: 0.0,              // upper left corner longitude in degrees
        ip_y: 0.0,              // upper left corner latitude in degrees
        skew_x: 0.0,            // rotation in degrees (0 to 360)
        skew_y: 0.0,            // rotation in degrees (0 to 360)
        srid: 4326,             // SRID EPSG identifier
        width: 2,               // pixel columns
        height: 2,              // rows
        bands: vec![RasterBand {
            is_nodata_value: false,                     // See documentation, usually false
            data: RasterDataSource::InMemory(
                InMemoryRasterData::UInt8 {
                    data: bytes,
                    nodata: None,
                }
            ),
        }],
    };

    println!("{}", raster.to_wkb_string());
}

pub fn from_wkb_string(string_bytes: &[u8]) -> Result<Self, ParseError>

Examples found in repository

examples/read.rs (line 5)

fn main() {
    let s = b"0000000001407F4000000000003FF00000000000000000000000000000000000000000000000000000000000000000000000000000000010E600020002040022283800";
    let raster = Raster::from_wkb_string(&s[..]);
    println!("raster: {:#?}", raster);
}

examples/test_runner.rs (line 24)

fn run_encode_test_inner(endian: Endian, input: InMemoryRasterData, width: u16, height: u16) {
    let setup = Raster {
        endian,
        version: 0,
        scale_x: 500.0,
        scale_y: 1.0,
        ip_x: 0.0,
        ip_y: 0.0,
        skew_x: 0.0,
        skew_y: 0.0,
        srid: 4326,
        width,
        height,
        bands: vec![RasterBand {
            is_nodata_value: false,
            data: RasterDataSource::InMemory(input),
        }],
    };

    let encoded = setup.clone().to_wkb_string();
    let decoded = Raster::from_wkb_string(&encoded.as_bytes()).unwrap();
    if decoded != setup {
        use std::process::exit;
        println!("expected: {:#?}\n\ngot:{:#?}", setup, decoded);
        exit(1);
    }
}

fn run_encode_test(input: InMemoryRasterData, width: u16, height: u16) {
    run_encode_test_inner(Endian::Big, input.clone(), width, height);
    run_encode_test_inner(Endian::Little, input, width, height);
}

fn run_decode_test(decode: &[u8]) {
    let _ = Raster::from_wkb_string(decode);
}

Trait Implementations

impl Clone for Raster

fn clone(&self) -> Raster

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Raster

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Raster

fn eq(&self, other: &Raster) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for Raster

fn partial_cmp(&self, other: &Raster) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Raster