public async Task Test_Lookup_Track_AudioFeatures()
{
AudioFeatures item = await _client.LookupAsync <AudioFeatures>(
"1cTZMwcBJT0Ka3UJPXOeeN", LookupType.AudioFeatures);
Assert.IsNotNull(item);
}
public static Task <Track> GetTrackAsync(
this AudioFeatures audioFeatures,
HttpClient httpClient,
IAccessTokenProvider accessTokenProvider,
CancellationToken cancellationToken = default)
{
return(httpClient.GetAsync <Track>(audioFeatures.TrackHref, accessTokenProvider, cancellationToken));
}
// Start is called before the first frame update
void Start()
{
af = GameObject.Find("Audio Source").GetComponent <AudioFeatures>();
cy = GameObject.Find("Cylinder"); //_00000
//m = cy.GetComponent<Renderer>().sharedMaterial;
//.SetFloat("_YourParameter", someValue);
}
void Start()
{
af = GameObject.Find("Audio Source").GetComponent <AudioFeatures>();
m_Vignette = ScriptableObject.CreateInstance <Bloom>();
m_Vignette.enabled.Override(true);
m_Vignette.intensity.Override(1f);
m_Volume = PostProcessManager.instance.QuickVolume(gameObject.layer, 100f, m_Vignette);
}
void Start()
{
numcubes = 100;
cubeindex = 0;
af = GameObject.Find("Audio Source").GetComponent <AudioFeatures>();
//https://answers.unity.com/questions/847848/refer-to-a-parent-rigidbody.html
//daVodaParent.rigidbody;
cubes = new GameObject[numcubes];
body = new Rigidbody[numcubes];
centre = new Vector3(0, 7, -1);
}
public async void UpdateTrack(Track track)
{
_currentTrack = track;
advertLabel.Text = track.IsAd() ? "ADVERT" : "";
timeProgressBar.Maximum = track.Length;
if (track.IsAd())
{
return; //Don't process further, maybe null values
}
titleLinkLabel.Text = track.TrackResource?.Name;
titleLinkLabel.Tag = track.TrackResource?.Uri;
artistLinkLabel.Text = track.ArtistResource?.Name;
artistLinkLabel.Tag = track.ArtistResource?.Uri;
albumLinkLabel.Text = track.AlbumResource?.Name;
albumLinkLabel.Tag = track.AlbumResource?.Uri;
SpotifyUri uri = track.TrackResource?.ParseUri();
trackInfoBox.Text = $@"Track Info - {uri?.Id}";
bigAlbumPicture.Image = track.AlbumResource != null ? await track.GetAlbumArtAsync(AlbumArtSize.Size640, _config.ProxyConfig) : null;
smallAlbumPicture.Image = track.AlbumResource != null ? await track.GetAlbumArtAsync(AlbumArtSize.Size160, _config.ProxyConfig) : null;
SpotifyWebAPI swa = WebControl._spotify;
if (swa != null)
{
AudioFeatures af = swa.GetAudioFeatures(uri?.Id);
// int i = int.Parse(af.Acousticness.ToString());
FloatToTrackbar(af.Acousticness, tbarAcousticness);
FloatToTrackbar(af.Danceability, tbarDanceability);
FloatToTrackbar(af.Energy, tbarEnergy);
FloatToTrackbar(af.Instrumentalness, tbarInstrumentalness);
FloatToTrackbar(af.Liveness, tbarLiveness);
FloatToTrackbar(af.Speechiness, tbarSpeechiness);
FloatToTrackbar(af.Tempo / 100, tbarTempo);
FloatToTrackbar(af.Loudness, tbarLoudness);
FloatToTrackbar(af.Valence, tbarValence);
txtKey.Text = String.Format("{0} {1}", Enum.GetName(typeof(KeyType), af.Key), Enum.GetName(typeof(ModeType), af.Mode));
txtTime.Text = af.TimeSignature.ToString();
}
}
private void LoadAudioFeatures(CSCore.IWaveSource audioSource, float correction, IProgress <string> progress, Song s)
{
var options = DetectorOptions.Default;
options.MinimumTimeDelta = 7.5f;
options.ActivationThreshold = (float)SceneManager.GameSettings["OnsetActivationThreshold"];
options.AdaptiveWhitening = (bool)SceneManager.GameSettings["OnsetAdaptiveWhitening"];
options.Online = (bool)SceneManager.GameSettings["OnsetOnline"];
options.SlicePaddingLength = (float)SceneManager.GameSettings["OnsetSlicePaddingLength"];
options.SliceLength = (float)SceneManager.GameSettings["OnsetSliceLength"];
_audioFeatures = new AudioFeatures(options, SceneManager.Directories["ProcessedSongs"].FullName, correction + (float)_easeInTime, progress);
progress.Report("Extracting audio features");
_audioFeatures.Extract(audioSource, s);
}
public void WriteMetrics(
List <Artist> uniqueArtists,
List <Genre> genres,
List <AudioFeatures> audioFeatures,
AudioFeatures avgAudioFeatures)
{
WriteLine();
WriteLine("METRICS:");
WriteLine("------------------------------------------------------------");
WriteLine();
WriteLine("Top artists:");
WriteLine();
int i = 0;
foreach (var artist in uniqueArtists.OrderByDescending(x => x.TrackCount))
{
WriteLine($"{++i}. {artist.name} - {artist.TrackCount} tracks");
if (i >= configuration.Settings.MetricSettings.TopArtistsToShow)
{
break;
}
}
WriteLine();
WriteLine("Top genres (tracks can have multiple genres):");
WriteLine();
int g = 0;
foreach (var genre in genres.OrderByDescending(x => x.TrackCount))
{
WriteLine($"{++g}. {genre.name} - {genre.TrackCount} tracks");
if (g >= configuration.Settings.MetricSettings.TopGenresToShow)
{
break;
}
}
WriteLine();
WriteLine();
WriteLine($"Number of tracks with Spotify Audio Features data: {audioFeatures.Count()}");
WriteLine();
WriteLine($"Avg Danceability (0 = least, 1 = most) : {avgAudioFeatures.danceability}");
WriteLine($"Avg Energy (0 = least, 1 = most) : {avgAudioFeatures.energy}");
WriteLine($"Avg Loudness (dB, range is -60 to 0) : {avgAudioFeatures.loudness}");
WriteLine($"Avg Tempo (BPM, range is 0 to 250) : {avgAudioFeatures.tempo}");
WriteLine($"Avg Valence (0 = least, 1 = most positive) : {avgAudioFeatures.valence}");
}
public string getChef(string artistID)
{
var chefAverage = new Dictionary <string, object>();
SeveralTracks tracks = spotify.GetArtistsTopTracks(artistID, "CR");
var average = 0.0;
for (int i = 0; i < 3; i++)
{
var individualValue = 0.0;
AudioFeatures audio = spotify.GetAudioFeatures(tracks.Tracks[1].Id);
individualValue = (audio.Speechiness * 20) + (audio.Instrumentalness * 20) + (audio.Valence * 20)
+ (audio.Energy * 20) + (audio.Danceability * 20);
average += individualValue;
}
chefAverage.Add("average", average / 3);
return(Models.UtilityMethods.diccTOstrinJson(chefAverage));
}
public async Task <AudioFeatures> GetPlayListAvarageAudioFeature(string playlistId)
{
var playlistAudioFeatures = await GetPlayListAudioFeatures(playlistId);
var result = new AudioFeatures();
foreach (var playlist in playlistAudioFeatures)
{
result.Acousticness += playlist.Acousticness;
result.Danceability += playlist.Danceability;
result.DurationInMs += playlist.DurationInMs;
result.Energy += playlist.Energy;
result.Instrumentalness += playlist.Instrumentalness;
result.Key += playlist.Key;
result.Liveness += playlist.Liveness;
result.Loudness += playlist.Loudness;
result.Mode += playlist.Mode;
result.Speechiness += playlist.Speechiness;
result.Tempo += playlist.Tempo;
result.TimeSignature += playlist.TimeSignature;
result.Valence += playlist.Valence;
}
result.Acousticness /= playlistAudioFeatures.Count;
result.Danceability /= playlistAudioFeatures.Count;
result.DurationInMs /= playlistAudioFeatures.Count;
result.Energy /= playlistAudioFeatures.Count;
result.Instrumentalness /= playlistAudioFeatures.Count;
result.Key /= playlistAudioFeatures.Count;
result.Liveness /= playlistAudioFeatures.Count;
result.Loudness /= playlistAudioFeatures.Count;
result.Mode /= playlistAudioFeatures.Count;
result.Speechiness /= playlistAudioFeatures.Count;
result.Tempo /= playlistAudioFeatures.Count;
result.TimeSignature /= playlistAudioFeatures.Count;
result.Valence /= playlistAudioFeatures.Count;
return(result);
}
public StageGeometry Build(AudioFeatures audioFeatures, Random random, GeometryBuilderOptions builderOptions)
{
_audioFeatures = audioFeatures;
_builderOptions = builderOptions;
_random = random;
_builderOptions.RandomFunction = _random;
BuildGoodBeatsList();
BuildBeatFrequencyList();
BuildGeometry();
SetStartColour();
var backgroundPolygon = new PolarPolygon(6, new PolarVector(0.5, 0), 500000, -20, 0);
backgroundPolygon.ShaderProgram = _builderOptions.GeometryShaderProgram;
return(new StageGeometry(_onsets, _onsetDrawing, _segmentStartColour, _random)
{
BackgroundPolygon = backgroundPolygon
});
}
public static AudioFeaturesResponse Map(this IMapper mapper, AudioFeatures audioFeatures) => mapper.Map <AudioFeaturesResponse>(audioFeatures);
public static void Save(AudioFeatures af) => AnalysedTracks.Save(af?.Id, af);
