score.h

#pragma once
 
#include <initializer_list>
#include <map>
#include <string>
#include <vector>
 
#include "SQLiteCpp/SQLiteCpp.h"
#include "maiacore/chord.h"
#include "maiacore/constants.h"
#include "maiacore/key.h"
#include "maiacore/measure.h"
#include "maiacore/note.h"
#include "maiacore/part.h"
#include "nlohmann/json.hpp"
#include "pugi/pugixml.hpp"
 
class Score {
   private:
    std::string _title; 
    std::string _composerName; 
    std::vector<Part> _part; 
    std::string _filePath; 
    std::string _fileName; 
 
    pugi::xml_document _doc; 
    int _numParts; 
    int _numMeasures; 
    int _numNotes; 
    bool _isValidXML; 
    bool _haveTypeTag; 
    bool _isLoadedXML; 
    std::vector<Chord> _stackedChords; 
    int _lcmDivisionsPerQuarterNote; 
    bool _haveAnacrusisMeasure; 
 
    struct NoteEvent {
        std::string partName;
        int measureIdx;
        int staveIdx;
        int noteIdx;
        const std::string keyName;
        const Note* notePtr;
    };
 
    mutable std::vector<NoteEvent> _cachedNoteEvents; 
    mutable bool _isNoteEventsCached = false; 
    std::vector<NoteEvent> collectNoteEvents() const;
 
    mutable std::vector<std::vector<NoteEvent>> _cachedNoteEventsPerPart; 
    mutable bool _isNoteEventsPerPartCached = false; 
    std::vector<std::vector<NoteEvent>> collectNoteEventsPerPart() const;
 
    void removeDuplicatePatterns(std::vector<std::vector<Note>>* patterns) const;
 
    typedef struct noteData_st {
        float currentTimeValue = 0.0f;
        const Note* notePtr = nullptr;
        float floatBeatStartTime = 0.0f;
        float floatBeatEndTime = 0.0f;
    } NoteData;
 
    typedef struct chordData_st {
        std::vector<NoteData> noteData;
        const Measure* measurePtr = nullptr;
        bool isHomophonicChord = true;
        float beatEndTimeHigherLimit = 0.0f;
        float beatStartTimeLowerLimit = 1000.0f;
        float chordQuarterDuration = 0.0f;
    } ChordData;
 
    void loadXMLFile(const std::string& filePath);
 
    std::vector<std::tuple<int, float, Key, Chord, bool>> getChordsPerEachNoteEvent(
        SQLite::Database& db, const bool includeDuplicates);
 
   public:
    explicit Score(const std::initializer_list<std::string>& partsName, const int numMeasures = 20);
 
    explicit Score(const std::vector<std::string>& partsName, const int numMeasures = 20);
 
    explicit Score(const std::string& filePath);
 
    Score(Score&&) = default;
 
    ~Score();
 
    void clear();
 
    void addPart(const std::string& partName, const int numStaves = 1);
 
    void removePart(const int partId);
 
    void addMeasure(const int numMeasures);
 
    void removeMeasure(const int measureStart, const int measureEnd);
 
    Part& getPart(const int partId);
 
    Part& getPart(const std::string& partName);
 
    int getNumParts() const;
 
    int getNumMeasures() const;
 
    int getNumNotes() const;
 
    const std::vector<std::string> getPartsNames() const;
 
    std::string getTitle() const;
 
    void setTitle(const std::string& scoreTitle);
 
    std::string getComposerName() const;
 
    void setComposerName(const std::string& composerName);
 
    void setKeySignature(const int fifthCicle, const bool isMajorMode = true, const int measureId = 0);
 
    void setKeySignature(const std::string& key, const int measureId = 0);
 
    void setTimeSignature(const int timeUpper, const int timeLower, const int measureId = -1);
 
    void setMetronomeMark(int bpm, const RhythmFigure duration = RhythmFigure::QUARTER, int measureStart = 0);
 
    const std::string toXML(const int identSize = 2) const;
 
    const std::string toJSON() const;
 
    void toFile(std::string fileName, bool compressedXML = false, const int identSize = 2) const;
 
    void info() const;
 
    void forEachNote(
        std::function<void(Part* part, Measure* measure, int staveId, Note* note)> callback,
        int measureStart = 0, int measureEnd = -1, std::vector<std::string> partNames = {});
 
    bool isValid(void) const;
 
    std::string getFilePath() const;
 
    std::string getFileName() const;
 
    bool haveTypeTag(void) const;
 
    bool getNote(const int part, const int measure, const int note, std::string& pitch,
                 std::string& step, int& octave, int& duration, int& voice, std::string& type,
                 std::string& steam, int& staff) const;
 
    bool getNote(const int part, const int measure, const int note, std::string& pitch,
                 std::string& step, int& octave) const;
 
    bool getNote(const int part, const int measure, const int note, std::string& pitch) const;
 
    void printPartNames() const;
 
    int xPathCountNodes(const std::string& xPath) const;
 
    const std::string getPartName(const int partId) const;
 
    bool getPartIndex(const std::string& partName, int* index) const;
 
    bool haveAnacrusisMeasure() const;
 
    void getNoteNodeData(const pugi::xml_node& node, std::string& partName, int& measure,
                         std::string& pitch, std::string& pitchClass, std::string& alterSymbol,
                         int& alterValue, int& octave, std::string& type, float& duration) const;
 
    void setRepeat(int measureStart, int measureEnd = -1);
 
    nlohmann::json instrumentFragmentation(nlohmann::json config = nlohmann::json());
 
    // /**
    //  * @brief Returns the vertical (stacked) chords of the score, with configurable filters.
    //  * @details Extracts chords considering parts, measures, min/max duration, duplicates, etc.
    //  * @param config JSON object with configuration parameters.
    //  * @return Vector of tuples: {measure number, time, key, chord, homophony}.
    //  */
    // std::vector<std::tuple<int, float, Key, Chord, bool>> getChords(nlohmann::json config = {});
 
    Score(const Score& other) {
        _title = other._title;
        _composerName = other._composerName;
        _filePath = other._filePath;
        _fileName = other._fileName;
        _part = other._part;
        _numParts = other._numParts;
        _numMeasures = other._numMeasures;
        _numNotes = other._numNotes;
        _isValidXML = other._isValidXML;
        _haveTypeTag = other._haveTypeTag;
        _isLoadedXML = other._isLoadedXML;
        _lcmDivisionsPerQuarterNote = other._lcmDivisionsPerQuarterNote;
        _stackedChords = other._stackedChords;
        _haveAnacrusisMeasure = other._haveAnacrusisMeasure;
 
        // Deep copy of XML document
        _doc.reset(other._doc);
 
        // Invalidate caches - they will be rebuilt when needed
        _isNoteEventsCached = false;
        _isNoteEventsPerPartCached = false;
        _cachedNoteEvents.clear();
        _cachedNoteEventsPerPart.clear();
    }
 
    Score& operator=(const Score& other) {
        if (this == &other) return *this;
 
        _title = other._title;
        _composerName = other._composerName;
        _filePath = other._filePath;
        _fileName = other._fileName;
        _part = other._part;
        _numParts = other._numParts;
        _numMeasures = other._numMeasures;
        _numNotes = other._numNotes;
        _isValidXML = other._isValidXML;
        _haveTypeTag = other._haveTypeTag;
        _isLoadedXML = other._isLoadedXML;
        _lcmDivisionsPerQuarterNote = other._lcmDivisionsPerQuarterNote;
        _stackedChords = other._stackedChords;
        _haveAnacrusisMeasure = other._haveAnacrusisMeasure;
 
        // Deep copy of XML document
        _doc.reset(other._doc);
 
        // Invalidate caches - they will be rebuilt when needed
        _isNoteEventsCached = false;
        _isNoteEventsPerPartCached = false;
        _cachedNoteEvents.clear();
        _cachedNoteEventsPerPart.clear();
 
        return *this;
    }
 
    // ====== MELODIC PATTERN ANALYSIS ======
 
    typedef std::tuple<std::string, int, int, std::string, std::string, std::vector<std::string>, std::vector<float>, std::vector<float>,
                       float, float, float> MelodyPatternRow;
    typedef std::vector<MelodyPatternRow> MelodyPatternTable;
 
    MelodyPatternTable findMelodyPattern(
        const std::vector<Note>& melodyPattern, const float totalIntervalsSimilarityThreshold = 0.5,
        const float totalRhythmSimilarityThreshold = 0.5,
        const std::function<std::vector<float>(const std::vector<Note>&, const std::vector<Note>&)>
            intervalsSimilarityCallback = nullptr,
        const std::function<std::vector<float>(const std::vector<Note>&, const std::vector<Note>&)>
            rhythmSimilarityCallback = nullptr,
        const std::function<float(const std::vector<float>&)> totalIntervalSimilarityCallback =
            nullptr,
        const std::function<float(const std::vector<float>&)> totalRhythmSimilarityCallback =
            nullptr,
        const std::function<float(float, float)> totalSimilarityCallback = nullptr) const;
 
    std::vector<MelodyPatternTable> findMelodyPattern(
        const std::vector<std::vector<Note>>& melodyPatterns, const float totalIntervalsSimilarityThreshold = 0.5,
        const float totalRhythmSimilarityThreshold = 0.5,
        const std::function<std::vector<float>(const std::vector<Note>&, const std::vector<Note>&)>
            intervalsSimilarityCallback = nullptr,
        const std::function<std::vector<float>(const std::vector<Note>&, const std::vector<Note>&)>
            rhythmSimilarityCallback = nullptr,
        const std::function<float(const std::vector<float>&)> totalIntervalSimilarityCallback =
            nullptr,
        const std::function<float(const std::vector<float>&)> totalRhythmSimilarityCallback =
            nullptr,
        const std::function<float(float, float)> totalSimilarityCallback = nullptr) const;
 
    std::vector<MelodyPatternTable> findAnyMelodyPattern(const int patternNumNotes = 5,
        const float totalIntervalsSimilarityThreshold = 1.0f,
        const float totalRhythmSimilarityThreshold = 1.0f,
        const std::function<std::vector<float>(const std::vector<Note>&, const std::vector<Note>&)>
            intervalsSimilarityCallback = nullptr,
        const std::function<std::vector<float>(const std::vector<Note>&, const std::vector<Note>&)>
            rhythmSimilarityCallback = nullptr,
        const std::function<float(const std::vector<float>&)> totalIntervalSimilarityCallback =
            nullptr,
        const std::function<float(const std::vector<float>&)> totalRhythmSimilarityCallback =
            nullptr,
        const std::function<float(float, float)> totalSimilarityCallback = nullptr) const;
    
    std::vector<std::tuple<int, float, Key, Chord, bool>> getChords(nlohmann::json config = {});
};