harmonizer.js

const Max = require("max-api");
const fs = require("fs");
var voices = [];
var currentVoicesIndex = 0;
var currentPitch = undefined;
var currentPreset = { name: "new preset", mapping: [{}, {}] };
const MS = require("musictheoryjs");
let mode = "MIDI";
let currentScale = MS.ScaleTemplates["major"];
let latchMode = false;
let lockMode = false;
let voiceSortMode = "TOP_NOTE"; // DEFAULT, TOP_NOTE

// Store the last output to prevent unnecessary resets
let lastOutput = [0, 0, 0, 0];
// Max.outlet("scales", ...Object.keys(MS.ScaleTemplates));

// Log file path
const LOG_FILE_PATH = "./harmonizer-log.txt";

// Clear the log file at startup
try {
  fs.writeFileSync(LOG_FILE_PATH, `Log started: ${new Date().toISOString()}\n`);
  Max.post("Log file reset");
} catch (err) {
  Max.post("Error resetting log file: " + err.message);
}

// Logging function that writes to a file
const logToFile = (message) => {
  const timestamp = new Date().toISOString();
  const logMessage = `${timestamp}: ${message}\n`;

  try {
    fs.appendFileSync(LOG_FILE_PATH, logMessage);
  } catch (err) {
    Max.post("Error writing to log file: " + err.message);
  }
};

const resetNotes = [0, 0, 0, 0];

Max.addHandler("scale", (scale) => {
  currentScale = MS.ScaleTemplates[scale];
  Max.post("scale", MS.ScaleTemplates[scale]);
});

Max.addHandler("harm-in", (...arr) => {
  if (lockMode) return;

  logToFile(`Received harm-in: ${JSON.stringify(arr)}`);

  assignHarmony(arr);
  outputHarmony();
});

Max.addHandler("latchMode", (m) => {
  latchMode = m;
});

Max.addHandler("lockMode", (m) => {
  lockMode = m;
});

Max.addHandler("voicesPart", (i) => {
  logToFile(`Switching voice part index from ${currentVoicesIndex} to ${i}`);
  currentVoicesIndex = i;
  outputHarmony();
});

Max.addHandler("savePreset", (name) => {
  Max.post("saving preset");
  currentPreset.name = name;
  if (!fs.existsSync("presets")) fs.mkdirSync("presets");
  fs.writeFileSync(
    `./presets/${currentPreset.name}.json`,
    JSON.stringify(currentPreset)
  );
});

Max.addHandler("loadPreset", (name) => {
  Max.post("loading preset " + name);
  currentPreset = JSON.parse(fs.readFileSync(`./presets/${name}`));
  Max.post(currentPreset);
  outputHarmony();
});

Max.addHandler("mode", (type) => {
  mode = type;
});

Max.addHandler("voiceSortMode", (type) => {
  logToFile(`Switching voiceSortMode from ${voiceSortMode} to ${type}`);
  voiceSortMode = type;
  outputHarmony();
});

Max.addHandler("note-in", (pitch) => {
  if (pitch < 0) return;

  logToFile(
    `Received note-in: pitch=${pitch}, mode=${mode}, voiceSortMode=${voiceSortMode}`
  );

  if (mode === "MIDI") {
    midiHarmonize(pitch);
  } else {
    autoHarmonize(pitch);
  }
});

const autoHarmonize = (pitch) => {
  currentPitch = pitch;
  var chord = new MS.Scale(currentScale).notes.map((n) => n._tone);
  // chord.pitch = currentPitch;
  Max.post(chord);

  var chord2 = new MS.Scale(currentScale).shift(1).notes.map((n) => n._tone);
  Max.post(chord2);

  // if (chord) {
  //   var first = chord[0];

  //   var arr = chord.map(function (v) {
  //     if (v === null) {
  //       return 0;
  //     } else {
  //       return v - first;
  //     }
  //   });
  //   outputNotes(resetNotes);
  //   outputNotes(arr);
  // } else {
  //   outputNotes(resetNotes);
  // }
};

const midiHarmonize = (pitch) => {
  currentPitch = pitch;
  var chord = currentPreset.mapping[currentVoicesIndex][pitch];

  logToFile(
    `midiHarmonize: pitch=${pitch}, voiceIndex=${currentVoicesIndex}, chord=${JSON.stringify(
      chord
    )}`
  );

  if (chord) {
    const activeNotes = chord.filter((v) => v !== null);

    logToFile(`midiHarmonize: activeNotes=${JSON.stringify(activeNotes)}`);

    if (activeNotes.length === 0) {
      logToFile(`midiHarmonize: No active notes, outputting resetNotes`);
      outputNotes(resetNotes);
      return;
    }

    let referenceNote;

    if (voiceSortMode === "TOP_NOTE") {
      // Use the highest note as reference
      referenceNote = Math.max(...activeNotes);
      logToFile(`midiHarmonize: TOP_NOTE mode, referenceNote=${referenceNote}`);
    } else {
      // Use the first note as reference
      referenceNote = chord[0];
      logToFile(`midiHarmonize: DEFAULT mode, referenceNote=${referenceNote}`);
    }

    // Calculate intervals from each note to the reference note
    let intervals = chord.map(function (v) {
      if (v === null) {
        return 0;
      } else {
        return v - referenceNote;
      }
    });

    logToFile(
      `midiHarmonize: calculated intervals=${JSON.stringify(intervals)}`
    );
    outputNotes(intervals);
  } else if (latchMode) {
    logToFile(
      `midiHarmonize: No chord found for pitch ${pitch}, latchMode=${latchMode}, outputting resetNotes`
    );
    outputNotes(resetNotes);
  } else {
    logToFile(
      `midiHarmonize: No chord found for pitch ${pitch}, no output (latchMode=${latchMode})`
    );
  }
};

const outputHarmony = () => {
  logToFile(
    `outputHarmony: Start - voices=${JSON.stringify(
      voices
    )}, voiceSortMode=${voiceSortMode}`
  );

  // Filter out null voices and create a copy to work with
  const activeVoices = voices.filter((v) => v !== null);
  logToFile(`outputHarmony: activeVoices=${JSON.stringify(activeVoices)}`);

  if (activeVoices.length === 0) {
    logToFile(`outputHarmony: No active voices, outputting resetNotes`);
    outputNotes(resetNotes);
    return;
  }

  let arrangedVoices = [];
  let referenceNote;

  if (voiceSortMode === "TOP_NOTE") {
    // Find the highest note (top note)
    const topNote = Math.max(...activeVoices);
    referenceNote = topNote;
    logToFile(`outputHarmony: TOP_NOTE mode, topNote=${topNote}`);

    // Sort all voices ascending but put the top note first
    arrangedVoices = [
      topNote,
      ...activeVoices.filter((v) => v !== topNote).sort((a, b) => a - b),
    ];
  } else {
    // Default mode - first voice as reference, sort other voices
    referenceNote = voices[0];
    logToFile(`outputHarmony: DEFAULT mode, referenceNote=${referenceNote}`);

    arrangedVoices = [
      referenceNote,
      ...voices
        .slice(1)
        .filter((v) => v !== null)
        .sort((a, b) => a - b),
    ];
  }

  logToFile(
    `outputHarmony: arrangedVoices=${JSON.stringify(
      arrangedVoices
    )}, referenceNote=${referenceNote}`
  );

  // Calculate intervals based on reference note
  let intervals = voices.map((v) => (v === null ? 0 : v - referenceNote));
  logToFile(`outputHarmony: calculated intervals=${JSON.stringify(intervals)}`);
  outputNotes(intervals);
};

const outputNotes = (notes) => {
  // Ensure we have exactly 4 notes (pad with zeros if needed)
  while (notes.length < 4) {
    notes.push(0);
  }
  notes = notes.slice(0, 4); // Ensure no more than 4
  
  // Put the reference note (0) at the beginning and sort other notes
  // This improves voice leading while maintaining consistent positioning
  
  // First, we'll place the reference note (0) at position 0
  let result = [0, 0, 0, 0]; // Start with all zeros
  
  // Get non-zero notes sorted from highest pitch to lowest
  // This means smallest negative values first (-3 before -7 before -12)
  const nonZeroNotes = notes.filter(n => n !== 0).sort((a, b) => a - b);
  
  // If this is the first chord we're processing (lastOutput is all zeros)
  if (lastOutput.every(n => n === 0) && nonZeroNotes.length > 0) {
    // Simple initial assignment - just place in order
    for (let i = 0; i < nonZeroNotes.length && i < 3; i++) {
      result[i + 1] = nonZeroNotes[i];
    }
    logToFile(`outputNotes: Initial assignment: ${JSON.stringify(result)}`);
  } 
  // For subsequent chords, try to maintain voice continuity
  else if (nonZeroNotes.length > 0) {
    // Find the non-zero notes from the previous output
    const lastNonZeros = lastOutput.filter(n => n !== 0);
    
    // For each position in the previous output that had a non-zero note,
    // find the closest matching note from the new set
    const usedIndices = new Set();
    
    // First, go through positions 1-3 and try to assign notes
    for (let i = 1; i < 4; i++) {
      if (lastOutput[i] !== 0 && nonZeroNotes.length > 0) {
        // Find the closest note that hasn't been used yet
        let closestIndex = -1;
        let minDistance = Infinity;
        
        for (let j = 0; j < nonZeroNotes.length; j++) {
          if (!usedIndices.has(j)) {
            const distance = Math.abs(nonZeroNotes[j] - lastOutput[i]);
            if (distance < minDistance) {
              minDistance = distance;
              closestIndex = j;
            }
          }
        }
        
        if (closestIndex !== -1) {
          result[i] = nonZeroNotes[closestIndex];
          usedIndices.add(closestIndex);
        }
      }
    }
    
    // Assign any remaining notes to empty positions
    let remainingIndex = 0;
    for (let i = 0; i < nonZeroNotes.length; i++) {
      if (!usedIndices.has(i)) {
        // Find the next empty position
        while (remainingIndex < 4 && result[remainingIndex] !== 0) {
          remainingIndex++;
        }
        
        if (remainingIndex < 4) {
          result[remainingIndex] = nonZeroNotes[i];
          remainingIndex++;
        }
      }
    }
    
    logToFile(`outputNotes: Voice-led assignment: ${JSON.stringify(result)}`);
  }
  
  // Compare with last output - only send if different
  const isDifferent = 
    result[0] !== lastOutput[0] || 
    result[1] !== lastOutput[1] || 
    result[2] !== lastOutput[2] || 
    result[3] !== lastOutput[3];
    
  if (isDifferent) {
    logToFile(`outputNotes: Sending to Max (voice-led): ${JSON.stringify(result)}`);
    Max.outlet(["notes", ...result]);
    lastOutput = [...result]; // Store current output as last output
  } else {
    logToFile(`outputNotes: Skipping identical output: ${JSON.stringify(result)}`);
  }
};

const assignHarmony = (arr) => {
  const vel = arr[2];
  const pitch = arr[1];
  const voice = arr[0];

  logToFile(
    `assignHarmony: voice=${voice}, pitch=${pitch}, velocity=${vel}, currentPitch=${currentPitch}`
  );

  if (vel == 0) {
    logToFile(`assignHarmony: Setting voice ${voice - 1} to null (note off)`);
    voices[voice - 1] = null;
  } else {
    logToFile(`assignHarmony: Setting voice ${voice - 1} to pitch ${pitch}`);
    voices[voice - 1] = pitch;

    logToFile(
      `assignHarmony: Saving to preset at currentVoicesIndex=${currentVoicesIndex}, currentPitch=${currentPitch}`
    );
    currentPreset.mapping[currentVoicesIndex][currentPitch] = [...voices];
    logToFile(`assignHarmony: Updated voices array: ${JSON.stringify(voices)}`);
  }
};