Esempio n. 1
0
        private void driftCalcButton_Click(object sender, RoutedEventArgs e)
        {
            List <Match> matches = new List <Match>(matchGrid.SelectedItems.Cast <Match>());

            if (matches.Count != 2 || new HashSet <AudioTrack> {
                matches[0].Track1, matches[0].Track2, matches[1].Track1, matches[1].Track2
            }.Count != 2)
            {
                MessageBox.Show("Please select two matches between two tracks!", "Drift calculation failed",
                                MessageBoxButton.OK, MessageBoxImage.Error);
                return;
            }

            Match m1      = matches[0];
            Match m2      = matches[1];
            bool  crossed = m1.Track1 == m2.Track2;

            TimeSpan d1 = (crossed ? m2.Track2Time : m2.Track1Time) - m1.Track1Time;
            TimeSpan d2 = (crossed ? m2.Track1Time : m2.Track2Time) - m1.Track2Time;

            //TimeSpan diff = d2 - d1;
            double driftPercentage = 100d / d1.Ticks * d2.Ticks;

            MessageBox.Show(
                String.Format("Speed of track '{0}' is {2}% compared to track '{1}", m1.Track2.Name, m1.Track2.Name,
                              driftPercentage), "Drift calculation", MessageBoxButton.OK, MessageBoxImage.Information);
        }
Esempio n. 2
0
        private void crossCorrelateButton_Click(object sender, RoutedEventArgs e)
        {
            List <Match> matches = new List <Match>(matchGrid.SelectedItems.Cast <Match>());

            foreach (Match matchFE in matches)
            {
                Match match = matchFE; // needed as reference for async task
                Task.Factory.StartNew(() => {
                    Match ccm = CrossCorrelation.Adjust(match, progressMonitor);
                    Dispatcher.BeginInvoke((Action) delegate {
                        multiTrackViewer.Matches.Add(ccm);
                        matchGrid.Items.Refresh();
                        multiTrackViewer.RefreshAdornerLayer();
                    });
                });
            }
        }
Esempio n. 3
0
        private void addManualMatchPopupAddButton_Click(object sender, RoutedEventArgs e)
        {
            TimeSpan   position = new TimeSpan(multiTrackViewer.VirtualCaretOffset);
            AudioTrack t1       = addManualMatchPopupComboBoxA.SelectedItem as AudioTrack;
            AudioTrack t2       = addManualMatchPopupComboBoxB.SelectedItem as AudioTrack;

            if (t1 != null && t2 != null)
            {
                Match match = new Match {
                    Track1     = t1, Track1Time = position - t1.Offset,
                    Track2     = t2, Track2Time = position - t2.Offset,
                    Similarity = 1,
                    Source     = "User"
                };
                multiTrackViewer.Matches.Add(match);
                matchGrid.SelectedItem = match;
                matchGrid.ScrollIntoView(match);
                addManualMatchPopup.IsOpen = false;
            }
        }
Esempio n. 4
0
        private void matchGrid_MouseDoubleClick(object sender, MouseButtonEventArgs e)
        {
            Match match = matchGrid.SelectedItem as Match;

            if (match != null)
            {
                TimeSpan t1   = match.Track1.Offset + match.Track1Time;
                TimeSpan t2   = match.Track2.Offset + match.Track2Time;
                TimeSpan diff = t1 - t2;
                multiTrackViewer.Display(t1 - new TimeSpan(diff.Ticks / 2), true);
                multiTrackViewer.Display(match);

                if (Keyboard.IsKeyDown(Key.LeftCtrl))
                {
                    // sync
                    MatchProcessor.Align(match);
                }

                if (Keyboard.IsKeyDown(Key.LeftAlt))
                {
                    if (Keyboard.IsKeyDown(Key.LeftShift))
                    {
                        // mute all but selected tracks
                        foreach (AudioTrack t in trackList)
                        {
                            t.Mute = true;
                        }
                        match.Track1.Mute = false;
                        match.Track2.Mute = false;
                    }
                    // start playback
                    MediaCommands.Pause.Execute(null, multiTrackViewer);
                    MediaCommands.Play.Execute(null, multiTrackViewer);
                }
            }
        }
Esempio n. 5
0
        private void dtwButton_Click(object sender, RoutedEventArgs e)
        {
            if (trackList.Count > 1)
            {
                TimeWarpType type = TimeWarpType.DTW;
                if ((bool)dtwRadioButton.IsChecked)
                {
                    type = TimeWarpType.DTW;
                }
                else if ((bool)oltwRadioButton.IsChecked)
                {
                    type = TimeWarpType.OLTW;
                }

                TimeWarpMode mode = TimeWarpMode.SelectedTracks;
                if ((bool)timeWarpModeBorderSectionsRadioButton.IsChecked)
                {
                    mode = TimeWarpMode.BorderSections;
                }
                else if ((bool)timeWarpModeAllSectionsRadioButton.IsChecked)
                {
                    mode = TimeWarpMode.AllSections;
                }

                bool calculateSimilarity = (bool)dtwSimilarityCheckBox.IsChecked;
                bool normalizeSimilarity = (bool)dtwSimilarityNormalizationCheckBox.IsChecked;

                if (mode == TimeWarpMode.SelectedTracks)
                {
                    if (trackList.Count > 1)
                    {
                        var masterTrack = (AudioTrack)multiTrackViewer.SelectedItem;
                        var slaveTracks = new List <AudioTrack>(multiTrackViewer.SelectedItems.Cast <AudioTrack>());
                        slaveTracks.Remove(masterTrack);

                        Task.Factory.StartNew(() => {
                            Parallel.ForEach(slaveTracks,
                                             new ParallelOptions {
                                MaxDegreeOfParallelism = Math.Max(1, Environment.ProcessorCount - 1)
                            },
                                             slaveTrack => {
                                TimeWarp(type,
                                         masterTrack, TimeSpan.Zero, masterTrack.Length,
                                         slaveTrack, TimeSpan.Zero, slaveTrack.Length,
                                         calculateSimilarity, normalizeSimilarity,
                                         false, false);
                            });
                        });
                    }
                }
                else
                {
                    List <MatchGroup> trackGroups = DetermineMatchGroups(MatchFilterMode.None);
                    Task.Factory.StartNew(() => {
                        foreach (MatchGroup trackGroup in trackGroups)
                        {
                            foreach (MatchPair trackPair in trackGroup.MatchPairs)
                            {
                                List <Match> matches = trackPair.Matches.OrderBy(match => match.Track1Time).ToList();
                                Match first          = matches.First();
                                Match last           = matches.Last();

                                //Task.Factory.StartNew(() => {
                                TimeSpan sectionLength = first.Track1Time > first.Track2Time ? first.Track2Time : first.Track1Time;
                                TimeWarp(type,
                                         first.Track1, first.Track1Time - sectionLength, first.Track1Time,
                                         first.Track2, first.Track2Time - sectionLength, first.Track2Time,
                                         calculateSimilarity, normalizeSimilarity,
                                         true, false);
                                //});

                                if (mode == TimeWarpMode.AllSections)
                                {
                                    if (matches.Count > 1)
                                    {
                                        for (int i = 0; i < matches.Count - 1; i++)
                                        {
                                            Match from = matches[i];
                                            Match to   = matches[i + 1];
                                            TimeWarp(type,
                                                     from.Track1, from.Track1Time, to.Track1Time,
                                                     from.Track2, from.Track2Time, to.Track2Time,
                                                     calculateSimilarity, normalizeSimilarity,
                                                     false, false);
                                        }
                                    }
                                }

                                //Task.Factory.StartNew(() => {
                                sectionLength = last.Track1.Length - last.Track1Time > last.Track2.Length - last.Track2Time ?
                                                last.Track2.Length - last.Track2Time : last.Track1.Length - last.Track1Time;
                                TimeWarp(type,
                                         last.Track1, last.Track1Time, last.Track1Time + sectionLength,
                                         last.Track2, last.Track2Time, last.Track2Time + sectionLength,
                                         calculateSimilarity, normalizeSimilarity,
                                         false, true);
                                //});
                            }
                        }
                    });
                }
            }
        }