< Summary

Information
Class: MusicTheory.Theory.Harmony.HarmonyAnalyzer
Assembly: MusicTheory
File(s): /home/runner/work/MusicTheory/MusicTheory/Theory/Harmony/HarmonyAnalyzer.cs
Line coverage
72%
Covered lines: 355
Uncovered lines: 137
Coverable lines: 492
Total lines: 853
Line coverage: 72.1%
Branch coverage
63%
Covered branches: 484
Total branches: 765
Branch coverage: 63.2%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
AddMixtureSeventhWarnings(...)90%101091.66%
AnalyzeTriad(...)100%11100%
AnalyzeTriad(...)61.86%830064573.6%
GetTriadQualityFromRoman(...)94.11%1717100%
BuildSeventhLabel(...)97.05%343497.14%
DegreeFromRoman(...)80%161581.81%
SeventhQualityInMajor(...)0%7280%
SeventhQualityInMinor(...)0%7280%
SeventhRootSuffix(...)100%44100%
DegreeRootPcLocal(...)100%44100%
EnsureSeventhAccidental(...)35%2722014.28%

File(s)

/home/runner/work/MusicTheory/MusicTheory/Theory/Harmony/HarmonyAnalyzer.cs

#LineLine coverage
 1using System.Collections.Generic;
 2using System.Linq;
 3
 4namespace MusicTheory.Theory.Harmony;
 5
 6/// <summary>
 7/// Result of a single harmony analysis.
 8/// </summary>
 9/// <param name="Success">True if any roman numeral labeling was determined.</param>
 10/// <param name="Roman">Structured roman numeral head (nullable for special cases like Aug6 only text).</param>
 11/// <param name="Function">Approximate tonal function (Tonic/Subdominant/Dominant/Unknown).</param>
 12/// <param name="RomanText">Display text including accidentals and inversion figures (e.g., "bII6", "V65/V", "Ger65").</
 13/// <param name="Warnings">Non-blocking diagnostics (voice-leading hints, Neapolitan recommendations, etc.).</param>
 14/// <param name="Errors">Blocking or structural issues (range/order violations, overlaps, etc.).</param>
 15public readonly record struct HarmonyAnalysisResult(
 16    bool Success,
 17    RomanNumeral? Roman,
 18    TonalFunction Function,
 19    string? RomanText,
 20    List<string> Warnings,
 21    List<string> Errors
 22);
 23
 24public static class HarmonyAnalyzer
 25{
 26    private static void AddMixtureSeventhWarnings(List<string> warnings, string mix7Label, Key key, FourPartVoicing? voi
 27    {
 28        try
 29        {
 3130            if (string.IsNullOrEmpty(mix7Label)) return;
 31            // Generic, non-blocking hints about common resolutions
 32            // Check longer tokens first to avoid prefix collisions (e.g., bVII vs bVI)
 3133            if (mix7Label.StartsWith("bVII", System.StringComparison.Ordinal))
 34            {
 735                warnings.Add("Mixture: bVII7 often resolves to I (backdoor)");
 36            }
 2437            else if (mix7Label.StartsWith("bVI", System.StringComparison.Ordinal))
 38            {
 1039                warnings.Add("Mixture: bVI7 typically resolves to V");
 40            }
 1441            else if (mix7Label.StartsWith("bII", System.StringComparison.Ordinal))
 42            {
 743                warnings.Add("Mixture: bII7 (Neapolitan 7) often resolves to V or I6");
 44            }
 745            else if (mix7Label.StartsWith("iv", System.StringComparison.Ordinal))
 46            {
 747                warnings.Add("Mixture: iv7 typically resolves to V");
 48            }
 3149        }
 050        catch { /* diagnostics must not throw */ }
 3151    }
 52    /// <summary>
 53    /// Analyze a chord snapshot as triad/seventh harmony and return roman numeral labeling.
 54    /// </summary>
 55    /// <param name="pcs">All sounding pitch classes (MIDI modulo 12 recommended).</param>
 56    /// <param name="key">The harmonic context.</param>
 57    /// <param name="voicing">Optional four-part voicing for inversion and voice-leading diagnostics.</param>
 58    /// <param name="prev">Optional previous four-part voicing for motion diagnostics (parallels/overlaps).</param>
 59    /// <returns>HarmonyAnalysisResult with roman text, function and diagnostics.</returns>
 60    public static HarmonyAnalysisResult AnalyzeTriad(int[] pcs, Key key, FourPartVoicing? voicing = null, FourPartVoicin
 31461        => AnalyzeTriad(pcs, key, HarmonyOptions.Default, voicing, prev);
 62
 63    /// <summary>
 64    /// Analyze with custom <see cref="HarmonyOptions"/> for disambiguation preferences.
 65    /// </summary>
 66    /// <param name="pcs">All sounding pitch classes.</param>
 67    /// <param name="key">The harmonic context.</param>
 68    /// <param name="options">Preference toggles (Aug6 vs mixture, Neapolitan enforcement, etc.).</param>
 69    /// <param name="voicing">Optional four-part voicing.</param>
 70    /// <param name="prev">Optional previous four-part voicing for motion checks.</param>
 71    public static HarmonyAnalysisResult AnalyzeTriad(int[] pcs, Key key, HarmonyOptions options, FourPartVoicing? voicin
 72    {
 42173        var warnings = new List<string>();
 42174        var errors = new List<string>();
 75
 76        // Normalize inputs
 182477        int[] raw = pcs.Select(p => ((p % 12) + 12) % 12).ToArray();
 42178        int[] distinct = raw.Distinct().ToArray();
 182479    int[] ordered = distinct.OrderBy(x => x).ToArray();
 42180    bool preferSeventh = ordered.Length >= 4; // 4音以上は7th/テンション系を最優先（V9 等も含む）
 81
 82        // 1) V9 は常に最優先で即時リターン（distinct/raw の両方で判定）
 42183    if (ChordRomanizer.TryRomanizeDominantNinth(ordered, key, out var v9Early)
 42184     || ChordRomanizer.TryRomanizeDominantNinth(raw, key, out v9Early))
 85        {
 1986        var v9label = options is not null && options.PreferV7Paren9OverV9 ? "V7(9)" : v9Early;
 1987        var funcV = RomanNumeralUtils.FunctionOf(RomanNumeral.V);
 1988        return new HarmonyAnalysisResult(true, RomanNumeral.V, funcV, v9label, warnings, errors);
 89        }
 90
 91    // (moved) Augmented Sixth detection occurs after mixture sevenths, to preserve bVI7 labeling unless bass=b6 voicing
 92
 93        // 2) ダイアトニック7th（4音）: ボイシングがあれば反転を付与（最優先で、曖昧な二次導七等より優先）
 94        //    ただし、voicingがあり bass=b6 の正規Augmented Sixth (It6/Fr43/Ger65) に一致する場合は、
 95        //    先にAug6を優先して即時リターン（まれな誤認を防ぐための早期チェック）。
 40296        if (preferSeventh && voicing is FourPartVoicing vAugEarly && !options.PreferMixtureSeventhOverAugmentedSixthWhen
 97        {
 8898            int tonicPcE = (key.TonicMidi % 12 + 12) % 12;
 8899            int b6pcE = (tonicPcE + 8) % 12;
 88100            int sopranoPcE = (vAugEarly.S % 12 + 12) % 12;
 88101            bool suppressAug6E = options.DisallowAugmentedSixthWhenSopranoFlat6 && sopranoPcE == b6pcE;
 88102            if (!suppressAug6E && ChordRomanizer.TryRomanizeAugmentedSixth(pcs, key, options, vAugEarly, out var aug6Ear
 103            {
 6104                return new HarmonyAnalysisResult(true, null, TonalFunction.Subdominant, aug6EarlyPre, warnings, errors);
 105            }
 106        }
 396107            if (preferSeventh && ChordRomanizer.TryRomanizeSeventh(pcs, key, out var rn7, out var degree7, out var q7))
 108        {
 109            // Guard: if this voicing also forms an Augmented Sixth and suppression is not requested,
 110            // prefer Aug6 over a diatonic seventh label (safety for rare ambiguous edge cases).
 40111            if (voicing is FourPartVoicing vAug2 && !options.PreferMixtureSeventhOverAugmentedSixthWhenAmbiguous)
 112            {
 32113                int tonicPcG = (key.TonicMidi % 12 + 12) % 12;
 32114                int b6pcG = (tonicPcG + 8) % 12;
 32115                int sopranoPcG = (vAug2.S % 12 + 12) % 12;
 32116                bool suppressAug6OnSop = options.DisallowAugmentedSixthWhenSopranoFlat6 && sopranoPcG == b6pcG;
 32117                if (!suppressAug6OnSop && ChordRomanizer.TryRomanizeAugmentedSixth(pcs, key, options, vAug2, out var aug
 118                {
 0119                    return new HarmonyAnalysisResult(true, null, TonalFunction.Subdominant, aug6OverDia, warnings, error
 120                }
 121            }
 122            string? label;
 40123            if (voicing.HasValue)
 124            {
 32125                var v7 = voicing.Value;
 32126                label = BuildSeventhLabel(rn7, degree7, q7, key, v7, options);
 127            }
 128            else
 129            {
 8130                label = rn7 + SeventhRootSuffix(q7);
 8131                label = EnsureSeventhAccidental(rn7, q7, label);
 132            }
 40133            var func7 = RomanNumeralUtils.FunctionOf(rn7);
 134            // Final sanitation: ensure °/ø prefix on diminished-type sevenths
 40135            if ((q7 == ChordQuality.DiminishedSeventh || q7 == ChordQuality.HalfDiminishedSeventh) && label is string l0
 136            {
 9137                if (!l0.Contains('°') && !l0.Contains('ø'))
 138                {
 0139                    string sym = q7 == ChordQuality.DiminishedSeventh ? "°" : "ø";
 0140                    if (l0.StartsWith("vii")) l0 = "vii" + sym + l0.Substring(3);
 0141                    else if (l0.StartsWith("VII")) l0 = "VII" + sym + l0.Substring(3);
 0142                    label = l0;
 143                }
 144            }
 40145            return new HarmonyAnalysisResult(true, rn7, func7, label, warnings, errors);
 146        }
 147
 148        // 3) 借用7th（iv7/bVII7/bII7/bVI7）と Aug6 の優先関係はオプションで切替
 149        //    PreferMixtureSeventhOverAugmentedSixthWhenAmbiguous=true の場合、Mixture7th を先に試し、
 150        //    そうでなければ Aug6 を先に試す（従来挙動）。いずれも S=b6 抑制を尊重。
 356151        if (preferSeventh && voicing is FourPartVoicing vMix)
 152        {
 153            // Guard: if options disallow Aug6 when soprano is b6, avoid early Aug6 return here
 51154            int tonicPc0 = (key.TonicMidi % 12 + 12) % 12;
 51155            int b6pc0 = (tonicPc0 + 8) % 12;
 51156            int sopranoPc0 = (vMix.S % 12 + 12) % 12;
 51157            bool suppressAug6Early = options.DisallowAugmentedSixthWhenSopranoFlat6 && sopranoPc0 == b6pc0;
 51158            if (options.PreferMixtureSeventhOverAugmentedSixthWhenAmbiguous)
 159            {
 1160                if (ChordRomanizer.TryRomanizeSeventhMixture(pcs, key, options, vMix, out var mix7))
 161                {
 1162                    RomanNumeral baseRn = mix7!.StartsWith("iv") ? RomanNumeral.iv
 1163                        : mix7!.StartsWith("bII") ? RomanNumeral.II
 1164                        : mix7!.StartsWith("bVI") ? RomanNumeral.VI
 1165                        : RomanNumeral.VII;
 1166                    var funcMix = RomanNumeralUtils.FunctionOf(baseRn);
 1167                    AddMixtureSeventhWarnings(warnings, mix7!, key, vMix);
 1168                    return new HarmonyAnalysisResult(true, baseRn, funcMix, mix7, warnings, errors);
 169                }
 0170                if (!suppressAug6Early && ChordRomanizer.TryRomanizeAugmentedSixth(pcs, key, options, vMix, out var aug6
 171                {
 0172                    return new HarmonyAnalysisResult(true, null, TonalFunction.Subdominant, aug6Early, warnings, errors)
 173                }
 174            }
 175            else
 176            {
 50177                if (!suppressAug6Early && ChordRomanizer.TryRomanizeAugmentedSixth(pcs, key, options, vMix, out var aug6
 178                {
 0179                    return new HarmonyAnalysisResult(true, null, TonalFunction.Subdominant, aug6Early, warnings, errors)
 180                }
 50181                if (ChordRomanizer.TryRomanizeSeventhMixture(pcs, key, options, vMix, out var mix7))
 182                {
 22183                    RomanNumeral baseRn = mix7!.StartsWith("iv") ? RomanNumeral.iv
 22184                        : mix7!.StartsWith("bII") ? RomanNumeral.II
 22185                        : mix7!.StartsWith("bVI") ? RomanNumeral.VI
 22186                        : RomanNumeral.VII;
 22187                    var funcMix = RomanNumeralUtils.FunctionOf(baseRn);
 22188                    AddMixtureSeventhWarnings(warnings, mix7!, key, vMix);
 22189                    return new HarmonyAnalysisResult(true, baseRn, funcMix, mix7, warnings, errors);
 190                }
 191            }
 192        }
 193
 194        // 4) 借用7th（iv7/bVII7）: ボイシング無し（root position 表記）
 333195    if (preferSeventh && ChordRomanizer.TryRomanizeSeventhMixture(pcs, key, options, null, out var mix7NoVoicing))
 196        {
 8197            RomanNumeral baseRn = mix7NoVoicing!.StartsWith("iv") ? RomanNumeral.iv
 8198                : mix7NoVoicing!.StartsWith("bII") ? RomanNumeral.II
 8199                : mix7NoVoicing!.StartsWith("bVI") ? RomanNumeral.VI
 8200                : RomanNumeral.VII;
 8201            var funcMix = RomanNumeralUtils.FunctionOf(baseRn);
 8202            AddMixtureSeventhWarnings(warnings, mix7NoVoicing!, key, null);
 8203            return new HarmonyAnalysisResult(true, baseRn, funcMix, mix7NoVoicing, warnings, errors);
 204        }
 205
 206        // 4.2) Augmented Sixth (requires bass=b6 in voicing to disambiguate from bVI7)
 207        //      ただし、ソプラノも b6 かつ抑制オプション有効時はここでもスキップして bVI7 を優先
 325208        if (voicing is FourPartVoicing vAug)
 209        {
 227210            int tonicPc1 = (key.TonicMidi % 12 + 12) % 12;
 227211            int b6pc1 = (tonicPc1 + 8) % 12;
 227212            int sopranoPc1 = (vAug.S % 12 + 12) % 12;
 227213            bool suppressAug6 = options.DisallowAugmentedSixthWhenSopranoFlat6 && sopranoPc1 == b6pc1;
 227214            if (!options.PreferMixtureSeventhOverAugmentedSixthWhenAmbiguous)
 215            {
 227216                if (!suppressAug6 && ChordRomanizer.TryRomanizeAugmentedSixth(pcs, key, options, vAug, out var aug6))
 217                {
 1218                    return new HarmonyAnalysisResult(true, null, TonalFunction.Subdominant, aug6, warnings, errors);
 219                }
 220            }
 221        }
 222
 223        // 4.5) Minor key safeguard: prefer diatonic iiø7 over any secondary interpretation
 324224    if (preferSeventh && !key.IsMajor && options.PreferDiatonicIiHalfDimInMinor)
 225        {
 0226            int degPc = DegreeRootPcLocal(key, 1); // ii root in minor
 0227            var iiDim7 = new Chord(degPc, ChordQuality.HalfDiminishedSeventh).PitchClasses().OrderBy(x => x).ToArray();
 0228            var set = ordered;
 0229            if (iiDim7.Length == set.Length && iiDim7.All(set.Contains))
 230            {
 0231                string label = "iiø7";
 0232                if (voicing is FourPartVoicing vMinor)
 233                {
 0234                    int bass = (vMinor.B % 12 + 12) % 12;
 0235                    int third = (degPc + 3) % 12;
 0236                    int fifth = (degPc + 6) % 12;
 0237                    int seventh = (degPc + 10) % 12;
 0238                    if      (bass == degPc)   label = "iiø7";
 0239                    else if (bass == third)   label = "iiø65";
 0240                    else if (bass == fifth)   label = "iiø43";
 0241                    else if (bass == seventh) label = "iiø42";
 242                }
 0243                return new HarmonyAnalysisResult(true, RomanNumeral.ii, TonalFunction.Subdominant, label, warnings, erro
 244            }
 245        }
 246
 247        // 5) Secondary dominants / secondary leading-tone sevenths（root or inversion when voicingあり）
 324248        if (preferSeventh)
 249        {
 34250            if (voicing is FourPartVoicing vSec7)
 251            {
 28252                if (ChordRomanizer.TryRomanizeSecondaryDominant(pcs, key, vSec7, out var secDom7))
 8253                    return new HarmonyAnalysisResult(true, RomanNumeral.V, TonalFunction.Dominant, secDom7, warnings, er
 20254                if (ChordRomanizer.TryRomanizeSecondaryLeadingTone(pcs, key, vSec7, options, out var secLt7))
 255                {
 256                    // Prefer diatonic seventh if also matches (e.g., iiø7 in minor vs viiø7/III)
 20257                    if (ChordRomanizer.TryRomanizeSeventh(pcs, key, out var rnDia7, out var degDia7, out var qDia7))
 258                    {
 259                        // Preserve inversion when voicing is available
 0260                        string diatxt = BuildSeventhLabel(rnDia7, degDia7, qDia7, key, vSec7, options);
 0261                        return new HarmonyAnalysisResult(true, rnDia7, RomanNumeralUtils.FunctionOf(rnDia7), diatxt, war
 262                    }
 20263                    return new HarmonyAnalysisResult(true, RomanNumeral.vii, TonalFunction.Dominant, secLt7, warnings, e
 264                }
 265            }
 266            else
 267            {
 6268                if (ChordRomanizer.TryRomanizeSecondaryDominant(pcs, key, null, out var secDom7NoV))
 2269                    return new HarmonyAnalysisResult(true, RomanNumeral.V, TonalFunction.Dominant, secDom7NoV, warnings,
 4270                if (ChordRomanizer.TryRomanizeSecondaryLeadingTone(pcs, key, null, options, out var secLt7NoV))
 271                {
 4272                    if (ChordRomanizer.TryRomanizeSeventh(pcs, key, out var rnDia7b, out var degDia7b, out var qDia7b))
 273                    {
 0274                        string diatxt = rnDia7b + SeventhRootSuffix(qDia7b);
 0275                        return new HarmonyAnalysisResult(true, rnDia7b, RomanNumeralUtils.FunctionOf(rnDia7b), diatxt, w
 276                    }
 4277                    return new HarmonyAnalysisResult(true, RomanNumeral.vii, TonalFunction.Dominant, secLt7NoV, warnings
 278                }
 279            }
 280        }
 281
 282    // 6) 三和音（ダイアトニック→借用→二次属/二次導）。4音以上（テンション/7th系）は三和音ローマナイズをスキップ
 870283        RomanNumeral rn = default; bool hasRn = false; string? romanText = null;
 290284        string? mixtureText = null;
 285    // Triad pathway: only when distinct pitch classes count is exactly 3.
 286    // (Previously <=3 allowed degenerate dyads; tighten per spec: distinct=3 音時のみ)
 290287    if (ordered.Length == 3)
 288        {
 288289            if (ChordRomanizer.TryRomanizeTriad(pcs, key, out rn))
 290            {
 444291                hasRn = true; romanText = rn.ToString();
 292            }
 66293            else if (ChordRomanizer.TryRomanizeTriadMixture(pcs, key, out rn, out mixtureText))
 294            {
 58295                hasRn = true; romanText = mixtureText ?? rn.ToString();
 296            }
 37297            else if (ChordRomanizer.TryRomanizeSecondaryDominant(pcs, key, voicing, out var secDomTri))
 298            {
 52299                hasRn = true; romanText = secDomTri;
 300                // Immediate reinforcement: add inversion 6/64 for secondary dominant triads if missing
 26301                if (voicing is FourPartVoicing vSecImm && ordered.Length == 3 && romanText is string rtImm && rtImm.Star
 302                {
 8303                    int slash = rtImm.IndexOf('/');
 8304                    if (slash > 0 && slash < rtImm.Length - 1)
 305                    {
 8306                        string target = rtImm[(slash + 1)..];
 16307                        int? deg = target switch { "ii" => 1, "iii" => 2, "IV" => 3, "V" => 4, "vi" => 5, "vii" or "vii°
 8308                        if (deg is int d)
 309                        {
 8310                            int targetPc = DegreeRootPcLocal(key, d);
 8311                            int root = (targetPc + 7) % 12; // V/x root
 8312                            int bassPc = (vSecImm.B % 12 + 12) % 12;
 8313                            int third = (root + 4) % 12;
 8314                            int fifth = (root + 7) % 12;
 8315                            if (bassPc == third) romanText = $"V6/{target}";
 8316                            else if (bassPc == fifth) romanText = $"V64/{target}";
 317                        }
 318                    }
 319                }
 320            }
 11321            else if (ChordRomanizer.TryRomanizeSecondaryLeadingTone(pcs, key, voicing, options, out var secLtTri))
 322            {
 20323                hasRn = true; romanText = secLtTri;
 324                // Immediate reinforcement: add inversion 6/64 for secondary leading-tone triads if missing
 10325                if (voicing is FourPartVoicing vSecImm2 && ordered.Length == 3 && romanText is string rtImm2 && rtImm2.S
 326                {
 3327                    int slash = rtImm2.IndexOf('/');
 3328                    if (slash > 0 && slash < rtImm2.Length - 1)
 329                    {
 3330                        string target = rtImm2[(slash + 1)..];
 6331                        int? deg = target switch { "ii" => 1, "iii" => 2, "IV" => 3, "V" => 4, "vi" => 5, "vii" or "vii°
 3332                        if (deg is int d)
 333                        {
 3334                            int targetPc = DegreeRootPcLocal(key, d);
 3335                            int root = (targetPc + 11) % 12; // leading-tone root to target
 3336                            int bassPc = (vSecImm2.B % 12 + 12) % 12;
 3337                            int third = (root + 3) % 12;
 3338                            int fifth = (root + 6) % 12;
 3339                            if (bassPc == third) romanText = $"vii°6/{target}";
 3340                            else if (bassPc == fifth) romanText = $"vii°64/{target}";
 341                        }
 342                    }
 343                }
 344            }
 345
 288346            if (hasRn)
 347            {
 348                // diminished の度数記号
 287349                var triQ0 = GetTriadQualityFromRoman(rn, key.IsMajor);
 287350                if (triQ0 == ChordQuality.Diminished && (romanText == null || !romanText.Contains("°")))
 2351                    romanText = (romanText ?? rn.ToString()) + "°";
 352
 353                // 反転は3音のときのみ
 287354                if (voicing is FourPartVoicing vTri && ordered.Length == 3)
 355                {
 356                    // Mixture triads like bII/bVI/bVII use non-diatonic roots; handle their inversion figures explicitl
 196357                    bool appliedMixtureInversion = false;
 196358                    if (!string.IsNullOrEmpty(mixtureText))
 359                    {
 19360                        int tonic = (key.TonicMidi % 12 + 12) % 12;
 38361                        int? mixRoot = null; ChordQuality mixQ = ChordQuality.Unknown;
 19362                        string mt = mixtureText!;
 363                        // Check longer tokens first to avoid prefix collisions (e.g., bVII vs bVI, bIII vs bII, iv vs i
 23364                        if (mt.StartsWith("bVII")) { mixRoot = (tonic + 10) % 12; mixQ = ChordQuality.Major; }
 19365                        else if (mt.StartsWith("bIII")) { mixRoot = (tonic + 3) % 12; mixQ = ChordQuality.Major; }
 24366                        else if (mt.StartsWith("bVI")) { mixRoot = (tonic + 8) % 12; mixQ = ChordQuality.Major; }
 36367                        else if (mt.StartsWith("bII")) { mixRoot = (tonic + 1) % 12; mixQ = ChordQuality.Major; }
 0368                        else if (mt.StartsWith("iv")) { mixRoot = DegreeRootPcLocal(key, 3); mixQ = ChordQuality.Minor; 
 0369                        else if (mt.StartsWith("i")) { mixRoot = tonic; mixQ = ChordQuality.Minor; }
 370
 19371                        if (mixRoot is int mr && mixQ != ChordQuality.Unknown)
 372                        {
 19373                            var tri = new Chord(mr, mixQ).PitchClasses().ToArray();
 19374                            var set = ordered.ToHashSet();
 19375                            if (tri.All(set.Contains))
 376                            {
 19377                                int bassPc = (vTri.B % 12 + 12) % 12;
 19378                                int thirdInt = (mixQ == ChordQuality.Minor || mixQ == ChordQuality.Diminished) ? 3 : 4;
 38379                                int fifthInt = mixQ switch { ChordQuality.Diminished => 6, ChordQuality.Augmented => 8, 
 19380                                int thirdPc = (mr + thirdInt) % 12;
 19381                                int fifthPc = (mr + fifthInt) % 12;
 19382                                string baseRoman = mt; // already includes accidental (e.g., bII)
 24383                                if      (bassPc == mr) romanText = baseRoman;
 21384                                else if (bassPc == thirdPc) romanText = baseRoman + "6";
 14385                                else if (bassPc == fifthPc) romanText = baseRoman + "64";
 19386                                appliedMixtureInversion = true;
 387                            }
 388                        }
 389                    }
 390
 196391                    if (!appliedMixtureInversion)
 392                    {
 177393                        int degree = DegreeFromRoman(rn, key.IsMajor) ?? -1;
 177394                        if (degree >= 0 && triQ0.HasValue)
 395                        {
 177396                            int degPc = DegreeRootPcLocal(key, degree);
 177397                            var tri = new Chord(degPc, triQ0.Value).PitchClasses().ToArray();
 177398                            var set = ordered.ToHashSet();
 177399                            if (tri.All(set.Contains))
 400                            {
 143401                                int bassPc = (vTri.B % 12 + 12) % 12;
 143402                                int thirdInt = (triQ0 == ChordQuality.Minor || triQ0 == ChordQuality.Diminished) ? 3 : 4
 286403                                int fifthInt = triQ0 switch { ChordQuality.Diminished => 6, ChordQuality.Augmented => 8,
 143404                                int thirdPc = (degPc + thirdInt) % 12;
 143405                                int fifthPc = (degPc + fifthInt) % 12;
 406                                // Preserve mixture accidental (e.g., bII) when present
 143407                                string baseRoman = (mixtureText ?? rn.ToString());
 145408                                if (triQ0 == ChordQuality.Diminished && !baseRoman.Contains("°")) baseRoman += "°";
 222409                                if      (bassPc == degPc) romanText = baseRoman;
 91410                                else if (bassPc == thirdPc) romanText = baseRoman + "6";
 74411                                else if (bassPc == fifthPc) romanText = baseRoman + "64";
 412                            }
 413                        }
 414
 415                        // Fallback: if mixtureText was not available but current romanText indicates a mixture triad
 416                        // (e.g., "bVII"), still compute inversion figures from voicing.
 177417                        if (voicing is FourPartVoicing vExtra && !string.IsNullOrEmpty(romanText))
 418                        {
 177419                            string rt = romanText!;
 177420                            int tonic = (key.TonicMidi % 12 + 12) % 12;
 354421                            int? mixRoot2 = null; ChordQuality mixQ2 = ChordQuality.Unknown;
 422                            // Same longer-first ordering
 177423                            if (rt.StartsWith("bVII")) { mixRoot2 = (tonic + 10) % 12; mixQ2 = ChordQuality.Major; }
 177424                            else if (rt.StartsWith("bIII")) { mixRoot2 = (tonic + 3) % 12; mixQ2 = ChordQuality.Major; }
 177425                            else if (rt.StartsWith("bVI")) { mixRoot2 = (tonic + 8) % 12; mixQ2 = ChordQuality.Major; }
 177426                            else if (rt.StartsWith("bII")) { mixRoot2 = (tonic + 1) % 12; mixQ2 = ChordQuality.Major; }
 177427                            else if (rt.StartsWith("iv")) { mixRoot2 = DegreeRootPcLocal(key, 3); mixQ2 = ChordQuality.M
 181428                            else if (rt.StartsWith("i")) { mixRoot2 = tonic; mixQ2 = ChordQuality.Minor; }
 429
 177430                            if (mixRoot2 is int mr2 && mixQ2 != ChordQuality.Unknown)
 431                            {
 2432                                var tri2 = new Chord(mr2, mixQ2).PitchClasses().ToArray();
 2433                                var set2 = ordered.ToHashSet();
 2434                                if (tri2.All(set2.Contains))
 435                                {
 1436                                    int bassPc2 = (vExtra.B % 12 + 12) % 12;
 1437                                    int thirdInt2 = (mixQ2 == ChordQuality.Minor || mixQ2 == ChordQuality.Diminished) ? 
 2438                                    int fifthInt2 = mixQ2 switch { ChordQuality.Diminished => 6, ChordQuality.Augmented 
 1439                                    int thirdPc2 = (mr2 + thirdInt2) % 12;
 1440                                    int fifthPc2 = (mr2 + fifthInt2) % 12;
 1441                                    if      (bassPc2 == mr2) { /* keep base */ }
 1442                                    else if (bassPc2 == thirdPc2 && !rt.EndsWith("6")) romanText = rt + "6";
 1443                                    else if (bassPc2 == fifthPc2 && !rt.EndsWith("64")) romanText = rt + "64";
 444                                }
 445                            }
 446                        }
 447
 448                        // Supplement: add inversion to secondary triads (V/x or vii°/x) when voicing indicates it
 177449                        if (voicing is FourPartVoicing vSec && !string.IsNullOrEmpty(romanText))
 450                        {
 177451                            string rt2 = romanText!;
 177452                            bool isSecondaryV = rt2.StartsWith("V/");
 177453                            bool isSecondaryVii = rt2.StartsWith("vii°/");
 177454                            if ((isSecondaryV || isSecondaryVii) && ordered.Length == 3 && !(rt2.Contains("6")))
 455                            {
 456                                // parse target after '/'
 11457                                int slash = rt2.IndexOf('/');
 11458                                if (slash > 0 && slash < rt2.Length - 1)
 459                                {
 11460                                    string target = rt2[(slash + 1)..];
 11461                                    int? deg = target switch
 11462                                    {
 3463                                        "ii" => 1,
 0464                                        "iii" => 2,
 0465                                        "IV" => 3,
 2466                                        "V" => 4,
 3467                                        "vi" => 5,
 3468                                        "vii" or "vii°" => 6,
 0469                                        _ => null
 11470                                    };
 11471                                    if (deg is int d)
 472                                    {
 11473                                        int targetPc = DegreeRootPcLocal(key, d);
 11474                                        int root = isSecondaryV ? (targetPc + 7) % 12 : (targetPc + 11) % 12; // V/x or 
 11475                                        int bassPc = (vSec.B % 12 + 12) % 12;
 11476                                        int third = (root + (isSecondaryV ? 4 : 3)) % 12;
 11477                                        int fifth = (root + (isSecondaryV ? 7 : 6)) % 12;
 11478                                        if (bassPc == third) romanText = (isSecondaryV ? "V6/" : "vii°6/") + target;
 11479                                        else if (bassPc == fifth) romanText = (isSecondaryV ? "V64/" : "vii°64/") + targ
 480                                    }
 481                                }
 482                            }
 483                        }
 484                    }
 485                }
 486            }
 487        }
 488
 489        // 7) 最終セーフティ: V9 を常に再確認（上書き許可）
 290490    if (ChordRomanizer.TryRomanizeDominantNinth(ordered, key, out var v9b)
 290491     || ChordRomanizer.TryRomanizeDominantNinth(raw, key, out v9b))
 492        {
 0493        var funcV2 = RomanNumeralUtils.FunctionOf(RomanNumeral.V);
 0494        var v9label2 = options is not null && options.PreferV7Paren9OverV9 ? "V7(9)" : v9b;
 0495        return new HarmonyAnalysisResult(true, RomanNumeral.V, funcV2, v9label2, warnings, errors);
 496        }
 497
 498    // 8) 最終セーフティ: 4音以上かつボイシングありで借用7th/二次属7th/二次導七に一致するなら上書き
 290499    if (voicing is FourPartVoicing vFinal && ordered.Length >= 4 && ChordRomanizer.TryRomanizeSeventhMixture(pcs, key, o
 500        {
 0501            RomanNumeral baseRn = mix7Final!.StartsWith("iv") ? RomanNumeral.iv
 0502                : mix7Final!.StartsWith("bII") ? RomanNumeral.II
 0503                : mix7Final!.StartsWith("bVI") ? RomanNumeral.VI
 0504                : RomanNumeral.VII;
 0505            var funcMix = RomanNumeralUtils.FunctionOf(baseRn);
 0506            AddMixtureSeventhWarnings(warnings, mix7Final!, key, vFinal);
 0507            return new HarmonyAnalysisResult(true, baseRn, funcMix, mix7Final, warnings, errors);
 508        }
 290509        if (voicing is FourPartVoicing vFinal2 && ordered.Length >= 4)
 510        {
 0511            if (ChordRomanizer.TryRomanizeSecondaryDominant(pcs, key, vFinal2, out var secDomFinal))
 0512                return new HarmonyAnalysisResult(true, RomanNumeral.V, TonalFunction.Dominant, secDomFinal, warnings, er
 0513            if (ChordRomanizer.TryRomanizeSecondaryLeadingTone(pcs, key, vFinal2, options, out var secLtFinal))
 0514                return new HarmonyAnalysisResult(true, RomanNumeral.vii, TonalFunction.Dominant, secLtFinal, warnings, e
 515        }
 516
 517        // 8) ボイシング診断（任意）
 290518        if (voicing is FourPartVoicing v)
 519        {
 286520            if (VoiceLeadingRules.HasRangeViolation(v)) errors.Add("Range violation");
 1980521            foreach (var (voice, midi) in v.Notes())
 522            {
 792523                var range = VoiceRanges.ForVoice(voice);
 1093524                if (!range.InHardRange(midi) && range.InWarnRange(midi)) warnings.Add($"{voice} near range (±M3)");
 525            }
 199526            if (VoiceLeadingRules.HasSpacingViolations(v)) warnings.Add("Wide spacing S-A or A-T");
 214527            if (!v.IsOrderedTopDown()) errors.Add("Voices not ordered S>=A>=T>=B");
 198528            if (prev is FourPartVoicing p)
 529            {
 102530                if (VoiceLeadingRules.HasOverlap(p, v)) errors.Add("Voice overlap");
 114531                if (VoiceLeadingRules.HasParallelPerfects(p, v)) warnings.Add("Parallel perfects detected");
 532            }
 533        }
 534
 535        // 8.5) セーフティ: 一般ダイアトニック7thの再判定（万一ここまで未検出の場合）
 290536        if (ChordRomanizer.TryRomanizeSeventh(pcs, key, out var rn7Late, out var degree7Late, out var q7Late))
 537        {
 538            string? labelLate;
 0539            if (voicing is FourPartVoicing v7Late)
 540            {
 0541                int rootLate = DegreeRootPcLocal(key, degree7Late);
 0542                var chord7Late = new Chord(rootLate, q7Late).PitchClasses().ToArray();
 0543                int bassPcLate = (v7Late.B % 12 + 12) % 12;
 0544                int thirdLate = chord7Late.First(pc => pc != rootLate && (((pc - rootLate + 12) % 12) == 3 || ((pc - roo
 0545                int fifthIntLate = q7Late is ChordQuality.DiminishedSeventh or ChordQuality.HalfDiminishedSeventh ? 6 : 
 0546                int fifthLate = (rootLate + fifthIntLate) % 12;
 0547                int sevIntLate = q7Late switch { ChordQuality.MajorSeventh => 11, ChordQuality.DiminishedSeventh => 9, _
 0548                int sevLate = (rootLate + sevIntLate) % 12;
 0549                string headAccL = q7Late switch
 0550                {
 0551                    ChordQuality.MajorSeventh when options.IncludeMajInSeventhInversions => rn7Late + "maj",
 0552                    ChordQuality.HalfDiminishedSeventh => rn7Late + "ø",
 0553                    ChordQuality.DiminishedSeventh => rn7Late + "°",
 0554                    _ => rn7Late.ToString()
 0555                };
 0556                if      (bassPcLate == rootLate) labelLate = rn7Late + SeventhRootSuffix(q7Late);
 0557                else if (bassPcLate == thirdLate) labelLate = headAccL + "65";
 0558                else if (bassPcLate == fifthLate) labelLate = headAccL + "43";
 0559                else if (bassPcLate == sevLate)   labelLate = headAccL + "42";
 0560                else                              labelLate = rn7Late + SeventhRootSuffix(q7Late);
 0561                labelLate = EnsureSeventhAccidental(rn7Late, q7Late, labelLate);
 562                // Strong enforcement for diminished-type sevenths: recompute figure unconditionally from voicing
 0563                if (q7Late == ChordQuality.DiminishedSeventh || q7Late == ChordQuality.HalfDiminishedSeventh)
 564                {
 0565                    string head = rn7Late + (q7Late == ChordQuality.DiminishedSeventh ? "°" : "ø");
 0566                    if      (bassPcLate == rootLate) labelLate = head + "7";
 0567                    else if (bassPcLate == thirdLate) labelLate = head + "65";
 0568                    else if (bassPcLate == fifthLate) labelLate = head + "43";
 0569                    else if (bassPcLate == sevLate)   labelLate = head + "42";
 570                }
 0571                if ((q7Late == ChordQuality.DiminishedSeventh || q7Late == ChordQuality.HalfDiminishedSeventh)
 0572                    && labelLate.EndsWith("7") && !labelLate.EndsWith("maj7"))
 573                {
 0574                    int bpc = bassPcLate;
 0575                    int thirdPc = (rootLate + 3) % 12;
 0576                    int fifthPc = (rootLate + (q7Late == ChordQuality.DiminishedSeventh || q7Late == ChordQuality.HalfDi
 0577                    int sevPc = (rootLate + (q7Late == ChordQuality.DiminishedSeventh ? 9 : 10)) % 12;
 0578                    string head = rn7Late + (q7Late == ChordQuality.DiminishedSeventh ? "°" : (q7Late == ChordQuality.Ha
 0579                    if      (bpc == thirdPc) labelLate = head + "65";
 0580                    else if (bpc == fifthPc) labelLate = head + "43";
 0581                    else if (bpc == sevPc)   labelLate = head + "42";
 582                }
 0583                if ((q7Late == ChordQuality.DiminishedSeventh || q7Late == ChordQuality.HalfDiminishedSeventh)
 0584                    && !labelLate.Contains('°') && !labelLate.Contains('ø') && labelLate.StartsWith(rn7Late.ToString()))
 585                {
 0586                    labelLate = labelLate.Insert(rn7Late.ToString().Length, q7Late == ChordQuality.DiminishedSeventh ? "
 587                }
 588            }
 589            else
 590            {
 0591                labelLate = rn7Late + SeventhRootSuffix(q7Late);
 0592                labelLate = EnsureSeventhAccidental(rn7Late, q7Late, labelLate);
 593            }
 0594            var func7Late = RomanNumeralUtils.FunctionOf(rn7Late);
 0595            if ((q7Late == ChordQuality.DiminishedSeventh || q7Late == ChordQuality.HalfDiminishedSeventh) && labelLate 
 596            {
 0597                if (!l1.Contains('°') && !l1.Contains('ø'))
 598                {
 0599                    string sym = q7Late == ChordQuality.DiminishedSeventh ? "°" : "ø";
 0600                    if (l1.StartsWith("vii")) l1 = "vii" + sym + l1.Substring(3);
 0601                    else if (l1.StartsWith("VII")) l1 = "VII" + sym + l1.Substring(3);
 0602                    labelLate = l1;
 603                }
 604            }
 0605            return new HarmonyAnalysisResult(true, rn7Late, func7Late, labelLate, warnings, errors);
 606        }
 607
 290608        if (hasRn)
 609        {
 610            // Final safety: if this is a mixture triad and inversion suffix is missing, enforce based on voicing
 611            try
 612            {
 287613                if (ordered.Length == 3 && voicing is FourPartVoicing vMixt && !string.IsNullOrEmpty(romanText))
 614                {
 196615                    string rt = romanText!;
 616                    // Target only mixture heads where triad inversion figures apply
 196617                    int tonic = (key.TonicMidi % 12 + 12) % 12;
 392618                    int? mixRootF = null; ChordQuality mixQF = ChordQuality.Unknown;
 200619                    if (rt.StartsWith("bVII")) { mixRootF = (tonic + 10) % 12; mixQF = ChordQuality.Major; }
 196620                    else if (rt.StartsWith("bIII")) { mixRootF = (tonic + 3) % 12; mixQF = ChordQuality.Major; }
 201621                    else if (rt.StartsWith("bVI")) { mixRootF = (tonic + 8) % 12; mixQF = ChordQuality.Major; }
 213622                    else if (rt.StartsWith("bII")) { mixRootF = (tonic + 1) % 12; mixQF = ChordQuality.Major; }
 177623                    else if (rt.StartsWith("iv")) { mixRootF = DegreeRootPcLocal(key, 3); mixQF = ChordQuality.Minor; }
 181624                    else if (rt.StartsWith("i")) { mixRootF = tonic; mixQF = ChordQuality.Minor; }
 625
 196626                    if (mixRootF is int mrF && mixQF != ChordQuality.Unknown)
 627                    {
 21628                        var triF = new Chord(mrF, mixQF).PitchClasses().ToArray();
 21629                        var setF = ordered.ToHashSet();
 21630                        if (triF.All(setF.Contains))
 631                        {
 20632                            int bassF = (vMixt.B % 12 + 12) % 12;
 20633                            int thirdIntF = (mixQF == ChordQuality.Minor || mixQF == ChordQuality.Diminished) ? 3 : 4;
 40634                            int fifthIntF = mixQF switch { ChordQuality.Diminished => 6, ChordQuality.Augmented => 8, _ 
 20635                            int thirdPcF = (mrF + thirdIntF) % 12;
 20636                            int fifthPcF = (mrF + fifthIntF) % 12;
 20637                            bool hasFig6 = rt.EndsWith("6");
 20638                            bool hasFig64 = rt.EndsWith("64");
 20639                            if (!hasFig64 && !hasFig6)
 640                            {
 5641                                if (bassF == thirdPcF) romanText = rt + "6";
 5642                                else if (bassF == fifthPcF) romanText = rt + "64";
 643                            }
 644                        }
 645                    }
 646                }
 287647            }
 0648            catch { /* safety must not throw */ }
 287649            var func = RomanNumeralUtils.FunctionOf(rn);
 650            // Neapolitan (bII) diagnostics & optional enforcement
 651            try
 652            {
 653                // Only triads (distinct 3 PCs) participate in inversion diagnostics here
 287654                if (ordered.Length == 3)
 655                {
 287656                    var rt = romanText ?? rn.ToString();
 287657                    if (!string.IsNullOrEmpty(rt) && rt.StartsWith("bII"))
 658                    {
 659                        // Resolution hint (informational)
 19660                        warnings.Add("Neapolitan: typical resolution to V");
 661
 662                        // Prefer bII6 over root or 64 when voicing indicates those
 19663                        if (voicing is FourPartVoicing vNeap)
 664                        {
 13665                            int tonicPcN = (key.TonicMidi % 12 + 12) % 12;
 13666                            int neapRoot = (tonicPcN + 1) % 12; // bII root
 13667                            int bassPcN = (vNeap.B % 12 + 12) % 12;
 13668                            bool isRootPos = bassPcN == neapRoot;
 669                            // compute fifth pc for completeness
 13670                            int fifthPcN = (neapRoot + 7) % 12;
 13671                            bool isSecondInv = bassPcN == fifthPcN;
 13672                            if ((rt == "bII" && isRootPos) || (rt == "bII64" && isSecondInv))
 673                            {
 8674                                warnings.Add("Neapolitan: prefer bII6 (first inversion)");
 675                            }
 676
 677                            // Optional enforcement: relabel to bII6 when enabled
 13678                            if (options.EnforceNeapolitanFirstInversion)
 679                            {
 680                                // Enforce only on plain triads (not sevenths), which we are in
 681                                // If already 6, leave as is. Otherwise coerce to 6 when head is bII
 3682                                if (!rt.EndsWith("6") || rt.EndsWith("64"))
 683                                {
 2684                                    romanText = "bII6";
 685                                }
 686                            }
 687                        }
 6688                        else if (options.EnforceNeapolitanFirstInversion)
 689                        {
 690                            // Without voicing, still coerce to bII6 when enabled (pedagogical style)
 6691                            if (rt == "bII" || rt == "bII64") romanText = "bII6";
 692                        }
 693                    }
 694                }
 287695            }
 0696            catch { /* diagnostics must not break analysis */ }
 287697            return new HarmonyAnalysisResult(true, rn, func, romanText, warnings, errors);
 698        }
 699
 700        // 9) 何も一致しない
 3701        return new HarmonyAnalysisResult(false, null, TonalFunction.Unknown, null, warnings, errors);
 702    }
 703
 704    private static ChordQuality? GetTriadQualityFromRoman(RomanNumeral rn, bool isMajor)
 705    {
 287706        return rn switch
 287707        {
 248708            RomanNumeral.I or RomanNumeral.IV or RomanNumeral.V => ChordQuality.Major,
 5709            RomanNumeral.ii or RomanNumeral.iii or RomanNumeral.vi => ChordQuality.Minor,
 2710            RomanNumeral.vii => ChordQuality.Diminished,
 5711            RomanNumeral.i or RomanNumeral.iv or RomanNumeral.v => ChordQuality.Minor,
 5712            RomanNumeral.III or RomanNumeral.VII => isMajor ? null : ChordQuality.Major,
 22713            _ => null
 287714        };
 715    }
 716
 717    private static string BuildSeventhLabel(RomanNumeral rn7, int degree, ChordQuality q7, Key key, FourPartVoicing voic
 718    {
 32719        int root = DegreeRootPcLocal(key, degree);
 32720        int bassPc = (voicing.B % 12 + 12) % 12;
 32721        int thirdInt = q7 switch
 32722        {
 18723            ChordQuality.MajorSeventh or ChordQuality.DominantSeventh => 4,
 14724            _ => 3
 32725        };
 32726        int fifthInt = q7 is ChordQuality.DiminishedSeventh or ChordQuality.HalfDiminishedSeventh ? 6 : 7;
 64727        int sevInt = q7 switch { ChordQuality.MajorSeventh => 11, ChordQuality.DiminishedSeventh => 9, _ => 10 };
 32728        int delta = (bassPc - root + 12) % 12;
 32729        string head = q7 switch
 32730        {
 15731            ChordQuality.MajorSeventh when options.IncludeMajInSeventhInversions => rn7 + "maj",
 5732            ChordQuality.HalfDiminishedSeventh => rn7 + "ø",
 4733            ChordQuality.DiminishedSeventh => rn7 + "°",
 18734            _ => rn7.ToString()
 32735        };
 32736        string fig = delta switch
 32737        {
 9738            0 => SeventhRootSuffix(q7),
 32739            var d when d == thirdInt => "65",
 21740            var d when d == fifthInt => "43",
 14741            var d when d == sevInt => "42",
 0742            _ => SeventhRootSuffix(q7)
 32743        };
 744        // Avoid duplicating accidentals: when fig already includes '°7' or 'ø7', do not prepend head with symbol.
 32745        string label = fig switch
 32746        {
 4747            "7" => rn7 + fig,
 2748            "maj7" => rn7 + fig,
 1749            "°7" => rn7 + fig,
 2750            "ø7" => rn7 + fig,
 23751            _ => head + fig
 32752        };
 32753        label = EnsureSeventhAccidental(rn7, q7, label);
 32754        return label;
 755    }
 756
 757    private static int? DegreeFromRoman(RomanNumeral rn, bool isMajor)
 758    {
 177759        return rn switch
 177760        {
 86761            RomanNumeral.I or RomanNumeral.i => 0,
 1762            RomanNumeral.II or RomanNumeral.ii => 1,
 0763            RomanNumeral.III or RomanNumeral.iii => 2,
 59764            RomanNumeral.IV or RomanNumeral.iv => 3,
 28765            RomanNumeral.V or RomanNumeral.v => 4,
 1766            RomanNumeral.VI or RomanNumeral.vi => 5,
 2767            RomanNumeral.VII or RomanNumeral.vii => 6,
 0768            _ => null
 177769        };
 770    }
 771
 772    private static ChordQuality? SeventhQualityInMajor(int degree)
 773    {
 0774        return degree switch
 0775        {
 0776            0 => ChordQuality.MajorSeventh,     // Imaj7
 0777            1 => ChordQuality.MinorSeventh,     // ii7
 0778            2 => ChordQuality.MinorSeventh,     // iii7
 0779            3 => ChordQuality.MajorSeventh,     // IVmaj7
 0780            4 => ChordQuality.DominantSeventh,  // V7
 0781            5 => ChordQuality.MinorSeventh,     // vi7
 0782            6 => ChordQuality.HalfDiminishedSeventh, // viiø7
 0783            _ => null
 0784        };
 785    }
 786
 787    private static ChordQuality? SeventhQualityInMinor(int degree)
 788    {
 789        // Harmonic minor diatonic sevenths:
 790        // i7, iiø7, IIImaj7, iv7, V7, VImaj7, vii°7 (or ø7 depending). We'll use fully diminished for leading-tone seve
 0791        return degree switch
 0792        {
 0793            0 => ChordQuality.MinorSeventh,             // i7
 0794            1 => ChordQuality.HalfDiminishedSeventh,     // iiø7
 0795            2 => ChordQuality.MajorSeventh,              // IIImaj7
 0796            3 => ChordQuality.MinorSeventh,              // iv7
 0797            4 => ChordQuality.DominantSeventh,           // V7
 0798            5 => ChordQuality.MajorSeventh,              // VImaj7
 0799            6 => ChordQuality.DiminishedSeventh,         // vii°7
 0800            _ => null
 0801        };
 802    }
 803
 804    private static string SeventhRootSuffix(ChordQuality q)
 805    {
 17806        return q switch
 17807        {
 5808            ChordQuality.MajorSeventh => "maj7",
 2809            ChordQuality.HalfDiminishedSeventh => "ø7",
 1810            ChordQuality.DiminishedSeventh => "°7",
 9811            _ => "7"
 17812        };
 813    }
 814
 815    private static int DegreeRootPcLocal(Key key, int degree)
 816    {
 231817        if (key.IsMajor)
 818        {
 217819            return (key.ScaleDegreeMidi(degree) % 12 + 12) % 12;
 820        }
 821        else
 822        {
 14823            if (degree == 6)
 824            {
 6825                int tonicPc = (key.TonicMidi % 12 + 12) % 12;
 6826                return (tonicPc + 11) % 12;
 827            }
 8828            return (key.ScaleDegreeMidi(degree) % 12 + 12) % 12;
 829        }
 830    }
 831
 832    private static string EnsureSeventhAccidental(RomanNumeral rn, ChordQuality q, string label)
 833    {
 834        // Ensure '°' or 'ø' is present before inversion figures for diminished/half-diminished sevenths
 71835        if (q != ChordQuality.DiminishedSeventh && q != ChordQuality.HalfDiminishedSeventh) return label;
 18836        if (label.Contains('°') || label.Contains('ø')) return label;
 0837        var head = rn.ToString();
 0838        int idx = label.IndexOf(head);
 0839        if (idx < 0)
 840        {
 841            // Fallback: insert after the initial roman head letters (e.g., 'vii' in 'vii65')
 0842            int pos = 0;
 0843            while (pos < label.Length && char.IsLetter(label[pos])) pos++;
 0844            if (pos == 0) return label; // no letters found; give up
 0845            int insertPosFallback = pos;
 0846            string symFallback = q == ChordQuality.DiminishedSeventh ? "°" : "ø";
 0847            return label.Insert(insertPosFallback, symFallback);
 848        }
 0849        int insertPos = idx + head.Length;
 0850        string sym = q == ChordQuality.DiminishedSeventh ? "°" : "ø";
 0851        return label.Insert(insertPos, sym);
 852    }
 853}
Generated by: ReportGenerator 5.4.17.0
10/08/2025 - 01:23:29
GitHub | reportgenerator.io

Methods/Properties

AddMixtureSeventhWarnings(System.Collections.Generic.List`1<System.String>,System.String,MusicTheory.Theory.Harmony.Key,System.Nullable`1<MusicTheory.Theory.Harmony.FourPartVoicing>)
AnalyzeTriad(System.Int32[],MusicTheory.Theory.Harmony.Key,System.Nullable`1<MusicTheory.Theory.Harmony.FourPartVoicing>,System.Nullable`1<MusicTheory.Theory.Harmony.FourPartVoicing>)
AnalyzeTriad(System.Int32[],MusicTheory.Theory.Harmony.Key,MusicTheory.Theory.Harmony.HarmonyOptions,System.Nullable`1<MusicTheory.Theory.Harmony.FourPartVoicing>,System.Nullable`1<MusicTheory.Theory.Harmony.FourPartVoicing>)
GetTriadQualityFromRoman(MusicTheory.Theory.Harmony.RomanNumeral,System.Boolean)
BuildSeventhLabel(MusicTheory.Theory.Harmony.RomanNumeral,System.Int32,MusicTheory.Theory.Harmony.ChordQuality,MusicTheory.Theory.Harmony.Key,MusicTheory.Theory.Harmony.FourPartVoicing,MusicTheory.Theory.Harmony.HarmonyOptions)
DegreeFromRoman(MusicTheory.Theory.Harmony.RomanNumeral,System.Boolean)
SeventhQualityInMajor(System.Int32)
SeventhQualityInMinor(System.Int32)
SeventhRootSuffix(MusicTheory.Theory.Harmony.ChordQuality)
DegreeRootPcLocal(MusicTheory.Theory.Harmony.Key,System.Int32)
EnsureSeventhAccidental(MusicTheory.Theory.Harmony.RomanNumeral,MusicTheory.Theory.Harmony.ChordQuality,System.String)