Colorir uma forma de onda com centróide espectral ou por outros meios

Atualização 8

Insatisfeito por ter que fazer o upload de faixas para o serviço e olhar para o novo lançamento do RekordBox 3, decidi dar uma nova olhada em uma abordagem offline e em uma resolução mais precisa: D

Parece promissor, embora ainda esteja em um estado muito alfa:

Johnick - Good Time

Observe que não há escala logarítmica nem ajuste de paleta, apenas um mapeamento bruto da frequência para o HSL.

A idéia : agora um renderizador de forma de onda tem um provedor de cores que é consultado por uma cor para uma posição específica. O que você está vendo acima obtém a taxa de cruzamento zero para as 1024 amostras próximas a essa posição.

Obviamente, ainda há muito o que fazer antes de obter algo robusto, mas parece um bom caminho ...

Do RekordBox 3 :

Atualização 7

A forma final que adotarei, assim como na atualização 3

(foi um pouco de Photoshop para obter transições suaves entre cores)

A conclusão é que eu estava perto meses atrás, mas não considerou esse resultado pensando que era ruim X)

Atualização 6

Eu descobri o projeto recentemente, então pensei em atualizar aqui: D

Música: Chic - Good Times 2001 (mix do Stonebridge Club)

É IMO muito melhor, as batidas têm uma cor constante, etc ... não é otimizado.

Como ?

Ainda com http://developer.echonest.com/docs/v4/_static/AnalyzeDocumentation.pdf (página 6)

Para cada segmento:

public static int GetSegmentColorFromTimbre(Segment[] segments, Segment segment)
{
    var timbres = segment.Timbre;

    var avgLoudness = timbres[0];
    var avgLoudnesses = segments.Select(s => s.Timbre[0]).ToArray();
    double avgLoudnessNormalized = Normalize(avgLoudness, avgLoudnesses);

    var brightness = timbres[1];
    var brightnesses = segments.Select(s => s.Timbre[1]).ToArray();
    double brightnessNormalized = Normalize(brightness, brightnesses);

    ColorHSL hsl = new ColorHSL(brightnessNormalized, 1.0d, avgLoudnessNormalized);
    var i = hsl.ToInt32();
    return i;
}

public static double Normalize(double value, double[] values)
{
    var min = values.Min();
    var max = values.Max();
    return (value - min) / (max - min);
}

Obviamente, há muito mais código necessário antes de você chegar aqui (fazer o upload para o serviço, analisar JSON etc.), mas esse não é o objetivo deste site, por isso estou postando o material relevante para obter o resultado acima.

Então, eu estou usando as 2 primeiras funções do resultado da análise, certamente há mais a ver com isso, mas ainda preciso testar. Se algum dia encontrar algo mais legal do que o anterior, voltarei e atualizarei aqui.

Como sempre, qualquer dica sobre o tema é bem-vinda!

Atualização 5

Algum gradiente usando séries harmônicas

A suavização das cores é sensível à proporção, caso contrário, parece ruim, precisará de alguns ajustes.

Atualização 4

Reescreva a coloração que ocorrerá na origem e nas cores suavizadas usando um filtro Alpha beta com valores de 0,08 e 0,02.

Um pouco melhor quando diminui o zoom

O próximo passo é obter uma ótima paleta de cores!

Atualização 3

Amarelos representam médiuns

Ainda não é tão bom quando não está sendo usado.

(a paleta precisa de um trabalho sério)

Atualização 2

Teste preliminar usando a segunda dica de coeficiente 'timbre' de pichenettes

Atualização 1

Um teste preliminar usando um resultado de análise do serviço EchoNest , observe que ele não está alinhado muito bem (minha culpa), mas é muito mais coerente do que a abordagem acima.

Para pessoas interessadas em usar essa excelente API, comece aqui: http://developer.echonest.com/docs/v4/track.html#profile

Além disso, não se confunda com essas formas de onda, pois representam 3 músicas diferentes.

Questão inicial

Até agora, esse é o resultado que eu recebo usando uma FFT de 256 amostras e calculando o centróide espectral de cada pedaço .

Resultado bruto dos cálculos

Alguma suavização aplicada (o formulário fica muito melhor com ele)

Forma de onda produzida

Idealmente, é assim que deve ser (tirada do software Serato DJ )

Você sabe qual técnica / algoritmo eu poderia usar para poder dividir o áudio quando a frequência média muda com o tempo? (como na imagem acima)

Você pode tentar primeiro o seguinte (sem segmentação):

• Processe o sinal em pequenos pedaços (digamos 10 ms a 50 ms de duração) - se necessário, com uma sobreposição de 50% entre eles.
• Calcule o centróide espectral em cada pedaço.
• Aplique uma função não linear ao valor do centróide espectral para obter uma distribuição uniforme da cor da paleta usada. O logaritmo é um bom começo. Outra opção é calcular primeiro a distribuição do valor do centróide e o arquivo inteiro e depois colorir de acordo com os percentis dessa distribuição ( CDF ). Essa abordagem adaptativa garante que cada cor da paleta seja usada na mesma proporção. A desvantagem é que o que é plotado em azul em um arquivo não será semelhante ao que é plotado em azul em outro arquivo se essa abordagem adaptativa for usada!

Não está claro pela imagem se o Serato faz isso, ou de fato vai um passo além e tenta segmentar o sinal - pode não ser surpreendente, pois conhecer os instantes em que as notas estão presentes em um sinal de música pode ajudar a sincronizá-los. ! Os passos seriam:

• Calcule uma transformada de Fourier de curto prazo (espectrograma) do sinal - usando a FFT em segmentos curtos e sobrepostos (comece com um tamanho de FFT de 1024 ou 2048 com áudio de 44,1kHz).
• Calcule uma função de detecção de onset. Eu recomendo que você analise este documento - a abordagem proposta é muito eficaz e até mesmo uma implementação em C ++ leva menos de 10 linhas. Você pode encontrar uma implementação no Yaafe - as ComplexDomainOnsetDetection.
• Detecte picos na função de detecção de início para obter a posição dos ajustes das notas.
• Calcule o centróide espectral em todos os segmentos de tempo delimitados pelos onets detectados (não se esqueça de exibir a janela e / ou zero-pad!)
• E não se esqueça do mapa não linear! Observe que o efeito de gradiente que aparece entre cada nota na forma de onda Serato pode ser gerado artificialmente.

Depois que você obtiver esse trabalho, um "resultado final" seria calcular alguns outros recursos em cada segmento (momentos, um punhado de MFCCs ...), executar k-means nesses vetores de recursos e decidir a cor de o segmento usando o índice de cluster. Veja a seção II do artigo de Ravelli .