[SciPy-user] phase wrapping algorithm
Bryan Cole
bryan at cole.uklinux.net
Tue Oct 10 15:55:49 CDT 2006
I do this quite a lot in the context of FFTs.
try:
def unwrap(thetaArray):
"""takes an array of theta values in degrees
returns the data in unwrapped form"""
diff = zeros_like(thetaArray)
diff[1:] = thetaArray[1:] - thetaArray[:-1]
upSteps = diff > 180
downSteps = diff < -180
shift = cumsum(upSteps) - cumsum(downSteps)
return thetaArray - 360*shift
Obviously, a Weave version will be a lot faster, but this is at least
fully vectorised, so it's not bad.
BC
On Tue, 2006-10-10 at 12:32 -0500, Ryan Krauss wrote:
> I am rethinking an algorithm for unwrapping phase data from arctan2
> for a vector of complex numbers (coming from lti models of feedback
> control systems). I had written something a while ago using weave,
> but my old code causes seg faults with a recent scipy update. So, I
> am rethinking the algorithm.
>
> The problem occurs when either because of noise or just the definition
> of the inverse tangent, their are discontinuities in the phase (which
> is coming from arctan2(imag(vector), real(vector)). For example, in
> the attached plot and data file, there is a point where the phase
> passes through -180 degrees. arctan2 jumps to returning +180, +175
> etc, when it makes a pretty plot and makes more sense to me to convert
> +175 to -185. What I had done previously is write a for loop that
> compares the current value of the phase to the value at the previous
> index (i.e. if phase[i]-phase[-1]>300 or if phase[i]-phase[i-1]<-300)
> to find the discontinuities. Is there a cleaner/faster way to do
> this? (I had done it in weave and will probably now do it in f2py for
> comparison on speeds). I have attached/included a first attempt at an
> algorithm that is more vectorized. But is there a fast, easy way to
> compare a vector to the same vector shift one element up or down?
> Right now I am doing this
>
> phase2=r_[phase[0:1],phase[0:-1]]
>
> to shift the vector (and reuse the first element so there isn't a jump
> from phase[-1] to phase[0] which may legitimately be far apart).
>
> Has anyone else already done this? Are there obvious bottlenecks with
> the algorithm?
>
> Thanks for your thoughts,
>
> Ryan
>
> =====================================
> from scipy import arange, io, r_
> from pylab import show, figure, subplot, clf, cla, semilogx, xlabel,
> ylabel, legend, xlim
>
> import copy
>
> data=io.read_array('phase_data.txt')
> f=data[:,0]
> phase=data[:,1]
> figure(1)
> clf()
> startphase=copy.copy(phase)
> semilogx(f,startphase)
>
> keepgoing=1
>
> inds=arange(0,len(phase))
>
> while keepgoing:
> phase2=r_[phase[0:1],phase[0:-1]]#artificially repeat the first element
> diff=phase-phase2
> jumps=inds[abs(diff)>250]
> keepgoing=jumps.any()
> if not keepgoing:
> break
> ind=jumps.min()
> if diff[ind]>0:
> phase[ind:]-=360
> else:
> phase[ind:]+=360
>
>
> semilogx(f,phase,'r--')
>
> legend(['Before unwrapping','after unwrapping'],2)
>
> xlim([1,30])
>
> show()
> _______________________________________________
> SciPy-user mailing list
> SciPy-user at scipy.org
> http://projects.scipy.org/mailman/listinfo/scipy-user
More information about the SciPy-user
mailing list