""" Legacy functions (do not use) """
import copy
import numpy as np
import matplotlib
import sys
import os
import cv2
import pickle
import warnings
import qtt.data
import qtt.algorithms.onedot
import datetime
# %%
from qtt.algorithms.gatesweep import analyseGateSweep
from qtt.data import loadDataset
from qtt.utilities.tools import diffImage, rdeprecated
from qtt import pgeometry as pmatlab
warnings.warn('please do not import this module')
# %%
try:
import graphviz
except:
pass
import matplotlib.pyplot as plt
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1 Sep 2018')
def showDotGraph(dot, fig=10):
dot.format = 'png'
outfile = dot.render('dot-dummy', view=False)
print(outfile)
im = plt.imread(outfile)
plt.figure(fig)
plt.clf()
plt.imshow(im)
plt.tight_layout()
plt.axis('off')
# %%
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='7-1-2018')
def positionScanjob(scanjob, pt):
""" Helper function
Changes an existing scanjob to scan at the centre of the specified point
"""
scanjob = copy.deepcopy(scanjob)
sh = float(pt[0] - (scanjob['sweepdata']['start'] + scanjob['sweepdata']['end']) / 2)
scanjob['sweepdata']['start'] += sh
scanjob['sweepdata']['end'] += sh
sh = float(pt[1] - (scanjob['stepdata']['start'] + scanjob['stepdata']['end']) / 2)
scanjob['stepdata']['start'] += sh
scanjob['stepdata']['end'] += sh
return scanjob
# %%
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1-7-2018')
def saveImage(resultsdir, name, fig=None, dpi=300, ext='png', tight=False):
""" Save matplotlib figure to disk
Arguments
---------
name : str
name of file to save
Returns
-------
imfilerel, imfile : string
filenames
"""
imfile0 = '%s.%s' % (name, ext)
imfile = os.path.join(resultsdir, 'pictures', imfile0)
qtt.utilities.tools.mkdirc(os.path.join(resultsdir, 'pictures'))
imfilerel = os.path.join('pictures', imfile0)
if fig is not None:
plt.figure(fig)
if tight:
plt.savefig(imfile, dpi=dpi, bbox_inches='tight', pad_inches=tight)
else:
plt.savefig(imfile, dpi=dpi)
return imfilerel, imfile
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1-7-2019')
def plotCircle(pt, radius=11.5, color='r', alpha=.5, linewidth=3, **kwargs):
""" Plot a circle in a matplotlib figure
Args:
pt (array): center of circle
radius (float): radius of circle
color (str or list)
alpha (float): transparency
"""
c2 = plt.Circle(pt, radius, color=color, fill=False, linewidth=3, alpha=alpha, **kwargs)
plt.gca().add_artist(c2)
return c2
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1 Sep 2018')
def scaleCmap(imx, setclim=True, verbose=0):
""" Scale colormap of sensing dot image """
p99 = np.percentile(imx, 99.9)
mval = p99
# 0 <-> alpha
# mval <->1
w = np.array([0, 1])
# cl=(1./mval)*(w)+.2)
alpha = .23
cl = (mval / (1 - alpha)) * (w - alpha)
if verbose:
print('scaleCmap to %.1f %.1f' % (cl[0], cl[1]))
if setclim:
plt.clim(cl)
return cl
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1-1-2019')
def writeBatchData(outputdir, tag, timestart, timecomplete):
tt = datetime.datetime.now().strftime('%d%m%Y-%H%m%S')
with open(os.path.join(outputdir, '%s-%s.txt' % (tag, tt)), 'wt') as fid:
fid.write('Tag: %s\n' % tag)
fid.write('Time start: %s\n' % timestart)
fid.write('Time complete: %s\n' % timecomplete)
fid.close()
print('writeBatchData: %s' % fid.name)
# %%
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1 Sep 2018')
def filterBG(imx, ksize, sigma=None):
""" Filter away background using Gaussian filter """
# imq = cv2.bilateralFilter(imx.astype(np.float32),9,75,75)
# imq=cv2.medianBlur(imx.astype(np.uint8), 33)
if ksize % 2 == 0:
ksize = ksize + 1
if sigma is None:
sigma = 0.3 * ((ksize - 1) * 0.5 - 1) + 0.8
# sigma=.8
imq = imx.copy()
imq = cv2.GaussianBlur(imq, (int(ksize), int(ksize)), sigma)
imq = imx - imq
return imq
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1 Sep 2018')
def filterGabor(im, theta0=-np.pi / 8, istep=1, widthmv=2, lengthmv=10, gammax=1, cut=None, verbose=0, fig=None):
"""
Filter image with Gabor
step is in pixel/mV
Parameters
----------
im : array
input image
theta0 : float
angle of Gabor filter (in radians)
"""
cwidth = 2. * widthmv * np.abs(istep)
clength = .5 * lengthmv * np.abs(istep)
# odd number, at least twice the length
ksize = 2 * int(np.ceil(clength)) + 1
if verbose:
print('filterGabor: kernel size %d %d' % (ksize, ksize))
print('filterGabor: width %.1f pixel (%.1f mV)' % (cwidth, widthmv))
print('filterGabor: length %.1f pixel (%.1f mV)' % (clength, lengthmv))
sigmax = cwidth / 2 * gammax
sigmay = clength / 2
gfilter = pmatlab.gaborFilter(ksize, sigma=sigmax, theta=theta0, Lambda=cwidth,
psi=0, gamma=sigmax / sigmay, cut=cut)
# gfilter=cv2.getGaborKernel( (ksize,ksize), sigma=sigmax, theta=theta0, lambd=cwidth, gamma=sigmax/sigmay, psi=0*np.pi/2)
gfilter -= gfilter.sum() / gfilter.size
imf = cv2.filter2D(im, -1, gfilter)
if fig is not None:
plt.figure(fig + 1)
plt.clf()
plt.imshow(r[0], interpolation='nearest')
plt.colorbar()
plt.clim([-1, 1])
return imf, (gfilter, )
# %%
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1 Sep 2018')
def cmap_map(function, cmap):
""" Applies function (which should operate on vectors of shape 3:
[r, g, b], on colormap cmap. This routine will break any discontinuous points in a colormap.
"""
cdict = cmap._segmentdata
step_dict = {}
# Firt get the list of points where the segments start or end
for key in ('red', 'green', 'blue'):
step_dict[key] = map(lambda x: x[0], cdict[key])
step_list = sum(step_dict.values(), [])
step_list = np.array(list(set(step_list)))
# Then compute the LUT, and apply the function to the LUT
def reduced_cmap(step): return np.array(cmap(step)[0:3])
old_LUT = np.array(map(reduced_cmap, step_list))
new_LUT = np.array(map(function, old_LUT))
# Now try to make a minimal segment definition of the new LUT
cdict = {}
for i, key in enumerate(('red', 'green', 'blue')):
this_cdict = {}
for j, step in enumerate(step_list):
if step in step_dict[key]:
this_cdict[step] = new_LUT[j, i]
elif new_LUT[j, i] != old_LUT[j, i]:
this_cdict[step] = new_LUT[j, i]
colorvector = sorted(map(lambda x: x + (x[1], ), this_cdict.items()))
cdict[key] = colorvector
return matplotlib.colors.LinearSegmentedColormap('colormap', cdict, 1024)
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1 Sep 2018')
def cmap_discretize(cmap, N, m=1024):
"""Return a discrete colormap from the continuous colormap cmap.
cmap: colormap instance, eg. cm.jet.
N: number of colors.
Example
x = resize(arange(100), (5,100))
djet = cmap_discretize(cm.jet, 5)
imshow(x, cmap=djet)
"""
if isinstance(cmap, str):
cmap = get_cmap(cmap)
colors_i = np.concatenate((np.linspace(0, 1., N), (0., 0., 0., 0.)))
colors_rgba = cmap(colors_i)
indices = np.linspace(0, 1., N + 1)
cdict = {}
for ki, key in enumerate(('red', 'green', 'blue')):
cdict[key] = [
(indices[i], colors_rgba[i - 1, ki], colors_rgba[i, ki]) for i in range(N + 1)]
# Return colormap object.
return matplotlib.colors.LinearSegmentedColormap(cmap.name + "_%d" % m, cdict, m)
# %%
from qtt.algorithms.misc import polyval2d, polyfit2d
from qtt.utilities.imagetools import fitBackground as fitBackgroundTmp
from qtt.utilities.imagetools import cleanSensingImage
fitBackground = qtt.utilities.tools.deprecated(fitBackgroundTmp)
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1 Sep 2018')
def showIm(ims, fig=1, title='', showz=False):
""" Show image with nearest neighbor interpolation and axis scaling """
plt.figure(fig)
plt.clf()
if showz:
pmatlab.imshowz(ims, interpolation='nearest')
else:
plt.imshow(ims, interpolation='nearest')
plt.axis('image')
plt.title(title)
# %%
from qtt.algorithms.misc import point_in_poly, points_in_poly, fillPoly
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1 Sep 2018')
def getPinchvalues(od, xdir, verbose=1):
""" Get pinch values from recorded data """
gg = od['gates']
od['pinchvalues'] = -800 * np.ones(3)
for jj, g in enumerate(gg):
# pp='%s-sweep-1d-%s.pickle' % (od['name'], g)
pp = pinchoffFilename(g, od=None)
pfile = os.path.join(xdir, pp)
dd, metadata = qtt.data.loadDataset(pfile)
adata = qtt.algorithms.gatesweep.analyseGateSweep(dd, fig=0, minthr=100, maxthr=800, verbose=0)
if verbose:
print('getPinchvalues: gate %s : %.2f' % (g, adata['pinchoff_point']))
od['pinchvalues'][jj] = adata['pinchoff_point']
return od
[docs]@qtt.utilities.tools.rdeprecated(txt='Method will be removed in future release of qtt.', expire='1 Sep 2018')
def loadOneDotPinchvalues(od, outputdir, verbose=1):
""" Load the pinch-off values for a one-dot
Arguments
---------
od : dict
one-dot structure
outputdir : string
location of the data
"""
print('analyse data for 1-dot: %s' % od['name'])
gg = od['gates']
pv = np.zeros((3, 1))
for ii, g in enumerate(gg):
basename = pinchoffFilename(g, od=None)
pfile = os.path.join(outputdir, 'one_dot', basename)
alldata, _ = loadDataset(pfile)
if alldata is None:
raise Exception('could not load file %s' % pfile)
adata = analyseGateSweep(
alldata, fig=None, minthr=None, maxthr=None, verbose=1)
if verbose:
print('loadOneDotPinchvalues: pinchvalue for gate %s: %.1f' %
(g, adata['pinchoff_point']))
pv[ii] = adata['pinchoff_point']
od['pinchvalues'] = pv
return od
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1 Sep 2018')
def createDoubleDotJobs(two_dots, one_dots, resultsdir, basevalues=dict(), sdinstruments=[], fig=None, verbose=1):
""" Create settings for a double-dot from scans of the individual one-dots """
raise Exception('function was removed from qtt')
# %%
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1-1-2019')
def printGateValues(gv, verbose=1):
s = ', '.join(['%s: %.1f' % (x, gv[x]) for x in sorted(gv.keys())])
return s
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1-1-2019')
def getODbalancepoint(od):
bp = od['balancepoint']
if 'balancepointfine' in od:
bp = od['balancepointfine']
return bp
[docs]@rdeprecated(txt='Method will be removed in future release of qtt', expire='1-6-2018')
def loadpickle(pkl_file):
""" Load objects from file """
try:
output = open(pkl_file, 'rb')
data2 = pickle.load(output)
output.close()
except:
if sys.version_info.major >= 3:
# if pickle file was saved in python2 we might fix issues with a different encoding
output = open(pkl_file, 'rb')
data2 = pickle.load(output, encoding='latin')
# pickle.load(pkl_file, fix_imports=True, encoding="ASCII", errors="strict")
output.close()
else:
data2 = None
return data2