Struct Volume 

pub struct Volume { /* private fields */ }

How loud a note is: music21’s volume.Volume.

Implementations

impl Volume

pub fn new() -> Self

A volume with no velocity of its own.

pub fn merge_attributes(&mut self, other: &Volume)

Takes everything another volume says, the velocity and whether it is relative: music21’s mergeAttributes.

pub fn from_velocity(velocity: IntegerType) -> Self

A volume at a MIDI velocity, 0 to 127, clamped to that range.

pub fn from_velocity_scalar(scalar: FloatType) -> Result<Self>

A volume at a scalar between 0 and 1, clamped to that range.

pub fn velocity(&self) -> Option<IntegerType>

The MIDI velocity, 0 to 127, or None when none was set.

pub fn set_velocity(&mut self, velocity: Option<IntegerType>)

Sets the MIDI velocity, clamped to 0 through 127, or clears it.

pub fn velocity_scalar(&self) -> Option<FloatType>

The velocity as a scalar between 0 and 1, or None when none was set.

pub fn set_velocity_scalar(&mut self, scalar: Option<FloatType>) -> Result<()>

Sets the velocity from a scalar, clamped to 0 through 1, or clears it. A value that is not a number is an error, as in music21.

pub fn velocity_is_relative(&self) -> bool

Whether the velocity shifts the dynamics around it (music21’s default) or fixes the loudness on its own, as a velocity read from a MIDI file does.

pub fn set_velocity_is_relative(&mut self, relative: bool)

Sets whether the velocity is relative to its context.

pub fn has_velocity_information(&self) -> bool

Whether a velocity was ever set: music21’s hasVolumeInformation on the note that owns it.

pub fn realized(&self) -> FloatType

The loudness this volume comes to on its own, between 0 and 1: music21’s realized with no dynamic or articulation context.

pub fn realized_with( &self, dynamic_scalar: Option<FloatType>, articulation_shift: FloatType, base_level: FloatType, clip: bool, ) -> FloatType

The loudness this volume comes to against the dynamic in force and whatever the articulations add: music21’s getRealized, with the context search it would do through a stream replaced by its answers.

A relative velocity doubles the scalar range, so 0.5 leaves the base level alone and 0.7 raises it; an absolute one decides the answer by itself. The dynamic scales; an articulation shifts, which is why an accent on a note nobody has marked lifts it rather than doubling it. clip holds the result inside 0 to 1.

pub fn realized_without_velocity( &self, dynamic_scalar: Option<FloatType>, articulation_shift: FloatType, base_level: FloatType, clip: bool, ) -> FloatType

Volume::realized_with leaving this volume’s velocity out: music21’s getRealized(useVelocity=False). The base level stands in for the velocity, with no shift for its being unset, and the dynamic and the articulations then act on it as they would.

pub fn realized_dynamic(&self) -> &'static str

The realized loudness as one of music21’s dynamic marks, ppp through fff: dynamics.dynamicStrFromDecimal of the realized value.

pub fn realized_str(&self) -> String

The realized loudness written out to two places, which is what music21’s getRealizedStr and cachedRealizedStr answer.

Trait Implementations

impl Clone for Volume

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Volume

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

Formats the value using the given formatter.

impl Default for Volume

fn default() -> Self

A volume with no velocity set, which reads as music21’s default loudness rather than as silence.

impl<'de> Deserialize<'de> for Volume

Available on crate feature serde only.

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Volume

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

music21’s repr body, realized=0.71.

music21 writes round(self.realized, 2) into an f-string, so Python’s float formatting drops a trailing zero the way {:.2} does not: half velocity reads realized=0.5, not realized=0.50.

impl PartialEq for Volume

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Volume

Available on crate feature serde only.

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Volume