note.h

#pragma once
 
#include <functional>
#include <string>
#include <vector>
 
#include "maiacore/constants.h"
#include "maiacore/duration.h"
#include "maiacore/key.h"
#include "maiacore/time-signature.h"
 
class Note {
   private:
    std::string _writtenPitchClass; 
    int _writtenOctave; 
 
    std::string _soundingPitchClass; 
    int _soundingOctave; 
 
    bool _isNoteOn; 
    bool _inChord; 
    int _midiNumber; 
    int _transposeDiatonic; 
    int _transposeChromatic; 
    int _voice; 
    int _staff; 
    bool _isGraceNote; 
    std::string _stem; 
    bool _isTuplet; 
    bool _isPitched; 
    int _unpitchedIndex; 
    Duration _duration; 
 
    std::pair<std::string, std::string> _slur; 
    std::string _alterSymbol; 
    std::vector<std::string> _tie; 
    std::vector<std::string> _articulation; 
    std::vector<std::string> _beam; 
 
   public:
    Note();
 
    explicit Note(const std::string& pitch, const RhythmFigure rhythmFigure = RhythmFigure::QUARTER,
                  bool isNoteOn = true, bool inChord = false, const int transposeDiatonic = 0,
                  const int transposeChromatic = 0, const int divisionsPerQuarterNote = 256);
 
    explicit Note(const int midiNumber, const std::string& accType = "",
                  const RhythmFigure rhythmFigure = RhythmFigure::QUARTER, bool isNoteOn = true,
                  bool inChord = false, const int transposeDiatonic = 0,
                  const int transposeChromatic = 0, const int divisionsPerQuarterNote = 256);
 
    ~Note();
 
    // ===== SETTERS ===== //
 
    void setPitchClass(const std::string& pitchClass);
 
    void setOctave(int octave);
 
    void setDuration(const Duration& duration);
 
    void setDuration(const float quarterDuration, const int divisionsPerQuarterNote = 256);
 
    void setDuration(const int durationTicks, const int divisionsPerQuarterNote);
 
    void setIsNoteOn(bool isNoteOn);
 
    void setPitch(const std::string& pitch);
 
    void setIsInChord(bool inChord);
 
    void setTransposingInterval(const int diatonicInterval, const int chromaticInterval);
 
    void setVoice(const int voice);
 
    void setStaff(const int staff);
 
    void setIsGraceNote(const bool isGraceNote = false);
 
    void setStem(const std::string& stem);
 
    void setIsTuplet(const bool isTuplet = false);
 
    void setTupleValues(const int actualNotes, const int normalNotes,
                        const std::string& normalType = "eighth");
 
    void setIsPitched(const bool isPitched = true);
 
    void setUnpitchedIndex(const int unpitchedIndex);
 
    void setTieStart();
 
    void setTieStop();
 
    void setTieStopStart();
 
    void addTie(const std::string& tieType);
 
    void addSlur(const std::string& slurType, const std::string& slurOrientation);
 
    void addArticulation(const std::string& articulation);
 
    void addBeam(const std::string& beam);
 
    // ===== GETTERS ===== //
 
    const std::string getSoundingPitchClass() const;
 
    const std::string getSoundingPitch() const;
 
    const std::string getWrittenPitchClass() const;
 
    const std::string getWrittenPitch() const;
 
    const std::string getDiatonicWrittenPitchClass() const;
 
    const std::string getDiatonicSoundingPitchClass() const;
 
    int getSoundingOctave() const;
 
    int getWrittenOctave() const;
 
    int getOctave() const;
 
    std::string getPitchClass() const;
 
    std::string getWrittenPitchStep() const;
 
    std::string getSoundingPitchStep() const;
 
    std::string getPitchStep() const;
 
    std::string getType() const;
 
    std::string getLongType() const;
 
    std::string getShortType() const;
 
    int getDurationTicks() const;
 
    int getNumDots() const;
 
    bool isDotted() const;
 
    bool isDoubleDotted() const;
 
    int getDivisionsPerQuarterNote() const;
 
    const Duration& getDuration() const;
 
    float getQuarterDuration() const;
 
    bool isGraceNote() const;
 
    bool isNoteOn() const;
 
    bool isNoteOff() const;
 
    std::string getPitch() const;
 
    int getMidiNumber() const;
 
    int getVoice() const;
 
    int getStaff() const;
 
    std::string getStem() const;
 
    std::vector<std::string> getTie() const;
 
    void removeTies();
 
    std::pair<std::string, std::string> getSlur() const;
 
    std::vector<std::string> getArticulation() const;
 
    std::vector<std::string> getBeam() const;
 
    bool isTuplet() const;
 
    bool isPitched() const;
 
    int getUnpitchedIndex() const;
 
    std::string getAlterSymbol() const;
 
    bool inChord() const;
 
    int getTransposeDiatonic() const;
 
    int getTransposeChromatic() const;
 
    bool isTransposed() const;
 
    std::string getEnharmonicPitch(const bool alternativeEnhamonicPitch = false) const;
 
    std::vector<std::string> getEnharmonicPitches(const bool includeCurrentPitch = false) const;
 
    Note getEnharmonicNote(const bool alternativeEnhamonicPitch = false) const;
 
    std::vector<Note> getEnharmonicNotes(const bool includeCurrentPitch = false) const;
 
    int getScaleDegree(const Key& key) const;
 
    void toEnharmonicPitch(const bool alternativeEnhamonicPitch = false);
 
    float getFrequency(const float freqA4 = 440.0f) const;
 
    std::pair<std::vector<float>, std::vector<float>> getHarmonicSpectrum(
        const int numPartials = 6,
        const std::function<std::vector<float>(std::vector<float>)> amplCallback = nullptr,
        const float partialsDecayExpRate = 0.88f,
        const float freqA4 = 440.0f) const;
 
    void transpose(const int semitones, const std::string& accType = MUSIC_XML::ACCIDENT::NONE);
 
    const std::string toXML(const size_t instrumentId = 1, const int identSize = 2) const;
 
    void info() const;
 
    // ===== OPERATORS ===== //
 
    bool operator<(const Note& otherNote) const;
 
    bool operator>(const Note& otherNote) const;
 
    bool operator<=(const Note& otherNote) const;
 
    bool operator>=(const Note& otherNote) const;
 
    bool operator==(const Note& otherNote) const;
 
    bool operator!=(const Note& otherNote) const;
};