Struct cgats::Cgats

pub struct Cgats { /* private fields */ }

The CGATS data

Implementations

impl Cgats

pub fn delta(&self, other: &Self, method: DEMethod) -> Result<Self>

Calculate the DeltaE between each value of two CGATS data sets. Returns an error if either of the two sets do not contain Lab data.

pub fn de_report( &self, other: &Self, method: DEMethod, upper_pct: f32 ) -> Result<DeReport>

Calculate DeltaE and generate a report

pub fn can_delta(&self, other: &Self) -> Result<()>

Determine if it is possible to calculate DeltaE between two CGATS data sets.

impl Cgats

pub fn new() -> Self

Creates a new empty Cgats object

pub fn with_capacity(cap: usize) -> Self

Creates a new empty Cgats object with the specified capacity

pub fn summary(&self) -> String

Returns a summary string:

Vendor[ColorTypes; n]

use cgats::Cgats;

let cgats: Cgats =
"CGATS.17
BEGIN_DATA_FORMAT
SAMPLE_ID	RGB_R	RGB_G	RGB_B
END_DATA_FORMAT
BEGIN_DATA
1	0	0	0
2	128	128	128
3	255	255	255
END_DATA"
.parse().unwrap();

assert_eq!(cgats.summary(), "Cgats[Rgb; 3]");

pub fn vendor(&self) -> &Vendor

Returns a reference the Vendor

pub fn get_metadata<'a>(&'a self, key: &str) -> Option<&'a str>

Find the MetaData value by key

use cgats::Cgats;

let cgats: Cgats =
"CGATS.17
NUMBER_OF_FIELDS 4
BEGIN_DATA_FORMAT
SAMPLE_ID	RGB_R	RGB_G	RGB_B
END_DATA_FORMAT
NUMBER_OF_SETS 3
BEGIN_DATA
1	0	0	0
2	128	128	128
3	255	255	255
END_DATA"
.parse().unwrap();

assert_eq!(cgats.get_metadata("NUMBER_OF_FIELDS"), Some("4"));
assert_eq!(cgats.get_metadata("NUMBER_OF_SETS"), Some("3"));

pub fn get_metadata_mut(&mut self, key: &str) -> Option<&mut String>

Returns a mutable reference to a metadata value by key

pub fn insert_metadata_keyval<S: ToString, T: ToString>( &mut self, key: S, val: T )

Insert a MetaData Key:Value, overwriting if it exists

pub fn iter(&self) -> impl Iterator<Item = &DataPoint>

Iterator over the DataPoints in a Cgats object

pub fn iter_with_fields(&self) -> impl Iterator<Item = (&Field, &DataPoint)>

Iterator over the DataPoints with their corresponding Field keys

use cgats::{Cgats, Field::*, DataPoint::*};

let cgats: Cgats =
"CGATS.17
BEGIN_DATA_FORMAT
SAMPLE_ID	DE2000
END_DATA_FORMAT
BEGIN_DATA
1	1.23
2	3.21
END_DATA"
.parse().unwrap();

let mut iter = cgats.iter_with_fields();

assert_eq!(iter.next(), Some((&SAMPLE_ID, &Int(1))));
assert_eq!(iter.next(), Some((&DE_2000, &Float(1.23))));
assert_eq!(iter.next(), Some((&SAMPLE_ID, &Int(2))));
assert_eq!(iter.next(), Some((&DE_2000, &Float(3.21))));
assert_eq!(iter.next(), None);

pub fn iter_mut_with_fields( &mut self ) -> impl Iterator<Item = (Field, &mut DataPoint)>

Mutable iterator over the DataPoints with their corresponding Field keys. Field values are cloned.

use cgats::{Cgats, Field::*, DataPoint::*};

let mut cgats: Cgats =
"CGATS.17
BEGIN_DATA_FORMAT
SAMPLE_ID	DE2000
END_DATA_FORMAT
BEGIN_DATA
1	1.23
2	3.21
END_DATA"
.parse().unwrap();

{
    let mut iter = cgats.iter_mut_with_fields();
    
    assert_eq!(iter.next(), Some((SAMPLE_ID, &mut Int(1))));
    assert_eq!(iter.next(), Some((DE_2000, &mut Float(1.23))));
    assert_eq!(iter.next(), Some((SAMPLE_ID, &mut Int(2))));
    
    if let Some((_field, data_point)) = iter.next() {
        *data_point = Float(4.56);
    }
    
    assert_eq!(iter.next(), None);
}

assert_eq!(cgats[3], Float(4.56));

pub fn fields(&self) -> impl Iterator<Item = &Field>

Iterator over the fields of the DataFormat

pub fn fields_mut(&mut self) -> impl Iterator<Item = &mut Field>

Mutable iterator over the fields of the DataFormat

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut DataPoint>

Mutable iterator over the DataPoints in a Cgats object

pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self>

Read a file into a Cgats object

pub fn to_file<P: AsRef<Path>>(&self, path: P) -> Result<()>

Write a Cgats object to a file

pub fn write<W: Write>(&self, writer: &mut W) -> Result<()>

Write a Cgats object to a Write object

pub fn len(&self) -> usize

Returns the total number of data points in the set (rows x cols)

pub fn is_empty(&self) -> bool

Returns true if self.len() == 0

pub fn n_rows(&self) -> usize

Returns the total number of rows (samples) in the set

pub fn n_cols(&self) -> usize

Returns the total number of columns (fields) in the set

pub fn get_row(&self, row: usize) -> Option<impl Iterator<Item = &DataPoint>>

Iterator over the data points in a given sample row

pub fn get_row_by_values<F: AsRef<Field>, D: AsRef<DataPoint>>( &self, fields_values: &[(F, D)] ) -> Option<impl Iterator<Item = &DataPoint>>

Returns the first row containing the given values

pub fn get_row_index_by_values<F: AsRef<Field>, D: AsRef<DataPoint>>( &self, fields_values: &[(F, D)] ) -> Option<usize>

Returns a row index to the first row containing the given values

pub fn remove_row( &mut self, row: usize ) -> Option<impl Iterator<Item = DataPoint> + '_>

Remove a row from a sample set by row index and return the row. Returns none if the row index is greater than or equal to the number of rows.

use cgats::Cgats;

let mut cgats: Cgats =
"CGATS.17
BEGIN_DATA_FORMAT
SAMPLE_ID	DE2000
END_DATA_FORMAT
BEGIN_DATA
1	1.23
2	3.21
3	4.56
END_DATA"
.parse().unwrap();

{
    let mut row = cgats.remove_row(1).unwrap();
    assert_eq!(row.next().unwrap(), 2);
    assert_eq!(row.next().unwrap(), 3.21);
    assert_eq!(row.next(), None);
}

{
    let mut row = cgats.remove_row(1).unwrap();
    assert_eq!(row.next().unwrap(), 3);
    assert_eq!(row.next().unwrap(), 4.56);
    assert_eq!(row.next(), None);
}

{
    assert!(cgats.remove_row(1).is_none());
}

pub fn move_row(&mut self, from_row: usize, to_row: usize) -> Result<()>

Move a row from one row index to another. Returns an error if the indices are out of range

use cgats::Cgats;

let mut cgats: Cgats =
"CGATS.17
BEGIN_DATA_FORMAT
SAMPLE_ID	DE2000
END_DATA_FORMAT
BEGIN_DATA
1	1.23
2	3.21
3	4.56
END_DATA"
.parse().unwrap();

cgats.move_row(2, 1).unwrap();

{
    let mut last_row = cgats.get_row(2).unwrap();
    assert_eq!(last_row.next().unwrap(), &2);
    assert_eq!(last_row.next().unwrap(), &3.21);
    assert_eq!(last_row.next(), None);
}

cgats.move_row(0, 2).unwrap();

{
    let mut last_row = cgats.get_row(2).unwrap();
    assert_eq!(last_row.next().unwrap(), &1);
    assert_eq!(last_row.next().unwrap(), &1.23);
    assert_eq!(last_row.next(), None);
}

pub fn transpose_chart(&mut self, chart_width: usize)

Re-order rows to transpose for chart layouts with a given current chart width (LGOROWLENGTH)

pub fn get_row_mut( &mut self, row: usize ) -> impl Iterator<Item = &mut DataPoint>

Iterator of mutable references to data points in a given sample row

pub fn rows(&self) -> impl Iterator<Item = impl Iterator<Item = &DataPoint>>

Iterator over the rows of DataPoints

pub fn get_col(&self, col: usize) -> impl Iterator<Item = &DataPoint>

Returns an iterator over the data points in a given column (field)

pub fn get_col_by_field( &self, field: &Field ) -> Option<impl Iterator<Item = &DataPoint>>

Find a column by it’s Field. Returns None if the Field does not exist.

pub fn get_col_mut( &mut self, col: usize ) -> impl Iterator<Item = &mut DataPoint>

Iterator of mutable references to data points in a given column (field)

pub fn get_col_mut_by_field( &mut self, field: &Field ) -> Option<impl Iterator<Item = &mut DataPoint>>

Find a mutable column by it’s Field. Returns None if the Field does not exist.

pub fn cols(&self) -> impl Iterator<Item = impl Iterator<Item = &DataPoint>>

Iterator over the columns of DataPoints

pub fn cols_with_fields( &self ) -> impl Iterator<Item = (&Field, impl Iterator<Item = &DataPoint>)>

Iterator over columns of DataPoints with their corresponding Fields

pub fn color_types(&self) -> Vec<ColorType>

Returns a list of ColorTypes based on the contents of the DATA_FORMAT

pub fn has_color_type(&self, color_type: &ColorType) -> bool

Determines if the data contains a ColorType

pub fn reindex_sample_id(&mut self)

Re-number the SAMPLE_ID field starting from 0

pub fn reindex_sample_id_at(&mut self, start: usize)

Re-number the SAMPLE_ID field starting from a given integer

pub fn index_by_field(&self, field: &Field) -> Option<usize>

Returns the position of a column with a given Field

Returns None if the DataFormat does not contain the Field

pub fn insert_column( &mut self, index: usize, label: Field, iter: impl Iterator<Item = DataPoint> ) -> Result<()>

Insert a column of DataPoints

pub fn push_column( &mut self, field: Field, iter: impl Iterator<Item = DataPoint> ) -> Result<()>

Append a column of DataPoints

pub fn insert_row( &mut self, index: usize, iter: impl Iterator<Item = DataPoint> ) -> Result<()>

Insert a row of DataPoints at a row index

pub fn push_row(&mut self, iter: impl Iterator<Item = DataPoint>) -> Result<()>

Append a row of DataPoints

pub fn append(&mut self, other: &Cgats) -> Result<()>

Append the rows from another Cgats. Returns an error if the DataFormats do not match.

pub fn concatenate<'a>( root: &Cgats, other: impl Iterator<Item = &'a Cgats> ) -> Result<Self>

Concatenate the rows from multiple Cgats

pub fn to_colorburst(&self) -> Result<Self>

Convert the CGATS to a ColorBurst linearization format.

pub fn colorburst_to_cgats(&self) -> Result<Self>

Convert ColorBurst linearization format to a conventional CGATS format

Trait Implementations

impl CgatsFmt for Cgats

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

Format data to a fmt::Formatter

impl Clone for Cgats

fn clone(&self) -> Cgats

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Cgats

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

Formats the value using the given formatter.

impl Default for Cgats

fn default() -> Self

Returns the “default value” for a type.

impl Display for Cgats

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

Formats the value using the given formatter.

impl FromStr for Cgats

type Err = Box<dyn Error>

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self>

Parses a string s to return a value of this type.

impl Index<(usize, usize)> for Cgats

fn index(&self, index: (usize, usize)) -> &Self::Output

Index into Cgats by (column, row)

use cgats::Cgats;

let mut cgats: Cgats =
"CGATS.17
BEGIN_DATA_FORMAT
RGB_R	RGB_G	RGB_B
END_DATA_FORMAT
BEGIN_DATA
0	1	2
126	127	128
253	254	255
END_DATA"
.parse().unwrap();

assert_eq!(cgats[(0, 0)], 0);
assert_eq!(cgats[(2, 1)], 128);
assert_eq!(cgats[(2, 2)], 255);

type Output = DataPoint

The returned type after indexing.

impl Index<usize> for Cgats

fn index(&self, index: usize) -> &Self::Output

Index into Cgats by usize

use cgats::Cgats;

let mut cgats: Cgats =
"CGATS.17
BEGIN_DATA_FORMAT
RGB_R	RGB_G	RGB_B
END_DATA_FORMAT
BEGIN_DATA
0	1	2
126	127	128
253	254	255
END_DATA"
.parse().unwrap();

assert_eq!(cgats[0], 0);
assert_eq!(cgats[5], 128);
assert_eq!(cgats[8], 255);

type Output = DataPoint

The returned type after indexing.

impl IndexMut<(usize, usize)> for Cgats

fn index_mut(&mut self, index: (usize, usize)) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl IndexMut<usize> for Cgats

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl PartialAdd<Cgats> for Cgats

type Output = Cgats

The output of a successfull add

fn partial_add(&self, rhs: &Self) -> Option<Self::Output>

Try to add the two values

impl PartialDiv<usize> for Cgats

type Output = Cgats

The output of a successful division

fn partial_div(&self, rhs: &usize) -> Option<Self::Output>

Divides the values. Returns None if either value is not a type that can divide.

impl PartialEq for Cgats

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for Cgats

impl StructuralPartialEq for Cgats