La localisation des sources de son

Le traitement implémente le principe exposé plus haut.
L’objectif est de trouver le décalage entre les canaux droits et gauches, en supposant qu’ils reçoivent le même son légèrement décalé dans le temps.

Pour ce faire, on va garder le canal droit original, et décaler le son du canal gauche progressivement.

Pour chaque décalage, on va mesurer la ressemblance entre les deux signaux : le décalage pour lequel ils sont le plus ressemblants est celui que l’on cherche ! En effet, si les deux canaux reçoivent le même son simplement décalé, lorsque l’on trouve le ’bon’ décalage ils sont identiques (i.e. très ressemblants).

En traitement du signal, la ressemblance de deux signaux s’appelle l’intercorrélation. C’est un gros mot, mais il suffit de retenir que c’est une mesure de la ressemblance. Bien sur, il y a tout un fatras mathématique autour, mais je vous en dispense 🙂
L’intercorrélation est un calcul assez lourd, mais dans notre cas on peut le simplifier : on ne veut pas vraiment la calculer, mais simplement trouver son maximum. Un peu de math permet de prouver que le maximum de l’intercorrélation est aussi le minimum de la somme des valeurs absolues des différences des deux signaux à chaque instant (ouf !).
L’avantage c’est que c’est un calcul assez simple, sans multiplication, donc peu consommateur de CPU.

En pratique on a donc :
– on fait varier un décalage ’t’ entre -décalage_max et +décalage_max
– pour chaque valeur de ’t’, on calcule la somme des différences des canaux à chaque instant, le canal gauche étant décalé de ’t’.
– on garde le décalage pour laquelle la somme est minimale

Ça donne çà :

float minDiff = Float.MAX_VALUE;
int minDiffTime = -1;
float[] right = _buffer.getChannel(0);
float[] left = _buffer.getChannel(1);

for (int t = -_nbSamplesMaxDiff; t < _nbSamplesMaxDiff; t++) {
  float diff = 0;
  for (int i = _nbSamplesMaxDiff; i < left.length - _nbSamplesMaxDiff - 1; i++) {
	diff += Math.abs(left[i] - right[i + t]);
  }
  if (diff < minDiff) {
	minDiff = diff;
	minDiffTime = t;
  }
}

Une bonne chose de faite, on connait maintenant le décalage.

Il reste un soucis : en pratique, on ne veut alerter le robot d’un son que si il est significatif, c’est à dire ’suffisamment’ fort. En effet, il y a toujours un bruit de fond autour du robot, et on ne veut pas osciller continuellement autour du bruit de fond, de direction plus ou moins aléatoire.
On va donc calculer la puissance du son, et ne réagir que pour les sons significatifs, c’est à dire au dessus du bruit de fond.

Afin d’éviter de coder ’en dur’ la puissance du bruit de fond, qui dépend de l’environnement, on va calculer la moyenne glissante du bruit entendu en permanence, et définir ’significatif’ comme étant 5% au dessus de ce bruit moyen. Cela permet une calibration automatique pour s’adapter au bruit ambiant.

On en profite pour éliminer les mesures de décalage extrême, qui sont souvent signe de mauvaise mesure, et ça donne ça :

float level = computeLevel(right, left);
_averageSoundLevel.newValue(level);
float relativeLevel = level / _averageSoundLevel.getMean();
if ((relativeLevel > _minLevelFactorForValidLoc)
	&& (minDiffTime > -_nbSamplesMaxDiff)
	&& (minDiffTime < _nbSamplesMaxDiff)) {
			<son significatif, on réagit>
}

Avec un peu de code pour calculer la puissance du son et la moyenne glissante :

private float computeLevel(float[] right, float[] left) {
		float level = 0;
		for (int i = 0; i < right.length; i++) {
			float s = (left[i] + right[i]) / 2;
			level += (s * s);
		}
		level /= right.length;
		level = (float) Math.sqrt(level);
		return level;
}

static public class RunningAverage {
		private final int _nbValuesForAverage;
		private int _nbValues;
		private float _mean;

		RunningAverage(int nbValuesForAverage) {
			_nbValuesForAverage = nbValuesForAverage;
		}

		public void newValue(float v) {
			if (_nbValues < _nbValuesForAverage)
				_nbValues++;
			_mean = ((_mean * (_nbValues - 1)) + v) / _nbValues;
		}

		public float getMean() {
			return _mean;
		}
}

Ouf ! On a le décalage et la puissance, il ne manque plus qu’à en déduire l’angle d’incidence et à réagir.

Pour calculer l’angle, on va supposer une relation linéaire entre le décalage de phase et l’angle d’incidence. En fait, ce n’est pas tout à fait exact mais c’est une assez bonne approximation, en tout cas suffisante pour notre usage. On peut trouver sur le net un tas de formules sur le front d’onde, donc on peut sans doute faire mieux avec un peu de trigo...
Mais comme je suis un peu feignant, j’ai juste mesuré la valeur maximum de décalage de temps que j’obtenais avec l’angle maximum (90 degrés par rapport aux micros), et fait une interpolation linéaire. Pas de calcul théorique sur la vitesse du son, l’écartement des micros, les angles, la fréquence échantillonnage... feignant quoi 🙂

Ça donne ça :

float angle = -(float) (Math.PI / 2 * ((float) minDiffTime / _nbSamplesMaxDiff));

On arrive au bout de nos peines, il ne reste plus qu’à mettre un peu de peinture autour de tout ça pour représenter le résultat et faire des essais.

Pour cela, quelques lignes de swing pour représenter l’angle sur un demi cercle, avec la largeur de la ligne dépendant de la puissance du son (grosse ligne = son fort) :

static private class SoundLocDraw extends JPanel {
	// sound angle, between -PI/2...+PI/2
	private float _angle;
	// relative power with respect to mean power (1.0=mean power)
	private float _relativePower;

	public void setSound(float angle, float relativePower) {
		_angle = angle;
		_relativePower = relativePower;
		repaint();
	}

	@Override
	protected void paintComponent(Graphics g) {
		super.paintComponent(g);
		Graphics2D g2d = (Graphics2D) g;
		Dimension d = getSize();
		int radius = Math.min(d.height, d.width / 2);
		int cx = d.width / 2;
		int cy = 0;
		int tx = cx + (int) (Math.cos(_angle + Math.PI / 2) * radius);
		int ty = cy + (int) (Math.sin(_angle + Math.PI / 2) * radius);
		g2d.drawOval(cx - radius, cy - radius, radius * 2, radius * 2);
		// use larger strokes for louder sounds:
		g2d.setStroke(new BasicStroke(1 + (int) ((Math.max(_relativePower,
				1) - 1.0) * 10)));
		g2d.drawLine(cx, cy, tx, ty);
	}
}

Le tout est rassemblé dans la classe soundsourceloc.SoundSourceLoc, que vous trouverez avec l’ensemble du code source dans l’archive jointe à cet article.

Résultats

En pratique, ça marche plutôt bien !
Je n’ai pas fait de mesure de précision, mais en jouant un peu avec le prototype la localisation du son semble fiable, même en présence de bruits de fond parasites.
Il y a peu de ’fausses’ détections, et l’ensemble devrait pouvoir remplir la fonction envisagée, tourner la tête en direction du son.

On appelle le ’robot’ pas trop fort à son extrême droite :

Puis un peu plus fort au milieu à gauche :

Voila !

Il ne reste plus qu’à mettre ça en place sur un vrai robot, et tester en conditions réelles... probablement l’objet d’un prochain article 🙂