def computeFilterResponse(self):
N = int(100 * self.samplingRate)
noise = numpy.zeros(N)
freq = numpy.fft.fftfreq(N, 1.0 / self.samplingRate)
for i in range(N):
noise[i] = random.random() - 0.5
fftN = numpy.fft.fft(noise)[list(range(N / 2))]
fftS = numpy.fft.fft(self.applyFilter(noise))[list(range(N / 2))]
fftNA = abs(fftN)
fftSA = abs(fftS)
fftP = angle(fftS) - angle(fftN)
Niter = 100
for i in range(1, Niter):
for i in range(N):
noise[i] = random.random() - 0.5
fftN = numpy.fft.fft(noise)[list(range(N / 2))]
fftS = numpy.fft.fft(self.applyFilter(noise))[list(range(N / 2))]
fftNA += abs(fftN)
fftSA += abs(fftS)
fftP += (angle(fftS) - angle(fftN))
return freq[list(range(N /
2))], fftSA / Niter, fftNA / Niter, fftP / Niter
def angle(x):
# Wrapper for angle that handles CXData objects
if isinstance(x, CXData):
l=[]
for i in xrange(len(x)):
l.append(sp.angle(x.data[i]))
return CXData(data=l)
elif isinstance(x, np.ndarray):
return sp.angle(x)
else:
raise Exception('Unknown data type passed to angle')
def angle(x):
# Wrapper for angle that handles CXData objects
if isinstance(x, CXData):
l = []
for i in xrange(len(x)):
l.append(sp.angle(x.data[i]))
return CXData(data=l)
elif isinstance(x, np.ndarray):
return sp.angle(x)
else:
raise Exception('Unknown data type passed to angle')
def symmetrydemo():
a = sin(linspace(-5 * pi, 5 * pi, 10000))
b = a + 2
c = a - 0.5
ah, bh, ch = hilbert(a), hilbert(b), hilbert(c)
ph_a, ph_b, ph_c = unwrap(angle(ah)), unwrap(angle(bh)), unwrap(angle(ch))
omega_a = diff(ph_a)
omega_b = diff(ph_b)
omega_c = diff(ph_c)
subplot(211), plot(ph_a), plot(ph_b), plot(ph_c)
subplot(212), plot(omega_a), plot(omega_b), plot(omega_c)
grid()
show()
return a, b, c
def symmetrydemo():
a=sin(linspace(-5*pi,5*pi,10000))
b=a+2
c=a-0.5
ah,bh,ch=hilbert(a),hilbert(b),hilbert(c)
ph_a,ph_b,ph_c=unwrap(angle(ah)),unwrap(angle(bh)),unwrap(angle(ch))
omega_a=diff(ph_a)
omega_b=diff(ph_b)
omega_c=diff(ph_c)
subplot(211),plot(ph_a),plot(ph_b),plot(ph_c)
subplot(212),plot(omega_a),plot(omega_b),plot(omega_c)
grid()
show()
return a,b,c
def inst_freq(x, t=None):
"""
Compute the instantaneous frequency of an analytic signal at specific time
instants using the trapezoidal integration rule.
Parameters
----------
x : array-like, shape (n_samples,)
The input analytic signal.
t : array-like, shape (n_samples,), optional
The time instants at which to calculate the instantaneous frequency.
Defaults to `np.arange(2, n_samples)`
Returns
-------
array-like
Normalized instantaneous frequencies of the input signal
Examples
--------
"""
if x.ndim != 1:
if 1 not in x.shape:
raise TypeError("Input should be a one dimensional array.")
else:
x = x.ravel()
if t is not None:
if t.ndim != 1:
if 1 not in t.shape:
raise TypeError("Time instants should be a one dimensional "
"array.")
else:
t = t.ravel()
else:
t = np.arange(2, len(x))
fnorm = 0.5 * (angle(-x[t] * np.conj(x[t - 2])) + np.pi) / (2 * np.pi)
return fnorm, t
def csr3(complex_n):
ang = sp.angle(complex_n) # sp.arctan(a.imag/a.real) why it does not work?!?!
r = sp.sqrt(sp.square(complex_n.real)+sp.square(complex_n.imag))
if (sp.sin(ang/2)>=0): #sin>0
return sp.sqrt(r)*(complex(sp.cos(ang/2),sp.sin(ang/2)))
else:
return sp.sqrt(r)*(complex(sp.cos((ang/2)+sp.pi),sp.sin((ang/2)+sp.pi)))
def get_fft(self, fs, taps, Npts):
Ts = 1.0/fs
fftpts = fftpack.fft(taps, Npts)
self.freq = scipy.arange(0, fs, 1.0/(Npts*Ts))
self.fftdB = 20.0*scipy.log10(abs(fftpts))
self.fftDeg = scipy.unwrap(scipy.angle(fftpts))
self.groupDelay = -scipy.diff(self.fftDeg)
def plot_freqz(b, a, w = None, npoints = None, title = '', db = False, createFigure = True, label = ''):
# Create the omega array if necessary
if npoints is None:
npoints = 1000
if w is None:
w = scipy.arange(-scipy.pi, scipy.pi, 2*scipy.pi/(npoints))
# Calculate the frequency response
d = loudia.freqz(b.T, a.T, w)
if db:
mag = 20.0 * scipy.log10(abs(d[:,0]))
else:
mag = abs(d[:,0])
import pylab
if createFigure:
pylab.figure()
pylab.subplot(2,1,1)
pylab.plot(w, mag, label = label)
pylab.title('%s \n Magnitude of the Frequency Response' % title)
pylab.subplot(2,1,2)
pylab.plot(w, scipy.angle(d[:,0]), label = label)
pylab.title('Angle of the Frequency Response')
def plot_freqz(b,
a,
w=None,
npoints=None,
title='',
db=False,
createFigure=True,
label=''):
# Create the omega array if necessary
if npoints is None:
npoints = 1000
if w is None:
w = scipy.arange(-scipy.pi, scipy.pi, 2 * scipy.pi / (npoints))
# Calculate the frequency response
d = loudia.freqz(b.T, a.T, w)
if db:
mag = 20.0 * scipy.log10(abs(d[:, 0]))
else:
mag = abs(d[:, 0])
import pylab
if createFigure:
pylab.figure()
pylab.subplot(2, 1, 1)
pylab.plot(w, mag, label=label)
pylab.title('%s \n Magnitude of the Frequency Response' % title)
pylab.subplot(2, 1, 2)
pylab.plot(w, scipy.angle(d[:, 0]), label=label)
pylab.title('Angle of the Frequency Response')
def ACphase(tf, unit='deg', unwrapTol=0.5): """ Return the phase in desired *unit* of a transfer function *tf* * ``deg`` stands for degrees * ``rad`` stands for radians The phase is unwrapped (discontinuities are stiched together to make it continuous). The tolerance of the unwrapping (in radians) is *unwrapTol* times ``pi``. """ # Get argument ph=angle(tf) # Unwrap if requested if (unwrapTol>0) and (unwrapTol<1): ph=unwrap(ph, unwrapTol*pi) # Convert to requested unit if unit=='deg': return ph/pi*180.0 elif unit=='rad': return ph else: raise Exception, "Bad phase unit."
def test_phasez_1(self):
# Testcase for return radian form
fil = FIRDesign.fir1(self.order, self.cut)
w, h = signal.freqz(fil[0], fil[1], worN=512, fs=2 * np.pi)
phase = sp.unwrap(sp.angle(h))
ww, pp = FilterSpec.phasez(fil)
self.assertTrue(np.all(w == ww) and np.all(pp == phase))
def ACphase(tf, unit='deg', unwrapTol=0.5):
"""
Return the phase in desired *unit* of a transfer function *tf*
* ``deg`` stands for degrees
* ``rad`` stands for radians
The phase is unwrapped (discontinuities are stiched together to make it
continuous). The tolerance of the unwrapping (in radians) is
*unwrapTol* times ``pi``.
"""
# Get argument
ph = angle(tf)
# Unwrap if requested
if (unwrapTol > 0) and (unwrapTol < 1):
ph = unwrap(ph, unwrapTol * pi)
# Convert to requested unit
if unit == 'deg':
return ph / pi * 180.0
elif unit == 'rad':
return ph
else:
raise Exception, "Bad phase unit."
def phase(abc, deg=False):
"""
return the (sine-)phase given the coefficients of\n
y = a*sin(2*pi*f0*t) + b*cos(2*pi*f0*t) + c \n
returns angle in rad by default, in degree if deg=True
"""
return sp.angle(abc[1] + 1j * abc[0], deg=deg)
def mmse_stsa(infile, outfile, noise_sum):
signal, params = read_signal(infile, WINSIZE)
nf = len(signal)/(WINSIZE/2) - 1
sig_out=sp.zeros(len(signal),sp.float32)
G = sp.ones(WINSIZE)
prevGamma = G
alpha = 0.98
window = sp.hanning(WINSIZE)
gamma15=spc.gamma(1.5)
lambdaD = noise_sum / 5.0
percentage = 0
for no in xrange(nf):
p = int(math.floor(1. * no / nf * 100))
if (p > percentage):
percentage = p
print "{}%".format(p),
y = get_frame(signal, WINSIZE, no)
Y = sp.fft(y*window)
Yr = sp.absolute(Y)
Yp = sp.angle(Y)
gamma = Yr**2/lambdaD
xi = alpha * G**2 * prevGamma + (1-alpha)*sp.maximum(gamma-1, 0)
prevGamma = gamma
nu = gamma * xi / (1+xi)
G = (gamma15 * sp.sqrt(nu) / gamma ) * sp.exp(-nu/2) * ((1+nu)*spc.i0(nu/2)+nu*spc.i1(nu/2))
idx = sp.isnan(G) + sp.isinf(G)
G[idx] = xi[idx] / (xi[idx] + 1)
Yr = G * Yr
Y = Yr * sp.exp(Yp*1j)
y_o = sp.real(sp.ifft(Y))
add_signal(sig_out, y_o, WINSIZE, no)
write_signal(outfile, params, sig_out)
def get_fft(self, fs, taps, Npts):
Ts = 1.0 / fs
fftpts = fftpack.fft(taps, Npts)
self.freq = scipy.arange(0, fs, 1.0 / (Npts * Ts))
self.fftdB = 20.0 * scipy.log10(abs(fftpts))
self.fftDeg = scipy.unwrap(scipy.angle(fftpts))
self.groupDelay = -scipy.diff(self.fftDeg)
def pulse_phase_thermography(thermogram,
frames_to_process=-1,
frame_start=0,
return_phase=1):
""" Expects a thermogram as a u_int16 3D numpy multdimensional array where
each dimension is: [frame, row, column].
frames_to_process sets the numbers of frames to use in FFT analysis, uses all frames
by default.
Return_phase controls what phase will be returned, 0 is always a blank map;
should almost always be 1.
Returns an array of 2D phase maps in the format: [frame_index, row, column]
"""
yLength = thermogram.shape[1]
#Note that y is before x; a carry over from
xLength = thermogram.shape[2]
# Matlab...
#Preallocate phase maps
phasemap = numpy.zeros([1, yLength, xLength], dtype=numpy.complex64)
# Perform FFT over the range specified
fftmap = scipy.fft(thermogram[frame_start:frame_start +
frames_to_process, :, :],
axis=0)
phasemap[0, :, :] = scipy.angle(fftmap[return_phase, :, :])
return phasemap
def redraw(self):
self.clearStems()
for i in range(0, 3):
axes = pylab.subplot('13' + str(1 + i))
if (self.mode == "phase"):
self.plots[i][0].set_ydata(
scipy.angle(self.fts[self.index + i]))
else:
mag = abs(self.fts[self.index + i])
self.plots[i][0].set_ydata(mag)
peak = max(mag)
peakInd = list(mag).index(peak)
stem_marker, stem_lines, stem_base = pylab.stem([peakInd],
[peak], 'r-',
'ro')
self.stemMarkers.append(stem_marker)
self.stemBase.append(stem_base)
self.stemLines.append(stem_lines)
xres = self.fov / self.xsize
pylab.xlabel(self.axis[i] + ':' +
'{0:.3}'.format(xres *
(peakInd - len(mag) / 2)) + ' mm')
pylab.draw()
def timescale(data, scaling=1):
"""Scales the playback_duration of input_filename, while keeping pitch constant."""
length = len(data)
phi = scipy.zeros(N)
out = scipy.zeros(N, dtype=complex)
sigout = scipy.zeros(length / scaling + N)
amplitude = max(data)
window = scipy.hanning(N)
for index in scipy.arange(0, length - (N + H), H * scaling):
spec1 = scipy.fft(window * data[index:index + N])
spec2 = scipy.fft(window * data[index + H:index + N + H])
phi += scipy.angle(spec2 / spec1)
phi %= 2 * scipy.pi
out.real, out.imag = scipy.cos(phi), scipy.sin(phi)
out_index = int(index / scaling)
sigout[out_index:out_index +
N] += (window * scipy.ifft(scipy.absolute(spec2) * out)).real
sigout *= amplitude / max(sigout)
return scipy.array(sigout, dtype='int16')
def floquet_modes(H, T, args=None, sort=False):
"""
Calculate the initial Floquet modes Phi_alpha(0) for a driven system with
period T.
Returns a list of :class:`qutip.Qobj` instances representing the Floquet
modes and a list of corresponding quasienergies, sorted by increasing
quasienergy in the interval [-pi/T, pi/T]. The optional parameter `sort`
decides if the output is to be sorted in increasing quasienergies or not.
Parameters
----------
H : :class:`qutip.Qobj`
system Hamiltonian, time-dependent with period `T`
args : dictionary
dictionary with variables required to evaluate H
T : float
The period of the time-dependence of the hamiltonian. The default value
'None' indicates that the 'tlist' spans a single period of the driving.
Returns
-------
output : list of kets, list of quasi energies
Two lists: the Floquet modes as kets and the quasi energies.
"""
# get the unitary propagator
U = propagator(H, T, [], args)
# find the eigenstates for the propagator
evals,evecs = la.eig(U.full())
eargs = angle(evals)
# make sure that the phase is in the interval [-pi, pi], so that the
# quasi energy is in the interval [-pi/T, pi/T] where T is the period of the
# driving.
#eargs += (eargs <= -2*pi) * (2*pi) + (eargs > 0) * (-2*pi)
eargs += (eargs <= -pi) * (2*pi) + (eargs > pi) * (-2*pi)
e_quasi = -eargs/T
# sort by the quasi energy
if sort == True:
order = np.argsort(-e_quasi)
else:
order = list(range(len(evals)))
# prepare a list of kets for the floquet states
new_dims = [U.dims[0], [1] * len(U.dims[0])]
new_shape = [U.shape[0], 1]
kets_order = [Qobj(np.matrix(evecs[:,o]).T, dims=new_dims, shape=new_shape) for o in order]
return kets_order, e_quasi[order]
def multi_phase(abc, deg=False): # abc = [bias, a1,b1 , a2,b2, ...]
"""
return the initial phases given the coefficients of a multi-sine\n
abc = [a1,b1 , a2,b2, ...,bias] \n
y = sum_i (a_i*sin(2*pi*f0_i*t) + b_i*cos(2*pi*f0_i*t) + c_i
"""
x = abc[1::2] + 1j * abc[2::2]
return sp.angle(x, deg=deg)
def getinstfreq(imfs):
omega = zeros((imfs.shape[0], imfs.shape[1] - 1), dtype=float)
for i in range(imfs.shape[0]):
h = hilbert(imfs[i, :])
theta = unwrap(angle(h))
omega[i, :] = diff(theta)
return omega
def getinstfreq(imfs):
omega=zeros((imfs.shape[0],imfs.shape[1]-1),dtype=float)
for i in range(imfs.shape[0]):
h=hilbert(imfs[i,:])
theta=unwrap(angle(h))
omega[i,:]=diff(theta)
return omega
def getinstfreq(imfs):
# print 'freq:'
omega = zeros((imfs.shape[0], imfs.shape[1]), dtype=float)
for i in range(imfs.shape[0]):
h = hilbert(imfs[i, :])
theta = unwrap(angle(h))
omega[i, 0:diff(theta).shape[0]] = diff(theta)
# print 'freq:',np.shape(omega)
return omega
def phase(self, degrees=False):
'''
Return an array of the phase angles of the wavelet coefficients,
in radians (set degrees=True for degrees).
'''
phase = sp.angle(self.wave)
if degrees:
phase *= 180 / sp.pi
return phase
def phase(self, degrees=False):
'''
Return an array of the phase angles of the wavelet coefficients,
in radians (set degrees=True for degrees).
'''
phase = sp.angle(self.wave)
if degrees:
phase *= 180 / sp.pi
return phase
def process_image(thermogram, return_phase=1):
''' Expects a thermogram as a u_int16 3D numpy multdimensional array where
each dimension is: [frame, row, column]. Return_phase controls
what phase will be returned, 0 is always a blank map; should almost
always be 1.
Returns a 2D phase map in the format: [row, column]
'''
fftmap = scipy.fft(thermogram, axis=0)
phasemap = scipy.angle(fftmap[return_phase, :, :])
return phasemap
def compute_by_noise_pow(self,signal,n_pow):
s_spec = sp.fft(signal*self._window)
s_amp = sp.absolute(s_spec)
s_phase = sp.angle(s_spec)
amp = s_amp**2.0 - n_pow*self._coefficient
amp = sp.maximum(amp,0.0)
amp = sp.sqrt(amp)
amp = self._ratio*amp + (1.0-self._ratio)*s_amp
spec = amp * sp.exp(s_phase*1j)
return sp.real(sp.ifft(spec))
def wiener(signal, noise, window):
n_amp = sp.absolute(sp.fft(noise *
window)) # Calculates noise frame amplitude
s_spec = sp.fft(signal * window)
s_amp = sp.absolute(s_spec) # Calculates signal frame amplitude
s_phase = sp.angle(s_spec) # Calculates signal frame phase
out_spec = s_spec * ((s_amp**2) - 0.7 *
(n_amp**2)) / (s_amp**2) # Performs wiener filtering
return sp.real(sp.ifft(out_spec)) # Returns ifft
def __filter(self, im, mysize=None, noise=None):
"""
Perform a noise filter on 1-dimensional array `im`.
Parameters
----------
im : ndarray
An 1-dimensional array.
mysize : int, optional
A scalar giving the size of the Wiener filter window. It should be
odd.
noise : noise
"""
im = np.asarray(im)
if mysize is None:
mysize = 3
substraction_coeff = 5.0
w = scipy.hanning(mysize)
n_spec = scipy.fft(noise.signal[:mysize] * w)
n_pow = scipy.absolute(n_spec)**2.0
hopsamp = mysize / 2
frames = np.array([
scipy.fft(w * self.signal[i:i + mysize])
for i in range(0, self.nsamples - mysize, hopsamp)
])
# plt.figure()
# plt.plot([sum(f) for f in frames])
# plt.show()
# new = np.zeros_like(frames)
# for i, f in enumerate(frames):
# # Estimate the local mean
# lMean = scipy.signal.correlate(f, w, 'same') / mysize
#
# # Estimate the local variance
# lVar = (scipy.signal.correlate(f ** 2, w ** 2, 'same') / mysize
# - lMean ** 2)
#
# res = lMean + (f - lMean)*(1 - noise / lVar)
# new[i] = np.where(lVar < noise, lMean, res)
n = sum(n_pow) / len(n_pow)
y = scipy.absolute(frames)**2
new = scipy.sqrt(scipy.maximum(y - substraction_coeff * n, 0.0))
new = new / (1 - float(len(y.flatten()) * n) / sum(y.flatten()))
new = new * scipy.exp(scipy.angle(frames) * 1j)
x = np.zeros(self.nsamples)
framesamp = new.shape[1]
hopsamp = framesamp / 2
for n, i in enumerate(range(0, self.nsamples - framesamp, hopsamp)):
x[i:i + framesamp] += scipy.real(scipy.ifft(new[n]))
return x
def steady_state_response(zs, rmin, rmax):
"""
Returns a plot with the steady state response of a
single degree of freedom damped system.
Parameters
----------
zs: array
Array with the damping values
rmin, rmax: float
Minimum and maximum frequency ratio
Returns
----------
r: Array
Array containing the values for the frequency ratio
A: Array
Array containing the values for anmplitude
Plot with steady state magnitude and phase
Examples:
>>> r, A = steady_state_response([0.1, 0.3, 0.8], 0, 2)
>>> A[10]
(0.98423159842039087-0.15988334018879749j)
"""
if not isinstance(zs, list):
zs = [zs]
r = sp.linspace(rmin, rmax, 100*(rmax-rmin))
A0 = sp.zeros((len(zs), len(r)), complex)
for z in enumerate(zs):
A0[z[0]] = (1/(1 - r**2 + 2*1j*r*z[1]))
fig = plt.figure()
ax1 = fig.add_subplot(211)
ax2 = fig.add_subplot(212, sharex=ax1)
plt.tight_layout()
ax1.set_ylabel('Normalized Amplitude (dB)')
ax1.set_title('Normalized Amplitude vs Frequency Ratio')
ax2.set_xlabel('Frequency Ratio')
ax2.set_ylabel('Phase Lag (deg)')
ax2.set_title('Phase vs Frequency Ratio')
for A in A0:
ax1.plot(r, (sp.absolute(A)))
ax2.plot(r, -sp.angle(A)/sp.pi*180)
ax1.legend((['$\zeta$ = ' + (str(s)) for s in zs]))
_ = plt.show()
return r, A
def init_data(self, *args, **kwargs):
if args[0] == 'det_mod':
if CXP.actions.preprocess_data:
self.read_in_data()
else:
self.load()
elif args[0] == 'probe_det_mod':
if CXP.actions.preprocess_data:
# Get list of white files
CXP.log.info('Preprocessing probe detector modulus.')
if CXP.io.whitefield_filename not in [None, '']: # If whitefields were measured
wfilename, wfilerange, wn_acqs = [CXP.io.whitefield_filename, CXP.io.whitefield_filename_range,
CXP.measurement.n_acqs_whitefield]
self.pattern = wfilename.count('{')
if self.pattern == 1:
wf = [wfilename.format(i) for i in range(wfilerange[0], wfilerange[1])]
elif self.pattern == 2:
wf = [wfilename.format(wfilerange[0], i) for i in range(wn_acqs)]
elif self.pattern == 3:
wf = glob.glob(wfilename.split('}')[0]+'}*')
res = self.preprocess_data_stack(0, 1, wf, self.pattern, None, None, no_decorate=True)
self.data = res[1]
else: #Guesstimate the whitefield from the average of the diffraction patterns
pass
else:
self.load(CXData.raw_data_filename_string.format('probe_det_mod'))
try:
probe = self.__class__.__all__['probe']
probe.data[0] = spf.ifft2(self.data[0]*exp(complex(0., 1.)*sp.angle(spf.fft2(probe.data[0]))))
CXP.log.info('Applied probe modulus constraint.')
except (AttributeError, KeyError):
pass
elif args[0] == 'dark':
if CXP.actions.preprocess_data:
# Get list of dark files
CXP.log.info('Preprocessing darkfield.')
dfilename, dfilerange, dn_acqs = [CXP.io.darkfield_filename, CXP.io.darkfield_filename_range,
CXP.measurement.n_acqs_darkfield]
self.pattern = dfilename.count('{')
if self.pattern == 1:
df = [dfilename.format(i) for i in range(dfilerange[0], dfilerange[1])]
elif self.pattern == 2:
df = [dfilename.format(dfilerange[0], i) for i in range(dn_acqs)]
elif self.pattern == 3:
df = glob.glob(dfilename.split('}')[0]+'}*')
res = self.preprocess_data_stack(0, 1, df, self.pattern, None, None, no_decorate=True)
self.data = res[1]
else:
self.load(CXData.raw_data_filename_string.format('probe_det_mod'))
def spec_sub(signal, noise, window):
n_amp = sp.absolute(sp.fft(noise *
window)) # Calculates noise frame amplitude
s_spec = sp.fft(signal * window)
s_amp = sp.absolute(s_spec) # Calculates signal frame amplitude
s_phase = sp.angle(s_spec) # Calculates signal frame phase
out_amp = sp.sqrt((s_amp**2) - (n_amp**2)) # Performs spectral subtraction
out_spec = out_amp * sp.exp(
s_phase * 1j) # Reconstructs spectrum using noisy phase
return sp.real(sp.ifft(out_spec)) # Returns ifft
def _griffin_lim(S):
'''librosa implementation of Griffin-Lim
Based on https://github.com/librosa/librosa/issues/434
'''
angles = sp.exp(2j * sp.pi * sp.random.rand(*S.shape))
S_complex = np.abs(S).astype(np.complex)
y = _istft(S_complex * angles)
for i in range(hparams.griffin_lim_iters):
angles = sp.exp(1j * sp.angle(_stft(y)))
y = _istft(S_complex * angles)
return y
def assert_is_analytic(self, signal, amlaw=None):
"""Assert that signal is analytic."""
omega = angle(signal)
if amlaw is not None:
recons = np.exp(1j * omega) * amlaw
else:
recons = np.exp(1j * omega)
real_identical = np.allclose(np.real(recons), np.real(signal))
imag_identical = np.allclose(np.imag(recons), np.imag(signal))
if not (imag_identical and real_identical):
raise AssertionError("Signal is not analytic.")
def assert_is_analytic(self, signal, amlaw=None):
"""Assert that signal is analytic."""
omega = angle(signal)
if amlaw is not None:
recons = np.exp(1j * omega) * amlaw
else:
recons = np.exp(1j * omega)
real_identical = np.allclose(np.real(recons), np.real(signal))
imag_identical = np.allclose(np.imag(recons), np.imag(signal))
if not (imag_identical and real_identical):
raise AssertionError("Signal is not analytic.")
def test_anaqpsk(self):
"""Test quaternary PSK signal."""
signal, phases = ana.anaqpsk(512, 64, 0.25)
self.assert_is_analytic(signal)
# Count discontinuities in the signal and the phases and assert that
# they appear in the same locations
uphase = unwrap(angle(signal))
dphase = np.diff(uphase)
base_value = mode(dphase)[0][0]
signal_phase_change = np.abs(dphase - base_value) > 0.0001
ideal_phase_change = np.diff(phases) != 0
np.testing.assert_allclose(signal_phase_change, ideal_phase_change)
def test_anaqpsk(self):
"""Test quaternary PSK signal."""
signal, phases = ana.anaqpsk(512, 64, 0.25)
self.assert_is_analytic(signal)
# Count discontinuities in the signal and the phases and assert that
# they appear in the same locations
uphase = unwrap(angle(signal))
dphase = np.diff(uphase)
base_value = mode(dphase)[0][0]
signal_phase_change = np.abs(dphase - base_value) > 0.0001
ideal_phase_change = np.diff(phases) != 0
np.testing.assert_allclose(signal_phase_change, ideal_phase_change)
def phasez(system, worN: int = 512, fs=2 * np.pi, deg: bool = False) -> Tuple:
"""
Phase response of a digital filter.
Parameters
----------
system : a tuple of array_like describing the system.
The following gives the number of elements in the tuple and
the interpretation:
* (num, den)
worN : {None, int, array_like}, optional
If a single integer, then compute at that many frequencies
(default is N=512). This is a convenient alternative to:
np.linspace(0, fs if whole else fs/2, N, endpoint=False)
Using a number that is fast for FFT computations can result in
faster computations (see Notes).
If an array_like, compute the response at the frequencies given.
These are in the same units as fs.
fs : float, optional
The sampling frequency of the digital system.
Defaults to 2*pi radians/sample (so w is from 0 to pi).
deg : bool, optional
If True, the phase response is returned as degree.
Default is False.
Returns
-------
w : ndarray
The frequencies at which h was computed, in the same units as fs.
By default, w is normalized to the range [0, pi) (radians/sample).
phase : ndarray
The phase response.
"""
# Calcurate the frequency response of the digital filter.
w, h = freqz(system, worN=worN, fs=fs)
# Calcurate the phase response from frequency response.
phase = sp.unwrap(sp.angle(h))
# If deg is True, return the phase response as degree
if deg == True:
phase = np.rad2deg(phase)
return w, phase
def ComplexNumToStr(val, eps=1e-12, fmt='%0.4g', polar=False, \
debug=0, strip_sympy=True):
#Note that this also becomes the default class for all elements of
#arrays, so the possibility of those elements being sympy
#expressions or something exists.
if debug:
print('In ComplexNumToStr, val='+str(val))
print('type(val)=%s' % type(val))
test = is_sage(val)
print('is_sage test = '+str(test))
if hasattr(val,'ToLatex'):
return val.ToLatex(eps=eps, fmt=fmt)
elif is_sympy(val) or is_sage(val):
sympy_out = sympy.latex(val, profile=sympy_profile)
if strip_sympy:
bad_list = ['\\begin{equation*}', \
'\\end{equation*}', \
'\\begin{equation}', \
'\\end{equation}', \
'$']
for item in bad_list:
sympy_out = sympy_out.replace(item,'')
if debug:
print('sympy_out='+sympy_out)
return sympy_out
val = AbsEpsilonCheck(val)#this zeros out any vals that have very small absolute values
test = bool(isinstance(val, complex))
#print('test = '+str(test))
if isinstance(val, complex):
realstr = ''
imagstr = ''
rpart = real(val)
ipart = imag(val)
if abs(ipart) < eps:
return fmt % rpart
elif abs(rpart) < eps:
return fmt%ipart+'j'
else:
realstr = fmt % rpart
imagstr = fmt % ipart+'j'
if ipart > 0:
rectstr = realstr+'+'+imagstr
else:
rectstr = realstr+imagstr
outstr = rectstr
if polar:
polarstr = fmt%abs(val) + ' \\angle '+fmt%angle(val,1)+'^\\circ'
outstr += ' \\; \\textrm{or} \\; ' +polarstr
return outstr
else:
return fmt % val
def plv(x, y, identities):
"""Function for computing phase-locking values between x and y.
Output arguments:
=================
cplv : ndarray
Complex-valued phase-locking values.
"""
"""Change to amplitude 1, keep angle using Euler's formula."""
x = scipy.exp(1j * (asmatrix(scipy.angle(x))))
y = scipy.exp(1j * (asmatrix(scipy.angle(y))))
"""Get cPLV needed for flips and weighting."""
cplv = scipy.zeros(len(identities), dtype='complex')
for i, identity in enumerate(identities):
"""Compute cPLV only of parcel source pairs of sources that
belong to that parcel. One source belong to only one parcel."""
if (identities[i] >= 0):
cplv[i] = (scipy.sum((scipy.asarray(y[identity])) *
scipy.conjugate(scipy.asarray(x[i]))))
cplv /= np.shape(x)[1]
return cplv
def hilbert_phaser(s):
"""
FUNC: hilbert_phaser
DESCR: Return the instantaneous phase of s using the hilbert transform
"""
#f = file("hilbert_fpe.pickle", "w")
#pickle.dump(s, f)
#f.close()
#print "utils:hilbert_phaser(): sig.hilbert(", s[0:10], ")"
h = scipy.signal.hilbert(s)
#print "utils:hilbert_phaser(): scipy.absolute(", h[0:10], ")"
a = scipy.absolute(h)
#print "utils:hilbert_phaser(): scipy.angle(", h[0:10], ")"
phase = scipy.angle(h)
return phase
def hilbert_phaser(s):
"""
FUNC: hilbert_phaser
DESCR: Return the instantaneous phase of s using the hilbert transform
"""
#f = file("hilbert_fpe.pickle", "w")
#pickle.dump(s, f)
#f.close()
#print "utils:hilbert_phaser(): sig.hilbert(", s[0:10], ")"
h = scipy.signal.hilbert(s)
#print "utils:hilbert_phaser(): scipy.absolute(", h[0:10], ")"
a = scipy.absolute(h)
#print "utils:hilbert_phaser(): scipy.angle(", h[0:10], ")"
phase = scipy.angle(h)
return phase
def calc_noise(filepath):
noise_sum=None
signal, params = read_signal(filepath, WINSIZE)
nf = len(signal)/(WINSIZE/2) - 1
noise_sum=sp.zeros(WINSIZE,sp.float32)
window = sp.hanning(WINSIZE)
for no in xrange(nf):
y = get_frame(signal, WINSIZE, no)
Y = sp.fft(y*window)
Yr = sp.absolute(Y)
Yp = sp.angle(Y)
if ( no < 20 ):
noise_sum = noise_sum + Yr**2
else:
break
return noise_sum
def detect(self, verbose=False):
frequencies, sdata = self._freqs, self._s_data
if not self._fast:
result = self._fit(verbose)
else:
amps = abs(self._s_data)
phas = angle(self._s_data)
min_idx = argmin(amps)
result = frequencies[min_idx], min(amps), phas[min_idx]
if result is not None:
if self._plot and not verbose:
self._port.plotall()
return result
def inst_freq(x, t=None):
"""
Compute the instantaneous frequency of an analytic signal at specific time
instants using the trapezoidal integration rule.
Parameters
----------
x : array-like, shape (n_samples,)
The input analytic signal.
t : array-like, shape (n_samples,), optional
The time instants at which to calculate the instantaneous frequency.
Defaults to `np.arange(2, n_samples)`
Returns
-------
array-like
Normalized instantaneous frequencies of the input signal
Examples
--------
>>> from tftb.generators import fmsin
>>> import matplotlib.pyplot as plt
>>> x = fmsin(70, 0.05, 0.35, 25)[0]
>>> instf, timestamps = inst_freq(x)
>>> plt.plot(timestamps, instf) #doctest: +SKIP
.. plot:: docstring_plots/utils/inst_freq.py
"""
if x.ndim != 1:
if 1 not in x.shape:
raise TypeError("Input should be a one dimensional array.")
else:
x = x.ravel()
if t is not None:
if t.ndim != 1:
if 1 not in t.shape:
raise TypeError("Time instants should be a one dimensional "
"array.")
else:
t = t.ravel()
else:
t = np.arange(2, len(x))
fnorm = 0.5 * (angle(-x[t] * np.conj(x[t - 2])) + np.pi) / (2 * np.pi)
return fnorm, t
def frfplot(f, H):
plt.subplot(211)
plt.plot(f, 20 * sp.log10(sp.absolute(sp.sum(H, axis=1))), '-')
plt.grid('on')
plt.xlabel('Frequency (Hz)')
plt.ylabel('FRF (dB)')
axlim = plt.axis()
plt.axis(
axlim + sp.array([0, 0, -0.1 * (axlim[3] - axlim[2]), 0.1 * (axlim[3] - axlim[2])]))
plt.subplot(212)
plt.plot(f, sp.unwrap(sp.angle(sp.sum(H, axis=1))) / sp.pi * 180, '-')
plt.grid('on')
plt.xlabel('Frequency (Hz)')
plt.ylabel('Phase (deg)')
axlim = plt.axis()
plt.axis(
axlim + sp.array([0, 0, -0.1 * (axlim[3] - axlim[2]), 0.1 * (axlim[3] - axlim[2])]))
def inst_freq(x, t=None, L=1):
"""
Compute the instantaneous frequency of an analytic signal at specific
time instants using the trapezoidal integration rule.
:param x: The input analytic signal
:param t: The time instants at which to calculate the instantaneous frequencies.
:param L: Non default values are currently not supported.
If L is 1, the normalized instantaneous frequency is computed. If L > 1,
the maximum likelihood estimate of the instantaneous frequency of the
deterministic part of the signal.
:type x: numpy.ndarray
:type t: numpy.ndarray
:type L: int
:return: instantaneous frequencies of the input signal.
:rtype: numpy.ndarray
:Example:
>>> from tftb.generators import fmsin
>>> x = fmsin(70, 0.05, 0.35, 25)[0]
>>> instf, timestamps = inst_freq(x)
>>> plot(timestamps, instf) #doctest: +SKIP
.. plot:: docstring_plots/processing/freq_domain/inst_freq.py
"""
if x.ndim != 1:
if 1 not in x.shape:
raise TypeError("Input should be a one dimensional array.")
else:
x = x.ravel()
if t is not None:
if t.ndim != 1:
if 1 not in t.shape:
raise TypeError("Time instants should be a one dimensional "
"array.")
else:
t = t.ravel()
else:
t = np.arange(2, len(x))
fnorm = 0.5 * (angle(-x[t] * np.conj(x[t - 2])) + np.pi) / (2 * np.pi)
return fnorm, t
def compute_by_noise_pow(self,signal,n_pow):
s_spec = sp.fft(signal*self._window)
s_amp = sp.absolute(s_spec)
s_phase = sp.angle(s_spec)
gamma = self._calc_aposteriori_snr(s_amp,n_pow)
xi = self._calc_apriori_snr(gamma)
self._prevGamma = gamma
nu = gamma * xi / (1.0+xi)
self._G = (self._gamma15*sp.sqrt(nu)/gamma)*sp.exp(-nu/2.0)* ((1.0+nu)*spc.i0(nu/2.0)+nu*spc.i1(nu/2.0))
idx = sp.less(s_amp**2.0,n_pow)
self._G[idx] = self._constant
idx = sp.isnan(self._G) + sp.isinf(self._G)
self._G[idx] = xi[idx] / ( xi[idx] + 1.0)
idx = sp.isnan(self._G) + sp.isinf(self._G)
self._G[idx] = self._constant
self._G = sp.maximum(self._G,0.0)
amp = self._G * s_amp
amp = sp.maximum(amp,0.0)
amp2 = self._ratio*amp + (1.0-self._ratio)*s_amp
self._prevAmp = amp
spec = amp2 * sp.exp(s_phase*1j)
return sp.real(sp.ifft(spec))
def compute_by_noise_pow(self,signal,n_pow):
s_spec = sp.fft(signal *self._window)
s_amp = sp.absolute(s_spec)
s_phase = sp.angle(s_spec)
gamma = self._calc_aposteriori_snr(s_amp,n_pow)
#xi = self._calc_apriori_snr2(gamma,n_pow)
xi = self._calc_apriori_snr(gamma)
self._prevGamma = gamma
u = 0.5 - self._mu/(4.0*sp.sqrt(gamma*xi))
self._G = u + sp.sqrt(u**2.0 + self._tau/(gamma*2.0))
idx = sp.less(s_amp**2.0,n_pow)
self._G[idx] = self._constant
idx = sp.isnan(self._G) + sp.isinf(self._G)
self._G[idx] = xi[idx] / ( xi[idx] + 1.0)
idx = sp.isnan(self._G) + sp.isinf(self._G)
self._G[idx] = self._constant
self._G = sp.maximum(self._G,0.0)
amp = self._G * s_amp
amp = sp.maximum(amp,0.0)
amp2 = self._ratio*amp + (1.0-self._ratio)*s_amp
self._prevAmp = amp
spec = amp2 * sp.exp(s_phase*1j)
return sp.real(sp.ifft(spec))
suma = abs(d[npoints/2:,:]).sum(axis=1)
suma.resize((suma.shape[0], 1))
pylab.plot(w[npoints/2:], loudia.magToDb(suma), c = 'red')
ax = pylab.gca()
# Show half of the spectrum
ax.set_xlim([0, scipy.pi])
# Set the ticks units to radians per second
ticks = ax.get_xticks()
ax.set_xticklabels(['%.2f' % (float(tick) / (scipy.pi * 2.0)) for tick in ticks])
# Set the title and labels
pylab.title('Magnitude of the Frequency Response of a \n Gammatone Filterbank implementation')
pylab.xlabel('Normalized Frequency')
pylab.ylabel('|H(w)| (no unit)')
if plotAngle:
pylab.subplot(2,1,2)
if plotColor:
pylab.plot(w[npoints/2:], scipy.angle(d[npoints/2:,:]))
else:
pylab.plot(w[npoints/2:], scipy.angle(d[npoints/2:,:]), c = 'black')
pylab.title('Angle of the Frequency Response')
pylab.gca().set_xlim([0, scipy.pi])
pylab.show()
peakSynth = loudia.PeakSynthesize( frameSize/6, fftSize, windowType )
trajsLocs = []
trajsMags = []
specs = []
specsSynth = []
specsResid = []
specsMagsResid = []
for frame in stream:
samples = frame
fft = ffter.process( windower.process( frame ) )[0, :plotSize]
spec = loudia.magToDb( abs( fft ) )[0, :plotSize]
if set(['phase', 'peak_phases']) | all_processes:
phase = scipy.angle( fft )
if set(['peak_mags', 'peak_phases']) | all_processes:
fft = scipy.reshape(fft, (1, plotSize))
peakLocs, peakMags, peakPhases = peaker.process( fft )
peakiLocs, peakiMags, peakiPhases = peakInterp.process( fft,
peakLocs,
peakMags,
peakPhases )
trajLocs, trajMags = tracker.process( fft,
peakiLocs,
peakiMags )
try :
if (x.shape[0]==0) or (y.shape[0]== 0) : raise ValueError("Empty signal")
if x.shape[0]!=y.shape[0] : raise ValueError("The two signals have different length")
except ValueError, err_msg:
raise ValueError(err_msg)
return
M=x.shape[0]
#computing the analytic signal and the instantaneous phase
x_analytic=hilbert(np.hstack(x.values))
y_analytic=hilbert(np.hstack(y.values))
phx=np.unwrap(scipy.angle(x_analytic))
phy=np.unwrap(scipy.angle(y_analytic))
disc_perc=np.floor(x.shape[0]/10.0)
phx_s=phx[disc_perc-1:M-disc_perc]
phy_s=phy[disc_perc-1:M-disc_perc]
ph_nm=(self._n*phx_s-self._m*phy_s)
psi_nm=np.mod(ph_nm, 2*np.pi)
gamma2_nm=np.square(np.mean(np.cos(psi_nm))) + np.square(np.mean(np.sin(psi_nm)))
result = dict()
result['gamma2_nm'] = gamma2_nm
for datafile_name in filenames:
## Getting 1D data
(freq, s11_ampli, s11p, s12_ampli, s12p, Nre, Nim, Zre, Zim, eps_r, eps_i, mu_r, mu_i) = \
np.loadtxt(datafile_name, usecols=range(13), unpack=True)
if quantity == 'reflection': znew = s11_ampli
elif quantity == 'transmission': znew = s12_ampli
elif quantity == 'loss': znew = np.log(1 - s11_ampli**2 - s12_ampli**2)
elif quantity == 'absNimag': znew = np.clip(abs(Nim), 0, 10)
#znew = np.log10(np.clip(abs(Nim), 0, 300 ))
elif quantity == 'absNre':
znew = abs(np.arcsin(np.sin(np.real(Nre*freq*100e-6/c) * np.pi)) / np.pi)
znew2 = np.clip(abs(Nim), 0, 10)
elif quantity == 'Nre': znew = Nre #np.real(Nre*freq*100e-6/c)
elif quantity == 'eps': znew = eps_r
elif quantity == 'epsangle': znew = np.angle(eps_r + 1j*eps_i)
elif quantity == 'mu': znew = mu_r
else: print 'Error!, select a known quantity to plot!'
## Truncate the data ranges
truncated = np.logical_and(freq>minf, freq<maxf)
(freq, znew) = map(lambda x: x[truncated], [freq, znew])
#(znew2) = map(lambda x: x[truncated], [znew2]) ## XXX
## Load header
parameters = {}
columns = []
with open(datafile_name) as datafile:
for line in datafile:
if (line[0:1] in '0123456789') or ('column' in line.lower()): break # end of parameter list
key, value = line.replace(',', ' ').split()[-2:]
# 4x4 are used
DMDpattern_superpixel, E_superpixel, fidelity_superpixel, efficiency_superpixel = superpixelMethod.superpixelMethod(E_target, resolution)
E_target_lowres = miscDMD.spatial_filter(E_target)
fidelity_superpixel_lowres = abs(miscDMD.inner_product(E_superpixel,E_target_lowres))**2
# Plot the results:
f1 = plt.figure()
a = f1.add_subplot(1,2,1)
plt.imshow(abs(E_target/ scipy.sqrt((abs(E_target)**2).sum())),"gray")
a.set_title('target intensity')
a = f1.add_subplot(1,2,2)
plt.imshow(scipy.angle(E_target/ scipy.sqrt((abs(E_target)**2).sum())),"gray")
a.set_title('target phase')
f2 = plt.figure()
a = f2.add_subplot(1,1,1)
plt.imshow(DMDpattern_superpixel, "gray")
a.set_title('DMD pattern superpixel')
f3 = plt.figure()
a = f3.add_subplot(1,2,1)
plt.imshow(abs(E_superpixel/ scipy.sqrt((abs(E_target_lowres)**2).sum())),"gray")
a.set_title('superpixel intensity')
a = f3.add_subplot(1,2,2)
plt.imshow(scipy.angle(E_superpixel/ scipy.sqrt((abs(E_target_lowres)**2).sum())),"gray")
a.set_title('superpixel phase')
def nichols_grid(cl_mags=None, cl_phases=None):
"""Nichols chart grid
Plots a Nichols chart grid on the current axis, or creates a new chart
if no plot already exists.
Parameters
----------
cl_mags : array-like (dB), optional
Array of closed-loop magnitudes defining the iso-gain lines on a
custom Nichols chart.
cl_phases : array-like (degrees), optional
Array of closed-loop phases defining the iso-phase lines on a custom
Nichols chart. Must be in the range -360 < cl_phases < 0
Returns
-------
None
"""
# Default chart size
ol_phase_min = -359.99
ol_phase_max = 0.0
ol_mag_min = -40.0
ol_mag_max = default_ol_mag_max = 50.0
# Find bounds of the current dataset, if there is one.
if plt.gcf().gca().has_data():
ol_phase_min, ol_phase_max, ol_mag_min, ol_mag_max = plt.axis()
# M-circle magnitudes.
if cl_mags is None:
# Default chart magnitudes
# The key set of magnitudes are always generated, since this
# guarantees a recognizable Nichols chart grid.
key_cl_mags = np.array([-40.0, -20.0, -12.0, -6.0, -3.0, -1.0, -0.5, 0.0,
0.25, 0.5, 1.0, 3.0, 6.0, 12.0])
# Extend the range of magnitudes if necessary. The extended arange
# will end up empty if no extension is required. Assumes that closed-loop
# magnitudes are approximately aligned with open-loop magnitudes beyond
# the value of np.min(key_cl_mags)
cl_mag_step = -20.0 # dB
extended_cl_mags = np.arange(np.min(key_cl_mags),
ol_mag_min + cl_mag_step, cl_mag_step)
cl_mags = np.concatenate((extended_cl_mags, key_cl_mags))
# N-circle phases (should be in the range -360 to 0)
if cl_phases is None:
# Choose a reasonable set of default phases (denser if the open-loop
# data is restricted to a relatively small range of phases).
key_cl_phases = np.array([-0.25, -45.0, -90.0, -180.0, -270.0, -325.0, -359.75])
if np.abs(ol_phase_max - ol_phase_min) < 90.0:
other_cl_phases = np.arange(-10.0, -360.0, -10.0)
else:
other_cl_phases = np.arange(-10.0, -360.0, -20.0)
cl_phases = np.concatenate((key_cl_phases, other_cl_phases))
else:
assert ((-360.0 < np.min(cl_phases)) and (np.max(cl_phases) < 0.0))
# Find the M-contours
m = m_circles(cl_mags, phase_min=np.min(cl_phases), phase_max=np.max(cl_phases))
m_mag = 20*sp.log10(np.abs(m))
m_phase = sp.mod(sp.degrees(sp.angle(m)), -360.0) # Unwrap
# Find the N-contours
n = n_circles(cl_phases, mag_min=np.min(cl_mags), mag_max=np.max(cl_mags))
n_mag = 20*sp.log10(np.abs(n))
n_phase = sp.mod(sp.degrees(sp.angle(n)), -360.0) # Unwrap
# Plot the contours behind other plot elements.
# The "phase offset" is used to produce copies of the chart that cover
# the entire range of the plotted data, starting from a base chart computed
# over the range -360 < phase < 0. Given the range
# the base chart is computed over, the phase offset should be 0
# for -360 < ol_phase_min < 0.
phase_offset_min = 360.0*np.ceil(ol_phase_min/360.0)
phase_offset_max = 360.0*np.ceil(ol_phase_max/360.0) + 360.0
phase_offsets = np.arange(phase_offset_min, phase_offset_max, 360.0)
for phase_offset in phase_offsets:
# Draw M and N contours
plt.plot(m_phase + phase_offset, m_mag, color='gray',
linestyle='dotted', zorder=0)
plt.plot(n_phase + phase_offset, n_mag, color='gray',
linestyle='dotted', zorder=0)
# Add magnitude labels
for x, y, m in zip(m_phase[:][-1] + phase_offset, m_mag[:][-1], cl_mags):
align = 'right' if m < 0.0 else 'left'
plt.text(x, y, str(m) + ' dB', size='small', ha=align, color='gray')
# Fit axes to generated chart
plt.axis([phase_offset_min - 360.0, phase_offset_max - 360.0,
np.min(cl_mags), np.max([ol_mag_max, default_ol_mag_max])])
def update_figure(self, i=0):
cur_cmap = cm.RdGy_r
self.f1.clf()
self.init_figure()
wh = sp.where(abs(self.object.data[0]) > 0.1 * (abs(self.object.data[0]).max()))
try:
x1, x2 = min(wh[0]), max(wh[0])
y1, y2 = min(wh[1]), max(wh[1])
except (ValueError, IndexError):
x1, x2 = 0, self.ob_p
y1, y2 = 0, self.ob_p
# Plot magnitude of object
s1 = pylab.subplot(231)
s1_im = s1.imshow(abs(self.object).data[0][x1:x2, y1:y2], cmap=cm.Greys_r)
s1.set_title('|object|')
plt.axis('off')
pylab.colorbar(s1_im)
# Plot phase of object
s2 = pylab.subplot(232)
s2_im = s2.imshow(sp.angle(self.object.data[0][x1:x2, y1:y2]), cmap=cm.hsv)
s2.set_title('phase(object)')
plt.axis('off')
pylab.colorbar(s2_im)
# Complex HSV plot of object
s3 = pylab.subplot(233)
h = ((angle(self.object).data[0][x1:x2, y1:y2] + np.pi) / (2*np.pi)) % 1.0
s = np.ones_like(h)
l = abs(self.object).data[0][x1:x2, y1:y2]
l-=l.min()
l/=l.max()
s3_im = s3.imshow(np.dstack(v_hls_to_rgb(h,l,s)))
s3.set_title('Complex plot of Object')
plt.axis('off')
# Plot probe mode 0
s4 = pylab.subplot(234)
s4_im = s4.imshow(abs(self.probe.modes[0].data[0]), cmap=cur_cmap)
s4.set_title('|probe0|')
plt.axis('off')
pylab.colorbar(s4_im)
if CXP.reconstruction.probe_modes>1:
s5 = pylab.subplot(235)
s5_im = s5.imshow(abs(self.probe.modes[1].data[0]), cmap=cur_cmap)
s5.set_title('|probe1|')
plt.axis('off')
pylab.colorbar(s5_im)
else:
pass
if self.ppc:
s6 = self.f1.add_subplot(236)
s6_im = s6.scatter(self.positions.data[0], self.positions.data[1], s=10,
c='b', marker='o', alpha=0.5, edgecolors='none', label='current')
patches = []
for m in range(self.positions.total):
patches.append(Circle((self.positions.initial[0][m], self.positions.initial[1][m]),
radius=CXP.reconstruction.ppc_search_radius))
collection = PatchCollection(patches, color='tomato', alpha=0.2, edgecolors=None)
s4.add_collection(collection)
if CXP.measurement.simulate_data:
s4_im = s4.scatter(self.positions.correct[0], self.positions.correct[1], s=10,
c='g', marker='o', alpha=0.5, edgecolors='none', label='correct')
CXP.log.info('RMS position deviation from correct: [x:{:3.2f},y:{:3.2f}] pixels'.format(
sp.sqrt(sp.mean((self.positions.data[0] - self.positions.correct[0])**2.)),
sp.sqrt(sp.mean((self.positions.data[1] - self.positions.correct[1])**2.))))
lines=[]
for m in range(self.positions.total):
lines.append(((self.positions.correct[0][m], self.positions.correct[1][m]),
(self.positions.data[0][m], self.positions.data[1][m])))
for element in lines:
x, y = zip(*element)
s4.plot(x, y, 'g-')
else:
lines = []
for m in range(self.positions.total):
lines.append(((self.positions.initial[0][m], self.positions.initial[1][m]),
(self.positions.data[0][m], self.positions.data[1][m])))
for element in lines:
x, y = zip(*element)
s6.plot(x, y, 'g-')
CXP.log.info('RMS position deviation from initial: [x:{:3.2f},y:{:3.2f}] pixels'.format(
sp.sqrt(sp.mean((self.positions.data[0] - self.positions.initial[0])**2.)),
sp.sqrt(sp.mean((self.positions.data[1] - self.positions.initial[1])**2.))))
s6.legend(prop={'size': 6})
s6.set_title('Position Correction')
s6.set_aspect('equal')
extent = s6.get_window_extent().transformed(self.f1.dpi_scale_trans.inverted())
pylab.savefig(self._cur_sequence_dir + '/ppc_{:d}.png'.format(self.total_its), bbox_inches=extent.expanded(1.2, 1.2), dpi=100)
s6.set_aspect('auto')
else:
s6 = pylab.subplot(236)
if CXP.measurement.simulate_data:
s6_im = s6.imshow(abs(self.input_probe[1].data[0]), cmap = cur_cmap)
s6.set_title('|input_probe1|')
else:
s6_im = s6.imshow(nlog(fftshift(self.det_mod[np.mod(i,self.positions.total)])).data[0], cmap=cur_cmap)
s6.set_title('Diff Patt: {:d}'.format(i))
plt.axis('off')
pylab.colorbar(s6_im)
pylab.draw()
pylab.savefig(self._cur_sequence_dir + '/recon_{:d}.png'.format(self.total_its), dpi=60)
print r_random_time print r_sine_time print "Freq:" print r_zeros_freq print r_ones_freq print r_random_freq print r_sine_freq print scipy.allclose(r_zeros_fft, s_zeros_fft) print scipy.allclose(r_ones_fft, s_ones_fft) print scipy.allclose(r_random_fft, s_random_fft) print scipy.allclose(r_sine_fft, s_sine_fft) r_abs = scipy.absolute(r_sine_fft).T r_ang = scipy.angle(r_sine_fft).T r_max = max(r_abs) s_abs = scipy.absolute(s_sine_fft).T s_ang = scipy.angle(s_sine_fft).T s_max = max(s_abs) import pylab pylab.subplot(311) pylab.plot(a_sine.T) pylab.subplot(312) pylab.hold(True) pylab.plot(r_abs, label = 'Loudia') pylab.plot(s_abs, label = 'Scipy') pylab.legend()
