Exemplo n.º 1
0
 def __init__(self, main_win):
     super(VisVisWidget, self).__init__()
     # self.app = vv.use()
     self._vv_widget = vv.gcf()
     self._vv_widget._widget.show()
     self.main_win = main_win
     self.create_gui()
Exemplo n.º 2
0
def clf():
    """ clf()
    
    Clear current figure. 
    
    """
    f = vv.gcf()
    f.Clear()
    return f
Exemplo n.º 3
0
def clf():
    """ clf()
    
    Clear current figure.
    
    """
    f = vv.gcf()
    f.Clear()
    return f
Exemplo n.º 4
0
def show_ctvolume(vol,
                  graph=None,
                  axis=None,
                  showVol='MIP',
                  clim=(0, 2500),
                  isoTh=250,
                  removeStent=True,
                  climEditor=False,
                  stripSize=6,
                  stripSizeZ=None):
    """ Different ways to visualize the CT volume as reference
    For '2D' clim (-550,500) often good range
    """
    import visvis as vv

    colormap = {
        'r': [(0.0, 0.0), (0.17727272, 1.0)],
        'g': [(0.0, 0.0), (0.27272728, 1.0)],
        'b': [(0.0, 0.0), (0.34545454, 1.0)],
        'a': [(0.0, 1.0), (1.0, 1.0)]
    }
    if axis is None:
        axis = vv.gca()
    axis.MakeCurrent()
    if showVol == 'MIP':
        t = vv.volshow(vol, clim=clim, renderStyle='mip')
    elif showVol == 'ISO':
        if removeStent == True:
            vol = remove_stent_from_volume(
                vol, graph, stripSize=stripSize,
                stripSizeZ=stripSizeZ)  # rings are removed for vis.
        t = vv.volshow(vol, clim=clim, renderStyle='iso')
        t.isoThreshold = isoTh
        t.colormap = colormap
    elif showVol == '2D':
        t = vv.volshow2(vol)
        t.clim = clim
    # bind ClimEditor to figure
    if climEditor:
        if showVol == 'ISO':
            c = _utils_GUI.IsoThEditor(axis)
        else:
            c = vv.ClimEditor(axis)
        c.position = (10, 50)
        # bind for show hide
        fig = vv.gcf()
        fig.eventKeyDown.Bind(
            lambda event: _utils_GUI.ShowHideSlider(event, c))
        print('****')
        print('Use "s" to show/hide slider')
        print('****')

    return t
Exemplo n.º 5
0
def volshow(*args, **kwargs):
    """ volshow(vol, clim=None, cm=CM_GRAY, axesAdjust=True, axes=None)
    
    Display a 3D image (a volume). 
    
    This is a convenience function that calls either volshow3() or 
    volshow2(). If the current system supports it (OpenGL version >= 2.0), 
    displays a 3D  rendering (volshow3). Otherwise shows three slices 
    that can be moved interactively (volshow2). 
    
    Parameters
    ----------
    vol : numpy array
        The 3D image to visualize. Can be grayscale, RGB, or RGBA.
        If the volume is an anisotropic array (vv.Aaray), the appropriate
        scale and translate transformations are applied.
    clim : 2-element tuple
        The color limits to scale the intensities of the image. If not given,
        the im.min() and im.max() are used (neglecting nan and inf).
    cm : Colormap
        Set the colormap to apply in case the volume is grayscale.
    axesAdjust : bool
        If axesAdjust==True, this function will call axes.SetLimits(), and set
        the camera type to 3D. If daspectAuto has not been set yet, it is
        set to False.
    axes : Axes instance
        Display the image in this axes, or the current axes if not given.
    
    Any other keyword arguments are passed to either volshow2() or volshow3().
    
    """
    
    # Make sure that a figure exists
    vv.gcf()
    
    # Test and run
    if vv.settings.volshowPreference==3 and vv.misc.getOpenGlCapable(2.0):
        return vv.volshow3(*args, **kwargs)
    else:
        return vv.volshow2(*args, **kwargs)
Exemplo n.º 6
0
def volshow(*args, **kwargs):
    """ volshow(vol, clim=None, cm=CM_GRAY, axesAdjust=True, axes=None)
    
    Display a 3D image (a volume). 
    
    This is a convenience function that calls either volshow3() or 
    volshow2(). If the current system supports it (OpenGL version >= 2.0), 
    displays a 3D  rendering (volshow3). Otherwise shows three slices 
    that can be moved interactively (volshow2). 
    
    Parameters
    ----------
    vol : numpy array
        The 3D image to visualize. Can be grayscale, RGB, or RGBA.
        If the volume is an anisotropic array (vv.Aaray), the appropriate
        scale and translate transformations are applied.
    clim : 2-element tuple
        The color limits to scale the intensities of the image. If not given,
        the im.min() and im.max() are used (neglecting nan and inf).
    cm : Colormap
        Set the colormap to apply in case the volume is grayscale.
    axesAdjust : bool
        If axesAdjust==True, this function will call axes.SetLimits(), and set
        the camera type to 3D. If daspectAuto has not been set yet, it is
        set to False.
    axes : Axes instance
        Display the image in this axes, or the current axes if not given.
    
    Any other keyword arguments are passed to either volshow2() or volshow3().
    
    """

    # Make sure that a figure exists
    vv.gcf()

    # Test and run
    if vv.settings.volshowPreference == 3 and vv.misc.getOpenGlCapable(2.0):
        return vv.volshow3(*args, **kwargs)
    else:
        return vv.volshow2(*args, **kwargs)
Exemplo n.º 7
0
def draw(figure=None, fast=False):
    """ draw(figure=None, fast=False)
    
    Makes the given figure (or the current figure if None) draw itself.
    If fast is True, some wobjects can draw itself faster at reduced
    quality.
    
    """

    # Get figure
    if figure is None:
        figure = vv.gcf()

    # Draw!
    figure.Draw(fast)
Exemplo n.º 8
0
def draw(figure=None, fast=False):
    """ draw(figure=None, fast=False)
    
    Makes the given figure (or the current figure if None) draw itself.
    If fast is True, some wobjects can draw itself faster at reduced
    quality.
    
    """ 
    
    # Get figure
    if figure is None:
        figure = vv.gcf()
    
    # Draw!
    figure.Draw(fast)
Exemplo n.º 9
0
    def __init__(self, vol, direction, axes=None, clim=None):
        self.direction = direction
        # Store vol and init
        if self.direction == 0:
            self.vol = vol
        elif self.direction == 1:
            self.vol = np.transpose(vol, (1, 0, 2))
            self.vol.origin = (vol.origin[1], vol.origin[0], vol.origin[2])
            self.vol.sampling = (vol.sampling[1], vol.sampling[0],
                                 vol.sampling[2])
        elif self.direction == 2:
            self.vol = np.transpose(vol, (2, 0, 1))
            self.vol.origin = (vol.origin[2], vol.origin[0], vol.origin[1])
            self.vol.sampling = (vol.sampling[2], vol.sampling[0],
                                 vol.sampling[1])
        else:
            S('No valid input for direction, only 1,2 or 3 is possible')
        self.slice = 0

        # Prepare figure and axex
        if axes is None:
            self.a = vv.gca()
        else:
            self.a = axes

        self.f = vv.gcf()

        # Create slice in 2D texture
        if clim:
            self.t = vv.imshow(self.vol[self.round_slice, :, :],
                               clim=clim,
                               axes=self.a)
        else:
            self.t = vv.imshow(self.vol[self.round_slice, :, :], axes=self.a)

        # Bind
        self.a.eventScroll.Bind(self.on_scroll)
        self.eventPositionUpdate = vv.events.BaseEvent(self)

        axes.eventMouseDown.Bind(self.on_click)

        # Fig properties
        self.a.bgcolor = [0, 0, 0]
        self.a.axis.visible = False
        self.a.showAxis = False
Exemplo n.º 10
0
def draw(figure=None, fast=False):
    """ draw(figure=None, fast=False)
    
    Makes the given figure (or the current figure if None) draw itself.
    If fast is True, some wobjects can draw itself faster at reduced
    quality.
    
    This function is now more or less deprecated; visvis is designed to
    invoke a draw whenever necessary.
    
    """

    # Get figure
    if figure is None:
        figure = vv.gcf()

    # Draw!
    figure.Draw(fast)
Exemplo n.º 11
0
def gca():
    """ gca() 
    
    Get the current axes in the current figure. If there is
    no axes, an Axes instance is created. To make an axes current, 
    use Axes.MakeCurrent().
    
    See also gcf(), Figure.MakeCurrent(), Figure.currentAxes
    
    """
    f = vv.gcf()
    a = f.currentAxes
    if not a:
        # create axes
        a = vv.Axes(f)
        #a.position = 2, 2, -4, -4
        a.position = 10, 10, -20, -20
    return a
Exemplo n.º 12
0
def draw(figure=None, fast=False):
    """ draw(figure=None, fast=False)
    
    Makes the given figure (or the current figure if None) draw itself.
    If fast is True, some wobjects can draw itself faster at reduced
    quality.
    
    This function is now more or less deprecated; visvis is designed to 
    invoke a draw whenever necessary.
    
    """

    # Get figure
    if figure is None:
        figure = vv.gcf()

    # Draw!
    figure.Draw(fast)
Exemplo n.º 13
0
def gca():
    """ gca()
    
    Get the current axes in the current figure. If there is
    no axes, an Axes instance is created. To make an axes current,
    use Axes.MakeCurrent().
    
    See also gcf(), Figure.MakeCurrent(), Figure.currentAxes
    
    """
    f = vv.gcf()
    a = f.currentAxes
    if not a:
        # create axes
        a = vv.Axes(f)
        #a.position = 2, 2, -4, -4
        a.position = 10, 10, -20, -20
    return a
Exemplo n.º 14
0
    def set_mesh(self, mesh):
        vv.clf()
        self._vv_widget = vv.gcf()
        self._vv_widget._widget.show()
        self.main_win.setCentralWidget(self.widget())
        if mesh:
            v_mesh = mesh.to_visvis_mesh()
            v_mesh.faceColor = 'y'
            v_mesh.edgeShading = 'plain'
            v_mesh.edgeColor = (0, 0, 1)

            axes = vv.gca()
            if axes.daspectAuto is None:
                axes.daspectAuto = False
            axes.SetLimits()
            axes.legend = 'X', 'Y', 'Z'
            axes.axis.showGrid = True
            axes.axis.xLabel = 'X'
            axes.axis.yLabel = 'Y'
            axes.axis.zLabel = 'Z'
Exemplo n.º 15
0
    def __init__(self,
                 fig=None,
                 filename=None,
                 dirsave=None,
                 fileformat='avi',
                 frameRate=None):
        """ fig or axes can be given. gif swf or avi possible
        framerate to save depends on graphics card pc. default is 10fps, if faster than real world, use 5-7fps
        """
        # import os
        # import imageio
        # import visvis as vv
        # import datetime
        # from stentseg.utils.datahandling import select_dir

        # self.os = os
        # self.imageio = imageio
        # self.vv = vv
        # self.datetime = datetime
        self.r = None
        self.frameRate = frameRate
        if fig is None:
            self.fig = vv.gcf()
        else:
            self.fig = fig
        self.filename = filename
        self.fileformat = fileformat
        if dirsave is None:
            self.dirsave = select_dir(r'C:\Users\Maaike\Desktop',
                                      r'D:\Profiles\koenradesma\Desktop')
        else:
            self.dirsave = dirsave
        print(
            '"recordMovie" active, use r (rec), t (stop), y (continue), m (save), q (clear)'
        )
        # Bind eventhandler record
        self.fig.eventKeyUp.Bind(self.record)
Exemplo n.º 16
0
def subplot(*args):
    """ subplot(ncols, nrows, nr)
    
    Create or return axes in current figure. Note that subplot(322) is the
    same as subplot(3,2,2).
    
    Parameters
    ----------
    ncols : int
        The number of columns to devide the figure in.
    nrows : int
        The number of rows to devide the figure in.
    nr : int
        The subfigure number on the grid specified by ncols and nrows.
        Should be at least one. subplot(221) is the top left. subplot(222)
        is the top right. 
    
    Notes
    -----
    It is checked whether (the center of) an axes is present at the 
    specified grid location. If so, that axes is returned. Otherwise
    a new axes is created at that location.
    
    """
    
    # parse input
    if len(args)==1:
        tmp = args[0]
        if tmp>999 or tmp<111:
            raise ValueError("Invalid cols/rows/nr specified.")
        rows = tmp // 100
        tmp  = tmp % 100
        cols = tmp // 10
        tmp  = tmp % 10
        nr   = tmp
    elif len(args)==3:
        rows, cols, nr = args
    else:
        raise ValueError("Invalid number of cols/rows/nr specified.")
    
    # check if ok
    if nr<=0 or cols<=0 or rows<=0:
        raise ValueError("Invalid cols/rows/nr: all bust be >0.")
    if nr > cols*rows:
        raise ValueError("Invalid nr: there are not so many positions.")
        
    # init
    f = vv.gcf()
    nr = nr-1
    
    # check if an axes is there
    for a in f._children:
        if isinstance(a, AxesContainer):           
            n = laysin( cols, rows, getcenter(f, a) )
            if n == nr:
                # make current and return
                a = a.GetAxes()
                f.currentAxes = a
                return a
    
    # create axes in container
    a = Axes(f)
    c = a.parent
    
    # calculate relative coordinates
    dx, dy = 1.0/cols, 1.0/rows
    y = int( nr / cols )
    x = int( nr % cols )
    
    # apply positions
    c.position = dx*x, dy*y, dx, dy
    a.position = 10, 10, -20, -20
    
    # done
    return a
Exemplo n.º 17
0
and exported to gif/swf/avi.

This is not an interactive example, but a script.

"""

import visvis as vv

# Create something to show, let's show a red teapot!
mesh = vv.solidTeapot()
mesh.faceColor = 'r'

# Prepare
Nangles = 36
a = vv.gca()
f = vv.gcf()
rec = vv.record(a)

# Rotate camera
for i in range(Nangles):
    a.camera.azimuth = 360 * float(i) / Nangles
    if a.camera.azimuth > 180:
        a.camera.azimuth -= 360
    a.Draw()  # Tell the axes to redraw
    f.DrawNow()  # Draw the figure NOW, instead of waiting for GUI event loop

# Export
rec.Stop()
rec.Export('teapot.gif')
""" NOTES
Exemplo n.º 18
0
                    D = {0:-3,1:-2,2:-1,3:None}
                    slicey = slice(iy, D[iy])
                    slicex = slice(ix, D[ix])
                    
                    # Get contribution and add to temp image
                    imTmp += w * im2[slicey, slicex, :]
            
            # Store contributions            
            D = [-1 for tmp in range(s)]; D.append(None)
            slicey = slice(dy,D[dy],s)
            slicex = slice(dx,D[dx],s)
            im3[slicey, slicex, :] = imTmp
    
    
    # Correct for overshoot
    im3[im3>1]=1
    im3[im3<0]=0
    
    # Store image to file
    if filename is not None:
        vv.imwrite(filename, im3, format)
    else:
        return im3


if __name__ == '__main__':
    # Make plot
    vv.plot([1,2,3,1,4,2,3], ms='.')
    # Take screenshot, twice enlarged, on a white background
    vv.screenshot('screenshot.jpg', vv.gcf(), sf=2, bg='w')
    
Exemplo n.º 19
0
def screenshot(filename, ob=None, sf=2, bg=None, format=None, tension=-0.25):
    """ screenshot(filename, ob=None sf=2, bg=None, format=None)
    
    Make a screenshot and store it to a file, using cubic interpolation
    to increase the resolution (and quality) of the image.
    
    Parameters
    ----------
    filename : string
        The name of the file to store the screenshot to. If filename is None, 
        the interpolated image is returned as a numpy array.
    ob : Axes, AxesContainer, or Figure
        The object to take the screenshot of. The AxesContainer can be
        obtained using vv.gca().parent. It can be usefull to take a 
        screeshot of an axes including thickmarks and labels.
    sf : integer
        The scale factor. The image is increased in size with this factor,
        using a high quality interpolation method. A factor of 2 or 3
        is recommended; the image quality does not improve with higher
        factors. If using a sf larger than 1, the image is best saved in
        the jpg format.
    bg : 3-element tuple or char
        The color of the background. If bg is given, ob.bgcolor is set to
        bg before the frame is captured.
    format : string
        The format for the screenshot to be saved in. If not given, the
        format is deduced from the filename.
    
    Notes
    -----
    Uses vv.getframe(ob) to obtain the image in the figure or axes. 
    That image is interpolated with the given scale factor (sf) using 
    bicubic interpolation. Then  vv.imwrite(filename, ..) is used to 
    store the resulting image to a file.
    
    Rationale
    ---------
    We'd prefer storing screenshots of plots as vector (eps) images, but 
    the nature of OpenGl prevents this. By applying high quality 
    interpolation (using a cardinal spline), the resolution can be increased, 
    thereby significantly improving the visibility/smoothness for lines 
    and fonts. Use this to produce publication quality snapshots of your
    plots.
    
    """
    
    # The tension controls the
    # responsivenes of the filter. The more negative, the more overshoot,
    # but the more it is capable to make for example font glyphs smooth.
    # If tension is 0, the interpolator is a Catmull-Rom spline.
    
    # Scale must be integer
    s = int(sf)
    
    # Object given?
    if ob is None:
        ob = vv.gcf()
    
    # Get figure
    fig = ob
    if not hasattr(ob, 'DrawNow'):
        fig = ob.GetFigure()
    
    # Get object to set background of
    bgob = ob
    
    # Set background
    if bg and fig:
        bgOld = bgob.bgcolor
        bgob.bgcolor = bg
        fig.DrawNow()  
    
    # Obtain image      
    im1 = vv.getframe(ob)
    shape1 = im1.shape
    
    # Return background
    if bg and fig:
        bgob.bgcolor = bgOld
        fig.Draw()
    
    # Pad original image, so we have no trouble at the edges
    shape2 = shape1[0]+2, shape1[1]+2, 3
    im2 = np.zeros(shape2, dtype=np.float32) # Also make float
    im2[1:-1,1:-1,:] = im1
    im2[0,:,:] = im2[1,:,:]
    im2[-1,:,:] = im2[-2,:,:]
    im2[:,0,:] = im2[:,1,:]
    im2[:,-1,:] = im2[:,-2,:]
    
    # Create empty new image. It is sized by the scaleFactor, 
    # but the last row is not. 
    shape3 = (shape1[0]-1)*s+1, (shape1[1]-1)*s+1, 3    
    im3 = np.zeros(shape3, dtype=np.float32)
    
    # Fill in values!
    for dy in range(s+1):
        for dx in range(s+1):
            
            # Get interpolation fraction and coefs
            ty = float(dy)/s
            tx = float(dx)/s
            cy = getCardinalSplineCoefs(ty, tension)
            cx = getCardinalSplineCoefs(tx, tension)
            
            # Create tmp image to which we add the contributions
            # Note that this image is 1 pixel smaller in each dimension.
            # The last pixel is filled because dy and dx iterate INCLUDING s.
            shapeTmp = shape1[0]-1, shape1[1]-1, 3
            imTmp = np.zeros(shapeTmp, dtype=np.float32)
            
            # Collect all 16 neighbours and weight them apropriately
            for iy in range(4):
                for ix in range(4):
                    
                    # Get weight
                    w = cy[iy]*cx[ix]
                    if w==0:
                        continue
                    
                    # Get slice. Note that we start at 0,1,2,3 rather than
                    # -1,0,1,2, because we padded the image.
                    D = {0:-3,1:-2,2:-1,3:None}
                    slicey = slice(iy, D[iy])
                    slicex = slice(ix, D[ix])
                    
                    # Get contribution and add to temp image
                    imTmp += w * im2[slicey, slicex, :]
            
            # Store contributions            
            D = [-1 for tmp in range(s)]; D.append(None)
            slicey = slice(dy,D[dy],s)
            slicex = slice(dx,D[dx],s)
            im3[slicey, slicex, :] = imTmp
    
    
    # Correct for overshoot
    im3[im3>1]=1
    im3[im3<0]=0
    
    # Store image to file
    if filename is not None:
        vv.imwrite(filename, im3, format)
    else:
        return im3
# Create visvis application
app = vv.use()
app.Create()

# Create main window frame and set a resolution.
main_w = MainWindow()
main_w.resize(700, 320)

# Create the 3 D shape model as a mesh. verticesPerFace equals 3 since triangles define the
# mesh's surface in this case
shape_obj = vv.mesh(vertices=VERTICES, faces=faces, verticesPerFace=3)
shape_obj.specular = 0.0
shape_obj.diffuse = 0.9

# Get figure
figure = vv.gcf()

# Get axes objects and set figure parameters
axes = vv.gca()
axes.bgcolor = (0, 0, 0)
axes.axis.showGrid = False
axes.axis.visible = False

# Set camera settings
#
axes.camera = '3d'
axes.camera.fov = 60
axes.camera.zoom = 0.1

# Turn off the main light
axes.light0.Off()
Exemplo n.º 21
0
def subplot(*args):
    """ subplot(ncols, nrows, nr)
    
    Create or return axes in current figure. Note that subplot(322) is the
    same as subplot(3,2,2).
    
    Parameters
    ----------
    ncols : int
        The number of columns to devide the figure in.
    nrows : int
        The number of rows to devide the figure in.
    nr : int
        The subfigure number on the grid specified by ncols and nrows.
        Should be at least one. subplot(221) is the top left. subplot(222)
        is the top right. 
    
    Notes
    -----
    It is checked whether (the center of) an axes is present at the 
    specified grid location. If so, that axes is returned. Otherwise
    a new axes is created at that location.
    
    """

    # parse input
    if len(args) == 1:
        tmp = args[0]
        if tmp > 999 or tmp < 111:
            raise ValueError("Invalid cols/rows/nr specified.")
        rows = tmp // 100
        tmp = tmp % 100
        cols = tmp // 10
        tmp = tmp % 10
        nr = tmp
    elif len(args) == 3:
        rows, cols, nr = args
    else:
        raise ValueError("Invalid number of cols/rows/nr specified.")

    # check if ok
    if nr <= 0 or cols <= 0 or rows <= 0:
        raise ValueError("Invalid cols/rows/nr: all bust be >0.")
    if nr > cols * rows:
        raise ValueError("Invalid nr: there are not so many positions.")

    # init
    f = vv.gcf()
    nr = nr - 1

    # check if an axes is there
    for a in f._children:
        if isinstance(a, AxesContainer):
            n = laysin(cols, rows, getcenter(f, a))
            if n == nr:
                # make current and return
                a = a.GetAxes()
                f.currentAxes = a
                return a

    # create axes in container
    a = Axes(f)
    c = a.parent

    # calculate relative coordinates
    dx, dy = 1.0 / cols, 1.0 / rows
    y = int(nr / cols)
    x = int(nr % cols)

    # apply positions
    c.position = dx * x, dy * y, dx, dy
    a.position = 10, 10, -20, -20

    # done
    return a
Exemplo n.º 22
0
						#vol[i,j,k] = (2.0/N)*(i-N/2)*(i-N/2) - (1/N)*(j-N/2)*(j-N/2) - (k-N/2) # Paraboloide hiperbolico
						#vol[i,j,k] = cos(i) + cos(j) + cos(k) # Triply periodic minimal surface (Schwarz)

# show
#impl_surf = vv.volshow(vol, renderStyle='iso')
# try the differtent render styles, for examample 
# "t.renderStyle='iso'" or "t.renderStyle='ray'"
# If the drawing hangs, your video drived decided to render in software mode.
# This is unfortunately (as far as I know) not possible to detect. 
# It might help if your data is shaped a power of 2.
#impl_surf.isoThreshold = 0.0
#impl_surf.colormap = vv.CM_WINTER

# Create colormap editor wibject.
#vv.ColormapEditor(axs)


#
# Graficación
#

axs = vv.gca() # "Get Current Axes"
#axs.bgcolor = (0.0, 0.0, 0.0)
axs.camera.fov = 60	

fig = vv.gcf() # "Get Current Figure"
fig._widget.showFullScreen() # Pantalla completa, para RaspberryPi

app.Run() # Corre aplicación/ventana

Exemplo n.º 23
0
def converge_to_centre(pp, c, nDirections=5, maxRadius=50, pauseTime=0):
    """ converge_to_centre(pp, c)
    Given a set of points and an initial center point c, 
    will find a better estimate of the center.
    Returns (c, L), with L indices in pp that were uses to fit 
    the final circle.
    """
    
    # Shorter names
    N = nDirections
    pi = np.pi
    
    # Init point to return on error
    ce = Point(0,0)
    ce.r = 0
    
    # Are there enough points?
    if len(pp) < 3:
        return ce, []
    
    # Init a pointset of centers we've has so far
    cc = Pointset(2) 
    
    # Init list with vis objects (to be able to delete them)
    showObjects = []
    if pauseTime:
        fig = vv.gcf()
    
    
    while c not in cc:
        
        # Add previous center
        cc.append(c)
        
        # Calculate distances and angles
        dists = c.distance(pp)
        angs = c.angle2(pp)
        
        # Get index of closest points
        i, = np.where(dists==dists.min())
        i = iClosest = int(i[0])
        
        # Offset the angles with the angle relative to the closest point.
        refAng = angs[i]
        angs = subtract_angles(angs, refAng)
        
        # Init L, the indices to the closest point in each direction
        L = []
        
        # Get closest point on N directions
        for angle in [float(angnr)/N*2*pi for angnr in range(N)]:
            
            # Get indices of points that are in this direction
            dangs = subtract_angles(angs, angle)
            I, = np.where(np.abs(dangs) < pi/N )
            
            # Select closest
            if len(I):
                distSelection = dists[I]
                minDist = distSelection.min()
                J, = np.where(distSelection==minDist)
                if len(J) and minDist < maxRadius:
                    L.append( int(I[J[0]]) )
        
        # Check if ok
        if len(L) < 3:
            return ce, []
        
        # Remove spurious points (points much furter away that the 3 closest)
        distSelection = dists[L]
        tmp = [d for d in distSelection]
        d3 = sorted(tmp)[2] # Get distance of 3th closest point
        I, = np.where(distSelection < d3*2)
        L = [L[i] for i in I]
        
        # Select points
        ppSelect = Pointset(2)
        for i in L:
            ppSelect.append(pp[i])
        
        # Refit circle
        cnew = fit_cirlce(ppSelect,False)
        if cnew.r==0:
            return ce, []
        
        # Show
        if pauseTime>0:
            # Delete
            for ob in showObjects:
                ob.Destroy()
            # Plot center and new center
            ob1 = vv.plot(c, ls='', ms='x', mc='r', mw=10, axesAdjust=0)
            ob2 = vv.plot(cnew, ls='', ms='x', mc='r', mw=10, mew=0, axesAdjust=0)
            # Plot selection points            
            ob3 = vv.plot(ppSelect, ls='', ms='.', mc='y', mw=10, axesAdjust=0)
            # Plot lines dividing the directions
            tmpSet1 = Pointset(2)
            tmpSet2 = Pointset(2)            
            for angle in [float(angnr)/N*2*pi for angnr in range(N)]:
                angle = -subtract_angles(angle, refAng)
                dx, dy = np.cos(angle), np.sin(angle)
                tmpSet1.append(c.x, c.y)
                tmpSet1.append(c.x+dx*d3*2, c.y+dy*d3*2)
            for angle in [float(angnr+0.5)/N*2*pi for angnr in range(N)]:
                angle = -subtract_angles(angle, refAng)
                dx, dy = np.cos(angle), np.sin(angle)
                tmpSet2.append(c.x, c.y)
                tmpSet2.append(c.x+dx*d3*2, c.y+dy*d3*2)
            ob4 = vv.plot(tmpSet1, lc='y', ls='--', axesAdjust=0)
            ob5 = vv.plot(tmpSet2, lc='y', lw=3, axesAdjust=0)
            # Store objects and wait
            showObjects = [ob1,ob2,ob3,ob4,ob5]
            fig.DrawNow()
            time.sleep(pauseTime)
        
        # Use new
        c = cnew
    
    # Done    
    for ob in showObjects:
        ob.Destroy()
    return c, L
Exemplo n.º 24
0
def showModelsStatic(ptcode,codes, vols, ss, mm, vs, showVol, clim, isoTh, clim2, 
    clim2D, drawMesh=True, meshDisplacement=True, drawModelLines=True, 
    showvol2D=False, showAxis=False, drawVessel=False, vesselType=1,
    meshColor=None, **kwargs):
    """ show one to four models in multipanel figure. 
    Input: arrays of codes, vols, ssdfs; params from show_models_static
    Output: axes, colorbars 
    """
    # init fig
    f = vv.figure(1); vv.clf()
    # f.position = 0.00, 22.00,  1920.00, 1018.00
    mw = 5
    if drawMesh == True:
        lc = 'w'
        meshColor = meshColor
    else:
        lc = 'g'
    # create subplots
    if isinstance(codes, str): # if 1 ctcode, otherwise tuple of strings
        a1 = vv.subplot(111)
        axes = [a1]
    elif codes == (codes[0],codes[1]):
        a1 = vv.subplot(121)
        a2 = vv.subplot(122)
        axes = [a1,a2]
    elif codes == (codes[0],codes[1], codes[2]):
        a1 = vv.subplot(131)
        a2 = vv.subplot(132)
        a3 = vv.subplot(133)
        axes = [a1,a2,a3]
    elif codes == (codes[0],codes[1], codes[2], codes[3]):
        a1 = vv.subplot(141)
        a2 = vv.subplot(142)
        a3 = vv.subplot(143)
        a4 = vv.subplot(144)
        axes = [a1,a2,a3,a4]
    elif codes == (codes[0],codes[1], codes[2], codes[3], codes[4]):
        a1 = vv.subplot(151)
        a2 = vv.subplot(152)
        a3 = vv.subplot(153)
        a4 = vv.subplot(154)
        a5 = vv.subplot(155)
        axes = [a1,a2,a3,a4,a5]
    else:
        a1 = vv.subplot(111)
        axes = [a1]
    for i, ax in enumerate(axes):
        ax.MakeCurrent()
        vv.xlabel('x (mm)');vv.ylabel('y (mm)');vv.zlabel('z (mm)')
        vv.title('Model for LSPEAS %s  -  %s' % (ptcode[7:], codes[i]))
        t = show_ctvolume(vols[i], ss[i].model, axis=ax, showVol=showVol, clim=clim, isoTh=isoTh, **kwargs)
        label = pick3d(ax, vols[i])
        if drawModelLines == True:
            ss[i].model.Draw(mc='b', mw = mw, lc=lc)
    if showvol2D:
        for i, ax in enumerate(axes):
            t2 = vv.volshow2(vols[i], clim=clim2D, axes=ax)
    cbars = [] # colorbars
    if drawMesh:
        for i, ax in enumerate(axes):
            m = vv.mesh(mm[i], axes=ax)
            if meshDisplacement:
                m.clim = clim2
                m.colormap = vv.CM_JET #todo: use colormap Viridis or Magma as JET is not linear (https://bids.github.io/colormap/)
                cb = vv.colorbar(ax)
                cbars.append(cb)
            elif meshColor is not None:
                if len(meshColor) == 1:
                    m.faceColor = meshColor[0] # (0,1,0,1)
                else:
                    m.faceColor = meshColor[i]
            else:
                m.faceColor = 'g'
    if drawVessel:
        for i, ax in enumerate(axes):
            v = showVesselMesh(vs[i], ax, type=vesselType)
    for ax in axes:
        ax.axis.axisColor = 1,1,1
        ax.bgcolor = 25/255,25/255,112/255 # midnightblue
        # http://cloford.com/resources/colours/500col.htm
        ax.daspect = 1, 1, -1  # z-axis flipped
        ax.axis.visible = showAxis
    # set colorbar position
    for cbar in cbars:
        p1 = cbar.position
        cbar.position = (p1[0], 20, p1[2], 0.98) # x,y,w,h
    
    # bind rotate view and view presets [1,2,3,4,5]
    f = vv.gcf()
    f.eventKeyDown.Bind(lambda event: _utils_GUI.RotateView(event,axes,axishandling=False) )
    f.eventKeyDown.Bind(lambda event: _utils_GUI.ViewPresets(event,axes) )
    
    return axes, cbars
            vv.xlabel('x'), vv.ylabel('y'), vv.zlabel('z')
            vv.title('Overlay')
            a2.daspect = 1, 1, -1

            a3 = vv.subplot(223)
            vv.volshow(volTr, clim=clim)
            vv.xlabel('x'), vv.ylabel('y'), vv.zlabel('z')
            vv.title(
                'Im2:Original transformed (DataDressedInterpolated u_\magnitude {})'
                .format(mat2['u_magnitude'][0][0]))
            a3.daspect = 1, 1, -1

        a4 = vv.subplot(224)
        a4.daspect = 1, 1, -1

        c = vv.ClimEditor(vv.gcf())

        a1.camera = a2.camera = a3.camera = a4.camera

    # Remove .mat for savename and loading below
    if fileTr.endswith('.mat'):
        fileTr = fileTr.replace('.mat', '')

    ## Do registration

    if True:
        t0 = time.time()

        # set final scale based on pixelwidth (scale should be =<0.5*pixelwidth)
        if max(sampling2) > 2:
            final_scale = max(sampling2) / 2
Exemplo n.º 26
0
def screenshot(filename, ob=None, sf=2, bg=None, format=None, tension=-0.25):
    """ screenshot(filename, ob=None sf=2, bg=None, format=None)
    
    Make a screenshot and store it to a file, using cubic interpolation
    to increase the resolution (and quality) of the image.
    
    Parameters
    ----------
    filename : string
        The name of the file to store the screenshot to. If filename is None, 
        the interpolated image is returned as a numpy array.
    ob : Axes, AxesContainer, or Figure
        The object to take the screenshot of. The AxesContainer can be
        obtained using vv.gca().parent. It can be usefull to take a 
        screeshot of an axes including thickmarks and labels.
    sf : integer
        The scale factor. The image is increased in size with this factor,
        using a high quality interpolation method. A factor of 2 or 3
        is recommended; the image quality does not improve with higher
        factors. If using a sf larger than 1, the image is best saved in
        the jpg format.
    bg : 3-element tuple or char
        The color of the background. If bg is given, ob.bgcolor is set to
        bg before the frame is captured.
    format : string
        The format for the screenshot to be saved in. If not given, the
        format is deduced from the filename.
    
    Notes
    -----
    Uses vv.getframe(ob) to obtain the image in the figure or axes. 
    That image is interpolated with the given scale factor (sf) using 
    bicubic interpolation. Then  vv.imwrite(filename, ..) is used to 
    store the resulting image to a file.
    
    Rationale
    ---------
    We'd prefer storing screenshots of plots as vector (eps) images, but 
    the nature of OpenGl prevents this. By applying high quality 
    interpolation (using a cardinal spline), the resolution can be increased, 
    thereby significantly improving the visibility/smoothness for lines 
    and fonts. Use this to produce publication quality snapshots of your
    plots.
    
    """

    # The tension controls the
    # responsivenes of the filter. The more negative, the more overshoot,
    # but the more it is capable to make for example font glyphs smooth.
    # If tension is 0, the interpolator is a Catmull-Rom spline.

    # Scale must be integer
    s = int(sf)

    # Object given?
    if ob is None:
        ob = vv.gcf()

    # Get figure
    fig = ob
    if not hasattr(ob, 'DrawNow'):
        fig = ob.GetFigure()

    # Get object to set background of
    bgob = ob

    # Set background
    if bg and fig:
        bgOld = bgob.bgcolor
        bgob.bgcolor = bg
        fig.DrawNow()

    # Obtain image
    im1 = vv.getframe(ob)
    shape1 = im1.shape

    # Return background
    if bg and fig:
        bgob.bgcolor = bgOld
        fig.Draw()

    # Pad original image, so we have no trouble at the edges
    shape2 = shape1[0] + 2, shape1[1] + 2, 3
    im2 = np.zeros(shape2, dtype=np.float32)  # Also make float
    im2[1:-1, 1:-1, :] = im1
    im2[0, :, :] = im2[1, :, :]
    im2[-1, :, :] = im2[-2, :, :]
    im2[:, 0, :] = im2[:, 1, :]
    im2[:, -1, :] = im2[:, -2, :]

    # Create empty new image. It is sized by the scaleFactor,
    # but the last row is not.
    shape3 = (shape1[0] - 1) * s + 1, (shape1[1] - 1) * s + 1, 3
    im3 = np.zeros(shape3, dtype=np.float32)

    # Fill in values!
    for dy in range(s + 1):
        for dx in range(s + 1):

            # Get interpolation fraction and coefs
            ty = float(dy) / s
            tx = float(dx) / s
            cy = getCardinalSplineCoefs(ty, tension)
            cx = getCardinalSplineCoefs(tx, tension)

            # Create tmp image to which we add the contributions
            # Note that this image is 1 pixel smaller in each dimension.
            # The last pixel is filled because dy and dx iterate INCLUDING s.
            shapeTmp = shape1[0] - 1, shape1[1] - 1, 3
            imTmp = np.zeros(shapeTmp, dtype=np.float32)

            # Collect all 16 neighbours and weight them apropriately
            for iy in range(4):
                for ix in range(4):

                    # Get weight
                    w = cy[iy] * cx[ix]
                    if w == 0:
                        continue

                    # Get slice. Note that we start at 0,1,2,3 rather than
                    # -1,0,1,2, because we padded the image.
                    D = {0: -3, 1: -2, 2: -1, 3: None}
                    slicey = slice(iy, D[iy])
                    slicex = slice(ix, D[ix])

                    # Get contribution and add to temp image
                    imTmp += w * im2[slicey, slicex, :]

            # Store contributions
            D = [-1 for tmp in range(s)]
            D.append(None)
            slicey = slice(dy, D[dy], s)
            slicex = slice(dx, D[dx], s)
            im3[slicey, slicex, :] = imTmp

    # Correct for overshoot
    im3[im3 > 1] = 1
    im3[im3 < 0] = 0

    # Store image to file
    if filename is not None:
        vv.imwrite(filename, im3, format)
    else:
        return im3
Exemplo n.º 27
0
tex3d.visible = False

# VesselMeshes
vesselVisMesh1 = axes1.wobjects[4]
vesselVisMesh1.cullFaces = "front"  # Show the back
# vesselVisMesh2 = vv.Mesh(axes1, *vesselMesh.get_vertices_and_faces())
vesselVisMesh2 = vv.Mesh(axes1, np.zeros((6, 3), np.float32),
                         np.zeros((3, 3), np.int32))
vesselVisMesh2.cullFaces = "back"
vesselVisMesh2.faceColor = "red"

# Show the centerline
vv.plot(centerline, ms='.', ls='', mw=8, mc='b', alpha=0.5)

# Initialize 2D view
axes2 = vv.Axes(vv.gcf())
axes2.position = 0.65, 0.05, 0.3, 0.4
axes2.daspectAuto = False
axes2.camera = '2d'
axes2.axis.showGrid = True
axes2.axis.axisColor = 'k'

# Initialize axes to put widgets and labels in
container = vv.Wibject(vv.gcf())
container.position = 0.65, 0.5, 0.3, 0.5

# Create labels to show measurements
labelpool = []
for i in range(16):
    label = vv.Label(container)
    label.fontSize = 11
Exemplo n.º 28
0
        #Use the gradient operator on the velocity array: gradient(m)[0] 
        #Makes the velocity be on the columns instead of rows.
        if(self.vMags == None):
            self.velocityMag()
            
        a = np.gradient(self.vels,1/self.fs)[0]
        self.aMags = np.linalg.norm(a,axis=1)
        return self.aMags
        
    def peakAccelMag(self):
        if(self.vMags == None):
            self.velocityMag()
        
        peakA = max(self.aMags)
        return peakA
        
    @staticmethod
    def resetSensorCount():
        Sensor.numSensors = 0
    
if(__name__ == '__main__'):
    figure = vv.gcf()
    axes = vv.gca()
    audiofile = "C:/Data/05_ENGL_F_words6.wav"
    kinfile =  "C:/Data/05_ENGL_F_words6_BPC.tsv"
    data = np.genfromtxt(unicode(kinfile), skip_header = 1, delimiter = '\t')
    newSensor = Sensor(data[:,14:21], axes, 'Upper Lip','UL', 400)
    newSensor.updateDataAndText(1000)
    newSensor.accelerationMag()
    
Exemplo n.º 29
0
                    D = {0: -3, 1: -2, 2: -1, 3: None}
                    slicey = slice(iy, D[iy])
                    slicex = slice(ix, D[ix])

                    # Get contribution and add to temp image
                    imTmp += w * im2[slicey, slicex, :]

            # Store contributions
            D = [-1 for tmp in range(s)]
            D.append(None)
            slicey = slice(dy, D[dy], s)
            slicex = slice(dx, D[dx], s)
            im3[slicey, slicex, :] = imTmp

    # Correct for overshoot
    im3[im3 > 1] = 1
    im3[im3 < 0] = 0

    # Store image to file
    if filename is not None:
        vv.imwrite(filename, im3, format)
    else:
        return im3


if __name__ == '__main__':
    # Make plot
    vv.plot([1, 2, 3, 1, 4, 2, 3], ms='.')
    # Take screenshot, twice enlarged, on a white background
    vv.screenshot('screenshot.jpg', vv.gcf(), sf=2, bg='w')
Exemplo n.º 30
0
# The full license can be found in 'license.txt'.

from visvis import BaseFigure
import visvis as vv

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 = list(BaseFigure._figures.keys())[0]
        BaseFigure._currentNr = nr
    
    return BaseFigure._figures[nr]

if __name__ == '__main__':
    fig = vv.gcf()
Exemplo n.º 31
0
                    for deform in deforms_forward]  # get backward mapping

# Start vis
f = vv.figure(nr)
vv.clf()
if nr == 1:
    f.position = 8.00, 30.00, 667.00, 690.00
else:
    f.position = 691.00, 30.00, 667.00, 690.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.ColormapEditor(vv.gcf())

# Setup motion container
dt = DeformableTexture3D(a, vol)
dt.clim = 0, 3000
dt.isoThreshold = 300
dt.renderStyle = 'iso'  # iso or mip work well
dt.SetDeforms(*[list(reversed(deform)) for deform in deforms_backward])
dt.colormap = {
    'g': [(0.0, 0.0), (0.33636364, 1.0)],
    'b': [(0.0, 0.0), (0.49545455, 1.0)],
    'a': [(0.0, 1.0), (1.0, 1.0)],
    'r': [(0.0, 0.0), (0.22272727, 1.0)]
}

# Set limits and play!
Exemplo n.º 32
0
from visvis import BaseFigure
import visvis as vv


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 = list(BaseFigure._figures.keys())[0]
        BaseFigure._currentNr = nr

    return BaseFigure._figures[nr]


if __name__ == '__main__':
    fig = vv.gcf()
Exemplo n.º 33
0
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

# Create colormap editor in first axes
cme = vv.ColormapEditor(vv.gcf(), *tt[3:])

# Run app
app.Create()
app.Run()
Exemplo n.º 34
0
# Zoom
axes.SetLimits(margin=0.0)
axes.SetLimits(margin=0.0, rangeX=(-1, 1))

# Control lighting
#axes.bgcolor='k'
# axes.light0.ambient = 0.0 # 0.2 is default for light 0
# axes.light0.diffuse = 0.0 # 1.0 is default
axes.light0.Off()
light1 = axes.lights[1]
light1.On()
light1.ambient = 0.8
light1.diffuse = 1.0
light1.isDirectional = True
light1.position = (2, -4, 2, 0)
rec = vv.record(vv.gcf())

# Timer for controlling rotation speed
timer = vv.Timer(axes, 100, False)
timer.Bind(onTimer)
timer.Start(interval=1)
app = vv.use()
app.Run()

# Output movie to gif
rec.Stop()
rec.Export('movie.gif')

# Old code that used matplotlib, which is like 10 times slower, but left in
# since visvis is discontinued
Exemplo n.º 35
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
Exemplo n.º 36
0
def record(ob):
    """ record(object)
    Take a snapshot of the given figure or axes after each draw.
    A Recorder instance is returned, with which the recording can
    be stopped, continued, and exported to GIF, SWF or AVI.
    """
    
    # establish wheter we can record that
    if not isinstance(ob, (vv.BaseFigure, vv.Axes)):
        raise ValueError("The given object is not a figure nor an axes.")
    
    # create recorder
    return Recorder(ob)    


if __name__ == '__main__':
    import time
    l = vv.plot([1,2,3,1,4])
    rec = vv.record(vv.gcf())
    for i in range(20):
        l.SetYdata([1+i/10.0, 2,3,1,4])
        vv.processEvents() # Process gui events
        time.sleep(0.1)
    # Export to swf, gif or avi
    fname = 'recordExample' # note: set location to an existing directory
    for ext in ['.swf', '.gif', '.avi']:
        try:
            rec.Export(fname+ext)
        except Exception:
            print('could not do %s' % ext)
Exemplo n.º 37
0
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

# Create colormap editor in first axes
cme = vv.ColormapEditor(vv.gcf(), *tt[3:])

# Run app
app.Create()
app.Run()
Exemplo n.º 38
0
def cluster_points(pp, c, pauseTime=0, showConvergeToo=True):
    """ cluster_points(pp, c, pauseTime=0) 
    
    Given a set of points, and the centreline position, this function 
    returns a set of points, which is a subset of pp. The returned pointset
    is empty on error.
    
    This algorithm uses the chopstick clustering implementation.
    
    The first step is the "stick" method. We take the closest point from the
    centre and attach one end of a stick to it. The stick has the length of
    the radius of the fitted circle. We rotate the stick counterclockwise
    untill it hits a point, or untill we rotate too far without finding a
    point, thus failing. When it fails, we try again with a slighly larger
    stick. This is to close gaps of up to almost 100 degrees. When we reach
    a point were we've already been, we stop. Afterwards, the set of points
    is sorted by angle.   
    
    In the second step we try to add points: we pick
    two subsequent points and check what other points are closer than "stick"
    to both these points, where "stick" is the distance between the points. We
    will break this stick in two and take the best point in the cluster, thus
    the name: chopstick. BUT ONLY if it is good enough! We draw two lines
    from the points under consideration to the centre. The angle that these
    two lines make is a reference for the allowed angle that the two lines
    may make that run from the two points to the new point. To be precise:
    ang > (180 - refang) - offset
    offset is a parameter to control the strictness. 
    
    The third part of this step consists of removing points. We will only
    remove points that are closer to the centre than both neighbours. We
    check each point, comparing it with its two neighbours on each side,
    applying the same criterion as  above. This will remove outliers that lie
    withing the stent, such as points found due to the contrast fluid...
    
    The latter two parts are repeated untill the set of points does not change.
    Each time the centre is recalculated by fitting a circle.
    
    """
    
    # Get better center
    if showConvergeToo:
        c, I = converge_to_centre(pp, c, pauseTime=pauseTime)
    else:
        c, I = converge_to_centre(pp, c)
    if not I:
        return Pointset(2)
    
    # Init list with vis objects (to be able to delete them)
    showObjects = []
    if pauseTime:
        fig = vv.gcf()
    
    # Short names
    pi = np.pi
    
    # Minimum and maximum angle that the stick is allowed to make with the line
    # to the circle-centre. Pretty intuitive...
    # it is a relative measure, we will multiply it with a ratio: 
    # radius/distance_current_point_to_radius. This allows ellipses to be
    # segmented, while remaining strict for circles.
    difAng1_p = 0.0*pi
    difAng2_p = 0.7*pi
    
    
    ## Step 1, stick method to find an initial set of points
    
    # Select start point (3th point returned by converge_to_centre)
    icurr = I[2]
    
    # Init list L, at the beginning only contains icurr
    L = [icurr]
    
    # Largest amount of iterations that makes sense. Probably the loop
    # exits sooner.
    maxIter = len(pp)
    
    # Enter loop
    for iter in range(maxIter):
        
        # We can think of it as fixing the stick at one end at the current
        # point and then rotating it in a direction such that a point is
        # found in the clockwise direction of the current point. We thus
        # need the angle between the next and current point to be not much
        # more than the angle between the current point and the circle
        # cenrre + 90 deg. But it must be larger than the angle between the
        # current point and the circle centre.
        
        # Calculate distances
        dists = pp.distance(pp[icurr])
        
        # Do the next bit using increasing stick length, untill success
        for stick in [c.r*1.0, c.r*1.5, c.r*2.0]:
            
            # Find subset of points that be "reached by the stick"
            Is, = np.where(dists<stick)
            
            # Calculate angle with circle centre
            refAng = c.angle2(pp[icurr])
            
            # Culcuate angles with points that are in reach of the stick
            angs = pp[Is].angle2(pp[icurr])
            
            # Select the points that are in the proper direction
            # There are TWO PARAMETERS HERE (one important) the second TH can
            # not be 0.5, because we allow an ellipse.
            # Use distance measure to make sure not to select the point itself.
            difAngs = subtract_angles(angs, refAng)
            difAng2 = difAng2_p # pp[icurr].distance(c) / c.r
            
            # Set current too really weid value
            icurr2, = np.where(Is==icurr)
            if len(icurr2):
                difAngs[icurr2] = 99999.0
            
            # Select. If a selection, we're good!
            II, = np.where( (difAngs > difAng1_p) + (difAngs < difAng2))
            if len(II):
                break
            
        else:
            # No success
            _objectClearer(showObjects)
            return Pointset(2)
        
        # Select the point with the smallest angle
        tmp = difAngs[II]
        inext, = np.where(tmp == tmp.min())
        
        # inext is index in subset. Make it apply to global set
        inext = Is[ II[ inext[0] ] ]
        inext = int(inext)
        
        # Show
        if pauseTime>0:
            # Delete
            _objectClearer(showObjects)
            # Show center
            ob1 = vv.plot(c, ls='', ms='x', mc='r', mw=10, axesAdjust=0)
            # Show all points
            ob2 = vv.plot(pp, ls='', ms='.', mc='g', mw=6, axesAdjust=0)
            # Show selected points L
            ob3 = vv.plot(pp[L], ls='', ms='.', mc='y', mw=10, axesAdjust=0)
            # Show next
            ob4 = vv.plot(pp[inext], ls='', ms='.', mc='r', mw=12, axesAdjust=0)
            # Show stick
            vec = ( pp[inext]-pp[icurr] ).normalize()
            tmp = Pointset(2)
            tmp.append(pp[icurr]); tmp.append(pp[icurr]+vec*stick)            
            ob5 = vv.plot(tmp, lw=2, lc='b')
            # Store objects and wait
            showObjects = [ob1,ob2,ob3,ob4,ob5]
            fig.DrawNow()
            time.sleep(pauseTime)
        
        
        # Check whether we completed a full round already 
        if inext in L:
            break
        else:
            L.append(inext)
        
        # Prepare for next round
        icurr = inext
    
    
    # Sort the list by the angles
    tmp = zip( pp[L].angle2(c), L )
    tmp.sort(key=lambda x:x[0])
    L = [i[1] for i in tmp]
    
    # Clear visualization
    _objectClearer(showObjects)
    
    
    ## Step 2 and 3, chopstick algorithm to find more points and discard outliers
    
    # Init
    L = [int(i) for i in L] # Make Python ints
    Lp = []
    round = 0
    
    # Iterate ...
    while Lp != L and round < 20:
        round += 1
        #print 'round', round
        
        # Clear list (but store previous)
        Lp = [i for i in L]
        L = []
        
        # We need at least three points
        if len(Lp)<3:
            _objectClearer(showObjects)
            print('oops: len(LP)<3' )
            return []
        
        # Recalculate circle
        c = fit_cirlce(pp[Lp], False)
        if c.r == 0.0:
            print('oops: c.r==0' )
            _objectClearer(showObjects)
            return []
        
        # Step2: ADD POINTS
        for iter in range(len(Lp)):
            
            # Current point
            icurr = Lp[iter]
            if iter < len(Lp)-1:
                inext = Lp[iter+1]
            else:
                inext = Lp[0]
            
            # Prepare, get p1 and p2
            p1 = pp[icurr]
            p2 = pp[inext]
            
            # Apply masks to points in pp
            M1, M2 = chopstick_criteria(c, p1, p2, pp)
            
            # Combine measures. I is now the subset (of p) of OK points
            I, = np.where(M1*M2)
            if not len(I):
                L.append(icurr)
                continue
            elif len(I)==1:
                ibetw = int(I)
            else:
                # Multiple candidates: find best match
                pptemp = pp[I]
                dists = p1.distance(pptemp) + p2.distance(pptemp)
                II, = np.where( dists==dists.min() )
                ibetw = int( I[II[0]] )
            
            # Add point            
            L.append(icurr)
            if not ibetw in L:
                L.append(ibetw)
            
            # Check
            assert ibetw not in [icurr, inext]
            
            # Draw
            if pauseTime>0:
                # Delete
                _objectClearer(showObjects)
                # Show center
                ob1 = vv.plot(c, ls='', ms='x', mc='r', mw=10, axesAdjust=0)
                # Show all points
                ob2 = vv.plot(pp, ls='', ms='.', mc='g', mw=6, axesAdjust=0)
                # Show selected points L
                ob3 = vv.plot(pp[L], ls='', ms='.', mc='y', mw=10, axesAdjust=0)
                # Show between and vectors
                ob4 = vv.plot(pp[ibetw], ls='', ms='.', mc='r', mw=12, axesAdjust=0)
                ob5 = vv.plot(pp[[icurr, ibetw, inext]], ls='-', lc='g', axesAdjust=0)
                ob6 = vv.plot(pp[[icurr, inext]], ls=':', lc='g', axesAdjust=0) 
                # Store objects and wait
                showObjects = [ob1,ob2,ob3,ob4,ob5,ob6]
                fig.DrawNow()
                time.sleep(pauseTime)
        
        # Lpp stores the set of points we have untill now, we will refill the
        # set L, maybe with less points
        Lpp = [int(i) for i in L]
        L = []
        
        # Step3: REMOVE POINTS 
        for iter in range(len(Lpp)):
            
            # Current point and neighbours
            ibetw = Lpp[iter]
            if iter<len(Lpp)-1:
                inext = Lpp[iter+1]
            else:
                inext = Lpp[0]
            if iter>0:
                icurr = Lpp[iter-1]
            else:
                icurr = Lpp[-1]
            
            # Test
#             print icurr, ibetw, inext
            assert ibetw not in [icurr, inext]
            
            # Prepare, get p1 and p2 and p3
            p1 = pp[icurr]
            p2 = pp[inext]
            p3 = pp[ibetw]
            
            # Apply masks to points in pp
            M1, M2 = chopstick_criteria(c, p1, p2, p3)
            M = M1*M2
            
            # Do we keep the point?           
            if M.sum():
                L.append(ibetw)
            
            # Draw
            if pauseTime>0 and not M.sum():
                # Delete
                _objectClearer(showObjects)
                # Show center
                ob1 = vv.plot(c, ls='', ms='x', mc='r', mw=10, axesAdjust=0)
                # Show all points
                ob2 = vv.plot(pp, ls='', ms='.', mc='g', mw=6, axesAdjust=0)
                # Show selected points L
                ob3 = vv.plot(pp[L], ls='', ms='.', mc='y', mw=10, axesAdjust=0)
                # Show between and vectors
                ob4 = vv.plot(pp[ibetw], ls='', ms='.', mc='r', mw=12, axesAdjust=0)
                ob5 = vv.plot(pp[[icurr, ibetw, inext]], ls='-', lc='r', axesAdjust=0)
                ob6 = vv.plot(pp[[icurr, inext]], ls='-', lc='g', axesAdjust=0)
                # Store objects and wait
                showObjects = [ob1,ob2,ob3,ob4,ob5,ob6]
                fig.DrawNow()
                time.sleep(pauseTime)
    
    
    # Done
    if round == 20:
        print('Warning: chopstick seemed not to converge.')
    _objectClearer(showObjects)
    #print 'cluster end', len(L)
    return pp[L]
Exemplo n.º 39
0
def showVolPhases(basedir, vols=None, ptcode=None, ctcode=None, cropname=None, 
    showVol='iso', mipIsocolor=False, isoTh=310,
            slider=False, clim=(0,3000), clim2D=(-550, 500), fname=None):
    """ Show vol phases in motion container
    showVol= mip or iso or 2D; Provide either vols or location
    """
    if vols is None:
        # Load volumes
        s = loadvol(basedir, ptcode, ctcode, cropname, 'phases', fname=fname)
        vols = []
        for key in dir(s):
            if key.startswith('vol'):
                vols.append(s[key])
        
    # Start vis
    f = vv.figure(1); vv.clf()
    f.position = 9.00, 38.00,  992.00, 944.00
    a = vv.gca()
    a.daspect = 1, 1, -1
    a.axis.axisColor = 1,1,1
    a.axis.visible = False
    a.bgcolor = 0,0,0
    if showVol=='mip':
        if not ptcode is None and not ctcode is None:
            vv.title('Maximum intensity projection cine-loop of the original ECG-gated CT volumes of patient %s at %s ' % (ptcode[8:], ctcode))
        else:
            vv.title('Maximum intensity projection cine-loop of the original ECG-gated CT volumes ')
    else:
        if not ptcode is None and not ctcode is None:
            vv.title('ECG-gated CT scan cine-loop of the original ECG-gated CT volumes of patient %s at %s ' % (ptcode[8:], ctcode))
        else:
            vv.title('ECG-gated CT scan cine-loop of the original ECG-gated CT volumes ')
    
    # Setup data container
    container = vv.MotionDataContainer(a)
    for vol in vols:
        if showVol == '2D':
            t = vv.volshow2(vol, clim=clim2D) # -750, 1000
            t.parent = container
        else:
            t = vv.volshow(vol, clim=clim, renderStyle = showVol)
            t.parent = container
            if showVol == 'iso':
                t.isoThreshold = isoTh    # iso or mip work well 
                t.colormap = {'r': [(0.0, 0.0), (0.17727272, 1.0)],
                            'g': [(0.0, 0.0), (0.27272728, 1.0)],
                            'b': [(0.0, 0.0), (0.34545454, 1.0)],
                            'a': [(0.0, 1.0), (1.0, 1.0)]}
            if mipIsocolor:
                t.colormap = {'r': [(0.0, 0.0), (0.17727272, 1.0)],
                            'g': [(0.0, 0.0), (0.27272728, 1.0)],
                            'b': [(0.0, 0.0), (0.34545454, 1.0)],
                            'a': [(0.0, 1.0), (1.0, 1.0)]}
    # bind ClimEditor to figure
    if slider:
        if showVol=='mip':
            c = vv.ClimEditor(vv.gcf())
            c.position = (10, 50)
            f.eventKeyDown.Bind(lambda event: _utils_GUI.ShowHideSlider(event, c) )
        if showVol=='iso':
            c = IsoThEditor(vv.gcf())
            c.position = (10, 50)
            f.eventKeyDown.Bind(lambda event: _utils_GUI.ShowHideSlider(event, c) )
    
    f.eventKeyDown.Bind(lambda event: _utils_GUI.ViewPresets(event, [a]) )
    print('------------------------')
    print('Use keys 1, 2, 3, 4 and 5 for preset anatomic views')
    print('Use v for a default zoomed view')
    print('Use x to show and hide axis')
    print('------------------------')
    
    return t
                               removeStent=removeStent,
                               showmodelavgreg=showmodelavgreg,
                               showvol=showvol,
                               phases=phases,
                               colors=colors,
                               meshWithColors=meshWithColors)
    vv.title('Model for LSPEAS %s  -  %s' % (ptcode[7:], ctcode3))
    axes.append(ax)

#bind view control
f.eventKeyDown.Bind(
    lambda event: _utils_GUI.RotateView(event, axes, axishandling=False))
f.eventKeyDown.Bind(lambda event: _utils_GUI.ViewPresets(event, axes))

## Set view
# a1.SetView(view1)
# a2.SetView(view2)
# a3.SetView(view3)

## Use same camera
#a1.camera = a2.camera = a3.camera
if False:
    a = vv.gca()
    a.camera = ax.camera

## Save figure
if False:
    vv.screenshot(r'D:\Profiles\koenradesma\Desktop\ZA3_phase90.jpg',
                  vv.gcf(),
                  sf=2)  #phantom validation manuscript
Exemplo n.º 41
0
    def __init__(self,
                 vol,
                 a_transversal,
                 a_coronal,
                 a_sagittal,
                 a_MIP,
                 a_text,
                 nr_of_stents,
                 clim=None):
        self.nr_of_stents = nr_of_stents
        self.f = vv.gcf()
        self.vol = vol

        # Create empty list of endpoints
        self.endpoints = []
        self.endpoints = ['xx,yy,zz'] * nr_of_stents * 2
        self.endpointsindex = 0

        # Create text objects
        self._labelcurrent = vv.Label(a_text)
        self._labelx = vv.Label(a_text)
        self._labelxslice = vv.Label(a_text)
        self._labely = vv.Label(a_text)
        self._labelyslice = vv.Label(a_text)
        self._labelz = vv.Label(a_text)
        self._labelzslice = vv.Label(a_text)
        self._labelcurrent.position = -250, 10
        self._labelx.position = -250, 35
        self._labelxslice.position = -200, 35
        self._labely.position = -250, 55
        self._labelyslice.position = -200, 55
        self._labelz.position = -250, 75
        self._labelzslice.position = -200, 75

        self._labelendpointstext = []
        self._labelendpointstext.append(vv.Label(a_text))
        self._labelendpointstext[0].position = 100, -5
        self._labelendpointstext.append(vv.Label(a_text))
        self._labelendpointstext[1].position = 230, -5
        for i in range(2, self.nr_of_stents + 2):
            self._labelendpointstext.append(vv.Label(a_text))
            self._labelendpointstext[i].position = 40, 15 + (20 * (i - 2))

        self._labelendpoints = []
        for i in range(0, self.nr_of_stents * 2, 2):
            self._labelendpoints.append(vv.Label(a_text))
            self._labelendpoints[i].position = 100, 15 + (20 * (i / 2)), 50, 20
            self._labelendpoints.append(vv.Label(a_text))
            self._labelendpoints[i + 1].position = 230, 15 + (20 *
                                                              (i / 2)), 50, 20

        # Create Select button
        self._select = False
        self._butselect = vv.PushButton(a_text)
        self._butselect.position = -110, 150
        self._butselect.text = 'Select'

        # Create Back button
        self._back = False
        self._butback = vv.PushButton(a_text)
        self._butback.position = 10, 150
        self._butback.text = 'Back'

        # Create Close button
        self._finished = False
        self._butclose = vv.PushButton(a_text)
        self._butclose.position = -50, 180
        self._butclose.text = 'Finish'

        # Get short name for sampling
        if isinstance(vol, Aarray):
            self._sam = sam = vol.sampling
        else:
            self._sam = None
            sam = (1, 1, 1)

        # Display the slices and 3D MIP
        self.b1 = VolViewer(vol, 0, axes=a_transversal, clim=clim)
        self.b2 = VolViewer(vol, 1, axes=a_coronal, clim=clim)
        self.b3 = VolViewer(vol, 2, axes=a_sagittal, clim=clim)

        renderstyle = 'mip'
        a_MIP.daspect = 1, 1, -1
        self.b4 = vv.volshow(vol,
                             clim=(0, 2500),
                             renderStyle=renderstyle,
                             axes=a_MIP)
        c = vv.ClimEditor(a_MIP)
        c.position = (10, 50)

        # set axis settings
        for a in [a_transversal, a_coronal, a_sagittal, a_MIP]:
            a.bgcolor = [0, 0, 0]
            a.axis.visible = False
            a.showAxis = True

        # get current slice number
        Zslice = self.b1.GetCurrentSlice()
        Yslice = self.b2.GetCurrentSlice()
        Xslice = self.b3.GetCurrentSlice()
        size = vol.shape

        # create lines for position of x,y and z slices
        origin = vol.origin
        Zrange = (origin[0], (size[0] * sam[0]) + origin[0])
        Xrange = (origin[1], (size[1] * sam[1]) + origin[1])
        Yrange = (origin[2], (size[2] * sam[2]) + origin[2])

        self.l11 = vv.Line(a_transversal, [(Yslice, Xrange[0]),
                                           (Yslice, Xrange[1])])
        self.l12 = vv.Line(a_transversal, [(Yrange[0], Xslice),
                                           (Yrange[1], Xslice)])

        self.l21 = vv.Line(a_coronal, [(Zslice, Zrange[0]),
                                       (Zslice, Zrange[1])])
        self.l22 = vv.Line(a_coronal, [(Yrange[0], Xslice),
                                       (Yrange[1], Xslice)])

        self.l31 = vv.Line(a_sagittal, [(Zslice, Zrange[0]),
                                        (Zslice, Zrange[1])])
        self.l32 = vv.Line(a_sagittal, [(Xrange[0], Yslice),
                                        (Xrange[1], Yslice)])

        # change color of the lines
        for i in [self.l11, self.l12, self.l21, self.l22, self.l31, self.l32]:
            i.lc = 'g'

        # create a point in the MIP figure for the current position
        self.mippoint = vv.Line(a_MIP, [(Zslice, Xslice, Yslice)])
        self.mippoint.ms = 'o'
        self.mippoint.mw = 5
        self.mippoint.mc = 'g'
        self.mippoint.alpha = 0.9

        # Get list of all range wobjects
        self._volviewers = [self.b1, self.b2, self.b3]

        # Bind events
        fig = a_text.GetFigure()
        fig.eventClose.Bind(self._OnFinish)
        self._butclose.eventPress.Bind(self._OnFinish)
        self._butselect.eventPress.Bind(self._OnSelect)
        self._butback.eventPress.Bind(self._OnBack)

        for r in self._volviewers:
            r.eventPositionUpdate.Bind(self._OnMouseClickAxis)
        for s in range(len(self._labelendpoints)):
            self._labelendpoints[s].eventMouseDown.Bind(
                self._OnMouseClickEndpoint)

        # Almost done
        self._SetTexts()
        self.updatePosition()
Exemplo n.º 42
0
and exported to gif/swf/avi.

This is not an interactive example, but a script.

"""

import visvis as vv

# Create something to show, let's show a red teapot!
mesh = vv.solidTeapot()
mesh.faceColor = 'r'

# Prepare
Nangles = 36
a = vv.gca()
f = vv.gcf()
rec = vv.record(a)

# Rotate camera
for i in range(Nangles):
    a.camera.azimuth = 360 * float(i) / Nangles
    if a.camera.azimuth>180:
        a.camera.azimuth -= 360
    a.Draw() # Tell the axes to redraw 
    f.DrawNow() # Draw the figure NOW, instead of waiting for GUI event loop


# Export
rec.Stop()
rec.Export('teapot.gif')
Exemplo n.º 43
0
vv.xlabel('x axis')
vv.ylabel('y axis')
vv.zlabel('z axis')

# show
print np.sum(data) 
t = vv.volshow(data,renderStyle='iso',axesAdjust=True)
#t.isoThreshold = 0.5
# try the differtent render styles, for examample 
# "t.renderStyle='iso'" or "t.renderStyle='ray'"
# If the drawing hangs, your video drived decided to render in software mode.
# This is unfortunately (as far as I know) not possible to detect. 
# It might help if your data is shaped a power of 2.

# Get axes and set camera to orthographic mode (with a field of view of 70)
a = vv.gcf()
f = vv.gca()#fqwang

#a.camera.fov = 45

# Create colormap editor wibject.
vv.ColormapEditor(a)

rec = vv.record(f)

# Rotate camera
#fqwang
Nangles = 36
for i in range(Nangles):
    f.camera.azimuth = 360 * float(i) / Nangles
    if f.camera.azimuth>180:
Exemplo n.º 44
0
    # Рисуем картинки
    plot_bg_image(image, z=j.start_level_value)
    ax = vv.gca()
    ax.bgcolor = (
        0.7, 0.7, 0.7
    )  # We draw path in white by default, so we need a dark background.
    ax.light0.position = (200, 200, 200, 0)
    # draw_arcs(ax, j.start_level_value * 1.01, color=(0.5, 0.5, 0.5))
    for path in long_normal_paths:
        if len(path) <= 3:
            # Для кубического сплайна нужно 4 точки.
            continue
        draw_smoothed_path(ax, path, radius=2, color=(1, 1, 1))
    # draw_critical_points(ax, 2, level=(j.start_level_value * 1.01), color=(1, 1, 1))
    # draw_critical_points(ax, 1, level=(j.start_level_value * 1.01), color=(1, 1, 1))
    # draw_critical_points(ax, 0, level=(j.start_level_value * 1.01), color=(1, 1, 1))
    # draw_top_points(ax, long_normal_paths, color=(1, 1, 1))

    # ax.camera.azimuth = 0.
    # ax.camera.elevation = 90.
    ax.camera.azimuth = 45.
    ax.camera.elevation = 30.
    ax.camera.daspect = (1, 1, 4)  # Увеличиваем масштаб по Z
    vv.gcf().relativeFontSize = 2.0

    # import time
    # print("Wait for rendering...")
    # time.sleep(30)
    # vv.screenshot(args.output, ob=ax)