def PlotReferencePhase (self, event) :
"""
Plot reference phase
"""
visvis.cla(); visvis.clf();
# get actual amplitude and phased
phase = self.GetReferencePhase()[0]
ampl = np.ones(phase.size)
ampl, phase = self.DevPulseShaper.GetUnwrappedAmplPhase(ampl, phase)
# Wrap the phase in radians
phase %= (2*np.pi)
# Get the phase in unites of 2*pi
phase /= (2*np.pi)
visvis.subplot(211)
visvis.plot(phase)
visvis.ylabel ('Reference phase')
visvis.xlabel ('puls shaper pixel number')
visvis.title ('Current reference phase (in unites of 2*pi)')
visvis.subplot(212)
visvis.plot( self.corrections, lc='r',ms='*', mc='r' )
visvis.ylabel ('Value of coefficients')
visvis.xlabel ('coefficient number')
visvis.title ('Value of corrections')
def _createWindow(self, name, im, axis):
vv.figure()
vv.gca()
vv.clf()
fig = vv.imshow(im)
dims = im.shape
''' Change color bounds '''
if im.dtype == np.uint8:
fig.clim.Set(0, 255)
else:
fig.clim.Set(0., 1.)
fig.GetFigure().title = name
''' Show ticks on axes? '''
if not axis:
fig.GetAxes().axis.visible = False
bgcolor = (0.,0.,0.)
else:
fig.GetAxes().axis.showBox = False
bgcolor = (1.,1.,1.)
''' Set background color '''
fig.GetFigure().bgcolor = bgcolor
fig.GetAxes().bgcolor = bgcolor
''' Setup keyboard event handler '''
fig.eventKeyDown.Bind(self._keyHandler)
win = {'name':name, 'canvas':fig, 'shape':dims, 'keyEvent':None, 'text':[]}
self.open_windows.append(win)
return win
def ShowImg (self) :
"""
Draw image
"""
if self._abort_img :
# Exit
return
# Get image
img = self.dev.StopImgAqusition()
# Display image
try :
if img <> RETURN_FAIL :
self._img_plot.SetData(img)
except AttributeError :
visvis.cla()
visvis.clf()
self._img_plot = visvis.imshow(img)
visvis.title ('Camera view')
ax = visvis.gca()
ax.axis.xTicks = []
ax.axis.yTicks = []
# Start acquisition of histogram
self.dev.StartImgAqusition()
wx.CallAfter(self.ShowImg)
def DisplayOptimization (self) :
"""
Display the progress of optimization
"""
wx.Yield()
# abort, if requested
if self.need_abort : return
def GetValueColourIter (d) :
return izip_longest( d.itervalues(), ['r', 'g', 'b', 'k'], fillvalue='y' )
visvis.cla(); visvis.clf()
visvis.subplot(211)
# Plot optimization statistics
for values, colour in GetValueColourIter(self.optimization_log) :
try : visvis.plot ( values, lc=colour )
except Exception : pass
visvis.xlabel ('iteration')
visvis.ylabel ('Objective function')
visvis.legend( self.optimization_log.keys() )
# Display reference signal
visvis.subplot(212)
# Plot reference signal
for values, colour in GetValueColourIter(self.log_reference_signal) :
try : visvis.plot ( values, lc=colour )
except Exception : pass
visvis.xlabel ('iteration')
visvis.ylabel ("Signal from reference pulse")
visvis.legend( ["channel %d" % x for x in self.log_reference_signal.keys()] )
def show(items, normals=None):
"""Function that shows a mesh object.
"""
for item in items:
vv.clf()
# convert to visvis.Mesh class
new_normals = []
new_vertices = []
for k, v in item.vertices.iteritems():
new_normals.append(item.normal(k))
new_vertices.append(v)
mesh = item.to_visvis_mesh()
mesh.SetVertices(new_vertices)
mesh.SetNormals(new_normals)
mesh.faceColor = 'y'
mesh.edgeShading = 'plain'
mesh.edgeColor = (0, 0, 1)
axes = vv.gca()
if axes.daspectAuto is None:
axes.daspectAuto = False
axes.SetLimits()
if normals is not None:
for normal in normals:
sl = solidLine(normal, 0.15)
sl.faceColor = 'r'
# Show title and enter main loop
vv.title('Show')
app = vv.use()
app.Run()
def StartInteractivelyMeasureSpectrum (self, event) :
"""
This method display spectrum
"""
button = self.show_spectrum_button
if button.GetLabel() == button.__start_label__ :
self.StopAllJobs()
# get spectrometer's settings
spect_settings = self.SettingsNotebook.Spectrometer.GetSettings()
# Initiate spectrometer
if self.Spectrometer.SetSettings(spect_settings) == RETURN_FAIL : return
try : self.wavelengths = self.Spectrometer.GetWavelengths()
except AttributeError : self.wavelengths = None
# Clearing the figure
visvis.cla(); visvis.clf();
# Set up timer to draw spectrum
TIMER_ID = wx.NewId()
self.spectrum_timer = wx.Timer (self, TIMER_ID)
self.spectrum_timer.Start (spect_settings["exposure_time"])
wx.EVT_TIMER (self, TIMER_ID, self.DrawSpectrum)
# Chose plotting options
try :
self.is_autoscaled_spectrum = not(spect_settings["fix_vertical_axis"])
except KeyError :
self.is_autoscaled_spectrum = True
if not self.is_autoscaled_spectrum :
self.spectrum_plot_limits = ( spect_settings["vertical_axis_min_val"],
spect_settings["vertical_axis_max_val"] )
# Change button's label
button.SetLabel (button.__stop_label__)
elif button.GetLabel() == button.__stop_label__ :
# Stopping timer
self.spectrum_timer.Stop()
del self.spectrum_timer
# Delete the parameter for auto-scaling
del self.spectrum_plot_limits, self.is_autoscaled_spectrum
# Delate visvis objects
try : del self.__interact_2d_spectrum__
except AttributeError : pass
try : del self.__interact_1d_spectrum__
except AttributeError : pass
# Change button's label
button.SetLabel (button.__start_label__)
else : raise ValueError("Label is not recognized")
def paint(self, visvis):
vv.clf()
colors = ["r", "g", "b", "c", "m", "y", "k"]
for index, dataset in enumerate(self._value):
l = visvis.plot(dataset, ms="o", mc=colors[index % len(colors)], mw="3", ls="", mew=0)
l.alpha = 0.3
self._a = vv.gca()
self._a.daspectAuto = True
def _Plot(self, event):
# Make sure our figure is the active one
# If only one figure, this is not necessary.
#vv.figure(self.fig.nr)
# Clear it:
vv.clf()
# Plot:
pcv.drawDisplacements(self.a, self.coords, self.edof, self.dofsPerNode, self.elType, doDrawUndisplacedMesh=True, title="Example 09")
def paint(self, visvis):
vv.clf()
colors = ['r','g','b','c','m','y','k']
for index, dataset in enumerate(self._value):
l = visvis.plot(dataset, ms='o', mc=colors[ index % len(colors) ], mw='3', ls='', mew=0 )
l.alpha = 0.3
self._a = vv.gca()
self._a.daspectAuto = True
def MeasureSingleSpectrum (self, event=None) :
"""
Button <self.show_spectrum_button> was clicked
"""
button = self.show_spectrum_button
if button.GetLabel() == button.__start_label__ :
self.StopAllJobs()
# get spectrometer's settings
spect_settings = self.SettingsNotebook.Spectrometer.GetSettings()
# Initiate spectrometer
if self.Spectrometer.SetSettings(spect_settings) == RETURN_FAIL : return
self.wavelengths = self.Spectrometer.GetWavelengths()
# Clearing the figure
visvis.clf()
def draw_spectrum (event) :
"""Timer function """
spectrum = self.Spectrometer.AcquiredData()
if spectrum == RETURN_FAIL : return
# Display the spectrum
############### Take the log of spectrum ##########
#spectrum = spectrum / float(spectrum.max())
#np.log10(spectrum, out=spectrum)
##############################
ax = visvis.gca()
ax.Clear()
visvis.plot (self.wavelengths, spectrum)
visvis.xlabel("wavelength (nm)")
visvis.ylabel("counts")
# Display the current temperature
visvis.title ("Temperature %d (C)" % self.Spectrometer.GetTemperature() )
# Set up timer to draw spectrum
TIMER_ID = wx.NewId()
self.spectrum_timer = wx.Timer (self, TIMER_ID)
self.spectrum_timer.Start (spect_settings["exposure_time"])
# Change button's label
button.SetLabel (button.__stop_label__)
wx.EVT_TIMER (self, TIMER_ID, draw_spectrum)
elif button.GetLabel() == button.__stop_label__ :
# Stopping timer
self.spectrum_timer.Stop()
del self.spectrum_timer
# Change button's label
button.SetLabel (button.__start_label__)
else : raise ValueError("Label is not recognized")
def main(select=3, **kwargs):
"""Script main function.
select: int
1: Medical data
2: Blocky data, different every time
3: Two donuts
4: Ellipsoid
"""
import visvis as vv # noqa: delay import visvis and GUI libraries
# Create test volume
if select == 1:
vol = vv.volread('stent')
isovalue = kwargs.pop('level', 800)
elif select == 2:
vol = vv.aVolume(20, 128)
isovalue = kwargs.pop('level', 0.2)
elif select == 3:
with timer('computing donuts'):
vol = donuts()
isovalue = kwargs.pop('level', 0.0)
# Uncommenting the line below will yield different results for
# classic MC
# vol *= -1
elif select == 4:
vol = ellipsoid(4, 3, 2, levelset=True)
isovalue = kwargs.pop('level', 0.0)
else:
raise ValueError('invalid selection')
# Get surface meshes
with timer('finding surface lewiner'):
vertices1, faces1 = marching_cubes_lewiner(vol, isovalue, **kwargs)[:2]
with timer('finding surface classic'):
vertices2, faces2 = marching_cubes_classic(vol, isovalue, **kwargs)
# Show
vv.figure(1)
vv.clf()
a1 = vv.subplot(121)
vv.title('Lewiner')
m1 = vv.mesh(np.fliplr(vertices1), faces1)
a2 = vv.subplot(122)
vv.title('Classic')
m2 = vv.mesh(np.fliplr(vertices2), faces2)
a1.camera = a2.camera
# visvis uses right-hand rule, gradient_direction param uses left-hand rule
m1.cullFaces = m2.cullFaces = 'front' # None, front or back
vv.use().Run()
def _Plot(self, event):
# Make sure our figure is the active one
# If only one figure, this is not necessary.
#vv.figure(self.fig.nr)
# Clear it
vv.clf()
# Plot
vv.plot([1,2,3,1,6])
vv.legend(['this is a line'])
def __plot(self, spectrum):
vv.clf()
axes = vv.gca()
axes.axis.showGrid = True
axes.axis.xLabel = 'Frequency (MHz)'
axes.axis.yLabel = 'Level (dB)'
total = len(spectrum)
count = 0.
for _time, sweep in spectrum.items():
alpha = (total - count) / total
vv.plot(sweep.keys(), sweep.values(), lw=1, alpha=alpha)
count += 1
def AnalyzeTotalFluorescence (self, event=None) : """ `analyse_button` was clicked """ # Get current settings settings = self.GetSettings() # Apply peak finding filter signal = self.peak_finders[ settings["peak_finder"] ](self.total_fluorescence) # Scale to (0,1) signal -= signal.min() signal = signal / signal.max() ########################################################################## # Partition signal into segments that are above the background noise #signal = gaussian_filter(total_fluorescence, sigma=0.5) background_cutoff = settings["background_cutoff"] segments = [ [] ] for num, is_segment in enumerate( signal > background_cutoff ) : if is_segment : # this index is in the segment segments[-1].append( num ) elif len(segments[-1]) : # this condition is not to add empty segments # Start new segments segments.append( [] ) # Find peaks as weighted average of the segment peaks = [ np.average(self.positions[S], weights=self.total_fluorescence[S]) for S in segments if len(S) ] ########################################################################## # Saving the positions self.chanel_positions_ctrl.SetValue( ", ".join( "%2.4f" % p for p in peaks ) ) ########################################################################## # Plot acquired data visvis.cla(); visvis.clf() visvis.plot( self.positions, signal ) visvis.plot( peaks, background_cutoff*np.ones(len(peaks)), ls=None, ms='+', mc='r', mw=20) visvis.plot( [self.positions.min(), self.positions.max()], [background_cutoff, background_cutoff], lc='r', ls='--', ms=None) visvis.legend( ["measured signal", "peaks found", "background cut-off"] ) visvis.ylabel( "total fluorescence") visvis.xlabel( 'position (mm)')
def plot(self, new_point):
vv.clf()
# checking amount of points
length = max(len(self.points[0]) - 90, len(self.points_i[0]) - 90, 0)
if self.check_u.checkState():
# plots points for voltage if voltage is on
self.plot_point_set(new_point[:2], 'b', length)
if self.check_i.checkState():
# plots points for currency if currency is on
self.plot_point_set([new_point[0], new_point[2]], 'r', length, i=True)
first_point = self.points_i[0][0] if self.check_i.checkState() else self.points[0][0]
# set Axes limits on current time
self.fig.currentAxes.SetLimits((first_point, first_point+10), (-5, 5))
self.fig.currentAxes.axis.showGrid = True
self.fig.DrawNow()
def setupAxes(self):
"""
Sets up the axes initially. Shows a 2d view with a range based
on the sensor positions. Might want to give the user the option to set the range
in future releases.
The if statement is for when the sensors got switched.. which only
happens on 2 subjects, but totally messes up the axes view then.
"""
vv.clf()
self.axes = vv.gca()
self.axisLabeler = self.axes.axis
self.axes.cameraType = 3
self.axes.daspectAuto= False
#.SetLimits(#rangeX = (xmin,xmax),rangeY = (ymin,ymax), rangeZ = (zmin,zmax))
self.axisLabeler.showGrid = True
def DrawSpectrum (self, event) :
"""
Draw spectrum interactively
"""
spectrum = self.Spectrometer.AcquiredData()
if spectrum == RETURN_FAIL : return
# Display the spectrum
if len(spectrum.shape) > 1:
try :
self.__interact_2d_spectrum__.SetData(spectrum)
except AttributeError :
visvis.cla(); visvis.clf();
# Spectrum is a 2D image
visvis.subplot(211)
self.__interact_2d_spectrum__ = visvis.imshow(spectrum, cm=visvis.CM_JET)
visvis.subplot(212)
# Plot a vertical binning
spectrum = spectrum.sum(axis=0)
# Linear spectrum
try :
self.__interact_1d_spectrum__.SetYdata(spectrum)
except AttributeError :
if self.wavelengths is None :
self.__interact_1d_spectrum__ = visvis.plot (spectrum, lw=3)
visvis.xlabel ("pixels")
else :
self.__interact_1d_spectrum__ = visvis.plot (self.wavelengths, spectrum, lw=3)
visvis.xlabel("wavelength (nm)")
visvis.ylabel("counts")
if self.is_autoscaled_spectrum :
# Smart auto-scale linear plot
try :
self.spectrum_plot_limits = GetSmartAutoScaleRange(spectrum, self.spectrum_plot_limits)
except AttributeError :
self.spectrum_plot_limits = GetSmartAutoScaleRange(spectrum)
visvis.gca().SetLimits ( rangeY=self.spectrum_plot_limits )
# Display the current temperature
try : visvis.title ("Temperature %d (C)" % self.Spectrometer.GetTemperature() )
except AttributeError : pass
def _Plot(self, event):
# Make sure our figure is the active one
# If only one figure, this is not necessary.
# vv.figure(self.fig.nr)
# Clear it
vv.clf()
song = wave.open("C:\Users\Mario\Desktop\infoadex antonio\\20150617070001.wav", 'r')
frames = song.getnframes()
ch = song.getnchannels()
song_f = song.readframes(ch*frames)
data = np.fromstring(song_f, np.int16)
print data
# Plot
# vv.plot([1,2,3,1,6])
vv.plot(data)
vv.legend(['this is a line'])
def set_mesh(self, mesh):
vv.clf()
self._vv_widget = vv.gcf()
self._vv_widget._widget.show()
self.main_win.setCentralWidget(self.widget())
if mesh:
v_mesh = mesh.to_visvis_mesh()
v_mesh.faceColor = 'y'
v_mesh.edgeShading = 'plain'
v_mesh.edgeColor = (0, 0, 1)
axes = vv.gca()
if axes.daspectAuto is None:
axes.daspectAuto = False
axes.SetLimits()
axes.legend = 'X', 'Y', 'Z'
axes.axis.showGrid = True
axes.axis.xLabel = 'X'
axes.axis.yLabel = 'Y'
axes.axis.zLabel = 'Z'
def show(self):
import visvis as vv
# If there are many tests, make a selection
if len(self._tests) > 1000:
tests = random.sample(self._tests, 1000)
else:
tests = self._tests
# Get ticks
nn = [test[0] for test in tests]
# Create figure
vv.figure(1)
vv.clf()
# Prepare kwargs
plotKwargsText = {'ms':'.', 'mc':'b', 'mw':5, 'ls':''}
plotKwargsBin = {'ms':'.', 'mc':'r', 'mw':5, 'ls':''}
# File size against number of elements
vv.subplot(221)
vv.plot(nn, [test[2][0] for test in tests], **plotKwargsText)
vv.plot(nn, [test[2][1] for test in tests], **plotKwargsBin)
vv.legend('text', 'binary')
vv.title('File size')
# Speed against number of elements
vv.subplot(223)
vv.plot(nn, [test[1][4] for test in tests], **plotKwargsText)
vv.plot(nn, [test[1][6] for test in tests], **plotKwargsBin)
vv.legend('text', 'binary')
vv.title('Save time')
# Speed (file) against number of elements
vv.subplot(224)
vv.plot(nn, [test[1][5] for test in tests], **plotKwargsText)
vv.plot(nn, [test[1][7] for test in tests], **plotKwargsBin)
vv.legend('text', 'binary')
vv.title('Load time')
def show_in_visvis():
reader = imageio.read('cockatoo.mp4', 'ffmpeg')
#reader = imageio.read('<video0>')
import visvis as vv
im = reader.get_next_data()
f = vv.clf()
f.title = reader.format.name
t = vv.imshow(im, clim=(0, 255))
while not f._destroyed:
t.SetData(reader.get_next_data())
vv.processEvents()
def _Plot(self, event):
# update status text
self.status.SetLabel("CPU:%.1f\nMemory:%.1f" % (cpudata[-1], vmemdata[-1]))
# Make sure our figure is the active one
# If only one figure, this is not necessary.
#vv.figure(self.fig.nr)
# Clear it
vv.clf()
# Plot
a = vv.subplot(211)
vv.plot(cpudata, lw=2, lc="c", mc ='y', ms='d')
vv.legend("cpu percent ")
a.axis.showGrid = True
a.axis.xlabel = "CPU Usage Percent"
a.axis.ylabel = "sampling time line"
a = vv.subplot(212)
vv.plot(vmemdata, lw=2, mew=1, lc='m', mc ='y', ms='d' )
vv.legend("virtual memory")
a.axis.showGrid = True
def show_in_visvis():
reader = imageio.read("cockatoo.mp4", "ffmpeg")
# reader = imageio.read('<video0>')
import visvis as vv
im = reader.get_next_data()
f = vv.clf()
f.title = reader.format.name
t = vv.imshow(im, clim=(0, 255))
while not f._destroyed:
t.SetData(reader.get_next_data())
vv.processEvents()
def _createWindow(self, name, im, axis):
vv.figure()
vv.gca()
vv.clf()
fig = vv.imshow(im)
dims = im.shape
''' Change color bounds '''
if im.dtype == np.uint8:
fig.clim.Set(0, 255)
else:
fig.clim.Set(0., 1.)
fig.GetFigure().title = name
''' Show ticks on axes? '''
if not axis:
fig.GetAxes().axis.visible = False
bgcolor = (0., 0., 0.)
else:
fig.GetAxes().axis.showBox = False
bgcolor = (1., 1., 1.)
''' Set background color '''
fig.GetFigure().bgcolor = bgcolor
fig.GetAxes().bgcolor = bgcolor
''' Setup keyboard event handler '''
fig.eventKeyDown.Bind(self._keyHandler)
win = {
'name': name,
'canvas': fig,
'shape': dims,
'keyEvent': None,
'text': []
}
self.open_windows.append(win)
return win
def __init__(self, c=None, p1=None, p2=None):
# Init visualization
fig = vv.figure(101); vv.clf()
a = vv.gca()
# Init patch
self._patchSize = patchSize = 64
self._im = np.zeros((patchSize,patchSize), dtype=np.float32)
self._t = vv.imshow(self._im, clim=(0,10))
# Init points
if c is None: c = Point(14,12)
if p1 is None: p1 = Point(12,16)
if p2 is None: p2 = Point(16,16)
#
self._c = vv.plot(c, ls='', ms='+', mw=10, mc='k')
self._p1 = vv.plot(p1, ls='', ms='.', mw=10, mc='r')
self._p2 = vv.plot(p2, ls='', ms='.', mw=10, mc='b')
# Init object being moved
self._movedPoint = None
# Enable callbacks
for line in [self._c, self._p1, self._p2]:
line.hitTest = True
line.eventMouseDown.Bind(self.OnDown)
line.eventMotion.Bind(self.OnMotion)
line.eventMouseUp.Bind(self.OnUp)
a.eventMotion.Bind(self.OnMotion)
a.eventMouseUp.Bind(self.OnUp)
# Start
self.Apply()
def _Plot(self, event):
# update status text
self.status.SetLabel("CPU:%.1f\nMemory:%.1f" %
(cpudata[-1], vmemdata[-1]))
# Make sure our figure is the active one
# If only one figure, this is not necessary.
#vv.figure(self.fig.nr)
# Clear it
vv.clf()
# Plot
a = vv.subplot(211)
vv.plot(cpudata, lw=2, lc="c", mc='y', ms='d')
vv.legend("cpu percent ")
a.axis.showGrid = True
a.axis.xlabel = "CPU Usage Percent"
a.axis.ylabel = "sampling time line"
a = vv.subplot(212)
vv.plot(vmemdata, lw=2, mew=1, lc='m', mc='y', ms='d')
vv.legend("virtual memory")
a.axis.showGrid = True
def createWindow(self, name, im, axis):
vv.figure()
vv.gca()
vv.clf()
fig = vv.imshow(im)
dims = im.shape
''' Change color bounds '''
if im.dtype == np.uint8:
fig.clim.Set(0, 255)
else:
fig.clim.Set(im.min(), im.max())
fig.GetFigure().title = name
''' Show ticks on axes? '''
if not axis:
fig.GetAxes().axis.visible = False
bgcolor = (0.,0.,0.)
else:
fig.GetAxes().axis.showBox = False
bgcolor = (1.,1.,1.)
fig.GetFigure().bgcolor = bgcolor
fig.GetAxes().bgcolor = bgcolor
fig.eventKeyUp.Bind(self.keyHandler)
win = {'name':name, 'figure':fig, 'shape':dims, 'keyEvent':None}
self.open_windows.append(win)
return win
def show_in_visvis():
# reader = imageio.read("imageio:cockatoo.mp4", "ffmpeg")
reader = imageio.read("<video0>", fps=20)
import visvis as vv
im = reader.get_next_data()
f = vv.clf()
f.title = reader.format.name
t = vv.imshow(im, clim=(0, 255))
while not f._destroyed:
im = reader.get_next_data()
if im.meta["new"]:
t.SetData(im)
vv.processEvents()
def show_in_visvis():
# reader = imageio.read("imageio:cockatoo.mp4", "ffmpeg")
reader = imageio.read("<video0>", fps=20)
import visvis as vv
im = reader.get_next_data()
f = vv.clf()
f.title = reader.format.name
t = vv.imshow(im, clim=(0, 255))
while not f._destroyed:
im = reader.get_next_data()
if im.meta["new"]:
t.SetData(im)
vv.processEvents()
def _Clear(self, event):
vv.clf() #Clear current figure
def __init__(self,
ptcode,
ctcode,
StartPoints,
EndPoints,
basedir,
modelname='modelavgreg'):
""" with start and endpoints provided, calculate centerline and save as
ssdf in basedir as model and dynamic model
"""
#todo: name of dynamic model is now deforms, unclear, should be dynamic
#import numpy as np
import visvis as vv
import numpy as np
import os
import copy
from stentseg.utils import PointSet, _utils_GUI
from stentseg.utils.centerline import (find_centerline,
points_from_nodes_in_graph,
points_from_mesh,
smooth_centerline)
from stentseg.utils.datahandling import loadmodel, loadvol
from stentseg.utils.visualization import show_ctvolume
from stentseg.utils.picker import pick3d
stentnr = len(StartPoints)
cropname = 'prox'
what = modelname
what_vol = 'avgreg'
vismids = True
m = loadmodel(basedir, ptcode, ctcode, cropname, what)
s = loadvol(basedir, ptcode, ctcode, cropname, what_vol)
s.vol.sampling = [s.sampling[1], s.sampling[1], s.sampling[2]]
s.sampling = s.vol.sampling
start1 = StartPoints.copy()
ends = EndPoints.copy()
from stentseg.stentdirect import stentgraph
ppp = points_from_nodes_in_graph(m.model)
allcenterlines = [] # for pp
allcenterlines_nosmooth = [] # for pp
centerlines = [] # for stentgraph
nodes_total = stentgraph.StentGraph()
for j in range(stentnr):
if j == 0 or not start1[j] == ends[j - 1]:
# if first stent or when stent did not continue with this start point
nodes = stentgraph.StentGraph()
centerline = PointSet(3) # empty
# Find main centerline
# if j > 3: # for stent with midpoints
# centerline1 = find_centerline(ppp, start1[j], ends[j], step= 1,
# ndist=10, regfactor=0.5, regsteps=10, verbose=False)
#else:
centerline1 = find_centerline(ppp,
start1[j],
ends[j],
step=1,
ndist=10,
regfactor=0.5,
regsteps=1,
verbose=False)
# centerline1 is a PointSet
print('Centerline calculation completed')
# ========= Maaike =======
smoothfactor = 15 # Mirthe used 2 or 4
# check if cll continued here from last end point
if not j == 0 and start1[j] == ends[j - 1]:
# yes we continued
ppart = centerline1[:
-1] # cut last but do not cut first point as this is midpoint
else:
# do not use first points, as they are influenced by user selected points
ppart = centerline1[1:-1]
for p in ppart:
centerline.append(p)
# if last stent or stent does not continue with next start-endpoint
if j == stentnr - 1 or not ends[j] == start1[j + 1]:
# store non-smoothed for vis
allcenterlines_nosmooth.append(centerline)
pp = smooth_centerline(centerline, n=smoothfactor)
# add pp to list
allcenterlines.append(pp) # list with PointSet per centerline
self.allcenterlines = allcenterlines
# add pp as nodes
for i, p in enumerate(pp):
p_as_tuple = tuple(p.flat)
nodes.add_node(p_as_tuple)
nodes_total.add_node(p_as_tuple)
# add pp as one edge so that pathpoints are in fixed order
pstart = tuple(pp[0].flat)
pend = tuple(pp[-1].flat)
nodes.add_edge(pstart, pend, path=pp)
nodes_total.add_edge(pstart, pend, path=pp)
# add final centerline nodes model to list
centerlines.append(nodes)
# ========= Maaike =======
## Store segmentation to disk
# Build struct
s2 = vv.ssdf.new()
s2.sampling = s.sampling
s2.origin = s.origin
s2.stenttype = m.stenttype
s2.croprange = m.croprange
for key in dir(m):
if key.startswith('meta'):
suffix = key[4:]
s2['meta' + suffix] = m['meta' + suffix]
s2.what = what
s2.params = s.params #reg
s2.paramsseeds = m.params
s2.stentType = 'nellix'
s2.StartPoints = StartPoints
s2.EndPoints = EndPoints
# keep centerlines as pp also [Maaike]
s2.ppallCenterlines = allcenterlines
for k in range(len(allcenterlines)):
suffix = str(k)
pp = allcenterlines[k]
s2['ppCenterline' + suffix] = pp
s3 = copy.deepcopy(s2)
s3['model'] = nodes_total.pack()
# Store model for each centerline
for j in range(len(centerlines)):
suffix = str(j)
model = centerlines[j]
s2['model' + suffix] = model.pack()
# Save model with seperate centerlines.
filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname,
'centerline_' + what)
vv.ssdf.save(os.path.join(basedir, ptcode, filename), s2)
print('saved to disk as {}.'.format(filename))
# Save model with combined centerlines
filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname,
'centerline_total_' + what)
vv.ssdf.save(os.path.join(basedir, ptcode, filename), s3)
print('saved to disk as {}.'.format(filename))
# remove intermediate centerline points
# start1 = map(tuple, start1)
# ends = map(tuple, ends)
startpoints_clean = copy.deepcopy(start1)
endpoints_clean = copy.deepcopy(ends)
duplicates = list(set(start1) & set(ends))
for i in range(len(duplicates)):
startpoints_clean.remove(duplicates[i])
endpoints_clean.remove(duplicates[i])
#Visualize
f = vv.figure(10)
vv.clf()
a1 = vv.subplot(121)
a1.daspect = 1, 1, -1
vv.plot(ppp, ms='.', ls='', alpha=0.6, mw=2)
for j in range(len(startpoints_clean)):
vv.plot(PointSet(list(startpoints_clean[j])),
ms='.',
ls='',
mc='g',
mw=20) # startpoint green
vv.plot(PointSet(list(endpoints_clean[j])),
ms='.',
ls='',
mc='r',
mw=20) # endpoint red
for j in range(len(allcenterlines)):
vv.plot(allcenterlines[j], ms='.', ls='', mw=10, mc='y')
vv.title('Centerlines and seed points')
vv.xlabel('x (mm)')
vv.ylabel('y (mm)')
vv.zlabel('z (mm)')
# for j in range(len(allcenterlines_nosmooth)):
# vv.plot(allcenterlines_nosmooth[j], ms='o', ls='', mw=10, mc='c', alpha=0.6)
a2 = vv.subplot(122)
a2.daspect = 1, 1, -1
vv.plot(ppp, ms='.', ls='', alpha=0.6, mw=2)
# vv.volshow(s.vol, clim=clim, renderStyle = 'mip')
t = show_ctvolume(s.vol,
axis=a2,
showVol='ISO',
clim=(0, 2500),
isoTh=250,
removeStent=False,
climEditor=True)
label = pick3d(vv.gca(), s.vol)
for j in range(len(startpoints_clean)):
vv.plot(PointSet(list(startpoints_clean[j])),
ms='.',
ls='',
mc='g',
mw=20,
alpha=0.6) # startpoint green
vv.plot(PointSet(list(endpoints_clean[j])),
ms='.',
ls='',
mc='r',
mw=20,
alpha=0.6) # endpoint red
for j in range(len(allcenterlines)):
vv.plot(allcenterlines[j], ms='o', ls='', mw=10, mc='y', alpha=0.6)
# show midpoints (e.g. duplicates)
if vismids:
for p in duplicates:
vv.plot(p[0], p[1], p[2], mc='m', ms='o', mw=10, alpha=0.6)
a2.axis.visible = False
vv.title('Centerlines and seed points')
a1.camera = a2.camera
f.eventKeyDown.Bind(
lambda event: _utils_GUI.RotateView(event, [a1, a2]))
f.eventKeyDown.Bind(
lambda event: _utils_GUI.ViewPresets(event, [a1, a2]))
# Pick node for midpoint to redo get_centerline
self.pickedCLLpoint = _utils_GUI.Event_pick_graph_point(
nodes_total, s.vol, label, nodesOnly=True) # x,y,z
# use key p to select point
#===============================================================================
vv.figure(11)
vv.gca().daspect = 1, 1, -1
t = show_ctvolume(s.vol,
showVol='ISO',
clim=(0, 2500),
isoTh=250,
removeStent=False,
climEditor=True)
label2 = pick3d(vv.gca(), s.vol)
for j in range(len(startpoints_clean)):
vv.plot(PointSet(list(startpoints_clean[j])),
ms='.',
ls='',
mc='g',
mw=20,
alpha=0.6) # startpoint green
vv.plot(PointSet(list(endpoints_clean[j])),
ms='.',
ls='',
mc='r',
mw=20,
alpha=0.6) # endpoint red
vv.xlabel('x (mm)')
vv.ylabel('y (mm)')
vv.zlabel('z (mm)')
#===============================================================================
## Make model dynamic (and store/overwrite to disk)
import pirt
from stentseg.motion.dynamic import incorporate_motion_nodes, incorporate_motion_edges
# Load deforms
filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, 'deforms')
s1 = vv.ssdf.load(os.path.join(basedir, ptcode, filename))
deformkeys = []
for key in dir(s1):
if key.startswith('deform'):
deformkeys.append(key)
deforms = [s1[key] for key in deformkeys]
deforms = [
pirt.DeformationFieldBackward(*fields) for fields in deforms
]
for i in range(len(deforms)):
deforms[i]._field_sampling = tuple(s1.sampling)
paramsreg = s1.params
# Load model
s2 = loadmodel(basedir, ptcode, ctcode, cropname, 'centerline_' + what)
s3 = loadmodel(basedir, ptcode, ctcode, cropname,
'centerline_total_' + what)
# Combine ...
for key in dir(s2):
if key.startswith('model'):
incorporate_motion_nodes(s2[key], deforms, s.origin)
incorporate_motion_edges(s2[key], deforms, s.origin)
model = s2[key]
s2[key] = model.pack()
# Combine ...
for key in dir(s3):
if key.startswith('model'):
incorporate_motion_nodes(s3[key], deforms, s.origin)
incorporate_motion_edges(s3[key], deforms, s.origin)
model = s3[key]
s3[key] = model.pack()
# Save
s2.paramsreg = paramsreg
filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname,
'centerline_' + what + '_deforms')
vv.ssdf.save(os.path.join(basedir, ptcode, filename), s2)
print('saved to disk as {}.'.format(filename))
# Save
s3.paramsreg = paramsreg
filename = '%s_%s_%s_%s.ssdf' % (
ptcode, ctcode, cropname, 'centerline_total_' + what + '_deforms')
vv.ssdf.save(os.path.join(basedir, ptcode, filename), s3)
print('saved to disk as {}.'.format(filename))
def plot(self, engine='pyplot', iterations=None):
"""Plots the system using a specified render engine.
Needs compute_3d_vectrices() to be called before.
- engine: String for the render engine. Can be 'pyplot', 'plotly' or 'visvis'.
pyplot is the nicest because it supports antialiasing on translucent objects.
plotly is a way faster alternative that uses your web browser's render engine.
visvis is faster but a bit rough.
- iterations: Limits the plotting to this number of iterations.
If None, the whole system states will be plotted."""
engine = engine.lower()
if iterations is None:
iterations = self.iterations
elif iterations > self.iterations:
raise ValueError("Unable to plot %s out of %s iterations"
% (iterations, self.iterations))
if engine == 'visvis':
try:
import visvis as vv
except ImportError:
raise ImportError("visvis must be installed in order to use it."
"Try to 'pip install visvis' in a command line.")
app = vv.use()
fig = vv.clf()
ax = vv.cla()
elif engine == 'pyplot':
try:
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
except ImportError:
raise ImportError("pyplot must be installed in order to use it."
"Try to 'pip install matplotlib' in a command line.")
fig = plt.figure(figsize=(32, 18), dpi=100)
ax = fig.gca(projection='3d')
ax.set_axis_off()
elif engine == 'plotly':
try:
import plotly as pl
from plotly.graph_objs import Scatter3d, Layout, Scene, Figure
except ImportError:
raise ImportError("plotly must be installed in order to use it."
"Try to 'pip install plotly' in a command line.")
data = []
layout = Layout(
scene = Scene(
xaxis=dict(
visible = False,
autorange = True,
),
yaxis=dict(
visible = False,
autorange = True,
),
zaxis=dict(
visible = False,
autorange = True,
)
),
margin=dict(
r=0, l=0,
b=0, t=0
),
showlegend = False,
hovermode = False
)
else:
raise ValueError("%s is not a supported render engine." % engine)
rings = self.rings[:iterations]
for i, ring in enumerate(rings):
color = self.cmap(i, 0, len(self.rings) / 2, 1)
if engine == 'visvis':
vv.plot(*ring, lc=color, mw=0, alpha=.2)
elif engine == 'pyplot':
ax.plot(*ring, c=color+(.4,)) # Adding alpha as (r, g, b, a)
else:
data.append(Scatter3d(
x = ring[0],
y = ring[1],
z = ring[2],
mode = 'lines',
opacity = .3,
line = dict(
color = ("rgb(%s,%s,%s)" % tuple([int(x*255) for x in color])),
width = 3)
))
curves = [curve[:iterations] for curve in self.curves]
for curve in curves:
if engine == 'visvis':
vv.plot(*curve, lc='k', mw=0, lw=2)
elif engine == 'pyplot':
ax.plot(*curve, c=(0, 0, 0, .8))
else:
data.append(Scatter3d(
x = curve[0],
y = curve[1],
z = curve[2],
mode = 'lines',
line = dict(
color = ("rgb(0, 0, 0)"),
width = 4)
))
if engine == 'visvis':
ax = vv.gca()
app.Run()
elif engine == 'pyplot':
fig.tight_layout()
# plt.draw()
mng = plt.get_current_fig_manager()
mng.full_screen_toggle()
plt.show()
else:
fig = Figure(data=data, layout=layout)
# pl.plot(fig, filename='3d-scatter-with-axes-titles')
pl.offline.plot(fig)
return
def DoScannning (self, event) :
"""
Perform scanning of different phase mask
"""
# Create pseudonyms of necessary devices
self.DevSpectrometer = self.parent.Spectrometer.dev
self.DevPulseShaper = self.parent.PulseShaper.dev
self.DevSampleSwitcher = self.parent.SampleSwitcher.dev
# Save global settings and get the name of log file
self.log_filename = SaveSettings(SettingsNotebook=self.parent,
title="Select file to save phase mask scanning", filename="scanning_phase_mask.hdf5")
if self.log_filename is None : return
####################### Initiate devices #############################
# Initiate spectrometer
settings = self.parent.Spectrometer.GetSettings()
if self.DevSpectrometer.SetSettings(settings) == RETURN_FAIL : return
# Initiate pulse shaper
settings = self.parent.PulseShaper.GetSettings()
if self.DevPulseShaper.Initialize(settings) == RETURN_FAIL : return
# Get number of optimization variables
self.num_pixels = self.DevPulseShaper.GetParamNumber()
if self.num_pixels == RETURN_FAIL :
raise RuntimeError ("Optimization cannot be started since calibration file was not loaded")
# Initiate sample switcher
settings = self.parent.SampleSwitcher.GetSettings()
if self.DevSampleSwitcher.Initialize(settings) == RETURN_FAIL : return
# Saving the name of channels
odd_settings = self.GetSettings()
self.channels = sorted(eval( "(%s,)" % odd_settings["channels"] ))
if self.DevSampleSwitcher.GetChannelNum()-1 < max(self.channels) :
raise ValueError ("Error: Some channels specified are not accessible by sample switcher.")
# Check whether the background signal array is present
self.CheckBackground()
#####################################################################
# Get range of coefficient
coeff_range = np.linspace( odd_settings["coeff_min"], odd_settings["coeff_max"], odd_settings["coeff_num"] )
# List all polynomial coefficients
N = odd_settings["polynomial_order"]
poly_coeffs = np.zeros( (coeff_range.size*N, N+1) )
for n in range(1,N+1) :
poly_coeffs[(n-1)*coeff_range.size:n*coeff_range.size, n ] = coeff_range
# Chose max amplitude
max_ampl = odd_settings["max_ampl"]*np.ones(self.num_pixels)
# Arguments of the basis
X = np.linspace(-1., 1., self.num_pixels)
# Retrieve the basis type
polynomial_basis = self.polynomial_bases[ odd_settings["polynomial_basis"] ]
# Adjusting button's settings
button = event.GetEventObject()
button.SetLabel (button._stop_label)
button.SetBackgroundColour('red')
button.Bind( wx.EVT_BUTTON, button._stop_method)
self.need_abort = False
#####################################################################
# Start scanning
with h5py.File (self.log_filename, 'a') as log_file :
for channel in self.channels :
# Move to a selected channel
self.DevSampleSwitcher.MoveToChannel(channel)
# abort, if requested
wx.Yield()
if self.need_abort : break
# Looping over pulse shapes
for scan_num, coeff in enumerate(poly_coeffs) :
# Calculate new phase
phase = polynomial_basis(coeff)(X)
# Set the pulse shape
self.DevPulseShaper.SetAmplPhase(max_ampl, phase)
# Save phase in radians
ampl, phase = self.DevPulseShaper.GetUnwrappedAmplPhase(max_ampl, phase)
if scan_num == 0 :
# Initialize the array
phases_rad = np.zeros( (len(poly_coeffs), phase.size), dtype=phase.dtype )
amplitudes = np.zeros_like(phases_rad)
amplitudes[:] = ampl.min()
# Save phase
phases_rad[scan_num] = phase
amplitudes[scan_num] = ampl
# abort, if requested
wx.Yield()
if self.need_abort : break
# Get spectrum
spectrum = self.GetSampleSpectrum(channel)
# Vertical binning
spectrum = ( spectrum.sum(axis=0) if len(spectrum.shape) == 2 else spectrum )
if scan_num == 0 :
# Initialize the array
spectra = np.zeros( (len(poly_coeffs), spectrum.size), dtype=spectrum.dtype )
spectra[:] = spectrum.min()
# Save the spectrum
spectra[scan_num] = spectrum
# Display the currently acquired data
try :
spectra_2d_img.SetData(spectra)
phases_rad_2d_img.SetData( phases_rad%(2*np.pi) )
#amplitudes_2d_img.SetData( amplitudes )
except NameError :
visvis.cla(); visvis.clf()
visvis.subplot(121)
spectra_2d_img = visvis.imshow(spectra, cm=visvis.CM_JET)
visvis.ylabel ('scans'); visvis.xlabel ('wavelegth')
visvis.title("spectral scan")
visvis.subplot(122)
phases_rad_2d_img = visvis.imshow( phases_rad%(2*np.pi), cm=visvis.CM_JET)
visvis.title("phase shapes")
#visvis.subplot(133)
#amplitudes_2d_img = visvis.imshow(amplitudes, cm=visvis.CM_JET)
#visvis.title("amplitudes")
# Save the data for the given channel
try : del log_file[ str(channel) ]
except KeyError : pass
channel_grp = log_file.create_group( str(channel) )
channel_grp["spectra"] = spectra
channel_grp["phases_rad"] = phases_rad
channel_grp["amplitudes"] = amplitudes
channel_grp["poly_coeffs"] = poly_coeffs
# Readjust buttons settings
self.StopScannning(event)
#!/usr/bin/env python """ This example illustrates picking using the simple event system. It also shows the working of the picking in an environment. Notice for example that the leave event is not fired when you move the mouse beyond the boundaries of the yellow rectangle as long as it's still inside the red rectangle. This is because the red rectangle is a child of the yellow rectangle. """ import numpy as np import visvis as vv app = vv.use() f = vv.clf() l1 = vv.plot([1, 2, 3, 2, 4], lw=3) l2 = vv.plot([4, 6, 5, 1, 3], lc='r', mc='r', lw=3) # im = np.zeros((10,10)); im[7:9,:]=1; im[:,7:9]=0.6 # t1 = vv.imshow(im) b1 = vv.Box(f) b1.position = 0.1, 0.2, 100, 40 b1.bgcolor = (1, 1, 0) b2 = vv.Box(b1) b2.position = 5, 20, 20, 50 #b2.bgcolor=(1,0,0) a = vv.gca() a.daspectAuto = True
def StartInteractivelyMeasureSpectrum(self, event):
"""
This method display spectrum
"""
button = self.show_spectrum_button
if button.GetLabel() == button.__start_label__:
self.StopAllJobs()
# get spectrometer's settings
spect_settings = self.SettingsNotebook.Spectrometer.GetSettings()
# Initiate spectrometer
if self.Spectrometer.SetSettings(spect_settings) == RETURN_FAIL:
return
try:
self.wavelengths = self.Spectrometer.GetWavelengths()
except AttributeError:
self.wavelengths = None
# Clearing the figure
visvis.cla()
visvis.clf()
# Set up timer to draw spectrum
TIMER_ID = wx.NewId()
self.spectrum_timer = wx.Timer(self, TIMER_ID)
self.spectrum_timer.Start(spect_settings["exposure_time"])
wx.EVT_TIMER(self, TIMER_ID, self.DrawSpectrum)
# Chose plotting options
try:
self.is_autoscaled_spectrum = not (
spect_settings["fix_vertical_axis"])
except KeyError:
self.is_autoscaled_spectrum = True
if not self.is_autoscaled_spectrum:
self.spectrum_plot_limits = (
spect_settings["vertical_axis_min_val"],
spect_settings["vertical_axis_max_val"])
# Change button's label
button.SetLabel(button.__stop_label__)
elif button.GetLabel() == button.__stop_label__:
# Stopping timer
self.spectrum_timer.Stop()
del self.spectrum_timer
# Delete the parameter for auto-scaling
del self.spectrum_plot_limits, self.is_autoscaled_spectrum
# Delate visvis objects
try:
del self.__interact_2d_spectrum__
except AttributeError:
pass
try:
del self.__interact_1d_spectrum__
except AttributeError:
pass
# Change button's label
button.SetLabel(button.__start_label__)
else:
raise ValueError("Label is not recognized")
c3 = fit_circle(pp3_2)
e3 = fit_ellipse(pp3_2)
print('area circle 3D: % 1.2f' % area(c3))
print('area ellipse 3D: % 1.2f' % area(e3))
# For visualization, calculate 4 points on rectangle that lies on the plane
x1, x2 = pp3.min(0)[0]-0.3, pp3.max(0)[0]+0.3
y1, y2 = pp3.min(0)[1]-0.3, pp3.max(0)[1]+0.3
p1 = x1, y1, -(x1*plane[0] + y1*plane[1] + plane[3]) / plane[2]
p2 = x2, y1, -(x2*plane[0] + y1*plane[1] + plane[3]) / plane[2]
p3 = x2, y2, -(x2*plane[0] + y2*plane[1] + plane[3]) / plane[2]
p4 = x1, y2, -(x1*plane[0] + y2*plane[1] + plane[3]) / plane[2]
# Init visualization
import visvis as vv
fig = vv.clf()
fig.position = 300, 300, 1000, 600
# 2D vis
a = vv.subplot(121)
a.daspectAuto = False
a.axis.showGrid = True
vv.title('2D fitting')
vv.xlabel('x'); vv.ylabel('y')
# Plot
vv.plot(pp2, ls='', ms='.', mc='k')
# vv.plot(sample_circle(c2), lc='r', lw=2)
vv.plot(sample_ellipse(e2), lc='b', lw=2)
# vv.legend('2D points', 'Circle fit', 'Ellipse fit')
vv.legend('2D points', 'Ellipse fit')
def identifyCenterlines(s,
ptcode,
ctcode,
basedir,
modelname,
showVol='MIP',
**kwargs):
""" s is struct with models
"""
from stentseg.utils.datahandling import select_dir, loadvol, loadmodel
from stentseg.utils.picker import pick3d
from stentseg.utils.visualization import show_ctvolume
from stentseg.utils import _utils_GUI
showAxis = False
# showVol = 'MIP' # MIP or ISO or 2D or None
clim = (0, 2500)
# clim = -200,500 # 2D
isoTh = 250
cropname = 'prox'
# init fig
f = vv.figure()
vv.clf()
f.position = 0.00, 22.00, 1920.00, 1018.00
# load vol
svol = loadvol(basedir, ptcode, ctcode, cropname, what='avgreg')
# set sampling for cases where this was not stored correctly
svol.vol.sampling = [svol.sampling[1], svol.sampling[1], svol.sampling[2]]
vol = svol.vol
s.sampling = [svol.sampling[1], svol.sampling[1],
svol.sampling[2]] # for model
# show vol
t = show_ctvolume(vol, showVol=showVol, clim=clim, isoTh=isoTh, **kwargs)
label = pick3d(vv.gca(), vol)
vv.xlabel('x (mm)')
vv.ylabel('y (mm)')
vv.zlabel('z (mm)')
if showVol == 'MIP':
c = vv.ClimEditor(vv.gca())
c.position = (10, 50)
f.eventKeyDown.Bind(lambda event: _utils_GUI.ShowHideSlider(event, c))
print('Use "s" to show/hide slider')
if showVol == 'ISO':
c = _utils_GUI.IsoThEditor(vv.gca())
c.position = (10, 50)
f.eventKeyDown.Bind(lambda event: _utils_GUI.ShowHideSlider(event, c))
print('Use "s" to show/hide slider')
f.eventKeyDown.Bind(
lambda event: _utils_GUI.ViewPresets(event, [vv.gca()]))
print('------------------------')
print('Use keys 1, 2, 3, 4 and 5 for preset anatomic views')
print('Use v for a default zoomed view')
print('Use x to show and hide axis')
print('------------------------')
ax, s2 = interactiveCenterlineID(s, ptcode, ctcode, basedir, cropname,
modelname)
return ax, s2
"""
# Auto determine bins?
if bins is None:
from visvis.processing.statistics import StatData
stats = StatData(data)
bins = stats.best_number_of_bins()
# let numpy do the work
if np.__version__ < '1.3':
values, edges = np.histogram(data, bins, drange, normed, weights, new=True)
else:
values, edges = np.histogram(data, bins, drange, normed, weights)
# the bins are the left bin edges, let's get the centers
centers = np.empty(values.shape, np.float64)
for i in range(len(values)):
centers[i] = (edges[i] + edges[i+1]) * 0.5
# plot
dbin = centers[1] - centers[0]
return vv.bar(centers, values, width=dbin*0.9)
#return vv.plot(centers, values, **kwargs)
if __name__ == '__main__':
vv.clf()
data = np.random.normal(7,2,size=(100,100))
b = hist(data)
b.color = 'r'
def _Plot(self, *args):
vv.figure(self.figure.nr)
vv.clf()
vv.plot([1, 2, 3, 1, 6])
vv.legend(['this is a line'])
def __init__(self, dicom_basedir, ptcode, ctcode, basedir):
import imageio
#import easygui
from stentseg.utils.datahandling import loadvol
from stentseg.utils.datahandling import savecropvols, saveaveraged
## Select base directory for LOADING DICOM data
#dicom_basedir = easygui.diropenbox()
print('DICOM Path = ', dicom_basedir)
#ctcode = '12months' # 'pre', 'post_x', '12months'
stenttype = 'nellix'
## Select base directory to SAVE SSDF
#basedir = easygui.diropenbox()
print('Base Path = ', basedir)
# Set which crops to save
cropnames = ['prox'] #,'stent'] # ['ring'] or ['ring','stent'] or ..
#===============================================================================
## Step A: read single volumes to get vols:
# folder1 = '10%'
# folder2 = '60%'
# vol1 = imageio.volread(os.path.join(dicom_basedir, folder1), 'dicom')
# vol2 = imageio.volread(os.path.join(dicom_basedir, folder2), 'dicom')
# print( )
#
# if vol1.meta.SeriesDescription[:2] < vol2.meta.SeriesDescription[:2]:
# vols4078 = [vol1,vol2]
# else:
# vols4078 = [vol2,vol1]
#
# vols = vols4078.copy()
#
# for vol in vols:
# vol.meta.PatientName = ptcode # anonimyze
# vol.meta.PatientID = 'anonymous'
# print(vol.meta.SeriesDescription,'-', vol.meta.sampling)
#===============================================================================
##Orginele code
#===============================================================================
#
# folder1 = '40% iDose'
# folder2 = '78 iDose'
# vol1 = imageio.volread(os.path.join(dicom_basedir, folder1), 'dicom')
# vol2 = imageio.volread(os.path.join(dicom_basedir, folder2), 'dicom')
# print( )
#
# if vol1.meta.SeriesDescription[:2] < vol2.meta.SeriesDescription[:2]:
# vols4078 = [vol1,vol2]
# else:
# vols4078 = [vol2,vol1]
#
# vols = vols4078.copy()
#
# for vol in vols:
# vol.meta.PatientName = ptcode # anonimyze
# vol.meta.PatientID = 'anonymous'
# print(vol.meta.SeriesDescription,'-', vol.meta.sampling)
#===============================================================================
## Step A: read 10 volumes to get vols
# Deze zoekt alle mappen en dat zijn er dus 10 maar niet in de goede volgorde
vols2 = [
vol2 for vol2 in imageio.get_reader(dicom_basedir, 'DICOM', 'V')
]
vols = [None] * len(vols2)
for i, vol in enumerate(vols2):
# print(vol.meta.sampling)
print(vol.meta.SeriesDescription)
phase = int(vol.meta.SeriesDescription[:1])
# use phase to fix order of phases
vols[phase] = vol
#vols[phase].meta.ImagePositionPatient = (0.0,0.0,0.0)
for i, vol in enumerate(
vols): #wat ik heb veranderd is i, en enumerate()
print(vol.meta.SeriesDescription)
assert vol.shape == vols[0].shape
assert str(i * 10) in vol.meta.SeriesDescription # 0% , 10% etc.
## Step B: Crop and Save SSDF
# 1 of 2 cropnames opgeven voor opslaan 1 of 2 crpos.
# Het eerste volume wordt geladen in MIP, crop met marges van minimaal 30 mm
for cropname in cropnames:
savecropvols(vols, basedir, ptcode, ctcode, cropname, stenttype)
# saveaveraged(basedir, ptcode, ctcode, cropname, range(0,100,10))
## Visualize result
#s1 = loadvol(basedir, ptcode, ctcode, cropnames[0], what ='10avgreg')
#s2 = loadvol(basedir, ptcode, ctcode, cropnames[0], what ='10phases')
s1 = loadvol(basedir, ptcode, ctcode, cropnames[0], what='phases')
#s2 = loadvol(basedir, ptcode, ctcode, cropnames[0], what = 'avg010')
#vol1 = s1.vol
vol1 = s1.vol40
# Visualize and compare
colormap = {
'r': [(0.0, 0.0), (0.17727272, 1.0)],
'g': [(0.0, 0.0), (0.27272728, 1.0)],
'b': [(0.0, 0.0), (0.34545454, 1.0)],
'a': [(0.0, 1.0), (1.0, 1.0)]
}
import visvis as vv
fig = vv.figure(1)
vv.clf()
fig.position = 0, 22, 1366, 706
a1 = vv.subplot(111)
a1.daspect = 1, 1, -1
# t1 = vv.volshow(vol1, clim=(0, 3000), renderStyle='iso') # iso or mip
# t1.isoThreshold = 600 # stond op 400 maar je moet hoger zetten als je alleen stent wil
# t1.colormap = colormap
a1 = vv.volshow2(vol1, clim=(-500, 1500), renderStyle='mip')
vv.xlabel('x'), vv.ylabel('y'), vv.zlabel('z')
# vv.title('One volume at %i procent of cardiac cycle' % phase )
vv.title('Vol40')
def updatePlot(self, X, Y, Z):
self.activePlot = (X,Y,Z)
x, y = np.meshgrid(X,Y)
vv.clf()
surface = vv.surf(x,y,Z)
surface.colormap = vv.CM_HOT
def _Plot(self, *args):
vv.figure(self.figure.nr)
vv.clf()
vv.plot([1,2,3,1,6])
vv.legend(['this is a line'])
# Perform the first (seeding) step out of 3 steps of stentDirect
sd.Step1()
vol = vol2
## Visualization and interactive segmentation steps
#todo: depending on the speedFactor fronts do not propagate from manually added seeds.
# see costfunction, from speedfactor > 750 it works
guiRemove = False # True for option to remove nodes/edges but takes longer
clim = (0,3000)
showVol = 'MIP'
meshColor = None # or give FaceColor
viewLR = {'azimuth': 90, 'roll': 0}
fig = vv.figure(3); vv.clf()
fig.position = 0.00, 22.00, 1920.00, 1018.00
# Show model Step 1
a1 = vv.subplot(131)
label = DrawModelAxes(vol, sd._nodes1, a1, clim=clim, showVol=showVol, climEditor=True, removeStent=False) # lc, mc
# Create axis for Step 2
a2 = vv.subplot(132)
DrawModelAxes(vol, ax=a2, clim=clim, showVol=showVol, climEditor=False)
# Create axis for Step 3
a3 = vv.subplot(133)
DrawModelAxes(vol, ax=a3, clim=clim, showVol=showVol, climEditor=False)
# _utils_GUI.vis_spared_edges(sd._nodes3)
def dicom2ssdf(dicom_basedir,
ptcode,
ctcode,
basedir,
cropnames=['stent'],
savedistolicavg=False,
visvol=True,
visdynamic=False):
""" read dicom volumes and store as ssdf format
"""
#Step A
vols2 = [vol2 for vol2 in imageio.get_reader(dicom_basedir, 'DICOM', 'V')]
try:
for i, vol in enumerate(vols2):
print(vol.meta.ImagePositionPatient)
for i, vol in enumerate(vols2):
print(vol.shape)
for i, vol in enumerate(vols2):
print(vol.meta.AcquisitionTime)
print(vol.meta.sampling)
assert vol.shape == vols2[0].shape
assert vol.meta.SeriesTime == vols2[0].meta.SeriesTime
except AttributeError:
print('Some meta information is not available')
pass
# check order of phases
vols = vols2.copy()
try:
for i, vol in enumerate(vols):
print(vol.meta.SeriesDescription)
assert str(i * 10) in vol.meta.SeriesDescription # 0% , 10% etc.
except AttributeError: # meta info is missing
print('vol.meta.SeriesDescription meta information is not available')
pass
except AssertionError: # not correct order, fix
vols = [None] * len(vols2)
for i, vol in enumerate(vols2):
print(vol.meta.SeriesDescription)
phase = int(vol.meta.SeriesDescription[:1])
# use phase to fix order of phases
vols[phase] = vol
# Step B: Crop and Save SSDF
# Load and show first volume: crop with a margin of at least ~25 mm
print()
print('Crop with margins ~25 mm around ROI for the registration algorithm')
stenttype = None # deprecate, not needed
for cropname in cropnames:
savecropvols(vols, basedir, ptcode, ctcode, cropname, stenttype)
# Step C: average diastolic phases
if savedistolicavg:
phases = 50, 10 # use 7 phases from 50% to 10%
saveaveraged(basedir, ptcode, ctcode, cropname, phases)
# Visualize 1 phase
import visvis as vv
if visvol:
vol1 = vols[1]
colormap = {
'r': [(0.0, 0.0), (0.17727272, 1.0)],
'g': [(0.0, 0.0), (0.27272728, 1.0)],
'b': [(0.0, 0.0), (0.34545454, 1.0)],
'a': [(0.0, 1.0), (1.0, 1.0)]
}
fig = vv.figure(2)
vv.clf()
fig.position = 0, 22, 1366, 706
a1 = vv.subplot(111)
a1.daspect = 1, 1, -1
renderStyle = 'mip'
t1 = vv.volshow(vol1, clim=(0, 3000),
renderStyle=renderStyle) # iso or mip
if renderStyle == 'iso':
t1.isoThreshold = 300
t1.colormap = colormap
a1 = vv.volshow2(vol1, clim=(-500, 500), renderStyle=renderStyle)
vv.xlabel('x'), vv.ylabel('y'), vv.zlabel('z')
vv.title('One volume at 10\% procent of cardiac cycle')
if visdynamic:
from lspeas.utils.vis import showVolPhases
showVol = 'mip'
t = showVolPhases(basedir,
vols2,
showVol=showVol,
mipIsocolor=True,
isoTh=310,
clim=(60, 3000),
slider=True)
return vols
model = s2.model
modelmesh = create_mesh(model, 0.6) # Param is thickness
showAxis = True # True or False
showVol = 'MIP' # MIP or ISO or 2D or None
ringpart = True # True; False
nstruts = 8
clim0 = (0,3000)
# clim0 = -550,500
clim2 = (0,4)
radius = 0.07
dimensions = 'xyz'
isoTh = 250
## Visualize with GUI
f = vv.figure(3); vv.clf()
f.position = 968.00, 30.00, 944.00, 1002.00
a = vv.gca()
show_ctvolume(vol, model, showVol=showVol, clim=clim0, isoTh=isoTh)
model.Draw(mc='b', mw = 10, lc='g')
vv.xlabel('x (mm)');vv.ylabel('y (mm)');vv.zlabel('z (mm)')
vv.title('Analysis for model LSPEAS %s - %s' % (ptcode[7:], ctcode))
a.axis.axisColor= 1,1,1
a.bgcolor= 0,0,0
a.daspect= 1, 1, -1 # z-axis flipped
a.axis.visible = showAxis
# Initialize labels GUI
from visvis import Pointset
from stentseg.stentdirect import stentgraph
def AnalyzeTotalFluorescence(self, event=None):
"""
`analyse_button` was clicked
"""
# Get current settings
settings = self.GetSettings()
# Apply peak finding filter
signal = self.peak_finders[settings["peak_finder"]](
self.total_fluorescence)
# Scale to (0,1)
signal -= signal.min()
signal = signal / signal.max()
##########################################################################
# Partition signal into segments that are above the background noise
#signal = gaussian_filter(total_fluorescence, sigma=0.5)
background_cutoff = settings["background_cutoff"]
segments = [[]]
for num, is_segment in enumerate(signal > background_cutoff):
if is_segment:
# this index is in the segment
segments[-1].append(num)
elif len(segments[-1]
): # this condition is not to add empty segments
# Start new segments
segments.append([])
# Find peaks as weighted average of the segment
peaks = [
np.average(self.positions[S], weights=self.total_fluorescence[S])
for S in segments if len(S)
]
##########################################################################
# Saving the positions
self.chanel_positions_ctrl.SetValue(", ".join("%2.4f" % p
for p in peaks))
##########################################################################
# Plot acquired data
visvis.cla()
visvis.clf()
visvis.plot(self.positions, signal)
visvis.plot(peaks,
background_cutoff * np.ones(len(peaks)),
ls=None,
ms='+',
mc='r',
mw=20)
visvis.plot(
[self.positions.min(), self.positions.max()],
[background_cutoff, background_cutoff],
lc='r',
ls='--',
ms=None)
visvis.legend(["measured signal", "peaks found", "background cut-off"])
visvis.ylabel("total fluorescence")
visvis.xlabel('position (mm)')
# Perform the three steps of stentDirect
sd.Step1()
sd.Step2()
# sd._nodes2 = stentgraph.StentGraph()
# sd._nodes2.Unpack(ssdf.load('/home/almar/tmp.ssdf'))
sd.Step3()
# Create a mesh object for visualization (argument is strut tickness)
if hasattr(sd._nodes3, 'CreateMesh'):
bm = sd._nodes3.CreateMesh(0.6) # old
else:
bm = create_mesh(sd._nodes3, 0.6) # new
# Create figue
vv.figure(2); vv.clf()
# Show volume and segmented stent as a graph
a1 = vv.subplot(131)
t = vv.volshow(vol)
t.clim = 0, 3000
#sd._nodes1.Draw(mc='g', mw = 6) # draw seeded nodes
#sd._nodes2.Draw(mc='g') # draw seeded and MCP connected nodes
# Show cleaned up
a2 = vv.subplot(132)
sd._nodes3.Draw(mc='g', lc='b')
# Show the mesh
a3 = vv.subplot(133)
a3.daspect = 1,-1,1
def clf():
"""Clear visvis figure"""
vv.clf()
def __init__(self, ptcode, ctcode, basedir):
## Perform image registration
import os, time
import numpy as np
import visvis as vv
import pirt.reg # Python Image Registration Toolkit
from stentseg.utils.datahandling import select_dir, loadvol
import scipy
from scipy import ndimage
# Select dataset to register
cropname = 'prox'
what = 'phases'
# Load volumes
s = loadvol(basedir, ptcode, ctcode, cropname, what)
vols = []
phases = []
for key in dir(s):
if key.startswith('vol'):
print(key)
# create vol with zoom in z-direction
zscale = (s[key].sampling[0] / s[key].sampling[1]) # z / y
# resample vol using spline interpolation, 3rd order piecewise polynomial
vol_zoom = scipy.ndimage.interpolation.zoom(
s[key], [zscale, 1, 1], 'float32')
s[key].sampling = [
s[key].sampling[1], s[key].sampling[1], s[key].sampling[2]
]
# set scale and origin
vol_zoom_type = vv.Aarray(vol_zoom, s[key].sampling,
s[key].origin)
vol = vol_zoom_type
phases.append(key)
vols.append(vol)
t0 = time.time()
# Initialize registration object
reg = pirt.reg.GravityRegistration(*vols)
reg.params.mass_transforms = 2 # 2nd order (Laplacian) triggers more at lines
reg.params.speed_factor = 1.0
reg.params.deform_wise = 'groupwise' # groupwise!
reg.params.mapping = 'backward'
reg.params.deform_limit = 1.0
reg.params.final_scale = 1.0 # We might set this a wee bit lower than 1 (but slower!)
reg.params.scale_sampling = 16
reg.params.final_grid_sampling = 20
reg.params.grid_sampling_factor = 0.5
# Go!
reg.register(verbose=1)
t1 = time.time()
print('Registration completed, which took %1.2f min.' %
((t1 - t0) / 60))
# Store registration result
from visvis import ssdf
# Create struct
s2 = vv.ssdf.new()
N = len(vols)
for key in dir(s):
if key.startswith('meta'):
s2[key] = s[key]
s2.origin = s.origin
s2.stenttype = s.stenttype
s2.croprange = s.croprange
# Obtain deform fields
for i in range(N):
fields = [field for field in reg.get_deform(i).as_backward()]
phase = phases[i][3:]
s2['deform%s' % phase] = fields
s2.sampling = s2['deform%s' %
phase][0].sampling # Sampling of deform is different!
s2.originDeforms = s2['deform%s' %
phase][0].origin # But origin is zero
s2.params = reg.params
# Save
filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, 'deforms')
ssdf.save(os.path.join(basedir, ptcode, filename), s2)
print("deforms saved to disk.")
#============================================================================
# Store averaged volume, where the volumes are registered
#from visvis import ssdf
# Create average volume from *all* volumes deformed to the "center"
N = len(reg._ims)
mean_vol = np.zeros(reg._ims[0].shape, 'float64')
for i in range(N):
vol, deform = reg._ims[i], reg.get_deform(i)
mean_vol += deform.as_backward().apply_deformation(vol)
mean_vol *= 1.0 / N
# Create struct
s_avg = ssdf.new()
for key in dir(s):
if key.startswith('meta'):
s_avg[key] = s[key]
s_avg.sampling = s.vol0.sampling # z, y, x after interpolation
s_avg.origin = s.origin
s_avg.stenttype = s.stenttype
s_avg.croprange = s.croprange
s_avg.vol = mean_vol.astype('float32')
s_avg.params = s2.params
fig1 = vv.figure(1)
vv.clf()
fig1.position = 0, 22, 1366, 706
a1 = vv.subplot(111)
a1.daspect = 1, 1, -1
renderstyle = 'mip'
a1b = vv.volshow(s_avg.vol, clim=(0, 2000), renderStyle=renderstyle)
#a1b.isoThreshold = 600
vv.xlabel('x'), vv.ylabel('y'), vv.zlabel('z')
vv.title('Average volume of %s phases (%s) (resized data)' %
(len(phases), renderstyle))
# Save
avg = 'avgreg'
filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, avg)
ssdf.save(os.path.join(basedir, ptcode, filename), s_avg)
print("avgreg saved to disk.")
t1 = time.time()
print('Registration completed, which took %1.2f min.' %
((t1 - t0) / 60))
def DoScannning(self, event):
"""
Perform scanning of different phase mask
"""
# Create pseudonyms of necessary devices
self.DevSpectrometer = self.parent.Spectrometer.dev
self.DevPulseShaper = self.parent.PulseShaper.dev
self.DevSampleSwitcher = self.parent.SampleSwitcher.dev
# Save global settings and get the name of log file
self.log_filename = SaveSettings(
SettingsNotebook=self.parent,
title="Select file to save phase mask scanning",
filename="scanning_phase_mask.hdf5")
if self.log_filename is None: return
####################### Initiate devices #############################
# Initiate spectrometer
settings = self.parent.Spectrometer.GetSettings()
if self.DevSpectrometer.SetSettings(settings) == RETURN_FAIL: return
# Initiate pulse shaper
settings = self.parent.PulseShaper.GetSettings()
if self.DevPulseShaper.Initialize(settings) == RETURN_FAIL: return
# Get number of optimization variables
self.num_pixels = self.DevPulseShaper.GetParamNumber()
if self.num_pixels == RETURN_FAIL:
raise RuntimeError(
"Optimization cannot be started since calibration file was not loaded"
)
# Initiate sample switcher
settings = self.parent.SampleSwitcher.GetSettings()
if self.DevSampleSwitcher.Initialize(settings) == RETURN_FAIL: return
# Saving the name of channels
odd_settings = self.GetSettings()
self.channels = sorted(eval("(%s,)" % odd_settings["channels"]))
if self.DevSampleSwitcher.GetChannelNum() - 1 < max(self.channels):
raise ValueError(
"Error: Some channels specified are not accessible by sample switcher."
)
# Check whether the background signal array is present
self.CheckBackground()
#####################################################################
# Get range of coefficient
coeff_range = np.linspace(odd_settings["coeff_min"],
odd_settings["coeff_max"],
odd_settings["coeff_num"])
# List all polynomial coefficients
N = odd_settings["polynomial_order"]
poly_coeffs = np.zeros((coeff_range.size * N, N + 1))
for n in range(1, N + 1):
poly_coeffs[(n - 1) * coeff_range.size:n * coeff_range.size,
n] = coeff_range
# Chose max amplitude
max_ampl = odd_settings["max_ampl"] * np.ones(self.num_pixels)
# Arguments of the basis
X = np.linspace(-1., 1., self.num_pixels)
# Retrieve the basis type
polynomial_basis = self.polynomial_bases[
odd_settings["polynomial_basis"]]
# Adjusting button's settings
button = event.GetEventObject()
button.SetLabel(button._stop_label)
button.SetBackgroundColour('red')
button.Bind(wx.EVT_BUTTON, button._stop_method)
self.need_abort = False
#####################################################################
# Start scanning
with h5py.File(self.log_filename, 'a') as log_file:
for channel in self.channels:
# Move to a selected channel
self.DevSampleSwitcher.MoveToChannel(channel)
# abort, if requested
wx.Yield()
if self.need_abort: break
# Looping over pulse shapes
for scan_num, coeff in enumerate(poly_coeffs):
# Calculate new phase
phase = polynomial_basis(coeff)(X)
# Set the pulse shape
self.DevPulseShaper.SetAmplPhase(max_ampl, phase)
# Save phase in radians
ampl, phase = self.DevPulseShaper.GetUnwrappedAmplPhase(
max_ampl, phase)
if scan_num == 0:
# Initialize the array
phases_rad = np.zeros((len(poly_coeffs), phase.size),
dtype=phase.dtype)
amplitudes = np.zeros_like(phases_rad)
amplitudes[:] = ampl.min()
# Save phase
phases_rad[scan_num] = phase
amplitudes[scan_num] = ampl
# abort, if requested
wx.Yield()
if self.need_abort: break
# Get spectrum
spectrum = self.GetSampleSpectrum(channel)
# Vertical binning
spectrum = (spectrum.sum(
axis=0) if len(spectrum.shape) == 2 else spectrum)
if scan_num == 0:
# Initialize the array
spectra = np.zeros((len(poly_coeffs), spectrum.size),
dtype=spectrum.dtype)
spectra[:] = spectrum.min()
# Save the spectrum
spectra[scan_num] = spectrum
# Display the currently acquired data
try:
spectra_2d_img.SetData(spectra)
phases_rad_2d_img.SetData(phases_rad % (2 * np.pi))
#amplitudes_2d_img.SetData( amplitudes )
except NameError:
visvis.cla()
visvis.clf()
visvis.subplot(121)
spectra_2d_img = visvis.imshow(spectra,
cm=visvis.CM_JET)
visvis.ylabel('scans')
visvis.xlabel('wavelegth')
visvis.title("spectral scan")
visvis.subplot(122)
phases_rad_2d_img = visvis.imshow(phases_rad %
(2 * np.pi),
cm=visvis.CM_JET)
visvis.title("phase shapes")
#visvis.subplot(133)
#amplitudes_2d_img = visvis.imshow(amplitudes, cm=visvis.CM_JET)
#visvis.title("amplitudes")
# Save the data for the given channel
try:
del log_file[str(channel)]
except KeyError:
pass
channel_grp = log_file.create_group(str(channel))
channel_grp["spectra"] = spectra
channel_grp["phases_rad"] = phases_rad
channel_grp["amplitudes"] = amplitudes
channel_grp["poly_coeffs"] = poly_coeffs
# Readjust buttons settings
self.StopScannning(event)
cc = pirt.get_cubic_spline_coefs(tt[i], type)
vv0[i] = cc[0]
vv1[i] = cc[1]
vv2[i] = cc[2]
vv3[i] = cc[3]
vvt[i] = sum(cc)
# Interpolate (0 means Cardinal with tension 0)
samples = np.arange(0,len(data)-1,0.05, dtype=np.float32)
values1 = pirt.warp(np.array(data, dtype=np.float32), samples, 3, 'linear')
values2 = pirt.warp(np.array(data, dtype=np.float32), samples, 3, 'basis')
values3 = pirt.warp(np.array(data, dtype=np.float32), samples, 3, 0)
# Visualize
fig = vv.figure(1); vv.clf()
fig.position = 57.00, 45.00, 948.00, 969.00
vv.subplot(211)
vv.title('The basis functions for the %s spline' % type)
vv.plot(tt, vv0, lc='r')
vv.plot(tt, vv1, lc='g')
vv.plot(tt, vv2, lc='b')
vv.plot(tt, vv3, lc='m')
vv.plot(tt, vvt, lc='k', ls='--')
vv.subplot(212)
vv.plot(range(len(data)), data, ms='.', ls='')
vv.plot(samples, values1, lc='r')
vv.plot(samples, values2, lc='g')
vv.plot(samples, values3, lc='b', lw=3)
def DoScannning(self, event):
"""
Perform scanning of different phase mask
"""
# Create pseudonyms of necessary devices
self.DevSpectrometer = self.parent.Spectrometer.dev
self.DevPulseShaper = self.parent.PulseShaper.dev
self.DevSampleSwitcher = self.parent.SampleSwitcher.dev
self.DevFilterWheel = self.parent.FilterWheel.dev
# Save global settings and get the name of log file
self.log_filename = SaveSettings(
SettingsNotebook=self.parent,
title="Select file to save phase mask scanning",
filename="scanning_phase_mask.hdf5")
if self.log_filename is None: return
####################### Initiate devices #############################
# Initiate spectrometer
settings = self.parent.Spectrometer.GetSettings()
if self.DevSpectrometer.SetSettings(settings) == RETURN_FAIL: return
# Initiate pulse shaper
settings = self.parent.PulseShaper.GetSettings()
if self.DevPulseShaper.Initialize(settings) == RETURN_FAIL: return
# Get number of optimization variables
self.num_pixels = self.DevPulseShaper.GetParamNumber()
if self.num_pixels == RETURN_FAIL:
raise RuntimeError(
"Optimization cannot be started since calibration file was not loaded"
)
# Initiate sample switcher
settings = self.parent.SampleSwitcher.GetSettings()
if self.DevSampleSwitcher.Initialize(settings) == RETURN_FAIL: return
# Initialize the filter wheel
settings = self.parent.FilterWheel.GetSettings()
if self.DevFilterWheel.Initialize(settings) == RETURN_FAIL: return
# Saving the name of channels
settings = self.GetSettings()
self.channels = sorted(eval("(%s,)" % settings["channels"]))
if self.DevSampleSwitcher.GetChannelNum() - 1 < max(self.channels):
raise ValueError(
"Error: Some channels specified are not accessible by sample switcher."
)
# Saving the name of filter
self.filters = sorted(eval("(%s,)" % settings["filters"]))
if self.DevFilterWheel.GetNumFilters() < max(self.filters):
raise ValueError(
"Error: Some filters specified are not accessible by filter wheel."
)
# Check whether the background signal array is present
self.CheckBackground()
#####################################################################
# Get range of coefficient
coeff_range = np.linspace(settings["coeff_min"], settings["coeff_max"],
settings["coeff_num"])
min_N = settings["min_polynomial_order"]
max_N = settings["max_polynomial_order"]
# Create all polynomial coefficients for scanning
coeff_iter = product(
*chain(repeat([0], min_N), repeat(coeff_range, max_N + 1 - min_N)))
poly_coeffs = np.array(list(coeff_iter))
# Chose max amplitude
max_ampl = settings["max_ampl"] * np.ones(self.num_pixels)
# Arguments of the basis
X = np.linspace(-1., 1., self.num_pixels)
# Retrieve the basis type
polynomial_basis = self.polynomial_bases[settings["polynomial_basis"]]
# Adjusting button's settings
button = event.GetEventObject()
button.SetLabel(button._stop_label)
button.SetBackgroundColour('red')
button.Bind(wx.EVT_BUTTON, button._stop_method)
self.need_abort = False
#####################################################################
# Start scanning
with h5py.File(self.log_filename, 'a') as log_file:
# Allocate memory for fluorescence signal of all proteins
fluorescences = dict(
(key, np.zeros(len(poly_coeffs), dtype=np.int))
for key in product(self.channels, self.filters))
# Allocate memory for reference fluoresence
ref_fluorescences = dict((C, []) for C in self.channels)
# Iterator for polynomial coefficients
poly_coeffs_iter = enumerate(poly_coeffs)
while True:
# Chunk up the data
chunk_poly_coeffs = list(
islice(poly_coeffs_iter, len(coeff_range)))
# about, if there is nothing to iterate over
if len(chunk_poly_coeffs) == 0: break
# abort, if requested
if self.need_abort: break
for channel in self.channels:
# Move to a selected channel
self.DevSampleSwitcher.MoveToChannel(channel)
# abort, if requested
if self.need_abort: break
# Looping over pulse shapes
for scan_num, coeff in chunk_poly_coeffs:
# Calculate new phase
phase = polynomial_basis(coeff)(X)
# Set the pulse shape
self.DevPulseShaper.SetAmplPhase(max_ampl, phase)
# abort, if requested
if self.need_abort: break
# Looping over filters in filter wheels
for filter in self.filters:
self.DevFilterWheel.SetFilter(filter)
# abort, if requested
wx.Yield()
if self.need_abort: break
# Get spectrum sum, i.e., fluorescence
spectrum_sum = self.GetSampleSpectrum(
channel).sum()
# Save the spectrum
fluorescences[(channel,
filter)][scan_num] = spectrum_sum
# Record reference fluorescence
self.DevPulseShaper.SetAmplPhase(max_ampl,
np.zeros_like(max_ampl))
# Go to filters with max transmission (ASSUMING that it has lowest number)
self.DevFilterWheel.SetFilter(min(self.filters))
spectrum_sum = self.GetSampleSpectrum(channel).sum()
ref_fluorescences[channel].append(spectrum_sum)
# Display the currently acquired data
try:
for key, img in fluorescence_imgs.items():
img.SetYdata(fluorescences[key])
except NameError:
visvis.cla()
visvis.clf()
# Iterator of colours
colour_iter = cycle(['r', 'g', 'b', 'k', 'y'])
fluorescence_imgs = dict(
(K, visvis.plot(F, lw=1, lc=colour_iter.next()))
for K, F in fluorescences.items())
visvis.xlabel("phase masks")
visvis.ylabel("Integrated fluorescence")
visvis.title("Measured fluorescence")
################ Scanning is over, save the data ########################
# Delete and create groups corresponding to channel
for channel in self.channels:
try:
del log_file["channel_%d" % channel]
except KeyError:
pass
gchannel_grp = log_file.create_group("channel_%d" % channel)
gchannel_grp["ref_fluorescence"] = ref_fluorescences[channel]
gchannel_grp["poly_coeffs"] = poly_coeffs
for channel_filter, fluorescence in fluorescences.items():
log_file["channel_%d/filter_%d_fluorescence" %
channel_filter] = fluorescence
# Readjust buttons settings
self.StopScannning(event)
@vv.misc.PropWithDraw
def whiskers():
""" Get/Set the style of the whiskers.
"""
def fget(self):
return self._boxes[0]._whiskers
def fset(self, value):
for box in self._boxes:
box.SetWhiskers(value)
return locals()
if __name__ == '__main__':
vv.figure(1); vv.clf()
a = vv.gca()
d1 = np.random.normal(1, 4, (1000,1000))
d2 = np.random.normal(2, 3, (20,))
d3 = np.random.uniform(-1, 3, (100,))
d4 = [1,2,1,2.0, 8, 2, 3, 1, 2, 2, 3, 2, 2.1, 8, 8, 8, 8, 8, 1.2, 1.3, 0, 0, 1.5, 2]
b = boxplot((d1,d2,d3, d4), width=0.8, whiskers='violin')
##
dd = d4
stat = StatData(dd)
bins1, values1 = stat.histogram_np(normed=True)
bins2, values2 = stat.histogram()
bins3, values3 = stat.kde( )
vv.figure(2); vv.clf()
vv.bar(bins2, values2)#, lc='r', ms='.', mc='r')
genres=pandas.DataFrame(all_by_week['BoxOffice'].mean()/norm1) genres.columns=['All Genres'] genres=genres.join(fantasy_by_week['BoxOffice'].mean()/norm2) genres.columns=['All Genres','Fantasy'] genres=genres.join(animation_by_week['BoxOffice'].mean()/norm3) genres.columns=['All Genres','Fantasy','Animation'] genres=genres.join(romance_by_week['BoxOffice'].mean()/norm4) genres.columns=['All Genres','Fantasy','Animation','Romance'] genres=genres.fillna(0) columns_name = ['All Genres','Fantasy','Animation','Romance'] genres.columns = [ 0, 4, 8, 12] x, y, z = genres.stack().reset_index().values.T #print genres.stack().reset_index().values.T #debug #print genres#debug app = vv.use() f = vv.clf() a = vv.cla() plot =vv.bar3(x, y, z) plot.colors = ["b","g","y","r"] * 53 a.axis.xLabel = 'Week #' a.axis.yTicks = dict(zip(genres.columns, columns_name)) a.axis.zLabel = 'Avg BoxOffice (Aribitrary Units)' app.Run()
except FileNotFoundError:
s2 = loadvol(basedir, ptcode, ctcode, 'ring', staticref)
vol = s2.vol
s3 = loadvol(basedir, ptcode, ctcode, cropname, 'phases')
vol0ori = s3.vol0
# todo: backward/forward based on how deforms were obtained??
# deforms was obtained as backward, from original phases to mean volume avgreg
deform = pirt.DeformationFieldBackward(deforms[0])
# vol2 = pirt.interp.deform_backward(vol, deforms[0]) # te low level, gebruikt awarp niet
vol2 = deform.inverse().as_backward().apply_deformation(
vol0ori) # gebruikt pirt deformation.py
vv.figure(1)
vv.clf()
a1 = vv.subplot(131)
t1 = vv.volshow(vol)
a1.daspect = (1, 1, -1)
vv.title('vol average of cardiac cycle')
# vv.figure(2); vv.clf()
a2 = vv.subplot(132)
t2 = vv.volshow(vol2)
a2.daspect = (1, 1, -1)
vv.title('vol 0 deformed to avg volume')
# vv.figure(3); vv.clf()
a3 = vv.subplot(133)
t3 = vv.volshow2((vol2 - vol), clim=(-500, 500))
a3.daspect = (1, 1, -1)
vv.title('difference')
def __init__(self,
ptcode,
ctcode,
basedir,
showVol='mip',
meshWithColors=False,
motion='amplitude',
clim2=(0, 2)):
"""
Script to show the stent model. [ nellix]
"""
import os
import pirt
import visvis as vv
from stentseg.utils.datahandling import select_dir, loadvol, loadmodel
from pirt.utils.deformvis import DeformableTexture3D, DeformableMesh
from stentseg.stentdirect.stentgraph import create_mesh
from stentseg.stentdirect import stentgraph
from stentseg.utils.visualization import show_ctvolume
from stentseg.motion.vis import create_mesh_with_abs_displacement
import copy
from stentseg.motion.dynamic import incorporate_motion_nodes, incorporate_motion_edges
from lspeas.utils.ecgslider import runEcgSlider
from stentseg.utils import _utils_GUI
import numpy as np
cropname = 'prox'
# params
nr = 1
# motion = 'amplitude' # amplitude or sum
dimension = 'xyz'
showVol = showVol # MIP or ISO or 2D or None
clim0 = (0, 2000)
# clim2 = (0,2)
motionPlay = 9, 1 # each x ms, a step of x %
s = loadvol(basedir, ptcode, ctcode, cropname, what='deforms')
m = loadmodel(basedir, ptcode, ctcode, cropname,
'centerline_total_modelavgreg_deforms')
v = loadmodel(basedir,
ptcode,
ctcode,
cropname,
modelname='centerline_total_modelvesselavgreg_deforms')
s2 = loadvol(basedir, ptcode, ctcode, cropname, what='avgreg')
vol_org = copy.deepcopy(s2.vol)
s2.vol.sampling = [
vol_org.sampling[1], vol_org.sampling[1], vol_org.sampling[2]
]
s2.sampling = s2.vol.sampling
vol = s2.vol
# merge models into one for dynamic visualization
model_total = stentgraph.StentGraph()
for key in dir(m):
if key.startswith('model'):
model_total.add_nodes_from(
m[key].nodes(data=True)) # also attributes
model_total.add_edges_from(m[key].edges(data=True))
for key in dir(v):
if key.startswith('model'):
model_total.add_nodes_from(
v[key].nodes(data=True)) # also attributes
model_total.add_edges_from(v[key].edges(data=True))
# Load deformations (forward for mesh)
deformkeys = []
for key in dir(s):
if key.startswith('deform'):
deformkeys.append(key)
deforms = [s[key] for key in deformkeys]
deforms = [[field[::2, ::2, ::2] for field in fields]
for fields in deforms]
# These deforms are forward mapping. Turn into DeformationFields.
# Also get the backwards mapping variants (i.e. the inverse deforms).
# The forward mapping deforms should be used to deform meshes (since
# the information is used to displace vertices). The backward mapping
# deforms should be used to deform textures (since they are used in
# interpolating the texture data).
deforms_f = [pirt.DeformationFieldForward(*f) for f in deforms]
deforms_b = [f.as_backward() for f in deforms_f]
# Create mesh
if meshWithColors:
try:
modelmesh = create_mesh_with_abs_displacement(model_total,
radius=0.7,
dim=dimension,
motion=motion)
except KeyError:
print('Centerline model has no pathdeforms so we create them')
# use unsampled deforms
deforms2 = [s[key] for key in deformkeys]
# deforms as backward for model
deformsB = [
pirt.DeformationFieldBackward(*fields)
for fields in deforms2
]
# set sampling to original
# for i in range(len(deformsB)):
# deformsB[i]._field_sampling = tuple(s.sampling)
# not needed because we use unsampled deforms
# Combine ...
incorporate_motion_nodes(model_total, deformsB, s2.origin)
convert_paths_to_PointSet(model_total)
incorporate_motion_edges(model_total, deformsB, s2.origin)
convert_paths_to_ndarray(model_total)
modelmesh = create_mesh_with_abs_displacement(model_total,
radius=0.7,
dim=dimension,
motion=motion)
else:
modelmesh = create_mesh(model_total, 0.7, fullPaths=True)
## Start vis
f = vv.figure(nr)
vv.clf()
if nr == 1:
f.position = 8.00, 30.00, 944.00, 1002.00
else:
f.position = 968.00, 30.00, 944.00, 1002.00
a = vv.gca()
a.axis.axisColor = 1, 1, 1
a.axis.visible = False
a.bgcolor = 0, 0, 0
a.daspect = 1, 1, -1
t = vv.volshow(vol, clim=clim0, renderStyle=showVol, axes=a)
vv.xlabel('x (mm)')
vv.ylabel('y (mm)')
vv.zlabel('z (mm)')
if meshWithColors:
if dimension == 'xyz':
dim = '3D'
vv.title(
'Model for chEVAS %s (color-coded %s of movement in %s in mm)'
% (ptcode[8:], motion, dim))
else:
vv.title('Model for chEVAS %s' % (ptcode[8:]))
colorbar = True
# Create deformable mesh
dm = DeformableMesh(a, modelmesh) # in x,y,z
dm.SetDeforms(*[list(reversed(deform))
for deform in deforms_f]) # from z,y,x to x,y,z
if meshWithColors:
dm.clim = clim2
dm.colormap = vv.CM_JET #todo: use colormap Viridis or Magma as JET is not linear (https://bids.github.io/colormap/)
if colorbar:
vv.colorbar()
colorbar = False
else:
dm.faceColor = 'g'
# Run mesh
a.SetLimits()
# a.SetView(viewringcrop)
dm.MotionPlay(motionPlay[0],
motionPlay[1]) # (10, 0.2) = each 10 ms do a step of 20%
dm.motionSplineType = 'B-spline'
dm.motionAmplitude = 0.5
## run ecgslider
ecg = runEcgSlider(dm, f, a, motionPlay)
def __init__(self,ptcode,ctcode,basedir, seed_th=[600], show=True,
normalize=False, modelname='model'):
import os
import numpy as np
import visvis as vv
from visvis import ssdf
from stentseg.utils import PointSet, _utils_GUI
from stentseg.utils.datahandling import select_dir, loadvol, loadmodel
from stentseg.stentdirect.stentgraph import create_mesh
from stentseg.stentdirect import stentgraph, StentDirect, getDefaultParams
from stentseg.stentdirect import AnacondaDirect, EndurantDirect, NellixDirect
from stentseg.utils.visualization import show_ctvolume
from stentseg.utils.picker import pick3d, label2worldcoordinates, label2volindices
import scipy
from scipy import ndimage
import copy
# Select dataset to register
cropname = 'prox'
# phase = 10
#dataset = 'avgreg'
#what = str(phase) + dataset # avgreg
what = 'avgreg'
# Load volumes
s = loadvol(basedir, ptcode, ctcode, cropname, what)
# sampling was not properly stored after registration for all cases: reset sampling
vol_org = copy.deepcopy(s.vol)
s.vol.sampling = [vol_org.sampling[1], vol_org.sampling[1], vol_org.sampling[2]] # z,y,x
s.sampling = s.vol.sampling
vol = s.vol
## Initialize segmentation parameters
stentType = 'nellix' # 'zenith';'nellix' runs modified pruning algorithm in Step3
p = getDefaultParams(stentType)
p.seed_threshold = seed_th # step 1 [lower th] or [lower th, higher th]
# p.seedSampleRate = 7 # step 1, nellix
p.whatphase = what
## Perform segmentation
# Instantiate stentdirect segmenter object
if stentType == 'anacondaRing':
sd = AnacondaDirect(vol, p) # inherit _Step3_iter from AnacondaDirect class
#runtime warning using anacondadirect due to mesh creation, ignore
elif stentType == 'endurant':
sd = EndurantDirect(vol, p)
elif stentType == 'nellix':
sd = NellixDirect(vol, p)
else:
sd = StentDirect(vol, p)
## show histogram and normalize
# f = vv.figure(3)
# a = vv.gca()
# vv.hist(vol, drange=(300,vol.max()))
# normalize vol to certain limit
if normalize:
sd.Step0(3071)
vol = sd._vol
# b= vv.hist(vol, drange=(300,3071))
# b.color = (1,0,0)
## Perform step 1 for seeds
sd.Step1()
## Visualize
if show:
fig = vv.figure(2); vv.clf()
fig.position = 0.00, 22.00, 1920.00, 1018.00
clim = (0,2000)
# Show volume and model as graph
a1 = vv.subplot(121)
a1.daspect = 1,1,-1
# t = vv.volshow(vol, clim=clim)
t = show_ctvolume(vol, axis=a1, showVol='MIP', clim =clim, isoTh=250,
removeStent=False, climEditor=True)
label = pick3d(vv.gca(), vol)
sd._nodes1.Draw(mc='b', mw = 2) # draw seeded nodes
#sd._nodes2.Draw(mc='b', lc = 'g') # draw seeded and MCP connected nodes
vv.xlabel('x (mm)');vv.ylabel('y (mm)');vv.zlabel('z (mm)')
# Show volume and cleaned up graph
a2 = vv.subplot(122)
a2.daspect = 1,1,-1
sd._nodes1.Draw(mc='b', mw = 2) # draw seeded nodes
# t = vv.volshow(vol, clim=clim)
# label = pick3d(vv.gca(), vol)
# sd._nodes2.Draw(mc='b', lc='g')
# sd._nodes3.Draw(mc='b', lc='g')
vv.xlabel('x (mm)');vv.ylabel('y (mm)');vv.zlabel('z (mm)')
# # Show the mesh
#===============================================================================
# a3 = vv.subplot(133)
# a3.daspect = 1,1,-1
# t = vv.volshow(vol, clim=clim)
# pick3d(vv.gca(), vol)
# #sd._nodes3.Draw(mc='b', lc='g')
# m = vv.mesh(bm)
# m.faceColor = 'g'
# # _utils_GUI.vis_spared_edges(sd._nodes3)
# vv.xlabel('x (mm)');vv.ylabel('y (mm)');vv.zlabel('z (mm)')
#===============================================================================
# Use same camera
a1.camera = a2.camera #= a3.camera
switch = True
a1.axis.visible = switch
a2.axis.visible = switch
#a3.axis.visible = switch
## Store segmentation to disk
# Get graph model
model = sd._nodes1
# Build struct
s2 = vv.ssdf.new()
s2.sampling = s.sampling
s2.origin = s.origin
s2.stenttype = s.stenttype
s2.croprange = s.croprange
for key in dir(s):
if key.startswith('meta'):
suffix = key[4:]
s2['meta'+suffix] = s['meta'+suffix]
s2.what = what
s2.params = p
s2.stentType = stentType
# Store model (not also volume)
s2.model = model.pack()
# Save
filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, modelname+ what)
ssdf.save(os.path.join(basedir, ptcode, filename), s2)
print('saved to disk as {}.'.format(filename) )
## Make model dynamic (and store/overwrite to disk)
#===============================================================================
#
# import pirt
# from stentsegf.motion.dynamic import incorporate_motion_nodes, incorporate_motion_edges
#
# # Load deforms
# s = loadvol(basedir, ptcode, ctcode, cropname, '10deforms')
# deformkeys = []
# for key in dir(s):
# if key.startswith('deform'):
# deformkeys.append(key)
# deforms = [s[key] for key in deformkeys]
# deforms = [pirt.DeformationFieldBackward(*fields) for fields in deforms]
# paramsreg = s.params
#
# # Load model
# s = loadmodel(basedir, ptcode, ctcode, cropname, 'model'+what)
# model = s.model
#
# # Combine ...
# incorporate_motion_nodes(model, deforms, s.origin)
# incorporate_motion_edges(model, deforms, s.origin)
#
# # Save back
# filename = '%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, 'model'+what)
# s.model = model.pack()
# s.paramsreg = paramsreg
# ssdf.save(os.path.join(basedir, ptcode, filename), s)
# print('saved to disk as {}.'.format(filename) )
#===============================================================================
FIG1 = False
## Load all rings of the limb
for i in nrs:
ring = 'ringR%s' %(i)
filename = '%s_%s_%s_%s_%s.ssdf' % (ptcode, ctcode, cropname, 'model'+what,ring)
s["ringR" + str(i)] = ssdf.load(os.path.join(basedir1, filename))
## Visualize centerlines rings
s2 = loadmodel(targetdir2, ptcode, ctcode, cropname, modelname='stentseedsavgreg')
pmodel = points_from_nodes_in_graph(s2.model)
if FIG1 == True:
f = vv.figure(1); vv.clf()
f.position = 709.00, 30.00, 1203.00, 1008.00
a1 = vv.subplot(121)
show_ctvolume(s.vol, None, showVol=showVol, clim=clim0, isoTh=isoTh, removeStent=False)
label = pick3d(vv.gca(), s.vol)
a1.axis.visible = showAxis
a1.daspect = 1,1,-1
a2 = vv.subplot(122)
vv.plot(pmodel, ms='.', ls='', alpha=0.2, mw = 2) # stent seed points
for i in nrs:
pp = s["ringR" + str(i)].ringpoints
vv.plot(pp[0],pp[1],pp[2], ms='.', ls='', mw=3, mc='c')
a2.axis.visible = showAxis
a2.daspect = 1,1,-1
def __init__(self,
dirsave,
ptcode,
ctcode,
cropname,
s,
what='phases',
axes=None,
**kwargs):
""" s is struct from loadvol
"""
self.fig = vv.figure(1)
vv.clf()
self.fig.position = 0.00, 29.00, 1680.00, 973.00
self.defaultzoom = 0.025 # check current zoom with foo.ax.GetView()
self.what = what
self.ptcode = ptcode
self.dirsave = dirsave
self.ctcode = ctcode
self.cropname = cropname
if self.what == 'phases':
self.phase = 0
else:
self.phase = self.what # avgreg
# self.vol = s.vol0
self.s = s # s with vol(s)
self.s_landmarks = vv.ssdf.new()
self.graph = stentgraph.StentGraph()
self.points = [] # selected points
self.nodepoints = []
self.pointindex = 0 # for selected points
try:
self.vol = s.vol0 # when phases
except AttributeError:
self.vol = s.vol # when avgreg
self.ax = vv.subplot(121)
self.axref = vv.subplot(122)
self.label = DrawModelAxes(self.vol,
ax=self.ax) # label of clicked point
self.axref.bgcolor = 0, 0, 0
self.axref.visible = False
# create axis for buttons
a_select = vv.Wibject(self.ax) # on self.ax or fig?
a_select.position = 0.55, 0.7, 0.6, 0.5 # x, y, w, h
# Create text objects
self._labelcurrentIndexT = vv.Label(a_select) # for text title
self._labelcurrentIndexT.position = 125, 180
self._labelcurrentIndexT.text = ' Total selected ='
self._labelcurrentIndex = vv.Label(a_select)
self._labelcurrentIndex.position = 225, 180
# Create Select button
self._select = False
self._butselect = vv.PushButton(a_select)
self._butselect.position = 10, 150
self._butselect.text = 'Select'
# Create Back button
self._back = False
self._butback = vv.PushButton(a_select)
self._butback.position = 125, 150
self._butback.text = 'Undo'
# Create Next/Save button
self._finished = False
self._butclose = vv.PushButton(a_select)
self._butclose.position = 10, 230
self._butclose.text = 'Next/Save'
# # Create Save landmarks button
# self._save = False
# self._butsave = vv.PushButton(a_select)
# self._butsave.position = 125,230
# self._butsave.text = 'Save|Finished'
# Create Reset-View button
self._resetview = False
self._butresetview = vv.PushButton(a_select)
self._butresetview.position = 10, 180
self._butresetview.text = 'Default Zoom' # back to default zoom
# bind event handlers
self.fig.eventClose.Bind(self._onFinish)
self._butclose.eventPress.Bind(self._onFinish)
self._butselect.eventPress.Bind(self._onSelect)
self._butback.eventPress.Bind(self._onBack)
self._butresetview.eventPress.Bind(self._onView)
# self._butsave.eventPress.Bind(self._onSave)
self._updateTextIndex()
self._updateTitle()
def GetDeltaScan(self, event):
"""
Measure spectra by varying parameter delta in reference phase mask
"""
# Create pseudonyms of necessary devices
self.DevSpectrometer = self.parent.Spectrometer.dev
self.DevPulseShaper = self.parent.PulseShaper.dev
####################### Initiate devices #############################
# Initiate spectrometer
settings = self.parent.Spectrometer.GetSettings()
if self.DevSpectrometer.SetSettings(settings) == RETURN_FAIL: return
# Initiate pulse shaper
settings = self.parent.PulseShaper.GetSettings()
if self.DevPulseShaper.Initialize(settings) == RETURN_FAIL: return
# Get number of optimization variables
self.num_pixels = self.DevPulseShaper.GetParamNumber()
if self.num_pixels == RETURN_FAIL:
raise RuntimeError(
"Optimization cannot be started since calibration file was not loaded"
)
miips_settings = self.GetSettings()
#####################################################################
# Get range of coefficient
coeff_range = np.linspace(miips_settings["coeff_min"],
miips_settings["coeff_max"],
miips_settings["coeff_num"])
# Get reference phase based on the corrections already obtained
reference_phase, X, polynomial_basis = self.GetReferencePhase(
miips_settings)
# Get new polynomial
new_coeffs = np.zeros(miips_settings["polynomial_order"] + 1)
new_coeffs[-1] = 1
current_polynomial = polynomial_basis(new_coeffs)(X)
# Chose max amplitude
max_ampl = miips_settings["max_ampl"] * np.ones(self.num_pixels)
# Adjusting button's settings
button = event.GetEventObject()
button.SetLabel(button._stop_label)
button.SetBackgroundColour('red')
button.Bind(wx.EVT_BUTTON, button._stop_method)
self.need_abort = False
for scan_num, coeff in enumerate(coeff_range):
# Get current phase mask
current_phase = coeff * current_polynomial
current_phase += reference_phase
# Check for consistency
current_phase %= 1
# Set the pulse shape
self.DevPulseShaper.SetAmplPhase(max_ampl, current_phase)
wx.Yield()
# abort, if requested
if self.need_abort: break
# Get spectrum
spectrum = self.DevSpectrometer.AcquiredData()
# Vertical binning
spectrum = (spectrum.sum(
axis=0) if len(spectrum.shape) == 2 else spectrum)
try:
spectral_scans
except NameError:
# Allocate space for spectral scans
spectral_scans = np.zeros((coeff_range.size, spectrum.size),
dtype=spectrum.dtype)
# Save spectrum
spectral_scans[scan_num] = spectrum
# Display the currently acquired data
try:
spectral_scan_2d_img.SetData(spectral_scans)
except NameError:
visvis.cla()
visvis.clf()
spectral_scan_2d_img = visvis.imshow(spectral_scans,
cm=visvis.CM_JET)
visvis.ylabel('coefficeints')
visvis.xlabel('wavelegth')
#######################################################
# Get current wavelength
wavelength = self.DevSpectrometer.GetWavelengths()
# Adding the scan to log
self.scan_log.append({
"spectral_scans": spectral_scans,
"reference_phase": reference_phase,
"current_polynomial": current_polynomial,
"coeff_range": coeff_range,
"wavelength": wavelength
})
# Plotting fit
visvis.cla()
visvis.clf()
################ Find the value of coeff such that it maximizes the total intensity of SHG
# Method 1: use polynomial filter
# Ignored not scanned parameter
spectral_sum = spectral_scans.sum(axis=1)
indx = np.nonzero(spectral_sum > 0)
# Fit the total spectral intensity with chosen polynomials
spectral_sum_fit = polynomial_basis.fit(coeff_range[indx],
spectral_sum[indx], 10)
# Find extrema of the polynomial fit
opt_coeff = spectral_sum_fit.deriv().roots()
# Find maximum
fit_max_sum_val = opt_coeff[np.argmax(
spectral_sum_fit(opt_coeff))].real
print "\n\nOptimal value of the coefficient (using the polynomial fit) is ", fit_max_sum_val
# Method 2: Use Gaussian filter
# Smoothing spectral scans
filtered_spectral_scans = gaussian_filter(spectral_scans, (2, 0.5))
gauss_max_sum_val = coeff_range[np.argmax(
filtered_spectral_scans.sum(axis=1))]
print "\nOptimal value of the coefficient (using the Gaussian filter) is ", gauss_max_sum_val
# If the difference between methods is great then use the Gaussian filter
if abs(gauss_max_sum_val - fit_max_sum_val) / np.abs(
[gauss_max_sum_val, fit_max_sum_val]).max() > 0.3:
max_sum_val = gauss_max_sum_val
else:
max_sum_val = fit_max_sum_val
self.current_coeff_val.SetValue(max_sum_val)
filtered_spectral_scans[np.searchsorted(
coeff_range, max_sum_val)][0:-1:2] = spectral_scans.min()
################ Plotting results ####################
#spectral_scan_2d_img.SetData(spectral_scans)
#spectral_scan_2d_img.SetClim( spectral_scans.min(), spectral_scans.max() )
visvis.subplot(121)
visvis.title("Raw spectral scans")
visvis.imshow(spectral_scans, cm=visvis.CM_JET)
visvis.ylabel('coefficeints')
visvis.xlabel('wavelegth')
visvis.subplot(122)
visvis.title("Finding maximum")
visvis.imshow(filtered_spectral_scans, cm=visvis.CM_JET)
visvis.ylabel('coefficeints')
visvis.xlabel('wavelegth')
# Readjust buttons settings
self.StopScannning(event)
