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"
#include "musx/util/Arpeggio.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 AccordionRegistration
{
    enum class Hand {
        Other,
        Right,
        Left
    };
 
    enum class RankCount {
        Other,
        Two,
        Three,
        Four
    };
 
    enum class InstrumentType {
        Other,
        Piccolo,
        Clarinet,
        Bassoon,
        Oboe,
        Violin,
        ImitationMusette,
        AuthenticMusette,
        Organ,
        Harmonium,
        Bandoneon,
        Accordion
    };
 
    enum class DotPosition {
        Other,
        Top,
        UpperMiddle,
        Middle,
        LowerMiddle,
        Bottom
    };
 
    struct Dot
    {
        DotPosition position{};
    };
 
    Hand hand{};
    RankCount rankCount{};
    InstrumentType instrumentType{};
    std::vector<Dot> dots;
    std::vector<std::string> glyphNames;
};
 
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{};
    std::optional<musx::util::ArpeggioSpanCandidate> candidate;
};
 
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::AccordionRegistration, 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