示例#1
0
文件: graph.py 项目: turapeach/TOAK
def compareGraphsVisually(graph1, graph2, fig=None):
    """ compareGraphsVisually(graph1, graph2, fig=None)
    Show the two graphs together in a figure. Matched nodes are
    indicated by lines between them.
    """
    
    # Get figure
    if isinstance(fig,int):
        fig = vv.figure(fig)
    elif fig is None:
        fig = vv.figure()
    
    # Prepare figure and axes
    fig.Clear()
    a = vv.gca()
    a.cameraType = '3d'; a.daspectAuto = False
    
    # Draw both graphs
    graph1.Draw(lc='b', mc='b')
    graph2.Draw(lc='r', mc='r')
    
    # Set the limits
    a.SetLimits()
    
    # Make a line from the edges
    pp = Pointset(3)
    for node in graph1:
        if hasattr(node, 'match') and node.match is not None:
            pp.append(node); pp.append(node.match)
    
    # Plot edges
    vv.plot(pp, lc='g', ls='+')
示例#2
0
    def __init__(self):

        # Create figure and axes
        vv.figure()
        self._a = a = vv.gca()
        vv.title("Hold mouse to draw lines. Use 'rgbcmyk' and '1-9' keys.")

        # Set axes
        a.SetLimits((0, 1), (0, 1))
        a.cameraType = "2d"
        a.daspectAuto = False
        a.axis.showGrid = True

        # Init variables needed during drawing
        self._active = None
        self._pp = Pointset(2)

        # Create null and empty line objects
        self._line1 = None
        self._line2 = vv.plot(vv.Pointset(2), ls="+", lc="c", lw="2", axes=a)

        # Bind to events
        a.eventMouseDown.Bind(self.OnDown)
        a.eventMouseUp.Bind(self.OnUp)
        a.eventMotion.Bind(self.OnMotion)
        a.eventKeyDown.Bind(self.OnKey)
示例#3
0
    def draw( self ):
            """Draw data."""
            if len(self.fitResults) == 0:
                return
            
            # Make sure our figure is the active one
            vv.figure(self.fig.nr)
            
            if not hasattr( self, 'subplot1' ):
                self.subplot1 = vv.subplot(211)
                #self.subplot1.position = (30, 2, -32, -32)
                self.subplot2 = vv.subplot(212)
                #self.subplot1.position = (30, 2, -32, -32)

            

            a, ed = numpy.histogram(self.fitResults['tIndex'], self.Size[0]/6)
            print((float(numpy.diff(ed[:2]))))

            self.subplot1.MakeCurrent()
            vv.cla()
            vv.plot(ed[:-1], a/float(numpy.diff(ed[:2])), lc='b', lw=2)
            #self.subplot1.set_xticks([0, ed.max()])
            #self.subplot1.set_yticks([0, numpy.floor(a.max()/float(numpy.diff(ed[:2])))])
            self.subplot2.MakeCurrent()
            vv.cla()
            #cs =
            csa = numpy.cumsum(a)
            vv.plot(ed[:-1], csa/float(csa[-1]), lc='g', lw=2)
            #self.subplot2.set_xticks([0, ed.max()])
            #self.subplot2.set_yticks([0, a.sum()])

            self.fig.DrawNow()
            self.subplot1.position = (20, 2, -22, -32)
            self.subplot2.position = (20, 2, -22, -32)
示例#4
0
文件: vis.py 项目: jupito/dwilib
def plot(image):
    # ax = vv.gca()
    # ms = vv.Mesh(ax)
    logging.warning([image.shape, image.spacing])
    vol = image[:, :, :, 0]
    logging.warning([vol.min(), vol.max()])
    vol = util.normalize(vol, 'ADCm')
    logging.warning([vol.min(), vol.max()])
    vol = vv.Aarray(vol, image.spacing)

    cmap = None
    # cmap = vv.CM_VIRIDIS
    render_style = 'mip'
    # render_style = 'iso'
    # render_style = 'ray'
    # render_style = 'edgeray'
    # render_style = 'litray'

    vv.figure()
    vv.xlabel('x axis')
    vv.ylabel('y axis')
    vv.zlabel('z axis')

    a1 = vv.subplot(111)
    t1 = vv.volshow(vol, cm=cmap, renderStyle=render_style)
    t1.isoThreshold = 0.7
    vv.title(render_style)

    # a1.camera = a2.camera = a3.camera
    vv.ColormapEditor(a1)
示例#5
0
	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
示例#6
0
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 refresh(self):
        if len(self._value) > 1:
            vv.figure(self._fig.nr)

            a = vv.gca()
            view = a.GetView()
            a.Clear()
            vv.volshow3(self._value, renderStyle="mip", cm=self._colorMap)
            if not self._first:
                a = vv.gca()
                a.SetView(view)

            self._first = False
    def initControl(self):
        self._form = QtGui.QWidget();layout = QtGui.QVBoxLayout();layout.setMargin(0);self._form.setLayout( layout )
        self._app = vv.use('pyqt4')
        self._first=True

        Figure = self._app.GetFigureClass()
        self._fig = Figure(self._form)
        vv.figure(self._fig.nr)
        
        policy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
        widget = self._fig._widget
        widget.setSizePolicy(policy)

        layout.addWidget(widget)
示例#9
0
def figure(figure=None):
    f = None
    
    if figure == None:
        f = vv.figure()
    else:
        try:
            f = vv.figure(figure)
        except:
            f = vv.figure() 

    f._widget.show()
    f._widget.raise_()
    return f
示例#10
0
文件: vv.py 项目: avelo/Pythics
 def _call_new_item(self, key, item_type, *args, **kwargs):
     if key in self.items:
         # an item with that key already exists
         # should raise an exception or warning
         pass
     else:
         # make this the current figure
         vv.figure(self.figure)
         # create a new dictionary of options for plotting
         plot_kwargs = dict()
         if 'line_width' in kwargs:
             value = kwargs.pop('line_width')
             plot_kwargs['lw'] = value
         if 'marker_width' in kwargs:
             value = kwargs.pop('marker_width')
             plot_kwargs['mw'] = value
         if 'marker_edge_width' in kwargs:
             value = kwargs.pop('marker_edge_width')
             plot_kwargs['mew'] = value
         if 'line_color' in kwargs:
             value = kwargs.pop('line_color')
             plot_kwargs['lc'] = value
         if 'marker_color' in kwargs:
             value = kwargs.pop('marker_color')
             plot_kwargs['mc'] = value
         if 'marker_edge_color' in kwargs:
             value = kwargs.pop('marker_edge_color')
             plot_kwargs['mec'] = value
         if 'line_style' in kwargs:
             value = kwargs.pop('line_style')
             plot_kwargs['ls'] = value
         if 'marker_style' in kwargs:
             value = kwargs.pop('marker_style')
             plot_kwargs['ms'] = value
         if 'adjust_axes' in kwargs:
             value = kwargs.pop('adjust_axes')
             plot_kwargs['axesAdjust'] = value
         # create the plot item
         if item_type == 'circular':
             data = pythics.lib.CircularArray(cols=2, length=kwargs['length'])
             item = vv.plot(np.array([]), np.array([]), axes=self.axes, **plot_kwargs)
         elif item_type == 'growable':
             data = pythics.lib.GrowableArray(cols=2, length=kwargs['length'])
             item = vv.plot(np.array([]), np.array([]), axes=self.axes, **plot_kwargs)
         else:
             data = np.array([])
             item = vv.plot(np.array([]), np.array([]), axes=self.axes, **plot_kwargs)
         self.items[key] = (item_type, data, item)
示例#11
0
    def initForm(self):
        self._form = QtGui.QWidget();layout = QtGui.QVBoxLayout();layout.setMargin(0);self._form.setLayout( layout )
        self._app = vv.use('pyqt4')
        self._app.Create()
        self._first=True

        Figure = self._app.GetFigureClass()
        self._fig = Figure(self._form)
        vv.figure(self._fig.nr)
        
        policy = QtGui.QSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Expanding)
        widget = self._fig._widget
        widget.setSizePolicy(policy)
        widget.setMinimumSize(100, 100)

        layout.addWidget(widget)

        self._colorMap = vv.CM_AUTUMN
        self._colors_limits = None
示例#12
0
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')
示例#13
0
文件: vv.py 项目: avelo/Pythics
 def set_plot_properties(self, **kwargs):
     # make this the current figure
     vv.figure(self.figure)
     if 'antialiasing' in kwargs:
         value = kwargs.pop('antialiasing')
         p_w.setAntialiasing(value)
     if 'background' in kwargs:
         value = kwargs.pop('background')
         p_w.setBackground(value)
     if 'aspect_ratio' in kwargs:
         # 'auto', 'equal', or a number
         value = kwargs.pop('aspect_ratio')
         if value == 'auto':
             self.axes.daspectAuto = True
         elif value == 'equal':
             self.axes.daspectAuto = False
             self.axes.daspect = (1, 1)
     if 'x_auto_scale' in kwargs:
         value = kwargs.pop('x_auto_scale')
     if 'y_auto_scale' in kwargs:
         value = kwargs.pop('y_auto_scale')
     if 'x_scale' in kwargs:
         value = kwargs.pop('x_scale')
     if 'y_scale' in kwargs:
         value = kwargs.pop('y_scale')
     if 'title' in kwargs:
         value = kwargs.pop('title')
         vv.title(value)
     if 'x_label' in kwargs:
         value = kwargs.pop('x_label')
         self.axes.axis.xLabel = value
     if 'y_label' in kwargs:
         value = kwargs.pop('y_label')
         self.axes.axis.yLabel = value
     if 'x_grid' in kwargs:
         value = kwargs.pop('x_grid')
         p_i.showGrid(x=value)
     if 'y_grid' in kwargs:
         value = kwargs.pop('y_grid')
         p_i.showGrid(y=value)
示例#14
0
def crop3d(vol, fig=None):
    """ crop3d(vol, fig=None)
    Manually crop a volume. In the given figure (or a new figure if None),
    three axes are created that display the transversal, sagittal and 
    coronal MIPs (maximum intensity projection) of the volume. The user
    can then use the mouse to select a 3D range to crop the data to.
    """
    app = vv.use()
    
    # Create figure?    
    if fig is None:        
        fig = vv.figure()    
        figCleanup = True
    else:
        fig.Clear()
        figCleanup = False
    
    # Create three axes and a wibject to attach text labels to    
    a1 = vv.subplot(221)
    a2 = vv.subplot(222)
    a3 = vv.subplot(223)
    a4 = vv.Wibject(fig)
    a4.position = 0.5, 0.5, 0.5, 0.5
    
    # Set settings
    for a in [a1, a2, a3]:
        a.showAxis = False
    
    # Create cropper3D instance
    cropper3d = Cropper3D(vol, a1, a3, a2, a4)
    
    # Enter a mainloop
    while not cropper3d._finished:
        vv.processEvents()
        time.sleep(0.01)
    
    # Clean up figure (close if we opened it)
    fig.Clear()
    fig.DrawNow()
    if figCleanup:    
        fig.Destroy()
    
    # Obtain ranges
    rx = cropper3d._range_transversal._rangex
    ry = cropper3d._range_transversal._rangey
    rz = cropper3d._range_coronal._rangey
    
    # Perform crop
    vol2 = vol[rz.min:rz.max, ry.min:ry.max, rx.min:rx.max]
    
    # Done
    return vol2
示例#15
0
	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
示例#16
0
文件: gcf.py 项目: chiluf/visvis.dev
def gcf():
    """ gcf()
    
    Get the current figure. If there is no figure yet, figure() is
    called to create one. To make a figure current, 
    use Figure.MakeCurrent().
    
    See also gca()
    
    """
    
    if not BaseFigure._figures:
        # no figure yet
        return vv.figure()    
    
    nr = BaseFigure._currentNr    
    if not nr in BaseFigure._figures:
        # erroneous nr
        nr = BaseFigure._figures.keys()[0]
        BaseFigure._currentNr = nr
    
    return BaseFigure._figures[nr]
示例#17
0
def getOpenGlInfo():
    """ getOpenGlInfo()
    
    Get information about the OpenGl version on this system. 
    Returned is a tuple (version, vendor, renderer, extensions) 
    
    A figure is created and removed to create an openGl context if
    this is necessary.
    
    """
    
    # Open figure first. On Windows we can try obtaining the information,
    # but I found that on Ubuntu a segfault will happen (but this might
    # very well have to do with the OpenGl drivers).
    fig = vv.figure()
    result = vv.misc.getOpenGlInfo()
    
    # Should we open a figure and try again?    
    fig.Destroy()
    fig._ProcessGuiEvents() # so it can close
    
    return result
示例#18
0
 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()
    s2 = loadvol(basedir, ptcode, ctcode, 'ring', staticref)
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')
示例#20
0
 def _Plot(self, *args):
     vv.figure(self.figure.nr)
     vv.clf()
     vv.plot([1,2,3,1,6])
     vv.legend(['this is a line'])
示例#21
0
    # read
    # use floats to prevent strides etc. uint8 caused crash on qt backend.
    im = gl.glReadPixels(x, y, w, h, gl.GL_RGB, gl.GL_FLOAT)

    # reshape, flip, and store
    im.shape = h, w, 3
    im = np.flipud(im)

    # done
    return im


if __name__ == '__main__':

    # Prepare
    f = vv.figure()
    a1 = vv.subplot(211)
    a2 = vv.subplot(212)

    # Draw some data
    vv.plot([2, 3, 4, 2, 4, 3], axes=a1)
    f.DrawNow()

    # Take snapshots
    im1 = vv.getframe(f)
    im2 = vv.getframe(a1)
    # clear and show snapshots
    a1.Clear()
    a2.Clear()
    vv.imshow(im1, axes=a1, clim=(0, 1))
    vv.imshow(im2, axes=a2, clim=(0, 1))
示例#22
0
    im = np.random.normal(0.0, 0.1, (101, 101)).astype('float32')
    # Create circle
    circLoc = circLocs[i]
    for y in range(im.shape[0]):
        for x in range(im.shape[1]):
            #if (y-circLoc[0])**2 + (x-circLoc[1])**2 < radius**2: # circles
            if abs(y - circLoc[0]) + abs(
                    x - circLoc[1]) < radius * 1.1:  # diamonds
                im[y, x] += 1.0
    # Add
    ims.append(im)

INDEXMAP = {0: 1, 1: 2, 2: 4, 3: 3}  # map index to subplot location

# Show images
fig = vv.figure(1)
vv.clf()
fig.position = 200, 200, 500, 500
for i in range(4):
    j = INDEXMAP[i]  # map index to subplot location
    a = vv.subplot(2, 2, j)
    vv.imshow(ims[i])
    a.axis.visible = False
# vv.screenshot('c:/almar/projects/fourBlocks_initial.jpg', vv.gcf(), sf=2, bg='w')

## Register groupwise

# Init figure for registration
fig = vv.figure(2)
vv.clf()
fig.position = 200, 100, 900, 500
示例#23
0
    Close a figure.
    
    fig can be a Figure object or an integer representing the id of the
    figure to close. Note that for the first case, you migh also call
    fig.Destroy().
    
    """

    if isinstance(fig, int):
        figDict = vv.BaseFigure._figures
        if fig in figDict:
            figDict[fig].Destroy()
        else:
            raise ValueError("A figure whith that id does not exist: " + str(fig))
    elif isinstance(fig, vv.BaseFigure):
        fig.Destroy()
    else:
        raise ValueError("Invalid argument for vv.functions.close")


if __name__ == "__main__":
    import time

    # Create figure
    fig = vv.figure(1)
    vv.processEvents()
    vv.processEvents()
    time.sleep(1.0)
    # Close it
    vv.close(1)  # Note: you can also pus the fig object
示例#24
0
    ms.edgeColor = edgeColor
    ms.edgeShading = edgeShading
    ms.faceColor = faceColor
    ms.shininess = shininess
    ms.specular = specular
    ms.emission = emission
    ax.SetLimits(rangeX=[-depRange[0], depRange[0]],
                 rangeY=[-depRange[0], depRange[0]],
                 rangeZ=[-depRange[0], depRange[0]])


# Start of test code.
if __name__ == '__main__':

    # Create figure
    fig = vv.figure()
    fig.position.w = 600

    # Cartesian plot
    numOfPts = 2000
    scale = 1

    # Create random points
    xyz = 2 * scale * (np.random.rand(numOfPts, 3) - 0.5)

    # 2D sync function
    xyz[:, 2] = np.sinc(5 * (np.sqrt(xyz[:, 0]**2 + xyz[:, 1]**2)))
    #xyz[:,2] =  scale - ( xyz[:,0]**2 + xyz[:,1]**2)

    # Plot
    vv.subplot(121)
示例#25
0
def demo(*args, **kwargs):
    import math
    m = 80  # width of grid
    n = m ** 2  # number of points

    minVal = -2.0
    maxVal = 2.0
    delta = (maxVal - minVal) / (m - 1)
    X, Y = numpy.mgrid[minVal:maxVal + delta:delta, minVal:maxVal + delta:delta]

    X = X.flatten()
    Y = Y.flatten()

    Z = numpy.sin(X) * numpy.cos(Y)

    # Create the data point-matrix
    M = numpy.array([X, Y, Z]).T

    # Translation values (a.u.):
    Tx = 0.5
    Ty = -0.3
    Tz = 0.2

    # Translation vector
    T = numpyTransform.translation(Tx, Ty, Tz)

    S = numpyTransform.scaling(1.0, N=4)

    # Rotation values (rad.):
    rx = 0.3
    ry = -0.2
    rz = 0.05

    Rx = numpy.matrix([[1, 0, 0, 0],
                      [0, math.cos(rx), -math.sin(rx), 0],
                      [0, math.sin(rx), math.cos(rx), 0],
                      [0, 0, 0, 1]])

    Ry = numpy.matrix([[math.cos(ry), 0, math.sin(ry), 0],
                       [0, 1, 0, 0],
                       [-math.sin(ry), 0, math.cos(ry), 0],
                       [0, 0, 0, 1]])

    Rz = numpy.matrix([[math.cos(rz), -math.sin(rz), 0, 0],
                       [math.sin(rz), math.cos(rz), 0, 0],
                       [0, 0, 1, 0],
                       [0, 0, 0, 1]])

    # Rotation matrix
    R = Rx * Ry * Rz

    transformMat = numpy.matrix(numpy.identity(4))
    transformMat *= T
    transformMat *= R
    transformMat *= S

    # Transform data-matrix plus noise into model-matrix
    D = numpyTransform.transformPoints(transformMat, M)

    # Add noise to model and data
    M = M + 0.01 * numpy.random.randn(n, 3)
    D = D + 0.01 * numpy.random.randn(n, 3)

    # Run ICP (standard settings)
    initialGuess = numpy.array([0.0, 0.0, 0.0, 0.0, 0.0, 0.0])
    lowerBounds = numpy.array([-pi, -pi, -pi, -100.0, -100.0, -100.0])
    upperBounds = numpy.array([pi, pi, pi, 100.0, 100.0, 100.0])
    icp = ICP(M, D, maxIterations=15, dataDownsampleFactor=1, minimizeMethod='fmincon', **kwargs)
#    icp = ICP(M, D, maxIterations=15, dataDownsampleFactor=1, minimizeMethod='point', **kwargs)
    transform, err, t = icp.runICP(x0=initialGuess, lb=lowerBounds, ub=upperBounds)

    # Transform data-matrix using ICP result
    Dicp = numpyTransform.transformPoints(transform[-1], D)

    # Plot model points blue and transformed points red
    if False:
        import matplotlib.pyplot as plt
        from mpl_toolkits.mplot3d import Axes3D
        fig = plt.figure()
        ax = fig.add_subplot(2, 2, 1, projection='3d')
        ax.scatter(M[:, 0], M[:, 1], M[:, 2], c='r', marker='o')
        ax.scatter(D[:, 0], D[:, 1], D[:, 2], c='b', marker='^')
        ax.set_xlabel('X Label')
        ax.set_ylabel('Y Label')
        ax.set_zlabel('Z Label')

        ax = fig.add_subplot(2, 2, 2, projection='3d')
        ax.scatter(M[:, 0], M[:, 1], M[:, 2], c='r', marker='o')
        ax.scatter(Dicp[:, 0], Dicp[:, 1], Dicp[:, 2], c='b', marker='^')
        ax.set_xlabel('X Label')
        ax.set_ylabel('Y Label')
        ax.set_zlabel('Z Label')

        ax = fig.add_subplot(2, 2, 3)
        ax.plot(t, err, 'x--')
        ax.set_xlabel('X Label')
        ax.set_ylabel('Y Label')

        plt.show()
    else:
        import visvis as vv
        app = vv.use()
        vv.figure()
        vv.subplot(2, 2, 1)
        vv.plot(M[:, 0], M[:, 1], M[:, 2], lc='b', ls='', ms='o')
        vv.plot(D[:, 0], D[:, 1], D[:, 2], lc='r', ls='', ms='x')
        vv.xlabel('[0,0,1] axis')
        vv.ylabel('[0,1,0] axis')
        vv.zlabel('[1,0,0] axis')
        vv.title('Red: z=sin(x)*cos(y), blue: transformed point cloud')

        # Plot the results
        vv.subplot(2, 2, 2)
        vv.plot(M[:, 0], M[:, 1], M[:, 2], lc='b', ls='', ms='o')
        vv.plot(Dicp[:, 0], Dicp[:, 1], Dicp[:, 2], lc='r', ls='', ms='x')
        vv.xlabel('[0,0,1] axis')
        vv.ylabel('[0,1,0] axis')
        vv.zlabel('[1,0,0] axis')
        vv.title('ICP result')

        # Plot RMS curve
        vv.subplot(2, 2, 3)
        vv.plot(t, err, ls='--', ms='x')
        vv.xlabel('time [s]')
        vv.ylabel('d_{RMS}')
        vv.title('KD-Tree matching')
        if 'optAlg' in kwargs:
            opt2 = nlopt.opt(kwargs['optAlg'], 2)
            vv.title(opt2.get_algorithm_name())
            del opt2
        else:
            vv.title('KD-Tree matching')
        app.Run()
示例#26
0
    def show_result(self, how=None, fig=None):
        """ show_result(self, how=None, fig=None)
        
        Convenience method to show the registration result. Only 
        works for two dimensional data.
        Requires visvis.
        
        """

        # Check if dimension ok
        if self._ims[0].ndim != 2:
            raise RuntimeError('show_result only works for 2D data.')

        # Check if result is set
        if not self._deforms:
            raise RuntimeError('The result is not available; run register().')

        # Make how lower if string
        if isinstance(how, str):
            how = how.lower()

        # Import visvis
        import visvis as vv

        # Create figure
        if fig is None:
            fig = vv.figure()
        else:
            fig = vv.figure(fig.nr)
            fig.Clear()

        if how in [None, 'grid', 'diff', 'dx', 'dy']:

            # Title map
            title_map = ['Moving', 'Static', 'Deformed', 'Grid']

            # Get deform
            deform = self.get_final_deform(0, 1)

            # Create third image
            im1_ = deform.apply_deformation(self._ims[0])

            # Create fourth image
            if how in [None, 'grid']:
                im2_ = create_grid_image(im1_.shape, im1_.sampling)
                im2_ = deform.apply_deformation(im2_)
            elif how == 'diff':
                im2_ = np.abs(im1_ - self._ims[1])
                title_map[3] = 'Diff'
            elif how == 'dx':
                im2_ = deform[1]
                title_map[3] = 'dx'
            elif how == 'dy':
                im2_ = deform[0]
                title_map[3] = 'dy'

            # Set images
            ims = [self._ims[0], self._ims[1], im1_, im2_]

            # Imshow all figures
            aa, tt = [], []
            for i in range(len(ims)):
                a = vv.subplot(2, 2, i + 1)
                t = vv.imshow(ims[i])
                vv.title(title_map[i])
                a.axis.visible = False
                aa.append(a)
                tt.append(t)

            # Done
            return tuple(tt)
示例#27
0
def plot_3d_orientation_map(name,
                            lat_data,
                            azth_data,
                            radius_structure_elem=1,
                            output_dir=None,
                            width=512,
                            height=512,
                            camera_azth=44.5,
                            camera_elev=35.8,
                            camera_roll=0.0,
                            camera_fov=35.0,
                            camera_zoom=0.0035,
                            camera_loc=(67.0, 81.6, 45.2),
                            xlabel='',
                            ylabel='',
                            zlabel='',
                            axis_color='w',
                            background_color='k'):
    """Renders orientation data in 3D with RGB angular color-coding.

    Parameters
    ----------
    name : str
        Indicates the name of the output png file.

    lat_data : 3D array
        Indicates the 3D array containing latitude / elevation angle at every point of
        the skeleton in radians.

    azth_data : 3D array
        Indicates the 3D array containing azimuth angle at every point of the skeleton
        in radians.

    radius_structure_elem : integer
        Indicates the size of the structure element of the dilation process to
        thicken the skeleton.

    output_dir : str
        Indicates the path to the output folder where the image will be stored.

    width : int
        Indicates the width of the visualization window.

    height : int
        Indicates the width of the visualization window.

    camera_azth : float
        Indicates the azimuth angle of the camera.

    camera_elev : float
        Indicates the latitude / elevation angle of the camera.

    camera_roll : float
        Indicates the roll angle of the camera.

    camera_fov : float
        Indicates the field of view of the camera.

    camera_zoom : float
        Indicates the zoom level of the camera.

    camera_loc : tuple
        Indicates the camera location.

    xlabel : str
        Indicates the label along the x-axis.

    ylabel : str
        Indicates the label along the y-axis.

    zlabel : str
        Indicates the label along the z-axis.

    axis_color : str
        Indicates the color of axes.

    background_color : str
        Indicates the background color of the figure.
    """
    if not visvis_available:
        print(
            'The visvis package is not found. The visualization cannot be done.'
        )
        return

    rmin, rmax, cmin, cmax, zmin, zmax = _bbox_3D(azth_data)

    azth, lat = azth_data[rmin:rmax, cmin:cmax, zmin:zmax], \
                np.abs(lat_data[rmin:rmax, cmin:cmax, zmin:zmax])

    skel = azth.copy().astype(np.float32)
    skel[skel.nonzero()] = 1.

    azth = ndi.grey_dilation(azth,
                             structure=morphology.ball(radius_structure_elem))
    lat = ndi.grey_dilation(lat,
                            structure=morphology.ball(radius_structure_elem))
    skel = ndi.binary_dilation(
        skel, structure=morphology.ball(radius_structure_elem))

    Z, Y, X = skel.nonzero()
    vol_orient = np.zeros(skel.shape + (3, ), dtype=np.float32)

    print(vol_orient.size, vol_orient[skel.nonzero()].size)

    for z, y, x in zip(Z, Y, X):
        vol_orient[z, y, x] = geo2rgb(lat[z, y, x], azth[z, y, x])

    app = vv.use()

    fig = vv.figure()
    fig._currentAxes = None
    fig.relativeFontSize = 2.
    fig.position.w = width
    fig.position.h = height

    t = vv.volshow(vol_orient[:, :, :], renderStyle='iso')
    t.isoThreshold = 0.5

    a = vv.gca()
    a.camera.azimuth = camera_azth
    a.camera.elevation = camera_elev
    a.camera.roll = camera_roll
    a.camera.fov = camera_fov
    a.camera.zoom = camera_zoom
    a.camera.loc = camera_loc

    a.bgcolor = background_color
    a.axis.axisColor = axis_color
    a.axis.xLabel = xlabel
    a.axis.yLabel = ylabel
    a.axis.zLabel = zlabel

    # def mouseUp(event):
    #     print 'mouseUp!!'
    #     a = vv.gca()
    #     print a.camera.GetViewParams()
    #
    # a.eventMouseUp.Bind(mouseUp)
    # fig.eventMouseUp.Bind(mouseUp)
    #
    # a.Draw()
    # fig.DrawNow()

    if output_dir is not None:
        if not os.path.exists(output_dir):
            os.makedirs(output_dir)

        vv.screenshot(os.path.join(output_dir, f'{name}_3d_orientation.png'),
                      sf=1,
                      bg=background_color)
    app.Run()
示例#28
0
#!/usr/bin/env python
import visvis as vv

# Create figure and make it wider than the default
fig = vv.figure()
fig.position.w = 700


# Create first axes
a1 = vv.subplot(121)

# Display an image
im = vv.imread('lena.png') # returns a numpy array
texture2d = vv.imshow(im)
texture2d.interpolate = True # if False the pixels are visible when zooming in

# Display two lines (values obtained via vv.ginput())
x = [220, 258, 308, 336, 356, 341, 318, 311, 253, 225, 220]
y = [287, 247, 212, 201, 253, 318, 364, 385, 382, 358, 287]
line1 = vv.plot(x, y, ms='.', mw=4, lw=2)
#
x = [237, 284, 326, 352, 381, 175, 195, 217, 232, 237]
y = [385, 386, 394, 413, 507, 507, 476, 441, 399, 385]
line2 = vv.plot(x, y, ms='s', mw=4, lw=2)

# The appearance of the line objects can be set in their
# constructor, or by using their properties
line1.lc, line1.mc = 'g', 'b'
line2.lc, line2.mc = 'y', 'r'

# Display a legend
示例#29
0
 def _Plot(self, *args):
     vv.figure(self.figure.nr)
     vv.clf()
     vv.plot([1, 2, 3, 1, 6])
     vv.legend(['this is a line'])
示例#30
0
def plot_reference_sphere(theta=0,
                          phi=0,
                          isometric=True,
                          ax=None,
                          azimuth=None,
                          elevation=None,
                          degrees=True,
                          labels=True,
                          light_ambient=.6,
                          zoom=1.4,
                          arrow_color=(.25, .95, .8),
                          close_figure=False):

    if azimuth is None:
        azimuth = DEFAULT_AZIMUTH
    if elevation is None:
        elevation = DEFAULT_ELEVATION

    import visvis as vv

    if ax is None:
        app = vv.use()
        fig = vv.figure()
        ax = vv.subplot(111)

    else:
        app = None
        fig = ax.GetFigure()

    ax.axis.visible = 0
    ax.axis.xLabel = 'x'
    ax.axis.yLabel = 'y'
    ax.axis.zLabel = 'z'

    # coordinate system
    length = 1.4
    cyl_diameter = .05
    for i in range(3):
        direction = np.zeros((3, ))
        direction[i] = 1
        cyl = vv.solidCylinder(translation=(0, 0, 0),
                               scaling=(cyl_diameter, cyl_diameter, length),
                               direction=tuple(direction),
                               axesAdjust=False,
                               axes=ax)
        cyl.faceColor = (.75, .75, .75)

        translation = np.zeros((3, ))
        translation[i] = length
        cone = vv.solidCone(translation=tuple(translation),
                            scaling=(.1, .1, .2),
                            direction=tuple(direction),
                            axesAdjust=False,
                            axes=ax)
        cone.faceColor = (.75, .75, .75)

    # example direction
    length = 1
    shrink = .825
    direction = sph2cart(1, theta, phi, degrees=degrees).ravel()
    cyl = vv.solidCylinder(translation=(0, 0, 0),
                           scaling=(.05, .05, shrink * length),
                           direction=tuple(direction),
                           axesAdjust=False,
                           axes=ax)
    cyl.faceColor = arrow_color

    translation = direction * shrink
    cone = vv.solidCone(translation=tuple(translation),
                        scaling=(.1, .1, .2),
                        direction=tuple(direction),
                        axesAdjust=False,
                        axes=ax)
    cone.faceColor = arrow_color

    # indicate unit sphere
    sphere = vv.solidSphere((0, 0, 0), N=100, M=100)
    sphere.faceColor = (.5, .5, .5, .25)

    # some lines on sphere indicating main axes
    phi = np.linspace(0, 2 * np.pi, 100)
    theta = np.ones_like(phi) * np.pi / 2.
    r = np.ones_like(phi)
    xyz = sph2cart(r, theta, phi, degrees=False)
    vv.plot(xyz[:, 0],
            xyz[:, 1],
            xyz[:, 2],
            lw=1,
            lc=(.5, .5, .5),
            ls="-",
            mc='b',
            axesAdjust=False,
            axes=ax)

    theta = np.linspace(-np.pi, np.pi, 100)
    phi = np.ones_like(theta) * 0
    r = np.ones_like(phi)
    xyz = sph2cart(r, theta, phi, degrees=False)
    vv.plot(xyz[:, 0],
            xyz[:, 1],
            xyz[:, 2],
            lw=1,
            lc=(.5, .5, .5),
            ls="-",
            mc='b',
            axesAdjust=False,
            axes=ax)

    theta = np.linspace(-np.pi, np.pi, 100)
    phi = np.ones_like(theta) * np.pi / 2.
    r = np.ones_like(phi)
    xyz = sph2cart(r, theta, phi, degrees=False)
    vv.plot(xyz[:, 0],
            xyz[:, 1],
            xyz[:, 2],
            lw=1,
            lc=(.5, .5, .5),
            ls="-",
            mc='b',
            axesAdjust=False,
            axes=ax)

    # add pitch and roll axes
    aa = np.deg2rad(np.linspace(45, 315, 100) - 90)
    r = .25 + .025
    d = 1.25 + .05
    color = (.25, .25, .25)

    # pitch rotation (in x/z plane, i.e. around y-axis)
    xx = r * np.cos(aa)
    zz = r * np.sin(aa)
    yy = d * np.ones_like(xx)
    vv.plot(xx, yy, zz, lw=5, lc=color, ls="-", axesAdjust=False, axes=ax)

    translation = (xx[0], yy[0], zz[0])
    direction = (xx[0] - xx[1], yy[0] - yy[1], zz[0] - zz[1])
    cone = vv.solidCone(translation=translation,
                        scaling=(.05, .05, .1),
                        direction=direction,
                        axesAdjust=False,
                        axes=ax)
    cone.faceColor = color

    if labels:
        vv.Text(ax, 'Pitch', x=0, y=1.25 * d, z=.25, fontSize=28, color=color)

    # roll rotation (in y/z plane, i.e. around x-axis)
    yy = r * np.cos(aa)
    zz = r * np.sin(aa)
    xx = d * np.ones_like(xx)
    vv.plot(xx, yy, zz, lw=5, lc=color, ls="-", axesAdjust=False, axes=ax)

    translation = (xx[-1], yy[-1], zz[-1])
    direction = (xx[-1] - xx[-2], yy[-1] - yy[-2], zz[-1] - zz[-2])
    cone = vv.solidCone(translation=translation,
                        scaling=(.05, .05, .1),
                        direction=direction,
                        axesAdjust=False,
                        axes=ax)
    cone.faceColor = color

    if labels:
        vv.Text(ax, 'Roll', x=1.25 * d, y=-.8, z=0, fontSize=28, color=color)

    # set camera view
    zoom_ = vv.view()['zoom']
    if isometric:
        vv.view(dict(azimuth=90 + ISO_AZIMUTH, elevation=ISO_ELEVATION),
                zoom=zoom * zoom_,
                axes=ax)
    else:
        vv.view(dict(azimuth=90 + azimuth, elevation=elevation),
                zoom=zoom * zoom_,
                _axes=ax)

    ax.light0.ambient = light_ambient
    ax.light0.specular = .5

    fig.DrawNow()

    if app is not None:
        app.ProcessEvents()

    img = vv.screenshot(None, ob=ax, sf=2, bg=None, format=None)

    if close_figure:
        vv.close(fig)
        fig = None

    return fig, img
示例#31
0
def plot_mouse_head(show_now=False,
                    size=(500, 500),
                    ax=None,
                    theta=0,
                    phi=0,
                    pitch=None,
                    roll=None,
                    isometric=True,
                    azimuth=None,
                    elevation=None,
                    zoom=1.5,
                    gravity_axes=True,
                    head_axes=True,
                    close_figure=False,
                    color_mouse=(.5, .5, .5),
                    color_head_axes=(.25, .95, .8),
                    color_gravity_axes=(.75, .75, .75),
                    backend='visvis',
                    light_ambient=.6,
                    light_specular=.5,
                    arrow_kw=dict(length_cone=.1,
                                  radius_cone=.05,
                                  radius_shaft=.025)):

    if azimuth is None:
        azimuth = DEFAULT_AZIMUTH
    if elevation is None:
        elevation = DEFAULT_ELEVATION

    t = np.arange(0, 1 * np.pi - 2 * np.pi / 10, np.pi / 10)
    r = 2 + np.cos(t)
    n = 20

    if backend in ['mayavi', 'mlab']:

        from mayavi import mlab
        from tvtk.tools import visual

        fig = mlab.figure(bgcolor=(1, 1, 1), size=size)
        fig.scene.parallel_projection = True

        # head
        c = -3
        [X, Y, Z] = cylinder(r, n=n)
        head = mlab.mesh(X, Y, c + Z * 6, color=(.5, .5, .5))

        # nose
        [x, y, z] = sphere(20)
        nose = mlab.mesh(x * 1.5, y * 1.5, c + z * 1.5 + 6, color=(.5, .5, .5))

        # EARS
        color = (.5, .5, .5)
        hsE1 = mlab.mesh((x * 1.0) - 2.427, (y * 1.8) - 1.763,
                         c + (z * 0.4) + 0,
                         color=color)
        hsE2 = mlab.mesh((x * 1.0) + 2.427, (y * 1.8) - 1.763,
                         c + (z * 0.4) + 0,
                         color=color)

        # EYES
        [x, y, z] = sphere(10)
        color = (.9, .9, .9)
        hsEYE1 = mlab.mesh((x * .8) - 1.2, (y * .8) - 1.6,
                           c + (z * .8) + 3.5,
                           color=color)
        hsEYE2 = mlab.mesh((x * .8) + 1.2, (y * .8) - 1.6,
                           c + (z * .8) + 3.5,
                           color=color)

        # pupils
        hsPUP1 = mlab.mesh((x * .3) - 1.476, (y * .3) - 1.98,
                           c + (z * .3) + 4.147,
                           color=(0.1, 0.1, 0.1))
        hsPUP2 = mlab.mesh((x * .3) + 1.476, (y * .3) - 1.98,
                           c + (z * .3) + 4.147,
                           color=(0.1, 0.1, 0.1))

        # whiskers
        Px = np.array([-1.154, -1.214, -1.154, +1.154, +1.214, +1.154])
        Py = np.array([-0.375, 0, 0.375, -0.375, 0, 0.375])
        Pz = np.ones(np.size(Px)) * 3.882
        WL = np.array([[0.5, 2], [0.05, 0.4]])  # whisker length

        hsWHISK = []
        for W in range(0, len(Px)):  # W=0

            if Px[W] < 0:
                XSIGN = -1
            else:
                XSIGN = +1

            if Py[W] < 0:
                YSIGN = -1
            elif Py[W] == 0:
                YSIGN = 0
            else:
                YSIGN = +1

            x = np.append(Px[W], Px[W] + XSIGN * WL[0, :])
            y = np.append(Py[W], Py[W] + YSIGN * WL[1, :])
            z = np.append(Pz[W], Pz[W])

            tck, u = interpolate.splprep([x, y], k=2)
            xi, yi = interpolate.splev(np.linspace(0, 1, 100), tck, der=0)

            zi = np.ones(np.size(yi)) * Pz[W]
            hsWHISK.append(
                mlab.plot3d(xi, yi, zi, color=(0, 0, 0), line_width=2))

        # rotate all objects
        angle_x = -90
        angle_y = 0
        angle_z = -90

        for actor in [head, nose, hsE1, hsE2, hsEYE1, hsEYE2, hsPUP1, hsPUP2]:
            actor.actor.actor.rotate_z(angle_z)
            actor.actor.actor.rotate_x(angle_x)
            actor.actor.actor.rotate_y(angle_y)

            #        actor.actor.actor.rotate_y(phi)
            #        actor.actor.actor.rotate_z(theta)

            actor.actor.actor.rotate_x(theta)
            actor.actor.actor.rotate_y(phi)

        for i in range(0, len(hsWHISK)):
            hsWHISK[i].actor.actor.rotate_z(angle_z)
            hsWHISK[i].actor.actor.rotate_x(angle_x)
            hsWHISK[i].actor.actor.rotate_y(angle_y)

            hsWHISK[i].actor.actor.rotate_x(theta)
            hsWHISK[i].actor.actor.rotate_y(phi)

        if head_axes:
            # axes of head-centered coordinate system
            visual.set_viewer(fig)

            arr1 = Arrow3D(0,
                           0,
                           0,
                           0,
                           -6,
                           0,
                           color=color_head_axes,
                           **arrow_kw)

            for arr in [arr1]:  # , arr2, arr3]:

                arr.actor.rotate_z(angle_z)
                arr.actor.rotate_x(angle_x)
                arr.actor.rotate_y(angle_y)

                arr.actor.rotate_x(theta)
                arr.actor.rotate_y(phi)

        if gravity_axes:

            # gravitational coordinate system
            visual.set_viewer(fig)

            arr1 = Arrow3D(0, 0, 0, -6, 0, 0, color=(.8, .8, .8), **arrow_kw)
            arr2 = Arrow3D(0, 0, 0, 0, -6, 0, color=(.5, .5, .5), **arrow_kw)
            arr3 = Arrow3D(0, 0, 0, 0, 0, 6, color=(.25, .25, .25), **arrow_kw)

            for arr in [arr1, arr2, arr3]:

                arr.actor.rotate_z(angle_z)
                arr.actor.rotate_x(angle_x)
                arr.actor.rotate_y(angle_y)

        if isometric:
            fig.scene.isometric_view()
        else:
            mlab.view(azimuth=azimuth, elevation=elevation, figure=fig)
        fig.scene.camera.zoom(zoom)

        if show_now:
            mlab.show()

        img = mlab.screenshot(figure=fig, mode='rgb', antialiased=False)

    elif backend in ['visvis']:

        import visvis as vv

        if ax is None:
            app = vv.use()
            fig = vv.figure()
            ax = vv.subplot(111)

        else:
            app = None
            fig = ax.GetFigure()

        ax.bgcolor = (1, 1, 1)

        ax.axis.visible = 0
        ax.axis.xLabel = 'x'
        ax.axis.yLabel = 'y'
        ax.axis.zLabel = 'z'

        # head
        c = -3
        [X, Y, Z] = cylinder(r, n=n)
        head = vv.surf(c + 6 * Z, X, Y)
        head.faceColor = color_mouse

        # nose
        [x, y, z] = sphere(20)
        nose = vv.surf(c + z * 1.5 + 6, x * 1.5, y * 1.5)
        nose.faceColor = color_mouse

        # ears
        color = (.5, .5, .5)
        ear1 = vv.surf(c + (z * 0.4) + 0, (x * 1.0) - 2.427,
                       -1 * ((y * 1.8) - 1.763))
        ear1.faceColor = color
        ear2 = vv.surf(c + (z * 0.4) + 0, (x * 1.0) + 2.427,
                       -1 * ((y * 1.8) - 1.763))
        ear2.faceColor = color_mouse

        # eyes
        [x, y, z] = sphere(10)
        color = (.9, .9, .9)
        eye1 = vv.surf(c + (z * .8) + 3.5, (x * .8) - 1.2,
                       -1 * ((y * .8) - 1.6))
        eye2 = vv.surf(c + (z * .8) + 3.5, (x * .8) + 1.2,
                       -1 * ((y * .8) - 1.6))
        [setattr(eye, 'faceColor', color) for eye in [eye1, eye2]]

        # pupils
        color = (.1, .1, .1)
        pupil1 = vv.surf(c + (z * .3) + 4.147 - .5, (x * .3) - 1.476 - .2,
                         -1 * ((y * .3) - 1.98))
        pupil2 = vv.surf(c + (z * .3) + 4.147 - .5, (x * .3) + 1.476 + .2,
                         -1 * ((y * .3) - 1.98))
        [setattr(pupil, 'faceColor', color) for pupil in [pupil1, pupil2]]

        # whiskers
        Px = np.array([-1.154, -1.214, -1.154, +1.154, +1.214, +1.154])
        Py = np.array([-0.375, 0, 0.375, -0.375, 0, 0.375])
        Pz = np.ones(np.size(Px)) * 3.882
        WL = np.array([[0.5, 2], [0.05, 0.4]])  # whisker length

        whiskers = []
        for W in range(0, len(Px)):  # W=0

            if Px[W] < 0:
                XSIGN = -1
            else:
                XSIGN = +1

            if Py[W] < 0:
                YSIGN = -1
            elif Py[W] == 0:
                YSIGN = 0
            else:
                YSIGN = +1

            x = np.append(Px[W], Px[W] + XSIGN * WL[0, :])
            y = np.append(Py[W], Py[W] + YSIGN * WL[1, :])
            z = np.append(Pz[W], Pz[W])

            tck, u = interpolate.splprep([x, y], k=2)
            xi, yi = interpolate.splev(np.linspace(0, 1, 100), tck, der=0)

            zi = np.ones(np.size(yi)) * Pz[W]
            whisker = vv.plot(zi, xi, -1 * yi, lw=2, lc=(0, 0, 0))
            whiskers.append(whisker)

        if head_axes:
            # show vector indicating orientation of head
            length = 1
            shrink = .825

            if pitch is not None and roll is not None:
                # convert pitch/roll to spherical coordinates by rotating
                # a reference point around cartesian axes; note that x and
                # y are swapped in visvis
                p0 = np.array([0, 0, 1])

                a = np.deg2rad(roll)
                Rx = np.array([[1, 0, 0], [0, np.cos(a), -np.sin(a)],
                               [0, np.sin(a), np.cos(a)]])

                b = np.deg2rad(pitch)
                Ry = np.array([[np.cos(b), 0, np.sin(b)], [0, 1, 0],
                               [-np.sin(b), 0, np.cos(b)]])

                direction = np.dot(Ry, np.dot(Rx, p0)) * length
            else:
                direction = sph2cart(length, theta, phi, degrees=True).ravel()
            cyl = vv.solidCylinder(translation=(0, 0, .25),
                                   scaling=(.05, .05, shrink * length),
                                   direction=tuple(direction),
                                   axesAdjust=False,
                                   axes=ax)
            cyl.faceColor = (.25, .95, .8)
            cyl.do_not_rotate = True
            cyl.do_not_scale = True

            translation = direction * shrink + np.array([0, 0, .25])
            cone = vv.solidCone(translation=tuple(translation),
                                scaling=(.1, .1, .2),
                                direction=tuple(direction),
                                axesAdjust=False,
                                axes=ax)
            cone.faceColor = (.25, .95, .8)
            cone.do_not_rotate = True
            cone.do_not_scale = True

        if gravity_axes:
            # show vector indicating (negative) orientation of gravity
            length = 1
            shrink = .825
            color = (.75, .75, .75)

            direction = np.array([0, 0, 1])
            cyl = vv.solidCylinder(translation=(0, 0, .25),
                                   scaling=(.05, .05, shrink * length),
                                   direction=tuple(direction),
                                   axesAdjust=False,
                                   axes=ax)
            cyl.faceColor = color
            cyl.do_not_rotate = True
            cyl.do_not_scale = True

            translation = direction * shrink + np.array([0, 0, .25])
            cone = vv.solidCone(translation=tuple(translation),
                                scaling=(.1, .1, .2),
                                direction=tuple(direction),
                                axesAdjust=False,
                                axes=ax)
            cone.faceColor = color
            cone.do_not_rotate = True
            cone.do_not_scale = True

        # compute pitch and/or roll if not given
        if pitch is None or roll is None:

            # we have to find rotations (=angles) between the unit vector
            # in spherical coordinates (1, theta, phi) and the planes
            # for pitch (y/z) and roll (x/z); note that xyz is already
            # normaizeed (norm = 1)
            xyz = sph2cart(1, theta, phi, degrees=True).ravel()

            if pitch is None:
                # pitch (y/z plane with normal vector (1, 0, 0))
                pitch = 90 - np.degrees(np.arccos(np.dot(xyz, [1, 0, 0])))

            if roll is None:
                # roll (x/z plane with normal vector (0, -1, 0))
                roll = 90 - np.degrees(np.arccos(np.dot(xyz, [0, -1, 0])))

        for obj in ax.wobjects:

            if not hasattr(obj, 'do_not_scale'):
                rot = vv.Transform_Scale(sx=.25, sy=.25, sz=.25)
                obj.transformations.append(rot)

            if obj.__class__ != vv.core.axises.CartesianAxis and\
                    not hasattr(obj, 'do_not_rotate'):

                # note that x and y are swapped
                rot = vv.Transform_Rotate(pitch, ax=0, ay=1, az=0)
                obj.transformations.append(rot)

                rot = vv.Transform_Rotate(roll, ax=1, ay=0, az=0)
                obj.transformations.append(rot)

        zoom = vv.view()['zoom']
        if isometric:
            vv.view(dict(azimuth=90 + ISO_AZIMUTH, elevation=ISO_ELEVATION),
                    zoom=4 * zoom,
                    axes=ax)
        else:
            vv.view(dict(azimuth=90 + azimuth, elevation=elevation),
                    zoom=4 * zoom,
                    axes=ax)

        ax.light0.ambient = light_ambient
        ax.light0.specular = light_specular

        fig.DrawNow()

        if app is not None:
            app.ProcessEvents()

        img = vv.screenshot(None, ob=ax, sf=2, bg=None, format=None)

        if close_figure:
            vv.close(fig)
            fig = None

    return fig, img
示例#32
0
def plot_density_sphere(xyz_centers,
                        H,
                        ax=None,
                        method='hist',
                        azimuth=None,
                        elevation=None,
                        backend='visvis',
                        oversample=1,
                        smoothing=None,
                        zoom=1.7,
                        cmap='jet',
                        scaling='log',
                        log_offset=-.1,
                        clim=None,
                        isometric=False,
                        light_ambient=.6,
                        light_specular=.5,
                        avg_direction=None,
                        pitch_label=True,
                        roll_label=True,
                        pitch_arrow=True,
                        roll_arrow=True,
                        arrow_color=(.25, .95, .8),
                        close_figure=False):

    if azimuth is None:
        azimuth = DEFAULT_AZIMUTH
    if elevation is None:
        elevation = DEFAULT_ELEVATION

    scaling = scaling.lower()
    if scaling.startswith('log'):
        H = H / float(H.sum())
        v = H > 0
        if scaling == 'log':
            H[v] = np.log(H[v])
        elif scaling == 'log2':
            H[v] = np.log2(H[v])
        H[~v] = H[v].min() + log_offset

    if smoothing is not None and smoothing > 1:
        x = np.linspace(-3., 3., smoothing)
        xx, yy = np.meshgrid(x, x)
        G = np.exp((-xx**2 - yy**2))
        H = signal.convolve2d(H, G / G.sum(), mode='same', boundary='wrap')

    if backend in ['mpl', 'matplotlib']:

        if ax is None:
            fig = plt.figure()
            ax = fig.add_subplot(111, projection='3d')

        from matplotlib.colors import LightSource
        ls = LightSource(azdeg=315, altdeg=45)
        cm = getattr(plt.cm, cmap)
        colors = ls.shade(H, cmap=cm, blend_mode='soft', vert_exag=1)
        ax.plot_surface(xyz_centers[:, 0].reshape(H),
                        xyz_centers[:, 1].reshape(H),
                        xyz_centers[:, 2].reshape(H),
                        cstride=1,
                        rstride=1,
                        facecolors=colors,
                        linewidth=0,
                        antialiased=False,
                        shade=False)

        # add arrows in front of sphere
        import mousecam_helpers as helpers
        arrow_props = dict(arrowstyle='simple',
                           mutation_scale=15,
                           mutation_aspect=None,
                           linewidth=.5,
                           facecolor=3 * [.75],
                           edgecolor=3 * [.1])
        length = .6

        arr = helpers.Arrow3D((1, 1 + length), (0, 0), (0, 0), **arrow_props)
        ax.add_artist(arr)

        arr = helpers.Arrow3D((0, 0), (1, 1 + length), (0, 0), **arrow_props)
        ax.add_artist(arr)

        arr = helpers.Arrow3D((0, 0), (0, 0), (1, 1 + length), **arrow_props)
        ax.add_artist(arr)

        extents = 3 * [[-.6, .6]]
        ax.auto_scale_xyz(*extents)
        ax.set_aspect('equal')
        ax.axis('off')

        ax.view_init(elev=elevation, azim=360 - azimuth)

    elif backend in ['mayavi', 'mlab']:

        from mayavi import mlab

        fig = mlab.figure(bgcolor=(1, 1, 1), size=(1000, 1000))
        fig.scene.parallel_projection = True

        mlab.mesh(xyz_centers[:, 0].reshape(H.shape),
                  xyz_centers[:, 1].reshape(H.shape),
                  xyz_centers[:, 2].reshape(H.shape),
                  scalars=H,
                  colormap='jet')

        from tvtk.tools import visual
        visual.set_viewer(fig)
        arrow_kw = dict(color=(.75, .75, .75),
                        length_cone=.1,
                        radius_cone=.05,
                        radius_shaft=.025)
        Arrow3D(0, 0, 0, 1.4, 0, 0, **arrow_kw)
        Arrow3D(0, 0, 0, 0, 1.4, 0, **arrow_kw)
        Arrow3D(0, 0, 0, 0, 0, 1.4, **arrow_kw)

        if isometric:
            fig.scene.isometric_view()
        else:
            mlab.view(azimuth=-azimuth, elevation=elevation, figure=fig)
        fig.scene.camera.zoom(zoom)

        ax = mlab.screenshot(figure=fig, mode='rgb', antialiased=False)

    elif backend in ['visvis']:

        import visvis as vv

        app = vv.use()

        fig = vv.figure()
        ax = vv.subplot(111)

        ax.axis.visible = 0
        ax.axis.xLabel = 'x'
        ax.axis.yLabel = 'y'
        ax.axis.zLabel = 'z'

        length = 1.4

        for i in range(3):
            direction = np.zeros((3, ))
            direction[i] = 1
            cyl = vv.solidCylinder(translation=(0, 0, 0),
                                   scaling=(.05, .05, length),
                                   direction=tuple(direction),
                                   axesAdjust=False,
                                   axes=ax)
            cyl.faceColor = (.75, .75, .75)

            translation = np.zeros((3, ))
            translation[i] = length
            cone = vv.solidCone(translation=tuple(translation),
                                scaling=(.1, .1, .2),
                                direction=tuple(direction),
                                axesAdjust=False,
                                axes=ax)
            cone.faceColor = (.75, .75, .75)

        surf = vv.surf(xyz_centers[:, 0].reshape(H.shape),
                       xyz_centers[:, 1].reshape(H.shape),
                       xyz_centers[:, 2].reshape(H.shape),
                       H,
                       axes=ax)

        # set colormap
        cmap = cmap.lower()
        if cmap.endswith('_r'):
            cm = vv.colormaps[cmap[:-2]]
            cm = cm[::-1]
        else:
            cm = vv.colormaps[cmap]
        surf.colormap = cm

        if clim is not None:
            # apply colormap limits
            surf.clim = clim


#            ax.Draw()

# add labels to indicate pitch and/or roll axes
        aa = np.deg2rad(np.linspace(45, 315, 100) - 90)
        r = .25 + .05
        d = 1.25 + .25
        color = (.25, .25, .25)

        if pitch_arrow:
            # pitch rotation (in x/z plane, i.e. around y-axis)
            xx = r * np.cos(aa)
            zz = r * np.sin(aa)
            yy = d * np.ones_like(xx)
            vv.plot(xx,
                    yy,
                    zz,
                    lw=5,
                    lc=color,
                    ls="-",
                    axesAdjust=False,
                    axes=ax)

            translation = (xx[0], yy[0], zz[0])
            direction = (xx[0] - xx[1], yy[0] - yy[1], zz[0] - zz[1])
            cone = vv.solidCone(translation=translation,
                                scaling=(.05, .05, .1),
                                direction=direction,
                                axesAdjust=False,
                                axes=ax)
            cone.faceColor = color

        if pitch_label:
            vv.Text(ax, 'Pitch', x=0, y=.9 * d, z=.5, fontSize=28, color=color)

        if roll_arrow:
            # roll rotation (in y/z plane, i.e. around x-axis)
            yy = r * np.cos(aa[::-1])
            zz = r * np.sin(aa[::-1])
            xx = d * np.ones_like(xx)
            vv.plot(xx,
                    yy,
                    zz,
                    lw=5,
                    lc=color,
                    ls="-",
                    axesAdjust=False,
                    axes=ax)

            translation = (xx[0], yy[0], zz[0])
            direction = (xx[0] - xx[1], yy[0] - yy[1], zz[0] - zz[1])
            cone = vv.solidCone(translation=translation,
                                scaling=(.05, .05, .1),
                                direction=direction,
                                axesAdjust=False,
                                axes=ax)
            cone.faceColor = color

        if roll_label:
            vv.Text(ax,
                    'Roll',
                    x=1.25 * d,
                    y=-.8,
                    z=0,
                    fontSize=28,
                    color=color)

        if avg_direction is not None:
            # indicate direction of avg head orientation
            avg_direction = avg_direction / np.sqrt(np.sum(avg_direction**2))
            avg_direction *= length
            cyl = vv.solidCylinder(translation=(0, 0, 0),
                                   scaling=(.05, .05, length),
                                   direction=tuple(avg_direction),
                                   axesAdjust=False,
                                   axes=ax)
            cyl.faceColor = arrow_color

            cone = vv.solidCone(translation=tuple(avg_direction),
                                scaling=(.1, .1, .2),
                                direction=tuple(avg_direction),
                                axesAdjust=False,
                                axes=ax)
            cone.faceColor = arrow_color

        zoom_ = vv.view()['zoom']
        if isometric:
            vv.view(dict(azimuth=90 + ISO_AZIMUTH, elevation=ISO_ELEVATION),
                    zoom=zoom_ * zoom,
                    axes=ax)
        else:
            vv.view(dict(azimuth=90 + azimuth, elevation=elevation),
                    zoom=zoom * zoom_,
                    axes=ax)

        ax.light0.ambient = light_ambient
        ax.light0.specular = light_specular

        fig.DrawNow()
        app.ProcessEvents()

        img = vv.screenshot(None, ob=ax, sf=2, bg=None, format=None)
        ax = img

        if close_figure:
            vv.close(fig)
            fig = None

    return fig, ax
示例#33
0
        m.scaling = scaling
    if direction is not None:
        m.direction = direction
    if rotation is not None:
        m.rotation = rotation

    # If necessary, use flat shading
    if N < 8 or M < 8:
        m.faceShading = 'flat'

    # Adjust axes
    if axesAdjust:
        if axes.daspectAuto is None:
            axes.daspectAuto = False
        axes.cameraType = '3d'
        axes.SetLimits()

    # Done
    axes.Draw()
    return m


if __name__ == '__main__':
    import visvis as vv
    vv.figure()
    # Create rings
    m1 = solidRing((0, 0, 1), M=4)
    m2 = solidRing((0, 0, 2))
    im = vv.imread('lena.png')
    m1.SetTexture(im)
示例#34
0
# Get image
im1 = vv.imread('astronaut.png')[:, :, 1].astype('float32')
im1 = pirt.diffuse(im1, 1)[::2, ::2] / 255.0

# Deform image
scale = im1.shape[0] * 0.4
rd = pirt.create_random_deformation(im1, 40, 40, mapping='backward', seed=1001)
im2 = rd.apply_deformation(im1)

# Add noise
im1 += np.random.normal(0, 0.1, im1.shape)
im2 += np.random.normal(0, 0.1, im1.shape)

# Get figure
vv.closeAll()
fig = vv.figure(1)
vv.clf()
fig.position = 200, 100, 900, 500

# Init registration
reg = pirt.GravityRegistration(im1, im2)
# reg = pirt.DiffeomorphicDemonsRegistration(im1, im2)
# reg = pirt.ElastixRegistration(im1, im2)

if isinstance(reg, pirt.DiffeomorphicDemonsRegistration):
    reg.params.speed_factor = 2
    reg.params.noise_factor = 0.1
    reg.params.mapping = 'backward'
    reg.params.scale_sampling = 16
    reg.params.final_grid_sampling = 35
if isinstance(reg, pirt.GravityRegistration):
示例#35
0
# 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)
示例#36
0
# 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
示例#37
0
    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()
示例#38
0
deforms = [[field[::2, ::2, ::2] for field in fields] for fields in deforms]
deforms_f = [pirt.DeformationFieldForward(*f) for f in deforms]

# Load mesh
basedir2 = select_dir(r'C:\MedData\LSPEAS_Mimics', r'F:\LSPEAS_Mimics_backup',
                      r'E:\LSPEAS_Mimics_backup')
mesh = vv.meshRead(os.path.join(basedir2, ptcode + '_' + ctcode, meshfile))
# z is negative, must be flipped to match dicom orientation
for vertice in mesh._vertices:
    vertice[-1] = vertice[-1] * -1
#mesh = vv.meshRead(r'D:\Profiles\koenradesma\Desktop\001_preavgreg 20150522 test itk.stl')
# x and y values of vertices are negative (as in original dicom), flip to match local coordinates
#mesh._vertices = mesh._vertices*-1  # when stl from itksnap

## Start vis
f = vv.figure(1)
vv.clf()
f.position = 8.00, 31.00, 944.00, 1001.00
a = vv.gca()
a.axis.axisColor = 1, 1, 1
a.axis.visible = False
a.bgcolor = 0, 0, 0
a.daspect = 1, 1, -1
vv.title('Model for LSPEAS %s  -  %s' % (ptcode[7:], ctcode))
vv.xlabel('x (mm)')
vv.ylabel('y (mm)')
vv.zlabel('z (mm)')

t = vv.volshow2(volavg, clim=(-550, 500))  # -750, 1000

# m = vv.mesh(mesh)
示例#39
0
def plot_3d_diameter_map(name,
                         data,
                         unit_scale=1.0,
                         measure_quantity='vox',
                         radius_structure_elem=1,
                         output_dir=None,
                         width=512,
                         height=512,
                         camera_azth=44.5,
                         camera_elev=35.8,
                         camera_roll=0.0,
                         camera_fov=35.0,
                         camera_zoom=0.0035,
                         camera_loc=(67.0, 81.6, 45.2),
                         xlabel='',
                         ylabel='',
                         zlabel='',
                         axis_color='w',
                         background_color='k',
                         cb_x_offset=10):
    """Renders orientation data in 3D with RGB angular color-coding.

    Parameters
    ----------
    name : str
        Indicates the name of the output png file.

    data : 3D array
        Indicates the 3D array containing diameter at every point of the skeleton.

    unit_scale : float
        Indicates the scale factor of the data values.

    measure_quantity : str
        Indicates the name of measure of the values.

    radius_structure_elem : integer
        Indicates the size of the structure element of the dilation process to
        thicken the skeleton.

    output_dir : str
        Indicates the path to the output folder where the image will be stored.

    camera_azth : float
        Indicates the azimuth angle of the camera.

    width : int
        Indicates the width of the visualization window.

    height : int
        Indicates the width of the visualization window.

    camera_elev : float
        Indicates the latitude / elevation angle of the camera.

    camera_roll : float
        Indicates the roll angle of the camera.

    camera_fov : float
        Indicates the field of view of the camera.

    camera_zoom : float
        Indicates the zoom level of the camera.

    camera_loc : tuple
        Indicates the camera location.

    xlabel : str
        Indicates the label along the x-axis.

    ylabel : str
        Indicates the label along the y-axis.

    zlabel : str
        Indicates the label along the z-axis.

    axis_color : str
        Indicates the color of axes.

    background_color : str
        Indicates the background color of the figure.

    cb_x_offset : int
        Indicates the offset of the colorbar from the right window side.
    """
    if not visvis_available:
        print(
            'The visvis package is not found. The visualization cannot be done.'
        )
        return

    rmin, rmax, cmin, cmax, zmin, zmax = _bbox_3D(data)
    dmtr = data[rmin:rmax, cmin:cmax, zmin:zmax] * unit_scale
    skel = np.zeros_like(dmtr, dtype=np.uint8)
    skel[dmtr.nonzero()] = 1

    dmtr = ndi.grey_dilation(dmtr,
                             structure=morphology.ball(radius_structure_elem))
    skel = ndi.binary_dilation(
        skel,
        structure=morphology.ball(radius_structure_elem)).astype(np.float32)
    skel[skel.nonzero()] = 1.

    dmtr = dmtr * skel

    app = vv.use()

    fig = vv.figure()
    fig._currentAxes = None
    fig.relativeFontSize = 2.
    fig.position.w = width
    fig.position.h = height

    t = vv.volshow(dmtr[:, :, :], renderStyle='iso')
    t.isoThreshold = 0.5
    t.colormap = vv.CM_JET

    a = vv.gca()
    a.camera.azimuth = camera_azth
    a.camera.elevation = camera_elev
    a.camera.roll = camera_roll
    a.camera.fov = camera_fov
    a.camera.zoom = camera_zoom
    a.camera.loc = camera_loc

    a.bgcolor = background_color
    a.axis.axisColor = axis_color
    a.axis.xLabel = xlabel
    a.axis.yLabel = ylabel
    a.axis.zLabel = zlabel

    cb = vv.colorbar()
    cb.SetLabel(f'Diameter, [{measure_quantity}]')
    cb._label.position.x += cb_x_offset

    if output_dir is not None:
        if not os.path.exists(output_dir):
            os.makedirs(output_dir)

        vv.screenshot(os.path.join(output_dir, f'{name}_3d_diameter.png'),
                      sf=1,
                      bg='w')
    app.Run()
示例#40
0
    pp1.append(400,200)
    pp2.append(400,200)
    #
    pp1.append(100,300)
    pp2.append(100,300)
    pp1.append(100,400)
    pp2.append(200,300)
    pp1.append(200,400)
    pp2.append(200,400)
    #
    pp1.append(300,400)
    pp2.append(300,400)
    pp1.append(400,400)
    pp2.append(300,300)
    pp1.append(400,300)
    pp2.append(400,300)

# Deform
def deform_and_show(injective):
    from_points_multiscale = pirt.DeformationFieldForward.from_points_multiscale
    deform = from_points_multiscale(im, 10, pp1, pp2, injective=injective, frozenedge=True)
    deform.show()

# Show
vv.figure(1);
vv.clf()
vv.subplot(131); deform_and_show(0); vv.title('Not injective')
vv.subplot(132); deform_and_show(-0.9); vv.title('Truncated injective')
vv.subplot(133); deform_and_show(+0.9); vv.title('Smooth injective')

示例#41
0
    # use floats to prevent strides etc. uint8 caused crash on qt backend.
    im = gl.glReadPixels(x, y, w, h, gl.GL_RGB, gl.GL_FLOAT)
    
    # reshape, flip, and store
    im.shape = h,w,3
    im = np.flipud(im)
    
    # done
    return im
    


if __name__ == '__main__':
    import time
    
    f = vv.figure()
    a1 = vv.subplot(211)
    a2 = vv.subplot(212)
    
    vv.plot([2,3,4,2,4,3], axes=a1)
    
    for i in range(4):
        # draw and wait a bit
        f.DrawNow()
        time.sleep(1)
        # make snapshots
        im1 = getframe(f)
        im2 = getframe(a1)
        # clear and show snapshots
        a1.Clear()
        a2.Clear()
示例#42
0
 
 # Load static CT image to add as reference
 s = loadvol(basedir, ptcode, ctcode, cropname, 'avgreg')
 vol = s.vol
 
 # Load the stent model and mesh
 s2 = loadmodel(basedir, ptcode, ctcode, cropname, modelname)
 model = s2.model
 
 
 ## Start visualization and GUI
 
 clim = (0,2500)
 showVol = 'MIP'
 
 fig = vv.figure(); vv.clf()
 fig.position = 9.00, 30.00,  944.00, 1002.00
 a = vv.gca()
 label = DrawModelAxes(vol, model, a, getLabel=True, clim=clim, showVol=showVol, mw=10)
 vv.title('Model for LSPEAS %s  -  %s' % (ptcode[7:], ctcode))
 viewAP = {'zoom': 0.006,'fov': 0.0,
 'daspect': (1.0, 1.0, -1.0),
 'azimuth': 0.0,
 'roll': 0.0}
 
 # Set view
 # a.SetView(viewAP)
 
 # Initialize labels
 t0 = vv.Label(a, '\b{Node nr|location}: ', fontSize=11, color='w')
 t0.position = 0.1, 25, 0.5, 20  # x (frac w), y, w (frac), h
示例#43
0
    mass = np.add(*massParts)**0.5

    # Normalize
    mass = normalize(mass)

    # Truncate
    if truncate:
        mass[mass < 0] = 0.0
    soft_limit(mass, 1)  # todo: half limit
    #mass = mass**0.5

    return mass


# Show
vv.figure(10)
vv.clf()
for i in range(3):
    a = vv.subplot(3, 3, i + 1)
    vv.imshow(ims[i])
    a.axis.visible = False

for i in range(3):
    a = vv.subplot(3, 3, i + 4)
    vv.imshow(getMass(ims[i]))
    a.axis.visible = False

for i in range(3):
    a = vv.subplot(3, 3, i + 7)
    vv.hist(getMass(ims[i], False), 64)
    a.SetLimits()
示例#44
0
    D = {}
    for i in SIZE_TICKS:
        il = math.log(i,factor)
        for j,c in reversed(zip([1, 10,20,30],['','K', 'M', 'G'])):
            jj = float(factor)**j
            if i>=jj:
                i = '%1.0f %s%s' % (i/jj, c, unit)
                D[il] = i
                break
    return D

SIZE_log = [math.log(i,2) for i in SIZE]
BPS_log = [math.log(i,2) for i in BPS]
TPM_log = [math.log(i,10) for i in TPM]

fig = vv.figure(1); vv.clf()
#
a1 = vv.subplot(211)
vv.plot(SIZE_log, BPS_log, ms='.')
vv.ylabel('speed [bytes/s]')
a1.axis.yTicks = logticks2()
#
a2 = vv.subplot(212)
vv.plot(SIZE_log, TPM_log, ms='.') # 0.001 0.4
vv.ylabel('time per message [s]')
a2.axis.yTicks = logticks10('s')


for a in [a1, a2]:
    a.axis.xLabel = 'message size'
    a.axis.showGrid = True
    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)
示例#46
0
 def __init__(self, im, grid_sampling=40):
     
     # Store image
     self._im = im
     
     # Setup visualization
     self._fig = fig = vv.figure()
     self._a1 = a1 = vv.subplot(231);
     self._a2 = a2 = vv.subplot(232);
     self._a3 = a3 = vv.subplot(233);
     self._a4 = a4 = vv.subplot(234);
     self._a5 = a5 = vv.subplot(235);
     self._a6 = a6 = vv.subplot(236);
     
     # Text objects
     self._text1 = vv.Label(fig)
     self._text1.position = 5, 2
     self._text2 = vv.Label(fig)
     self._text2.position = 5, 20
     
     # Move axes 
     a1.parent.position = 0.0, 0.1, 0.33, 0.45
     a2.parent.position = 0.33, 0.1, 0.33, 0.45
     a3.parent.position = 0.66, 0.1, 0.33, 0.45
     a4.parent.position = 0.0, 0.55, 0.33, 0.45
     a5.parent.position = 0.33, 0.55, 0.33, 0.45
     a6.parent.position = 0.66, 0.55, 0.33, 0.45
     
     # Correct axes, share camera
     cam = vv.cameras.TwoDCamera()
     for a in [a1, a2, a3, a4, a5, a6]:
         a.axis.visible = False
         a.camera = cam
     
     # Show images
     im0 = im*0
     self._t1 = vv.imshow(im, axes=a1)
     self._t2 = vv.imshow(im, axes=a2)
     self._t3 = vv.imshow(im, axes=a3)
     self._t4 = vv.imshow(im0, axes=a4)
     self._t5 = vv.imshow(im0, axes=a5)
     self._t6 = vv.imshow(im0, axes=a6)
     
     # Init pointsets
     self._pp1 = Pointset(2)
     self._pp2 = Pointset(2)
     self._active = None
     self._lines = []
     
     # Init lines to show all deformations
     tmp = vv.Pointset(2)        
     self._line1 = vv.plot(tmp, ls='', ms='.', mc='c', axes=a2)
     self._line2 = vv.plot(tmp, ls='+', lc='c', lw='2', axes=a2)
     
     # Init grid properties
     self._sampling = grid_sampling
     self._levels = 5
     self._multiscale = True
     self._injective = 0.5
     self._frozenedge = 1
     self._forward = True
     
     # Init grid
     self.DeformationField = DeformationFieldForward
     self._field1 = self.DeformationField(FieldDescription(self._im))
     self._field2 = self.DeformationField(FieldDescription(self._im))
     
     # Bind to events
     a2.eventMouseDown.Bind(self.on_down)
     a2.eventMouseUp.Bind(self.on_up)
     a2.eventMotion.Bind(self.on_motion)
     fig.eventKeyDown.Bind(self.on_key_down)
     #a1.eventDoubleClick.Bind(self.OnDone)
     
     # Apply
     self.apply()
示例#47
0
R1_post_and_cl_point = point_in_pointcloud_closest_to_p(centerline1, R1_post)
# calculate distance over centerline
dist_for_R1_left = dist_over_centerline(centerline1, R1_left_and_cl_point[0],
                                        renal1_and_cl_point[0])
dist_for_R1_right = dist_over_centerline(centerline1, R1_right_and_cl_point[0],
                                         renal1_and_cl_point[0])
dist_for_R1_ant = dist_over_centerline(centerline1, R1_ant_and_cl_point[0],
                                       renal1_and_cl_point[0])
dist_for_R1_post = dist_over_centerline(centerline1, R1_post_and_cl_point[0],
                                        renal1_and_cl_point[0])

# Main outcome 1: distance 2nd ring valleys to renal
# Main outcome 2: migration 2nd ring valleys from discharge to 1, 6, 12 months

## Visualize
f = vv.figure(2)
vv.clf()
f.position = 0.00, 22.00, 1920.00, 1018.00
alpha = 0.5
if ctcode2:
    a1 = vv.subplot(121)
else:
    a1 = vv.gca()
show_ctvolume(vol1, model1, showVol=showVol, clim=clim0, isoTh=isoTh)
pick3d(vv.gca(), vol1)
model1.Draw(mc='b', mw=10, lc='g')
vm = vv.mesh(modelmesh1)
vm.faceColor = 'g'
# m = vv.mesh(vessel1)
# m.faceColor = (1,0,0, alpha) # red
示例#48
0
    g.setCurveMarker(curveID, 80)

#MESHING:
elType = 2 #Element type 2 is triangle. (3 is quad. See user manual for more element types)
dofsPerNode= 2 #Degrees of freedom per node.

mesher = GmshMeshGenerator(g)
mesher.elSizeFactor = 0.05
mesher.elType = elType
mesher.dofsPerNode = 2

#Mesh the geometry:
# The first four return values are the same as those that trimesh2d() returns.
# value elementmarkers is a list of markers, and is used for finding the marker of a given element (index).
coords, edof, dofs, bdofs, elementmarkers = mesher.create()

#VISUALISATION:
#Hold left mouse button to pan.
#Hold right mouse button to zoom.
pcv.drawGeometry(g, labelCurves=True)#Draws the geometry.

vv.figure() #New figure window

pcv.drawMesh(coords=coords, edof=edof, dofsPerNode=dofsPerNode, elType=elType, filled=True, title="Example 02") #Draws the mesh.

vv.gca().axis.showGrid = True #Show grid

# Enter main loop:
app = vv.use()
app.Create()
app.Run()
示例#49
0
    def plot3d(self,
               img,
               bodies={
                   'pose3d': np.empty((0, 13, 3)),
                   'pose2d': np.empty((0, 13, 2))
               },
               hands={
                   'pose3d': np.empty((0, 21, 3)),
                   'pose2d': np.empty((0, 21, 2))
               },
               faces={
                   'pose3d': np.empty((0, 84, 3)),
                   'pose2d': np.empty((0, 84, 2))
               },
               body_with_wrists=[],
               body_with_head=[],
               interactive=False):
        """
        :param img: a HxWx3 numpy array
        :param bodies: dictionnaroes with 'pose3d' (resp 'pose2d') with the body 3D (resp 2D) pose
        :param faces: same with face pose
        :param hands: same with hand pose
        :param body_with_wrists: list with for each body, a tuple (left_hand_id, right_hand_id) of the index of the hand detection attached to this body detection (-1 if none) for left and right hands
        :parma body_with_head: list with for each body, the index of the face detection attached to this body detection (-1 if none)
        :param interactive: whether to open the viewer in an interactive manner or not
        """

        # body pose do not use the same coordinate systems
        bodies['pose3d'][:, :, 0] *= -1
        bodies['pose3d'][:, :, 1] *= -1

        # Compute 3D scaled representation of each part, stored in "points3d"
        hands, bodies, faces = [copy.copy(s) for s in (hands, bodies, faces)]
        parts = (hands, bodies, faces)
        for part in parts:
            part['points3d'] = np.zeros_like(part['pose3d'])
            for part_idx in range(len(part['pose3d'])):
                points3d = scale_orthographic(part['pose3d'][part_idx],
                                              part['pose2d'][part_idx])
                part['points3d'][part_idx] = points3d

        # Various display tricks to make the 3D visualization of full-body nice
        # (1) for faces, add a Z offset to faces to align them with the body
        for body_id, face_id in enumerate(body_with_head):
            if face_id != -1:
                z_offset = bodies['points3d'][body_id, 12, 2] - np.mean(
                    faces['points3d'][face_id, :, 2])
                faces['points3d'][face_id, :, 2] += z_offset
        # (2) for hands, add a 3D offset to put them at the wrist location
        for body_id, (lwrist_id, rwrist_id) in enumerate(body_with_wrists):
            if lwrist_id != -1:
                hands['points3d'][lwrist_id, :, :] = bodies['points3d'][
                    body_id, 7, :] - hands['points3d'][lwrist_id, 0, :]
            if rwrist_id != -1:
                hands['points3d'][rwrist_id, :, :] = bodies['points3d'][
                    body_id, 6, :] - hands['points3d'][rwrist_id, 0, :]

        img = np.asarray(img)
        height, width = img.shape[:2]

        fig = vv.figure(1)
        fig.Clear()

        fig._SetPosition(0, 0, self.figsize[0], self.figsize[1])
        if not interactive:
            fig._enableUserInteraction = False

        axes = vv.gca()
        # Hide axis
        axes.axis.visible = False

        scaling_factor = 1.0 / height

        # Camera interaction is not intuitive along z axis
        # We reference every object to a parent frame that is rotated to circumvent the issue
        ref_frame = vv.Wobject(axes)
        ref_frame.transformations.append(vv.Transform_Rotate(-90, 1, 0, 0))
        ref_frame.transformations.append(
            vv.Transform_Translate(-0.5 * width * scaling_factor, -0.5, 0))

        # Draw image
        if self.display2d:
            # Display pose in 2D
            img = visu.visualize_bodyhandface2d(img,
                                                dict_poses2d={
                                                    'body': bodies['pose2d'],
                                                    'hand': hands['pose2d'],
                                                    'face': faces['pose2d']
                                                },
                                                lw=2,
                                                max_padding=0,
                                                bgr=False)

            XX, YY = np.meshgrid([0, width * scaling_factor], [0, 1])
            img_z_offset = 0.5
            ZZ = img_z_offset * np.ones(XX.shape)
            # Draw image
            embedded_img = vv.surf(XX, YY, ZZ, img)
            embedded_img.parent = ref_frame
            embedded_img.ambientAndDiffuse = 1.0

            # Draw a grid on the bottom floor to get a sense of depth
            XX, ZZ = np.meshgrid(
                np.linspace(0, width * scaling_factor, 10),
                img_z_offset - np.linspace(0, width * scaling_factor, 10))
            YY = np.ones_like(XX)
            grid3d = vv.surf(XX, YY, ZZ)
            grid3d.parent = ref_frame
            grid3d.edgeColor = (0.1, 0.1, 0.1, 1.0)
            grid3d.edgeShading = 'plain'
            grid3d.faceShading = None

        # Draw pose
        for part in parts:

            for part_idx in range(len(part['points3d'])):
                points3d = part['points3d'][part_idx] * scaling_factor
                # Draw bones
                J = len(points3d)
                is_body = (J == 13)
                ignore_neck = False if not is_body else body_with_head[
                    part_idx] != -1
                bones, bonecolors, pltcolors = visu._get_bones_and_colors(
                    J, ignore_neck=ignore_neck)
                for (kpt_id1, kpt_id2), color in zip(bones, bonecolors):
                    color = color[2], color[1], color[0]  # BGR vs RGB
                    p1 = visu._get_xyz(points3d, kpt_id1)
                    p2 = visu._get_xyz(points3d, kpt_id2)
                    pointset = vv.Pointset(3)
                    pointset.append(p1)
                    pointset.append(p2)

                    # Draw bones as solid capsules
                    bone_radius = 0.005
                    line = vv.solidLine(pointset, radius=bone_radius)
                    line.faceColor = color
                    line.ambientAndDiffuse = 1.0

                    line.parent = ref_frame

                # Draw keypoints, except for faces
                if J != 84:
                    keypoints_to_plot = points3d
                    if ignore_neck:
                        # for a nicer display, ignore head keypoint
                        keypoints_to_plot = keypoints_to_plot[:12, :]
                    # Use solid spheres
                    for i in range(len(keypoints_to_plot)):
                        kpt_wobject = vv.solidSphere(
                            translation=keypoints_to_plot[i, :].tolist(),
                            scaling=1.5 * bone_radius)
                        kpt_wobject.faceColor = (255, 0, 0)
                        kpt_wobject.ambientAndDiffuse = 1.0
                        kpt_wobject.parent = ref_frame

        # Use just an ambient lighting
        axes.light0.ambient = 0.8
        axes.light0.diffuse = 0.2
        axes.light0.specular = 0.0

        cam = vv.cameras.ThreeDCamera()
        axes.camera = cam
        #z axis
        cam.azimuth = -45
        cam.elevation = 20
        cam.roll = 0
        # Orthographic camera
        cam.fov = 0
        if self.camera_zoom is None:
            cam.zoom *= 1.3  # Zoom a bit more
        else:
            cam.zoom = self.camera_zoom
        if self.camera_location is not None:
            cam.loc = self.camera_location
        cam.SetView()

        if interactive:
            self.app.Run()
        else:
            fig._widget.update()
            self.app.ProcessEvents()

            img3d = vv.getframe(vv.gcf())
            img3d = np.clip(img3d * 255, 0, 255).astype(np.uint8)
            # Crop gray borders
            img3d = img3d[10:-10, 10:-10, :]

            return img3d, img
示例#50
0
 def refresh(self):
     vv.figure(self._fig.nr)
     # self._app = vv.use()
     self.paint(vv)
示例#51
0
# Select dataset to register
ptcode = 'LSPEAS_008'
ctcode = '1month'
cropname = 'stent'
what = 'phases'  # avgreg

# Load volumes
s = loadvol(basedir, ptcode, ctcode, cropname, what)
vol = s.vol80

clim = (0, 2500)
# clim = (-100,300)
showVol = '2D'

fig = vv.figure(2)
vv.clf()
fig.position = 0.00, 22.00, 1920.00, 1018.00

label = DrawModelAxes(vol, clim=clim, showVol=showVol)  # lc, mc
a = vv.gca()

# bind rotate view [a,d rotate; z,x axes]
fig.eventKeyDown.Bind(lambda event: _utils_GUI.RotateView(event, [a]))

## Pseudocode

# get start points [voxels]
#     centerline stent
#     points on stent
#
示例#52
0
    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) )
        #===============================================================================
示例#53
0
    
    @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')
示例#54
0
# For fast step 3 testing: save output from step  2 and load afterwards for use
#ssdf.save(r'C:\Users\Maaike\Dropbox\ut ma3\research aortic stent grafts\data_nonecg-gated\tmp_nodes2\tmp_nodes2_700_100_006.ssdf', sd._nodes2.pack())
#sd._nodes2 = stentgraph.StentGraph()
#sd._nodes2.unpack(ssdf.load(r'C:\Users\Maaike\Dropbox\ut ma3\research aortic stent grafts\data_nonecg-gated\tmp_nodes2\tmp_nodes2_700_100_006.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 figure

fig = vv.figure(1)
vv.clf()
fig.position = 0, 22, 1366, 706
#fig.position = -1413.00, -2.00,  1366.00, 706.00

# Show volume and model as 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='b', lc='g')  # draw seeded and MCP connected nodes

# Show volume and cleaned up graph
a2 = vv.subplot(132)
t = vv.volshow(vol)
t.clim = 0, 3000
示例#55
0
    #
    if translation is not None:
        m.translation = translation
    if scaling is not None:
        m.scaling = scaling
    if direction is not None:
        m.direction = direction
    if rotation is not None:
        m.rotation = rotation
    
    # Set flat shading?
    if N<8 or M<8:
        m.faceShading = 'flat'
    
    # Adjust axes
    if axesAdjust:
        if axes.daspectAuto is None:
            axes.daspectAuto = False
        axes.cameraType = '3d'
        axes.SetLimits()
    
    # Done
    axes.Draw()
    return m


if __name__ == '__main__':
    vv.figure()
    m1 = solidCylinder(N=6)
    m2 = solidCylinder(translation=(0,0,0.1), scaling=(0.5,0.5,2.5))
示例#56
0
    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
    
示例#57
0
#!/usr/bin/env python
""" This example demonstrates rendering a color volume.
We demonstrate two renderers capable of rendering color data:
the colormip and coloriso renderer.
"""

import visvis as vv

app = vv.use()

# Load volume
vol = vv.volread("stent")

# Create figure and make subplots with different renderers
vv.figure(1)
vv.clf()
RS = ["mip", "iso", "edgeray", "ray", "litray"]
a0 = None
tt = []
for i in range(5):
    a = vv.subplot(3, 2, i + 2)
    t = vv.volshow(vol)
    vv.title("Renderstyle " + RS[i])
    t.colormap = vv.CM_HOT
    t.renderStyle = RS[i]
    t.isoThreshold = 200  # Only used in iso render style
    tt.append(t)
    if a0 is None:
        a0 = a
    else:
        a.camera = a0.camera
示例#58
0
def main():

    reqlog = logging.getLogger('requests')
    reqlog.setLevel(logging.ERROR)
    log = logging.getLogger(__name__)

    server = subprocess.Popen([sys.executable, '../dora/server/server.py'])
    time.sleep(5)

    try:

        # Set up a sampling problem:
        target_samples = 100
        n_train = 20
        lower = [1., 1.]
        upper = [3., 3.]
        acq_name = 'prod_max'

        initialiseArgs = {'lower': lower, 'upper': upper,
                          'acq_name': acq_name,
                          'n_train': n_train}

        # Initialise the sampler
        sampler_info = requests.post('http://localhost:5000/samplers',
                                     json=initialiseArgs).json()
        log.info("Model Info: " + str(sampler_info))

        # Set up plotting:
        plots = {'fig': vv.figure(),
                 'count': 0,
                 'shape': (2, 3)}
        plot_triggers = [22, 30, 40, 50, 65, target_samples-1]

        # Run the active sampling:
        for i in range(target_samples):

            log.info('Iteration: %d' % i)

            # post a request to the sampler for a query location
            req = requests.post(sampler_info['obs_uri'])
            query_loc = req.json()

            # Evaluate the sampler's query on the forward model
            characteristic = np.array(query_loc['query'])
            uid = query_loc['uid']
            uid, measurement = simulate_measurement_vector(characteristic, uid)
            # log.info('Generated measurement ' + measurement.__repr__())

            # Update the sampler with the new observation
            put_response = requests.put(query_loc['uri'],
                                        json=measurement.tolist())

            if i in plot_triggers:
                log.info("Plotting")
                plot_progress(plots, sampler_info)
        
        print('Finished.')

        # # Retrieve Training Data:
        # log.info('Retrieving training data')
        # training_data = requests.get(sampler_info['training_data_uri']).json()
        # log.info('X:' + str(training_data['X']))
        # log.info('y:' + str(training_data['y']))
        # log.info('Virtual X:' + str(training_data['virtual_X']))
        # log.info('Virtual y:' + str(training_data['virtual_y']))

        vv.use().Run()

    except Exception:
        etype, evalue, etraceback = sys.exc_info()
        tb = traceback.extract_tb(etraceback)
        print(tb.to_dict())

    server.terminate()