helper.h

#ifndef HELPERS_H
#define HELPERS_H
 
#include <math.h>
#include <string>
#include "maiacore/constants.h"
#include "maiacore/note.h"
#include "nlohmann/json.hpp"
#include "pugi/pugixml.hpp"
 
class Interval;
 
class Helper {
   public:
    static std::vector<std::string> splitString(const std::string& s, char delimiter);
 
    static std::string formatFloat(float floatValue, int digits);
 
    static const std::string generateIdentation(int identPosition, int identSize = 2);
 
    static std::pair<std::string, int> ticks2noteType(int durationTicks,
                                                      int divisionsPerQuarterNote,
                                                      int actualNotes = 1, int normalNotes = 1);
 
    static std::pair<RhythmFigure, int> ticks2rhythmFigure(int durationTicks,
                                                           int divisionsPerQuarterNote,
                                                           int actualNotes, int normalNotes);
 
    static int noteType2ticks(std::string noteType, const int divisionsPerQuarterNote = 256);
 
    static float pitch2number(const std::string& pitch);
 
    static const std::string number2pitch(const float number,
                                          const std::string& accType = MUSIC_XML::ACCIDENT::SHARP);
 
    static std::pair<int, int> freq2midiNote(const float freq,
                                             std::function<int(float)> modelo = nullptr);
 
    static float midiNote2freq(const int midiNote, const float freqA4 = 440.0f);
 
    static int midiNote2octave(const int midiNote);
 
    static int pitch2midiNote(const std::string& pitch);
 
    static const std::string midiNote2pitch(const int midiNote, const std::string& accType = {});
 
    static const std::vector<std::string> midiNote2pitches(const int midiNote);
 
    static std::vector<Interval> notes2Intervals(const std::vector<Note>& notes,
                                                 const bool firstNoteAsReference = false);
 
    static std::vector<Interval> notes2Intervals(const std::vector<std::string>& pitches,
                                                 const bool firstNoteAsReference = false);
 
    static int semitonesBetweenPitches(const std::string& pitch_A, const std::string& pitch_B);
 
    static float noteSimilarity(std::string& pitchClass_A, int octave_A, const float duration_A,
                                std::string& pitchClass_B, int octave_B, const float duration_B,
                                float& durRatio, float& pitRatio,
                                const bool enableEnharmonic = false);
 
    static float pitch2freq(const std::string& pitch);
 
    static int frequencies2cents(const float freq_A, const float freq_B);
 
    static float freq2equalTemperament(const float freq, const float referenceFreq = 440.0f);
 
    static std::string rhythmFigure2noteType(const RhythmFigure rhythmFigure);
 
    static int rhythmFigure2Ticks(const RhythmFigure rhythmFigure,
                                  const int divisionsPerQuarterNote = 256);
 
    static RhythmFigure noteType2RhythmFigure(const std::string& noteType);
 
    static const std::string transposePitch(
        const std::string& pitch, const int semitones,
        const std::string& accType = MUSIC_XML::ACCIDENT::SHARP);
 
    static bool isEnharmonic(const std::string& pitch_A, const std::string& pitch_B);
 
    static void splitPitch(const std::string& pitch, std::string& pitchClass,
                           std::string& pitchStep, int& octave, float& alterValue,
                           std::string& alterSymbol);
 
    static float durationRatio(float duration_A, float duration_B);
 
    // /**
    //  * @brief Converts an accidental RhythmFigure to a MusicXML note type string.
    //  * @param rhythmFigure RhythmFigure value.
    //  * @return Note type string.
    //  */
    // static std::string rhythmFigure2noteType(const RhythmFigure rhythmFigure);
 
    // /**
    //  * @brief Converts a MusicXML note type string to a RhythmFigure enum.
    //  * @param noteType Note type string.
    //  * @return RhythmFigure value.
    //  */
    // static RhythmFigure noteType2RhythmFigure(const std::string& noteType);
 
    static const std::string alterName2symbol(const std::string& alterName);
 
    static float alterSymbol2Value(const std::string& alterSymbol);
 
    static const std::string alterValue2symbol(const float alterValue);
 
    static const std::string alterValue2Name(const float alterValue);
 
    static void getNoteNodeData(const pugi::xml_node& node, std::string& pitch,
                                std::string& pitchClass, std::string& alterSymbol, int& alterValue,
                                int& octave, std::string& type, float& duration);
 
    static const pugi::xpath_node_set getNodeSet(const pugi::xml_document& doc,
                                                 const std::string& xPath);
 
    static const nlohmann::json getPercentiles(const nlohmann::json& table,
                                               const std::vector<float>& desiredPercentiles);
 
    // /**
    //  * @brief Converts a pitch string to its frequency in Hz.
    //  * @param pitch Pitch string.
    //  * @return Frequency in Hz.
    //  */
    // static float pitch2freq(const std::string& pitch);
 
    static std::pair<std::string, int> freq2pitch(
        const float freq, const std::string& accType = MUSIC_XML::ACCIDENT::NONE);
 
    static float pitchRatio(const std::string& pitch_A, const std::string& pitch_B);
 
    static std::string toString(const RhythmFigure rhythmFigure);
 
    static std::vector<float> getSemitonesDifferenceBetweenMelodies(
        const std::vector<Note>& referenceMelody, const std::vector<Note>& otherMelody);
 
    static float calculateMelodyEuclideanSimilarity(const std::vector<Note>& melodyPattern,
                                                    const std::vector<Note>& otherMelody);
 
    static float calculateMelodyEuclideanSimilarity(const std::vector<float>& semitonesDifference);
 
    static std::vector<float> getDurationDifferenceBetweenRhythms(
        const std::vector<Note>& referenceRhythm, const std::vector<Note>& otherRhythm);
 
    static float calculateRhythmicEuclideanSimilarity(const std::vector<Note>& rhythmPattern,
                                                      const std::vector<Note>& otherRhythm);
 
    static float calculateRhythmicEuclideanSimilarity(const std::vector<float>& durationDifferences);
};
#endif  // HELPERS_H