Optimisation par traduction pour mapper un x, y ensemble de points sur un autre

Question

J'ai une liste de x, y points idéaux, et une deuxième liste de x, y points mesurés. Ce dernier a un certain décalage et un peu de bruit. J'essaye d '"ajuster" ce dernier à celui-là. Donc, extraire le décalage x, y de ce dernier par rapport au premier.

Je suis quelques exemples de scipy.optimize.leastsq, mais j'ai du mal à le faire fonctionner. Voici mon code:

import random 
import numpy as np 
from scipy import optimize 
# Generate fake data. Goal: Get back dx=0.1, dy=0.2 at the end of this exercise 
dx = 0.1 
dy = 0.2 
# "Actual" (ideal) data. 
xa = np.array([0,0,0,1,1,1]) 
ya = np.array([0,1,2,0,1,2]) 
# "Measured" (non-ideal) data. Add the offset and some randomness. 
xm = map(lambda x: x + dx + random.uniform(0,0.01), xa) 
ym = map(lambda y: y + dy + random.uniform(0,0.01), ya) 
# Plot each 
plt.figure() 
plt.plot(xa, ya, 'b.', xm, ym, 'r.') 

# The error function. 
# 
# Args: 
# translations: A list of xy tuples, each xy tuple holding the xy offset 
# between 'coords' and the ideal positions. 
# coords: A list of xy tuples, each xy tuple holding the measured (non-ideal) 
# coordinates. 
def errfunc(translations, coords): 
    sum = 0 
    for t, xy in zip(translations, coords): 
    dx = t[0] + xy[0] 
    dy = t[1] + xy[1] 
    sum += np.sqrt(dx**2 + dy**2) 
    return sum 

translations, coords = [], [] 
for xxa, yya, xxm, yym in zip(xa, ya, xm, ym): 
    t = (xxm-xxa, yym-yya) 
    c = (xxm, yym) 
    translations.append(t) 
    coords.append(c) 

translation_guess = [0.05, 0.1] 
out = optimize.leastsq(errfunc, translation_guess, args=(translations, coords), full_output=1) 

print out 

Je reçois l'erreur:

errfunc() takes exactly 2 arguments (3 given)"

Je ne sais pas pourquoi il dit 3 arguments que je ne lui ai donné deux. Quelqu'un peut-il aider?

====

RÉPONSE:

Je pensais à ce mal. Tout ce que j'ai à faire est de prendre la moyenne des dx et dy - cela donne le bon résultat.

n = xa.shape[0] 
dx = -np.sum(xa - xm)/n 
dy = -np.sum(ya - ym)/n 
print dx, dy 

Answer 1

Le scipy.optimize.leastsq suppose que la fonction que vous utilisez a déjà une entrée, x0, l'estimation initiale. Les autres entrées supplémentaires sont ensuite listées dans les arguments. Par conséquent, vous envoyez trois arguments: translation_guess, transactions et coords.

Notez que here spécifie que les arguments sont "extra arguments."

---

Bon, je pense que je comprends maintenant. Vous avez les emplacements réels et les emplacements mesurés et vous voulez comprendre le décalage constant, mais il y a du bruit sur chaque paire. Corrigez-moi si je me trompe:

xy = tuple avec les coordonnées du point

t = tuple avec décalage mesuré (constant + bruit)

mesurée Les coordonnées réelles d'un point sont (xy - t) puis?

Si oui, alors nous pensons qu'il devrait être mesuré en (xy - t + guess).

Si oui, notre erreur est (xy - t + guess - xy) = (estimation - t)

Lorsqu'il est mesuré n'a même pas d'importance! Nous voulons juste trouver la supposition qui est la plus proche de toutes les traductions mesurées:

def errfunc(guess, translations): 
    errx = 0 
    erry = 0 
    for t in translations: 
    errx += guess[0] - t[0] 
    erry += guess[1] - t[1] 
    return errx,erry 

Qu'en pensez-vous? Cela a-t-il un sens ou ai-je oublié quelque chose?