Struct musical_note::Key

source ·

pub struct Key {
    pub tonic: (NoteName, Accidental),
    pub scale: Scale,
}

Fields§

§tonic: (NoteName, Accidental)§scale: Scale

Implementations§

source §

impl Key

source

pub fn new(note: NoteName, accidental: Accidental, scale: Scale) -> Self

Examples found in repository ?

src/lib.rs (line 399)

398
399
400

    fn default() -> Self {
        Self::new(Default::default(), Default::default(), Default::default())
    }

source

pub fn get_root(&self) -> [u8; 2]

[root_midi, root_index]

root_midi is u8 in rage 0..12, based on note name and accidental. root_index is u8 in rage 0..7, based only on note name.

Examples found in repository ?

src/lib.rs (line 529)

    pub fn resolve_pitch(
        &self,
        notes_map: &NotesMap,
        midi_note: u8,
        octave: Octave,
    ) -> ResolvedNote {
        let note: (NoteName, Accidental);
        let key_root_midi = self.key.get_root()[0];
        match self.degree_midi.binary_search(&midi_note) {
            Ok(note_index) => {
                note = self.degree_notes[note_index];
                // println!("found note from scale {:?} at index {:?}", note, note_index);
            }
            Err(_err) => {
                if midi_note == key_root_midi + 1 && self.key.scale == Scale::Minor {
                    // println!("that is minor II♭");
                    note = notes_map
                        .resolve_note_for_midi(self.degree_notes[1 as usize], midi_note)
                        .unwrap();
                } else if midi_note == (key_root_midi + 8) % 12 && self.key.scale == Scale::Major {
                    // println!("that is major VI♭");
                    let candidate_note = self.degree_notes[5 as usize];
                    note = notes_map
                        .resolve_note_for_midi(candidate_note, midi_note)
                        .unwrap();
                } else {
                    // println!("just search for anything for midi: {:?}", midi_note);
                    note = notes_map
                        .resolve_enharmonic(self.used_accidentals.last().copied(), midi_note);
                }
            }
        }
        ResolvedNote::new(note.0, note.1, octave, octave.apply_to_midi_note(midi_note))
    }
}

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Serialize, Deserialize)]
pub enum Scale {
    Major,
    Minor,
    Dorian,
    Phrygian,
    Lydian,
    Mixolidyan,
    Locrian,
}
impl Scale {
    /// Get interval structure of the scale.
    pub fn structure(&self) -> [u8; 6] {
        match self {
            Self::Major => [2, 2, 1, 2, 2, 2],
            Self::Minor => [2, 1, 2, 2, 1, 2],
            Self::Dorian => [2, 1, 2, 2, 2, 1],
            Self::Phrygian => [1, 2, 2, 2, 1, 2],
            Self::Lydian => [2, 2, 2, 1, 2, 2],
            Self::Mixolidyan => [2, 2, 1, 2, 2, 1],
            Self::Locrian => [1, 2, 2, 1, 2, 2],
        }
    }
    /// Make concrete representation, based on given Key.
    fn resolve_for_key(&self, notes_map: &NotesMap, key: &Key) -> ResolvedScale {
        let root = key.get_root();
        let (root_midi, _root_idx) = (root[0], root[1]);
        let mut degree_midi = [root_midi; 7];
        let mut degree_notes = [key.tonic; 7];
        let mut used_accidentals = Vec::with_capacity(10);
        for (idx, interval) in self.structure().iter().enumerate() {
            let mut next_midi = degree_midi[idx];
            next_midi += interval;
            if next_midi > 11 {
                next_midi %= 12;
            }
            let index = degree_notes[idx].0.index() + 1;
            let candidate_note = NoteName::by_index(index);
            // println!(
            //     "candidate_note: {:?}, next_midi: {:?}",
            //     candidate_note, next_midi
            // );
            let next_note = notes_map
                .resolve_note_for_midi((candidate_note, Accidental::White), next_midi)
                .unwrap();
            degree_notes[idx + 1] = next_note;
            degree_midi[idx + 1] = next_midi;
            if next_note.1 != Accidental::White {
                used_accidentals.push(next_note.1);
            }
            // println!(
            //     "next_note: {:?}, degree_notes: {:?}, degree_midi: {:?}, used_accidentals: {:?}",
            //     next_note, degree_notes, degree_midi, used_accidentals
            // )
        }
        ResolvedScale {
            key: *key,
            degree_midi,
            degree_notes,
            used_accidentals,
        }
    }