feat: Vibrato Variation, "Randomize pitch deviation" batch edit

OpenUtau.Core/Commands/NoteCommands.cs

@@ -454,6 +454,113 @@ public override void Unexecute() {
         }
     }
 
+    public class VibratoVariationDepthCommand : VibratoCommand {
+        readonly UNote note;
+        readonly float newVariation;
+        readonly float oldVariation;
+
+        public VibratoVariationDepthCommand(UVoicePart part, UNote note, float variation) : base(part, note) {
+            this.note = note;
+            newVariation = variation;
+            oldVariation = note.vibrato.variation;
+        }
+
+        public override string ToString() {
+            return "Change vibrato variation depth";
+        }
+
+        public override void Execute() {
+            lock (Part) {
+                note.vibrato.variation = newVariation;
+            }
+        }
+        public override void Unexecute() {
+            lock (Part) {
+                note.vibrato.variation = oldVariation;
+            }
+        }
+    }
+
+    public class VibratoPitchVariationCommand : VibratoCommand {
+        readonly UNote note;
+        readonly float newPitchVariation;
+        readonly float oldPitchVariation;
+
+        public VibratoPitchVariationCommand(UVoicePart part, UNote note, float pitchVariation) : base(part, note) {
+            this.note = note;
+            newPitchVariation = pitchVariation;
+            oldPitchVariation = note.vibrato.pitchVariation;
+        }
+
+        public override string ToString() {
+            return "Change vibrato pitch variation depth";
+        }
+
+        public override void Execute() {
+            lock (Part) {
+                note.vibrato.pitchVariation = newPitchVariation;
+            }
+        }
+        public override void Unexecute() {
+            lock (Part) {
+                note.vibrato.pitchVariation = oldPitchVariation;
+            }
+        }
+    }
+
+    public class VibratoVariationFrequencyCommand : VibratoCommand {
+        readonly UNote note;
+        readonly float newVariationFreq;
+        readonly float oldVariationFreq;
+
+        public VibratoVariationFrequencyCommand(UVoicePart part, UNote note, float frequency) : base(part, note) {
+            this.note = note;
+            newVariationFreq = frequency;
+            oldVariationFreq = note.vibrato.variationFreq;
+        }
+
+        public override string ToString() {
+            return "Change vibrato variation frequency";
+        }
+
+        public override void Execute() {
+            lock (Part) {
+                note.vibrato.variationFreq = newVariationFreq;
+            }
+        }
+        public override void Unexecute() {
+            lock (Part) {
+                note.vibrato.variationFreq = oldVariationFreq;
+            }
+        }
+    }
+
+    public class VibratoVariationSeedCommand : VibratoCommand {
+        readonly UNote note;
+        readonly int newVariationSeed;
+        readonly int oldVariationSeed;
+
+        public VibratoVariationSeedCommand(UVoicePart part, UNote note, int seed) : base(part, note) {
+            this.note = note;
+            newVariationSeed = seed;
+            oldVariationSeed = note.vibrato.variationSeed;
+        }
+
+        public override string ToString() {
+            return "Change vibrato variation seed";
+        }
+
+        public override void Execute() {
+            lock (Part) {
+                note.vibrato.variationSeed = newVariationSeed;
+            }
+        }
+        public override void Unexecute() {
+            lock (Part) {
+                note.vibrato.variationSeed = oldVariationSeed;
+            }
+        }
+    }
 
     public class PhonemeOffsetCommand : NoteCommand {
         readonly UNote note;

OpenUtau.Core/Editing/NoteBatchEdits.cs

@@ -4,6 +4,7 @@
 using System.Threading;
 using OpenUtau.Core.Ustx;
 using OpenUtau.Core.Format;
+using SimplexNoise;
 
 namespace OpenUtau.Core.Editing {
     public class AddTailNote : BatchEdit {
@@ -446,6 +447,83 @@ public void Run(UProject project, UVoicePart part, List<UNote> selectedNotes, Do
         }
     }
 
+    public class RandomPitchDeviation : BatchEdit {
+        public virtual string Name => name;
+        private string name;
+        public float noiseScale;
+        public float noiseFrequency;
+
+        public RandomPitchDeviation(float noiseScale, float noiseFrequency) {
+            name = "pianoroll.menu.notes.randompitd";
+            this.noiseScale = noiseScale;
+            this.noiseFrequency = noiseFrequency;
+        }
+
+        public void Run(UProject project, UVoicePart part, List<UNote> selectedNotes, DocManager docManager) {
+            if (selectedNotes.Count == 0) {
+                return;
+            }
+            docManager.StartUndoGroup("command.batch.note", true);
+
+            Random random = new Random();
+            int seed = random.Next();
+            int numOctaves = 4;
+            float baseScale = 0.25F;
+            float coarseFrequency = 0.001F;
+
+            var pitdCurve = part.curves.Find(c => c.abbr.Equals(Format.Ustx.PITD));
+            if (pitdCurve == null) {
+                // hmmm...
+                if (project.expressions.TryGetValue(Format.Ustx.PITD, out var descriptor)) {
+                    pitdCurve = new UCurve(descriptor);
+                    part.curves.Add(pitdCurve);
+                }
+            }
+
+            foreach(var note in selectedNotes) {
+                var start = note.position;
+                var end = note.position + note.duration;
+                int numSamples = note.duration;
+
+                float[] noiseSum = new float[numSamples];
+                Array.Fill(noiseSum, 0);
+
+                // when summing together the noise values in this manner
+                // 510 is the highest possible sum (for values generated by Calc1D, [0, 255]).
+                // multiplying by (1 - 0.5 ^ numOctaves) calculates
+                // the precise highest value based on the number of octaves
+
+                // i wanted to have a dialog for changing octaves and seed but that would be too 
+                // many single dialogs for a user to have to click through, IMO
+                float highestValue = 510 * (1 - (float)Math.Pow(0.5, numOctaves));
+                for (int i = 0; i < numOctaves; i++) {
+                    Noise.Seed = seed;
+
+                    float octaveInfluence = (float)Math.Pow(2, i);
+                    float octaveFrequency = (coarseFrequency * noiseFrequency) * (4 * octaveInfluence);
+                    float[] noise = Noise.Calc1D(numSamples, octaveFrequency);
+                    for (int j = 0; j < noise.Length; j++) {
+                        noiseSum[j] += noise[j] / octaveInfluence;
+                    }
+
+                    seed = random.Next();
+                }
+
+                for (int i = 0; i < noiseSum.Length; i++) {
+                    int curveValue = pitdCurve.Sample(start + i);
+                    float noiseValue = (noiseSum[i] - (highestValue / 2)) * baseScale;
+                    curveValue += (int)Math.Round(noiseValue * noiseScale);
+                    docManager.ExecuteCmd(new SetCurveCommand(project, part, Format.Ustx.PITD,
+                        start + i, curveValue,
+                        start + i, 0
+                    ));
+                }
+            }
+
+            docManager.EndUndoGroup();
+        }
+    }
+
     public class LoadRenderedPitch : BatchEdit {
         public virtual string Name => name;
 

OpenUtau.Core/Format/USTx.cs

@@ -10,7 +10,7 @@
 
 namespace OpenUtau.Core.Format {
     public class Ustx {
-        public static readonly Version kUstxVersion = new Version(0, 9);
+        public static readonly Version kUstxVersion = new Version(0, 9, 1);
 
         public const string DYN = "dyn";
         public const string PITD = "pitd";