NET OwnChordDetect API Reference

public static class ChordDetect
{
    // File-based chord detection with key and tempo detection
    public static (List<TimedChord>, MusicalKey, int) DetectFromFile(
        string audioFile,
        float intervalSecond = 1.0f);
    
    // Real-time chord detection from note list
    public static (string chord, float stability) DetectRealtime(
        List<Note> notes,
        DetectionMode mode = DetectionMode.Optimized,
        int buffersize = 5);
}

public class ChordDetector
{
    public ChordDetector(
        DetectionMode mode = DetectionMode.Basic,
        float confidenceThreshold = 0.7f,
        float ambiguityThreshold = 0.0f,
        int bufferSize = 0);
    
    // Main detection methods
    public (string chord, float confidence) DetectChord(List<Note> notes);
    public ChordAnalysis AnalyzeChord(List<Note> notes);
    public (string chord, float stability) ProcessNotes(List<Note> newNotes);
    
    // Key management
    public MusicalKey DetectKeyFromNotes(List<Note> notes);
    public void SetKey(MusicalKey key);
}

public class BaseChordDetector : ChordDetector
{
    public BaseChordDetector(float confidenceThreshold = 0.7f)
        : base(DetectionMode.Basic, confidenceThreshold) { }
}

public class ExtendedChordDetector : ChordDetector
{
    public ExtendedChordDetector(float confidenceThreshold = 0.6f)
        : base(DetectionMode.Extended, confidenceThreshold) { }
}

public class OptimizedChordDetector : ChordDetector
{
    public OptimizedChordDetector(
        float confidenceThreshold = 0.6f,
        float ambiguityThreshold = 0.1f)
        : base(DetectionMode.Optimized, confidenceThreshold, ambiguityThreshold) { }
    
    public (string chord, float confidence, bool isAmbiguous, string[] alternatives) 
        DetectChordAdvanced(List<Note> notes);
}

public class KeyAwareChordDetector : ChordDetector
{
    public KeyAwareChordDetector(
        float confidenceThreshold = 0.6f,
        float ambiguityThreshold = 0.0f)
        : base(DetectionMode.KeyAware, confidenceThreshold, ambiguityThreshold) { }
}

public class RealTimeChordDetector
{
    public RealTimeChordDetector(
        int bufferSize = 5,
        DetectionMode mode = DetectionMode.Optimized);
    
    public (string chord, float stability) ProcessNotes(List<Note> newNotes);
}

public class SongChordAnalyzer
{
    public SongChordAnalyzer(
        float windowSize = 1.0f,
        float hopSize = 0.5f,
        float minimumChordDuration = 0.8f,
        float confidence = 0.6f);
    
    public MusicalKey? DetectedKey { get; }
    
    public List<TimedChord> AnalyzeSong(List<Note> songNotes);
    public List<TimedChord> AnalyzeSongInKey(List<Note> songNotes, MusicalKey key);
}

public class TimedChord
{
    public float StartTime { get; }      // Start time in seconds
    public float EndTime { get; }        // End time in seconds
    public string ChordName { get; }     // Chord name (e.g., "Cm7")
    public float Confidence { get; }     // Detection confidence (0.0 to 1.0)
    public string[] Notes { get; }       // Note names in the chord
    
    public override string ToString();
}

public class ChordAnalysis
{
    public string ChordName { get; }      // Detected chord name
    public float Confidence { get; }      // Confidence level (0.0 to 1.0)
    public string Explanation { get; }    // Detailed explanation
    public string[] NoteNames { get; }    // Notes forming the chord
    public bool IsAmbiguous { get; set; } // Whether detection is ambiguous
    public string[] Alternatives { get; set; } // Alternative chord names
    public int[] PitchClasses { get; set; }    // Pitch classes used
    public float[] Chromagram { get; set; }    // Chromagram data
    
    public override string ToString();
}

public class MusicalKey
{
    public string KeyName { get; }              // Key name (e.g., "C", "F#", "Bb")
    public bool IsMajor { get; }                // Major (true) or Minor (false)
    public int Sharps { get; }                  // Number of sharps (0-7)
    public int Flats { get; }                   // Number of flats (0-7)
    public string[] PreferredNoteNames { get; } // Note naming preference
    
    public override string ToString(); // Returns "KeyName major/minor"
}

public class KeyDetector
{
    public MusicalKey DetectKey(List<Note> notes);
}

public static class ChordTemplates
{
    // Get note name for pitch class with key context
    public static string GetNoteName(int pitchClass, MusicalKey? key = null);
    
    // Create chord template from pitch classes
    public static float[] CreateTemplate(int[] pitchClasses);
    
    // Create all chord templates with key-aware naming
    public static Dictionary<string, float[]> CreateAllTemplates(
        MusicalKey? key = null,
        bool includeExtended = true);
}

public enum DetectionMode
{
    Basic,      // Basic triads and simple chords only
    Extended,   // Includes 7th, 9th, 11th, 13th chords
    Optimized,  // Extended + ambiguity analysis
    KeyAware    // Optimized + key-aware note naming
}

using OwnaudioNET.Features.OwnChordDetect;

// Detect chords from audio file
var (chords, key, tempo) = ChordDetect.DetectFromFile(
    audioFile: "song.mp3",
    intervalSecond: 1.0f
);

Console.WriteLine($"Detected key: {key}");
Console.WriteLine($"Detected tempo: {tempo} BPM");
Console.WriteLine($"Found {chords.Count} chords:");

foreach (var chord in chords)
{
    Console.WriteLine($"  {chord.StartTime:F1}s - {chord.EndTime:F1}s: " +
                     $"{chord.ChordName} (confidence: {chord.Confidence:F2})");
    Console.WriteLine($"    Notes: {string.Join(", ", chord.Notes)}");
}

using OwnaudioNET.Features.OwnChordDetect;
using OwnaudioNET.Features.OwnChordDetect.Detectors;

// Initialize real-time detector
var detector = new RealTimeChordDetector(
    bufferSize: 5,
    mode: DetectionMode.Optimized
);

// Process incoming notes
List<Note> currentNotes = GetCurrentNotes(); // Your note input

var (chord, stability) = detector.ProcessNotes(currentNotes);

Console.WriteLine($"Current chord: {chord}");
Console.WriteLine($"Stability: {stability:P1}");

// Alternative using static method
var (chord2, stability2) = ChordDetect.DetectRealtime(
    currentNotes,
    DetectionMode.Optimized,
    buffersize: 5
);

using OwnaudioNET.Features.OwnChordDetect.Analysis;

// Create analyzer with custom parameters
var analyzer = new SongChordAnalyzer(
    windowSize: 1.0f,           // 1 second windows
    hopSize: 0.5f,              // 0.5 second steps
    minimumChordDuration: 1.0f, // Min 1 second chords
    confidence: 0.90f           // 90% confidence threshold
);

// Analyze song (auto-detect key)
List<Note> songNotes = GetNotesFromAudio(); // Your note extraction
var chords = analyzer.AnalyzeSong(songNotes);

Console.WriteLine($"Detected key: {analyzer.DetectedKey}");

// Or analyze with specified key
var key = new MusicalKey("F#", true, 6, 0, sharpNoteNames);
var chordsInKey = analyzer.AnalyzeSongInKey(songNotes, key);

using OwnaudioNET.Features.OwnChordDetect.Detectors;

// Use optimized detector with ambiguity detection
var detector = new OptimizedChordDetector(
    confidenceThreshold: 0.6f,
    ambiguityThreshold: 0.1f
);

List<Note> notes = GetNotes();
var (chord, confidence, isAmbiguous, alternatives) = 
    detector.DetectChordAdvanced(notes);

Console.WriteLine($"Detected: {chord} (confidence: {confidence:F2})");

if (isAmbiguous)
{
    Console.WriteLine("Ambiguous detection!");
    Console.WriteLine($"Alternatives: {string.Join(", ", alternatives)}");
}

// Get detailed analysis
var analysis = detector.AnalyzeChord(notes);
Console.WriteLine(analysis.ToString());

using OwnaudioNET.Features.OwnChordDetect.Core;

// Create key detector
var keyDetector = new KeyDetector();

// Detect key from notes
List<Note> notes = GetNotesFromSong();
var key = keyDetector.DetectKey(notes);

Console.WriteLine($"Detected key: {key.KeyName} {(key.IsMajor ? "major" : "minor")}");
Console.WriteLine($"Sharps: {key.Sharps}, Flats: {key.Flats}");
Console.WriteLine($"Preferred notes: {string.Join(", ", key.PreferredNoteNames)}");

// Use key for chord detection
var detector = new KeyAwareChordDetector();
detector.SetKey(key);
var (chord, confidence) = detector.DetectChord(notes);

using OwnaudioNET.Features.OwnChordDetect.Core;

// Get note name with key context
var key = new MusicalKey("Bb", true, 0, 2, flatNoteNames);
string noteName = ChordTemplates.GetNoteName(10, key); // Returns "Bb"

// Create custom chord template
int[] pitchClasses = { 0, 4, 7 }; // Major triad
float[] template = ChordTemplates.CreateTemplate(pitchClasses);

// Get all chord templates for a key
var templates = ChordTemplates.CreateAllTemplates(
    key: key,
    includeExtended: true
);

Console.WriteLine($"Generated {templates.Count} chord templates");
foreach (var kvp in templates.Take(10))
{
    Console.WriteLine($"{kvp.Key}: {string.Join(", ", kvp.Value.Select(v => v.ToString("F2")))}");
}