예제 #1
0
        public void ClassifySongsTogether()
        {
            string positivitySvmPath = System.IO.Path.Combine(Classifier.ExecutableInformation.getModelsDir(), positiveClassificationMethod);
            string energySvmPath     = System.IO.Path.Combine(Classifier.ExecutableInformation.getModelsDir(), energyClassificationMethod);

            Classifier.SupportVectorMachine svm = new Classifier.SupportVectorMachine(positivitySvmPath, energySvmPath);
            List <string> unclassifiedSongs     = new List <string>();

            foreach (string song in songs)
            {
                if (!ServerDatabase.Instance.DoesSongExist(song))
                {
                    unclassifiedSongs.Add(song);
                }
            }
            //Don't try to reclassify the same song. Waste of time.
            string output = svm.Classify(unclassifiedSongs);

            foreach (ClassifierResult result in JsonDTOMapper.getJsonDTO(output).ClassifierResults)
            {
                Song            classifiedSong = result.song;
                EmotionSpaceDTO point          = new EmotionSpaceDTO(classifiedSong.energy, classifiedSong.positivity);
                ServerDatabase.Instance.addSongToDatabase(classifiedSong.title, point);
            }
        }
예제 #2
0
        public List <string> getSongs(int numberOfSongs, EmotionSpaceDTO emotionSpaceDTO)
        {
            Dictionary <string, EmotionSpaceDTO> songs          = new Dictionary <string, EmotionSpaceDTO>();
            Action <SQLiteDataReader>            addSongsToDict = (rdr) =>
            {
                while (rdr.Read())
                {
                    EmotionSpaceDTO point = new EmotionSpaceDTO();
                    point.Energy            = rdr.GetDouble(1);
                    point.Positivity        = rdr.GetDouble(2);
                    songs[rdr.GetString(0)] = point;
                }
            };

            getAllSongs(addSongsToDict);
            if (songs.Count < numberOfSongs)
            {
                numberOfSongs = songs.Count;
            }
            List <SongDistance> closeSongs = new List <SongDistance>(numberOfSongs);


            double farPoint = double.MinValue;

            foreach (KeyValuePair <string, EmotionSpaceDTO> kvp in songs)
            {
                SongDistance val = new SongDistance();
                val.distance = getDistance(emotionSpaceDTO, kvp.Value);
                val.song     = kvp.Key;
                if (closeSongs.Count < numberOfSongs)
                {
                    closeSongs.Add(val);
                    if (farPoint < val.distance)
                    {
                        farPoint = val.distance;
                    }
                }
                else
                {
                    if (val.distance < farPoint)
                    {
                        closeSongs.Add(val);
                        closeSongs.Sort(compareDistance);
                        closeSongs.RemoveAt(closeSongs.Count - 1);
                    }
                }
            }

            List <string> ret = new List <string>();

            foreach (SongDistance finalVal in closeSongs)
            {
                ret.Add(finalVal.song);
            }
            return(ret);
        }
예제 #3
0
        public void Classify()
        {
            Classifier clas = new Classifier();

            foreach (string song in songs)
            {
                if (!ServerDatabase.Instance.DoesSongExist(song))
                {
                    //Don't try to reclassify the same song. Waste of time.
                    string          output         = clas.classify(song);
                    Song            classifiedSong = JsonDTOMapper.getJsonDTO(output).ClassifierResults[0].song;
                    EmotionSpaceDTO point          = new EmotionSpaceDTO(classifiedSong.energy, classifiedSong.positivity);
                    ServerDatabase.Instance.addSongToDatabase(song, point);
                }
            }
        }
예제 #4
0
 /// <summary>
 /// Adds a song to the database
 /// </summary>
 /// <param name="songpath">The location of the song</param>
 /// <param name="emotionSpaceDTO">The coordinates in the emotionspace</param>
 public void addSongToDatabase(string songpath, EmotionSpaceDTO emotionSpaceDTO)
 {
     try
     {
         using (SQLiteConnection connection = Connect())
         {
             using (SQLiteTransaction tranaction = connection.BeginTransaction())
             {
                 using (SQLiteCommand command = connection.CreateCommand())
                 {
                     command.Transaction = tranaction;
                     command.CommandText = string.Format("INSERT INTO SONGS (Path, Energy, Postitvity) VALUES (\"{0}\",{1},{2})", songpath, emotionSpaceDTO.Energy, emotionSpaceDTO.Positivity);
                     command.ExecuteNonQuery();
                 }
                 tranaction.Commit();
             }
         }
     }
     catch
     {
         //This is likely trying to add a song twice. Just silently fail
     }
 }
예제 #5
0
 private double getDistance(EmotionSpaceDTO pointA, EmotionSpaceDTO pointB)
 {
     return(Math.Sqrt(Math.Pow(pointA.Energy - pointB.Energy, 2) + Math.Pow(pointA.Positivity - pointB.Positivity, 2)));
 }