Пример #1
0
        // This returns the patch names from the PNAMES lump
        // A directory resource does not support this lump, but the wads in the directory may contain this lump
        public override PatchNames LoadPatchNames()
        {
            PatchNames pnames;

            // Error when suspended
            if (issuspended)
            {
                throw new Exception("Data reader is suspended");
            }

            // Load from wad files
            // Note the backward order, because the last wad's images have priority
            for (int i = wads.Count - 1; i >= 0; i--)
            {
                pnames = wads[i].LoadPatchNames();
                if (pnames != null)
                {
                    return(pnames);
                }
            }

            // If none of the wads provides patch names, let's see if we can
            string pnamesfile = FindFirstFile("PNAMES", false);

            if ((pnamesfile != null) && FileExists(pnamesfile))
            {
                MemoryStream pnamesdata = LoadFile(pnamesfile);
                pnames = new PatchNames(pnamesdata);
                pnamesdata.Dispose();
                return(pnames);
            }

            return(null);
        }
        public SamplingWithReplacement(CompositionCategory cat, PatchNames instrument)
        {
            this.MaxIterations = 200;
            this.MaxLength = 100;
            this.instrument = instrument;
            this.category = cat;
            random = new SimpleRNG();
            random.SetSeedFromSystemTime();
            model = new MarkovChain<Note>(1);
            foreach(var comp in cat.Compositions)
            {
                foreach(var track in comp.Tracks)
                {
                    if (!IsValidTrack(track))
                        continue;

                    var mel = (track.GetMainSequence() as MelodySequence).Clone() as MelodySequence;
                    mel.StandardizeDuration();
                    model.Add(mel.ToArray());

                    break;//only first track
                }
            }

            CalculateStats();
        }
Пример #3
0
        public HMMGenerator(PatchNames instrument)
        {
            this.book = new Codebook<Note>();
            this.instrument = instrument;

            DotNetLearn.Data.SampleSet asdasd;

            Accord.Math.Tools.SetupGenerator(10);

            // Consider some phrases:
            //
            string[][] phrases =
            {
            "The Big Brown Fox Jumps Over the Ugly Dog".Split(new char[]{' '},  StringSplitOptions.RemoveEmptyEntries),
            "This is too hot to handle".Split(new char[]{' '},  StringSplitOptions.RemoveEmptyEntries),
            "I am flying away like a gold eagle".Split(new char[]{' '},  StringSplitOptions.RemoveEmptyEntries),
            "Onamae wa nan desu ka".Split(new char[]{' '},  StringSplitOptions.RemoveEmptyEntries),
            "And then she asked, why is it so small?".Split(new char[]{' '},  StringSplitOptions.RemoveEmptyEntries),
            "Great stuff John! Now you will surely be promoted".Split(new char[]{' '},  StringSplitOptions.RemoveEmptyEntries),
            "Jayne was taken aback when she found out her son was gay".Split(new char[]{' '},  StringSplitOptions.RemoveEmptyEntries),
            };

            // Let's begin by transforming them to sequence of
            // integer labels using a codification codebook:
            var codebook = new Codification("Words", phrases);

            // Now we can create the training data for the models:
            int[][] sequence = codebook.Translate("Words", phrases);

            // To create the models, we will specify a forward topology,
            // as the sequences have definite start and ending points.
            //
            var topology = new Forward(states: codebook["Words"].Symbols);
            int symbols = codebook["Words"].Symbols; // We have 7 different words

            // Create the hidden Markov model
            HiddenMarkovModel hmm = new HiddenMarkovModel(topology, symbols);

            // Create the learning algorithm
            var teacher = new ViterbiLearning(hmm);

            // Teach the model about the phrases
            double error = teacher.Run(sequence);

            // Now, we can ask the model to generate new samples
            // from the word distributions it has just learned:
            //
            List<int> sample = new List<int>();
            int count = 10;
            sample.Add(hmm.Generate(1)[0]);
            while(sample.Count < count)
            {
                var k = hmm.Predict(sample.ToArray(), 1);
                sample.AddRange(k);
            }

            // And the result will be: "those", "are", "words".
            string[] result = codebook.Translate("Words", sample.ToArray());
        }
Пример #4
0
 public void Play(MelodySequence seq, PatchNames instrument = PatchNames.Acoustic_Grand)
 {
     if (playingThread != null)
         playingThread.Abort();
     player.SetPatch((int)instrument, 1);
     playingThread = new System.Threading.Thread(() => player.Play(seq));
     playingThread.Start();
 }
Пример #5
0
 public PlaybackMessage(PatchNames patch, byte channel_)
 {
     message = PlaybackMessageType.Patch;
     velocity = (byte)patch;
     channel = channel_;
     pitch = 0;
     duration = 0;
     tag = null;
 }
 public ReflectingBrownNoteGenerator(
         NoteRangeRestrictor nrr, Random randGen,
         int lowestPitchChange, int highestPitchChange,
         int lowestLengthStep, int highestLengthStep, PatchNames instrument = PatchNames.Acoustic_Grand)
     : base(nrr, lowestPitchChange, highestPitchChange,
         lowestLengthStep, highestLengthStep)
 {
     this.instrument = instrument;
     this.MaxNotes = 200;
     gen = randGen;
 }
Пример #7
0
        public GeneticGenerator(IFitnessFunction fitnessFunction, PatchNames instrument = PatchNames.Acoustic_Grand, CompositionCategory cat=null)
        {
            this.fitnessFunction = fitnessFunction;
            this.cat = cat;
            this.MaxGenerations = 1000;
            this.PrintProgress = true;
            this.instrument = instrument;

            if (cat != null)
            {
                // Markov generator
                var mark = new MarkovChainGenerator(instrument, 2);

                // Allowed notes
                HashSet<Durations> durs = new HashSet<Durations>();
                HashSet<int> fullPitches = new HashSet<int>();

                foreach(var c in cat.Compositions)
                {
                    if (c.Tracks.Count < 1)
                        continue;
                    var cloneMel = (c.Tracks[0].GetMainSequence() as MelodySequence).Clone() as MelodySequence;

                    cloneMel.StandardizeDuration();
                    mark.AddMelody(cloneMel);

                    foreach (var n in cloneMel.Notes)
                    {
                        durs.Add(NoteGene.GetClosestDuration(n.Duration));
                        fullPitches.Add(n.Pitch);
                    }

                    avgLength += cloneMel.Length;
                }
                avgLength /= cat.Compositions.Length;
                GPCustomTree.generator = mark;

                NoteGene.AllowedDurations = durs.ToArray();
                NoteGene.AllowedFullPitches = fullPitches.ToArray();

            }
        }
Пример #8
0
        public MarkovGenerator(MelodySequence[] seqs, PatchNames instrument = PatchNames.Acoustic_Grand)
        {
            this.instrument = instrument;

            int count = seqs.Length;
            note_map = new Dictionary<Note, int>();

            int pitch = 0;
            int j = 0;
            pitches = new int[seqs.Length][];
            foreach (MelodySequence m in seqs)
            {
                Note[] song = m.ToArray();
                pitches[j] = new int[m.Length];

                for (int i = 0; i < song.Length; i++)
                {
                    if (note_map.ContainsKey(song[i]))
                    {

                    }
                    else
                    {
                        note_map[song[i]] = pitch++;
                    }
                    pitches[j][i] = note_map[song[i]];
                }
                j++;
                if (m.Length > max_length)
                    max_length = m.Length;
            }

            hmm = new HiddenMarkovModel(3, pitch+1);
            var teacher = new BaumWelchLearning(hmm);
            teacher.Iterations = 10000;
            teacher.Run(pitches);

            Console.WriteLine("Done training");
        }
Пример #9
0
 static void Play(IEnumerable<Note> notes, PatchNames instrument = PatchNames.Vibraphone)
 {
     MusicPlayer player = new MusicPlayer();
     player.SetPatch((int)instrument, 1);
     player.PlayNotes(notes);
     player.Close();
 }
Пример #10
0
 public Track(PatchNames instrument, byte channel)
 {
     this.Instrument = instrument;
     this.Channel = channel;
     sequences = new List<ISequence>();
 }
 public AccompanimentGeneratorANNFF(CompositionCategory category, PatchNames instrument)
 {
     this.Epochs = 50000;
     this.category = category;
     this.instrument = instrument;
 }
Пример #12
0
 public AccompanimentGenerator(CompositionCategory category, PatchNames instrument)
 {
     this.category = category;
     this.instrument = instrument;
 }
 public ExistingSequenceGenerator(MelodySequence sequence, PatchNames instrument)
 {
     this.sequence = sequence;
     this.instrument = instrument;
 }
Пример #14
0
 public MelodySequence GenerateInstrument(PatchNames patch)
 {
     Random r = new Random();
     int randomSeed = r.Next();
     return GenerateInstrument(patch, randomSeed);
 }
Пример #15
0
        public TrackGenerator(CompositionCategory category, Composition comp)
        {
            this.category = category;
            InitializeComponent();

            // Load data for accompany instruments
            string path = "save/" + category.CategoryName;
            if(System.IO.Directory.Exists(path))
            {
                var files = System.IO.Directory.GetFiles(path);
                foreach(var file in files)
                {
                    try
                    {
                        string filename = System.IO.Path.GetFileNameWithoutExtension(file);
                        if (!filename.ToLower().Contains("accomp_ann_ff_"))
                            continue;
                        var sub = filename.Substring(14);

                        PatchNames instrument = (PatchNames)(int.Parse(sub));

                        if(!accompInstruBox.Items.Contains(instrument))
                            accompInstruBox.Items.Add(instrument);
                    }
                    catch(Exception E)
                    {
                        Console.WriteLine(E);
                    }
                }
            }

            // Load data for accompany tracks
            if(comp != null)
                for(int i = 0; i < comp.Tracks.Count; i++)
                {
                    var track = comp.Tracks[i];

                    ComboBoxItem item = new ComboBoxItem();
                    item.Content = string.Format("Track {0} - {1}", i.ToString(), track.Instrument.ToString());
                    item.Tag = track;

                    accompTrackBox.Items.Add(item);
                }

            randomScale.Items.Clear();
            foreach(var s in Scales.ScaleTypes)
            {
                //ListBoxItem item = new ListBoxItem();
                randomScale.Items.Add(s);
            }

            randomInstrument.Items.Clear();
            var popularInstruments = new PatchNames[]{PatchNames.Acoustic_Grand,PatchNames.String_Ensemble_1,
                PatchNames.Acoustic_Bass,PatchNames.Trumpet,PatchNames.Violin,PatchNames.Electric_Grand,
                PatchNames.French_Horn,PatchNames.Flute,PatchNames.Trombone,PatchNames.Acoustic_Guitarnylon, PatchNames.Orchestral_Strings};
            foreach (var d in popularInstruments)
            {
                loadInstrument.Items.Add(d);
                geneticInstrumentBox.Items.Add(d);
                randomInstrument.Items.Add(d);
            }

            StopSpinner();

            LoadInstrumentalData();
        }
Пример #16
0
 public MelodySequence GenerateInstrument(PatchNames patch, int seed)
 {
     lastInstrument = patch;
     var chain = instruments[patch];
     return new MelodySequence(chain.Chain(MaxNotes,seed));
 }
Пример #17
0
 public void SetInstrument(PatchNames instrument)
 {
     this.lastInstrument = instrument;
 }
Пример #18
0
        // This loads the textures
        public override ICollection <ImageData> LoadTextures(PatchNames pnames)
        {
            Dictionary <long, ImageData> images = new Dictionary <long, ImageData>();
            ICollection <ImageData>      collection;
            List <ImageData>             imgset = new List <ImageData>();

            // Error when suspended
            if (issuspended)
            {
                throw new Exception("Data reader is suspended");
            }

            // Load from wad files (NOTE: backward order, because the last wad's images have priority)
            for (int i = wads.Count - 1; i >= 0; i--)
            {
                collection = wads[i].LoadTextures(pnames);
                AddImagesToList(images, collection);
            }

            // Should we load the images in this directory as textures?
            if (roottextures)
            {
                collection = LoadDirectoryImages("", ImageDataFormat.DOOMPICTURE, false);
                AddImagesToList(images, collection);
            }

            // Add images from texture directory
            collection = LoadDirectoryImages(TEXTURES_DIR, ImageDataFormat.DOOMPICTURE, true);
            AddImagesToList(images, collection);

            // Load TEXTURE1 lump file
            imgset.Clear();
            string texture1file = FindFirstFile("TEXTURE1", false);

            if ((texture1file != null) && FileExists(texture1file))
            {
                MemoryStream filedata = LoadFile(texture1file);
                WADReader.LoadTextureSet("TEXTURE1", filedata, ref imgset, pnames);
                filedata.Dispose();
            }

            // Load TEXTURE2 lump file
            string texture2file = FindFirstFile("TEXTURE2", false);

            if ((texture2file != null) && FileExists(texture2file))
            {
                MemoryStream filedata = LoadFile(texture2file);
                WADReader.LoadTextureSet("TEXTURE2", filedata, ref imgset, pnames);
                filedata.Dispose();
            }

            // Add images from TEXTURE1 and TEXTURE2 lump files
            AddImagesToList(images, imgset);

            // Load TEXTURES lump file
            imgset.Clear();
            string[] alltexturefiles = GetAllFilesWithTitle("", "TEXTURES", false);
            foreach (string texturesfile in alltexturefiles)
            {
                MemoryStream filedata = LoadFile(texturesfile);
                WADReader.LoadHighresTextures(filedata, texturesfile, ref imgset, images, null);
                filedata.Dispose();
            }

            // Add images from TEXTURES lump file
            AddImagesToList(images, imgset);

            // Add images to the container-specific texture set
            foreach (ImageData img in images.Values)
            {
                textureset.AddImage(img);
            }

            return(new List <ImageData>(images.Values));
        }
 public AccompanyGeneratorMarkov(CompositionCategory cat, PatchNames instrument)
 {
     this.instrument = instrument;
     Add(cat);
 }
Пример #20
0
 MelodySequence GenerateInstrument(PatchNames patch, int seed)
 {
     var chain = instruments[patch];
     return new MelodySequence(chain.Chain(100,seed));
 }
Пример #21
0
 public MarkovChainGenerator(PatchNames instrument, int order = 3, int length = 150)
 {
     this.instrument = instrument;
     this.chain = new MarkovChain<Note>(order);
     this.MaxLength = length;
 }
Пример #22
0
        static void TrainANNFFAccomp()
        {
            Console.WriteLine("This application trains accompaniment neural networks");
            var cats = Databank.GetCategories();

            Databank db = new Databank("lib");

            var popularInstruments = new PatchNames[]{PatchNames.Acoustic_Grand,PatchNames.String_Ensemble_1,
                PatchNames.Acoustic_Bass,PatchNames.Trumpet,PatchNames.Vibraphone,PatchNames.Electric_Grand,
                PatchNames.French_Horn,PatchNames.Flute,PatchNames.Trombone,PatchNames.Music_Box};

            foreach (var catName in cats)
            {

                Console.WriteLine("Category {0}", catName);
                var cat = db.Load(catName);

                if (cat.Compositions.Length > 3000)
                    Console.WriteLine("Skipping category {0} due to length", cat.CategoryName);

                foreach (var instr in popularInstruments)
                {
                    Console.WriteLine("Training ANN for {0} - {1}, {2} epochs", cat.ToString(), instr.ToString(), 6000);

                    try
                    {
                        AccompanimentGeneratorANNFF ann = new AccompanimentGeneratorANNFF(cat, instr);
                        ann.Epochs = 5000;
                        ann.Train();
                    }
                    catch (Exception e)
                    {
                        Console.WriteLine(e.Message);
                    }

                }

            }

            Console.ReadLine();
        }
Пример #23
0
 static void Play(MelodySequence notes, PatchNames instrument = PatchNames.Vibraphone)
 {
     MusicPlayer player = new MusicPlayer();
     player.SetPatch((int)instrument, 1);
     player.Play(notes);
     player.Close();
 }
Пример #24
0
        private void Button_Click_3(object sender, RoutedEventArgs e)
        {
            Composition comp;
            Microsoft.Win32.OpenFileDialog dlg = new Microsoft.Win32.OpenFileDialog();

            dlg.DefaultExt = ".mid";
            dlg.Filter = "MIDI Files (*.mid)|*.mid";
            dlg.Title = "Load MIDI file";

            Nullable<bool> result = dlg.ShowDialog();

            if (result == true)
            {
                comp = Composition.LoadFromMIDI(dlg.FileName);

                TrackSelector trackSel = new TrackSelector(comp);
                if(trackSel.ShowDialog() == true)
                {
                    this.GeneratedSequence = trackSel.SelectedSequence;
                    this.Instrument = trackSel.SelectedInstrument;
                    this.Generator = new ExistingSequenceGenerator(this.GeneratedSequence, this.Instrument);
                    this.DialogResult = true;
                    this.Close();
                }
            }
        }
Пример #25
0
        private void Generate()
        {
            int index = optionsTab.SelectedIndex;

            progressGenSlider.Value = 0;

            if (index == 0)
            {
                if (geneticInstrumentBox.SelectedItem == null)
                    return;

                fitnessPlot.ResetAllAxes();
                SetupLinePlot(fitnessPlot, "Average Fitness");
                (fitnessPlot.Model.Series[0] as LineSeries).Points.Clear();
                fitnessPlot.Model.Series[0].Unselect();
                fitnessPlot.InvalidatePlot();

                //GA
                IFitnessFunction fitness = null;

                //Options
                List<IMetric> activeMetrics = new List<IMetric>();
              //  if (metricChromaticTone.IsChecked == true)
              //      activeMetrics.Add(new ChromaticTone());
                if (metricChromaticToneDistance.IsChecked == true)
                    activeMetrics.Add(new ChromaticToneDistance());
                if (metricChromaticToneDuration.IsChecked == true)
                    activeMetrics.Add(new ChromaticToneDuration());
                if (metricMelodicBigram.IsChecked == true)
                    activeMetrics.Add(new MelodicBigram());
                if (metricMelodicInterval.IsChecked == true)
                    activeMetrics.Add(new MelodicInterval());
             //   if (metricPitch.IsChecked == true)
             //       activeMetrics.Add(new Pitch());
            //    if (metricPitchDistance.IsChecked == true)
             //       activeMetrics.Add(new PitchDistance());
            //    if (metricRhythm.IsChecked == true)
            //        activeMetrics.Add(new Rhythm());
                if (metricRhythmicBigram.IsChecked == true)
                    activeMetrics.Add(new RhythmicBigram());
                if (metricRhythmicInterval.IsChecked == true)
                    activeMetrics.Add(new RhythmicInterval());

                fitness = GeneticMIDI.FitnessFunctions.MetricSimilarity.GenerateMetricSimilarityMulti(category.Compositions, activeMetrics.ToArray(), GeneticMIDI.FitnessFunctions.SimilarityType.Cosine);
                /*
                if (fitnessFuncCombo.SelectedIndex == 0)
                    fitness = new GeneticMIDI.FitnessFunctions.MetricSimilarity(seq, activeMetrics.ToArray(), GeneticMIDI.FitnessFunctions.SimilarityType.Cosine);
                if (fitnessFuncCombo.SelectedIndex == 1)
                    fitness = new GeneticMIDI.FitnessFunctions.MetricSimilarity(seq, activeMetrics.ToArray(), GeneticMIDI.FitnessFunctions.SimilarityType.Euclidian);
                if (fitnessFuncCombo.SelectedIndex == 2)
                    fitness = new GeneticMIDI.FitnessFunctions.MetricSimilarity(seq, activeMetrics.ToArray(), GeneticMIDI.FitnessFunctions.SimilarityType.Pearson);
                if (fitnessFuncCombo.SelectedIndex == 3)
                    fitness = new GeneticMIDI.FitnessFunctions.CrossCorrelation(seq);
                if (fitnessFuncCombo.SelectedIndex == 4)
                    fitness = GeneticMIDI.FitnessFunctions.NCD.FromMelodies(category);*/

                Instrument = (PatchNames)geneticInstrumentBox.SelectedItem;

                var gen = new GeneticGenerator(fitness, Instrument, category);
                gen.OnPercentage += gen_OnPercentage;

                gen.MaxGenerations = (int)maxGenerationSlider.Value;
                Generator = gen;

                new Thread(() =>
                {
                    var notes = gen.Generate();

                    var mel = notes;
                    GeneratedSequence = mel;
                    progressGenSlider.Dispatcher.Invoke(() =>
                    {
                        progressGenSlider.Value = 100;
                    });
                }).Start();
            }
            if (index == 1)
            {
                if (instrBox.SelectedItem as ListBoxItem == null || (instrBox.SelectedItem as ListBoxItem).Tag == null)
                    return;
                if ((int)((instrBox.SelectedItem as ListBoxItem).Tag) == -1)
                {
                    // Drum Generator
                    DrumGenerator gen = new DrumGenerator();

                    Generator = gen;

                    Instrument = PatchNames.Helicopter;

                    new Thread(() =>
                    {
                            StartSpinner();
                            gen.Initialize(new Databank(GeneticMIDI.Constants.LOCAL_LIBRARY_PATH));
                            GeneratedSequence = gen.Generate();
                            StopSpinner();

                        progressGenSlider.Dispatcher.Invoke(() =>
                        {
                            progressGenSlider.Value = 100;
                        });

                    }).Start();

                }
                else
                {
                    PatchNames instrument = (PatchNames)((instrBox.SelectedItem as ListBoxItem).Tag);
                    Instrument = instrument;

                    InstrumentalGenerator gen = Generator as InstrumentalGenerator;
                    if (gen == null)
                        return;

                    gen.SetInstrument(Instrument);

                    new Thread(() =>
                    {
                        if (gen.IsInitialized)
                        {
                            StartSpinner();
                            GeneratedSequence = gen.GenerateInstrument(instrument);
                            StopSpinner();
                        }

                        progressGenSlider.Dispatcher.Invoke(() =>
                        {
                            progressGenSlider.Value = 100;
                        });

                    }).Start();
                }
            }
            if(index == 2)
            {
                if (accompInstruBox.Items.Count == 0 || accompTrackBox.Items.Count == 0)
                    return;
                Instrument = (PatchNames)(accompInstruBox.SelectedItem);
                Track track = (accompTrackBox.SelectedItem as ListBoxItem).Tag as Track;

                var melSeq = track.GetMainSequence() as MelodySequence;
                Random rnd = new Random();
                if(accompMethoBox.SelectedIndex == 0)
                {
                    AccompanyGeneratorMarkov gen = new AccompanyGeneratorMarkov(category, Instrument);
                    Generator = gen;
                    new Thread(() =>
                        {

                            StartSpinner();
                            GeneratedSequence = gen.Generate(melSeq,rnd.Next());
                            StopSpinner();
                            progressGenSlider.Dispatcher.Invoke(() =>
                            {
                                progressGenSlider.Value = 100;
                            });
                        }).Start();
                }
                else if (accompMethoBox.SelectedIndex == 1)
                {
                    AccompanimentGeneratorANNFF gen = new AccompanimentGeneratorANNFF(category, Instrument);
                    Generator = gen;
                    gen.SetSequence(melSeq);
                    new Thread(() =>
                        {

                            StartSpinner();
                            gen.Load();
                            GeneratedSequence = gen.Generate();

                            StopSpinner();
                            progressGenSlider.Dispatcher.Invoke(() =>
                                {
                                    progressGenSlider.Value = 100;
                                });

                        }).Start();
                }

            }
            if(index == 3)
            {
                //stochasticLogPlot.Model.Series.Clear();
                stochasticLogPlot.ResetAllAxes();
                SetupLinePlot(stochasticLogPlot, "Log Likelihood");
                (stochasticLogPlot.Model.Series[0] as LineSeries).Points.Clear();
                stochasticLogPlot.Model.Series[0].Unselect();
                stochasticLogPlot.InvalidatePlot();

                if (loadInstrument.SelectedItem == null)
                    return;
                Instrument = (PatchNames)(loadInstrument.SelectedItem);

                SamplingWithReplacement swr = new SamplingWithReplacement(category, Instrument);
                swr.OnProgressChange += swr_OnProgressChange;
                swr.MaxIterations = (int)loadGenerationsSlider.Value;

                Generator = swr;

                new Thread(() =>
                {
                    StartSpinner();
                    GeneratedSequence = swr.Generate();
                    StopSpinner();
                    progressGenSlider.Dispatcher.Invoke(() =>
                    {
                        progressGenSlider.Maximum = 100;
                        progressGenSlider.Value = 100;
                    });

                }).Start();

            }
            if(index == 4)
            {
                if (randomInstrument.SelectedItem == null)
                    return;
                Instrument = (PatchNames)randomInstrument.SelectedItem;

                int centralNotePitch = (int)randomOctave.Value * 12;
                int noteShift = (int)randomPitchVar.Value;
                int minNote = centralNotePitch - noteShift;
                int maxNote = centralNotePitch + noteShift;
                if (minNote <= 0)
                    minNote = 1;
                if (maxNote >= 127)
                    maxNote = 126;
                int durMin = (int)Math.Pow(randomDurationRange.LowerValue, 2);
                int durMax = (int)Math.Pow(randomDurationRange.UpperValue, 2);
                int length = (int)randomLength.Value;

                ScaleType scale = randomScale.SelectedItem as ScaleType;

                var gen = new ReflectingBrownNoteGenerator(new NoteRangeRestrictor(minNote, maxNote, durMin, durMax, scale), new Random(), -2, 2, -1, 1, Instrument);
                Generator = gen;
                gen.MaxNotes = length;

                new Thread(() =>
                {
                    StartSpinner();
                    GeneratedSequence = gen.Generate();
                    StopSpinner();
                    progressGenSlider.Dispatcher.Invoke(() =>
                    {
                        progressGenSlider.Value = 100;
                    });

                }).Start();

                Console.ReadLine();
            }
        }
Пример #26
0
 void listBoxItem_MouseDoubleClick(object sender, MouseButtonEventArgs e)
 {
     Track track = (sender as ListBoxItem).Tag as Track;
     this.SelectedSequence = track.GetMainSequence() as MelodySequence;
     this.SelectedInstrument = track.Instrument;
     this.DialogResult = true;
     this.Close();
 }