articulations.h

/*
 * Copyright (C) 2026, Robert Patterson
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#pragma once
 
#include <optional>
#include <string>
#include <variant>
#include <vector>
 
#include "denigma/classify/classifier_common.h"
#include "musx/musx.h"
 
namespace denigma {
 
namespace classify {
 
namespace articulation {
 
struct ArticulationMark
{
    enum class Type
    {
        Accent,
        BrassDoit,
        BrassFalloff,
        BrassPlop,
        BrassScoop,
        SoftAccent,
        Spiccato,
        Staccatissimo,
        Staccato,
        Stress,
        StrongAccent,
        Tenuto,
        Unstress
    };
 
    Type type{};
    GlyphStyle glyphStyle{};
};
 
struct ArticulationMarks
{
    std::vector<ArticulationMark> marks;
};
 
struct TechniqueMark
{
    enum class Type
    {
        BrassBend,
        BrassFlip,
        BrassHalfMuted,
        BrassLift,
        BrassOpen,
        BrassSmear,
        BrassStopped,
        BuzzPizzicato,
        Fingernails,
        LeftHandPizzicato,
        SnapPizzicato,
        ThumbPosition,
        UpBow,
        DownBow,
        StringHarmonic
    };
 
    Type type{};
    GlyphStyle glyphStyle{};
};
 
struct HarmonMute
{
    enum class Qualifier
    {
        Closed,
        HalfLeft,
        HalfRight,
        Open
    };
 
    Qualifier qualifier{};
    GlyphStyle glyphStyle{};
};
 
struct PluckedDamp
{
    enum class Type
    {
        Damp,
        DampAll
    };
 
    Type type{};
    GlyphStyle glyphStyle{};
};
 
struct StringMute
{
    enum class Type
    {
        On,
        Off
    };
 
    Type type{};
    GlyphStyle glyphStyle{};
};
 
struct Tremolo
{
    enum class Style
    {
        Measured,
        Unmeasured
    };
 
    Style style{};
    int marks{};
    GlyphStyle glyphStyle{};
};
 
struct Fermata
{
    enum class Shape
    {
        Normal,
        Angled,
        DoubleAngled,
        Square,
        DoubleSquare,
        HalfCurve,
        DoubleDot,
        Curlew
    };
 
    enum class Duration
    {
        Auto,
        VeryShort,
        Short,
        Long,
        VeryLong
    };
 
    Shape shape{};
    Duration duration{};
    GlyphStyle glyphStyle{};
};
 
struct BreathMark
{
    enum class Type
    {
        Unspecified,
        Comma,
        Tick,
        Upbow,
        Salzedo
    };
 
    Type type{};
    GlyphStyle glyphStyle{};
};
 
struct Caesura
{
    enum class Type
    {
        Normal,
        Curved,
        Short,
        Thick,
        Chant,
        SingleStroke
    };
 
    Type type{};
    GlyphStyle glyphStyle{};
};
 
struct Arpeggio
{
    enum class Type
    {
        VerticalSegment,
        Normal,
        Up,
        Down
    };
 
    Type type{};
    GlyphStyle glyphStyle{};
};
 
struct Ornament
{
    enum class Accidental
    {
        Unspecified,
        Flat,
        Natural,
        Sharp
    };
 
    enum class Type
    {
        InvertedMordent,
        InvertedTurn,
        Mordent,
        Shake,
        Trill,
        Turn
    };
 
    struct AccidentalMark
    {
        Accidental accidental{};
        musx::dom::VerticalPlacement placement{};
    };
 
    Type type{};
    GlyphStyle glyphStyle{};
    std::vector<AccidentalMark> accidentals;
};
 
struct VerticalEntryBracket
{
    GlyphStyle glyphStyle{};
};
 
struct Parenthesis
{
    enum class Side
    {
        Left,
        Right
    };
 
    Side side{};
    musx::dom::NoteInfoPtr note;
    GlyphStyle glyphStyle{};
};
 
struct OtherMark
{
    enum class Category
    {
        Articulation,
        PerformanceTechnique
    };
 
    Category category{};
    GlyphStyle glyphStyle{};
};
 
} // namespace articulation
 
using ArticulationValue = std::variant<
    std::monostate, articulation::ArticulationMarks, articulation::TechniqueMark, articulation::HarmonMute,
    articulation::PluckedDamp, articulation::StringMute, articulation::Tremolo, articulation::Fermata,
    articulation::BreathMark, articulation::Caesura, articulation::Arpeggio, articulation::Ornament,
    articulation::VerticalEntryBracket, articulation::Parenthesis, PseudoTie, articulation::OtherMark>;
 
struct ArticulationClassification
{
    ArticulationValue value{};
    musx::dom::VerticalPlacement placement{ musx::dom::VerticalPlacement::NotApplicable };
    std::optional<std::string> glyphName;
 
    explicit operator bool() const noexcept
    { return !std::holds_alternative<std::monostate>(value); }
 
    template <typename T>
    const T* as() const noexcept
    { return std::get_if<T>(&value); }
 
    template <typename T>
    bool is() const noexcept
    { return std::holds_alternative<T>(value); }
};
 
ArticulationClassification classifyArticulation(
    const musx::dom::MusxInstance<musx::dom::details::ArticulationAssign>& assignment,
    const musx::dom::EntryInfoPtr& entryInfo);
ArticulationClassification classifyArticulationSymbol(
    const musx::dom::MusxInstance<musx::dom::FontInfo>& fontInfo, char32_t symbol);
 
} // namespace classify
} // namespace denigma