def short_branches():
    """
    Visualization of short branches of the skeleton.
    
    """
    data1_sk = glob.glob('/backup/yuliya/vsi05/skeletons_largdom/*.h5')
    data1_sk.sort()

    for i,j, k in zip(d[1][37:47], data1_sk[46:56], ell[1][37:47]):
        g = nx.read_gpickle(i)
        dat = tb.openFile(j)
        skel = np.copy(dat.root.skel)
        bra = np.copy(dat.root.branches)
        mask = np.zeros_like(skel)    
        dat.close()
    
        length = nx.get_edge_attributes(g, 'length')
        number = nx.get_edge_attributes(g, 'number')
        num_dict = {}
        for m in number:
            for v in number[m]:
                num_dict.setdefault(v, []).append(m)
        find_br = ndimage.find_objects(bra)
        for l in list(length.keys()):
            if length[l]<0.5*k: #Criteria
                for b in number[l]:
                    mask[find_br[b-1]] = bra[find_br[b-1]]==b
        mlab.figure(bgcolor=(1,1,1), size=(1200,1200))
        mlab.contour3d(skel, colormap='hot')
        mlab.contour3d(mask)
        mlab.savefig('/backup/yuliya/vsi05/skeletons/short_bran/'+ i[42:-10] + '.png')
        mlab.close()
def vis_breakups():
    """
    This function allows to visualize break-ups as the highlighted branches in
    the original skeleton.
    """
    data_sk = glob.glob('/backup/yuliya/vsi05/skeletons_largdom/*.h5')
    data_sk.sort()
    
    data_br = glob.glob('/backup/yuliya/vsi05/breakups_con_correction/dict/*.npy')
    data_br.sort()
    
    for i,j in zip(data_sk[27:67][::-1], data_br[19:][::-1]):
        d = tb.openFile(i, mode='r')
        bran1 = np.copy(d.root.branches)
        skel1 = np.copy(d.root.skel)
        d.close() 

        br = np.load(j).item()
        
        mlab.figure(1, bgcolor=(1,1,1), size=(1200,1200))
        surf_skel = mlab.contour3d(skel1, colormap='hot')
        surf_skel.actor.property.representation = 'points'
        surf_skel.actor.property.line_width = 2.3
        mask = np.zeros_like(skel1)
        for k in br:
            sl = br[k]            
            mask[sl] = (bran1[sl] == k)
        surf_mask = mlab.contour3d(mask.astype('uint8'))
        surf_mask.actor.property.representation = 'wireframe'
        surf_mask.actor.property.line_width = 5
        
        mlab.savefig('/backup/yuliya/vsi05/breakups_con_correction/video_hot/' + i[39:-3] + '.png')
        mlab.close()
Exemple #3
0
def view_thresholdedT(design, contrast, threshold, inequality=np.greater):
    """
    A mayavi isosurface view of thresholded t-statistics

    Parameters
    ----------
    design : {'block', 'event'}
    contrast : str
    threshold : float
    inequality : {np.greater, np.less}, optional
    """
    maska = np.asarray(MASK)
    tmap = np.array(load_image_fiac('group', design, contrast, 't.nii'))
    test = inequality(tmap, threshold)
    tval = np.zeros(tmap.shape)
    tval[test] = tmap[test]

    # XXX make the array axes agree with mayavi2
    avganata = np.array(AVGANAT)
    avganat_iso = mlab.contour3d(avganata * maska, opacity=0.3, contours=[3600],
                               color=(0.8,0.8,0.8))

    avganat_iso.actor.property.backface_culling = True
    avganat_iso.actor.property.ambient = 0.3

    tval_iso = mlab.contour3d(tval * MASK, color=(0.8,0.3,0.3),
                            contours=[threshold])
    return avganat_iso, tval_iso
Exemple #4
0
def visual_test1():
    
    poly = polygon_gaussian_density(3)
    #s = mlab.contour3d(poly)
    #mlab.show()
    
    grid_dimesions = poly.shape
    grid_center = np.array(grid_dimesions) / 2.0
    radii = np.arange(2.0, 10.0)
    L_max = 25
    
    shg = SphHarmGrid(grid_dimesions, grid_center, radii, L_max)
    
    coeff = shg(poly)
    reconstructed_poly = shg.expand_sph_harm(coeff)
    
    print 'magnitudes'
    print 'real:', np.sum(np.abs(reconstructed_poly.real)), 'imag:', np.sum(np.abs(reconstructed_poly.imag))
    
    poly  /= poly.sum()
    rpoly  = np.abs(reconstructed_poly)
    rpoly /= rpoly.sum()
    
    err = np.sum( np.abs(poly - rpoly) / float(np.product(grid_dimesions)) )
    print "Reconstruction error:", err
    
    print 'showing model'
    s1 = mlab.contour3d(rpoly)
    mlab.show()
    
    print 'showing error'
    s2 = mlab.contour3d(rpoly - poly)
    mlab.show()
    
    return
Exemple #5
0
def test3():
    import numpy as np
    from mayavi import mlab
    sdf = np.load('/Users/yue/data/segment/sdf_diff_3d_1/imseg_iter_100.npz')['sdf']
    mlab.contour3d(sdf[0], contours=[0])
    # mlab.savefig('/Users/yue/data/segment/sdf_diff_3d_1/imseg_iter_100.png')
    mlab.show()
Exemple #6
0
 def showContour(self):
     """
     Display real space model using contour
     """
     mlab.contour3d(self.array, contours=8, opacity=0.3, transparent=True)
     mlab.outline()
     mlab.show()
Exemple #7
0
def show_scatterer(scatterer, spacing=None):
    mlab = import_mayavi()
    if spacing == None:
        # if no spacing given, represent the object with 100 voxels
        # along each dimension
        spacing = [(b[1]-b[0])/100 for b in scatterer.bounds]
    vol = scatterer.voxelate(spacing, 0)
    mlab.contour3d(vol)
	def plot_LAM_contours(self, readfile):
		if self.LAMgauss == None:
	 		print "Reading file..."
	 		self.LAMgauss = self.load_data(readfile)

	 	print "Plotting..."
		mlab.contour3d(self.LAMgauss, contours = 75, opacity=0.10)
		mlab.show()
Exemple #9
0
 def plotParcels(self, brain, label = None, contourVals = [], opacity = 0.5, cmap='autumn'):
     ''' plot an isosurface using Mayavi, almost the same as skull plotting '''
     
     if not(label):
         label = self.getAutoLabel()        
     
     if contourVals == []:            
         self.isosurfacePlots[label] = mlab.contour3d(brain.parcels, opacity = opacity, colormap=cmap)
     else:
         self.isosurfacePlots[label] = mlab.contour3d(brain.parcels, opacity = opacity, contours = contourVals, colormap=cmap)
def plot(ply):
    '''
    Plot vertices and triangles from a PlyData instance. Assumptions:
        `ply' has a 'vertex' element with 'x', 'y', and 'z'
            properties;

        `ply' has a 'face' element with an integral list property
            'vertex_indices', all of whose elements have length 3.

    '''
    vertex = ply['vertex']

    (x, y, z) = (vertex[t] for t in ('x', 'y', 'z'))

    # mlab.points3d(x, y, z, color=(1, 1, 1), mode='point')

    if 'face' in ply:
        tri_idx = ply['face']['vertex_indices']
        print type(tri_idx)
        idx_dtype = tri_idx[0].dtype
        print "idx_dtype" , idx_dtype
        triangles = numpy.fromiter(tri_idx, [('data', idx_dtype, (3,))],
                                   count=len(tri_idx))['data']
        k = triangles.byteswap()
        # p.from_array(numpy.array([[1,2,3],[3,4,5]], dtype=numpy.float32))
        p.from_array((triangles.byteswap().newbyteorder().astype('<f4')))
        # p1.add_points_from_input_cloud()
        p1.set_input_cloud(p)
        fil = p.make_statistical_outlier_filter()
        # cloud_filtered = fil.filter()
        # fil = p1.make_statistical_outlier_filter()
        fil.set_mean_k(20)
        fil.set_std_dev_mul_thresh(0.1)
        pointx = triangles[:,0]

       

        pc_1 = pcl.PointCloud()
        pc_1 = p
        pc_2 = pcl.PointCloud()
        pc_2 = p
        kd = pcl.KdTreeFLANN(pc_1)
        print('pc_1:')
        print type(triangles)
        # file1 = open("values.txt",'w')
        # file1.write(str(triangles[:]))

        # mlab.mesh(x,y,z)
        print numpy.shape(p)
        print numpy.shape(z)
        print numpy.shape(y)
        print numpy.shape(x)
        mlab.contour3d(x, y, z, p)
Exemple #11
0
	def show_fitting(self, depth_image, offsets, model_transform):
		v, u = np.nonzero(depth_image != 0)
		depth = depth_image[(v,u)]/1000.0
		
		points = np.vstack([depth*(u+offsets[0]), depth*(v+offsets[1]), depth])
		
		model_points = np.dot(d.K_default_inv, points)
		model_points = np.vstack([model_points, np.ones_like(model_points[0])])
		transformed_points = np.dot(inv(model_transform), model_points)[0:3,:]
		
		mlab.contour3d(self.x/self.scale[0], self.y/self.scale[1], self.z/self.scale[2], self.sdf, contours=[0.05], opacity=0.5)
		mlab.points3d(transformed_points[0], transformed_points[1], transformed_points[2], color=(1,0,0), mode='point')
		mlab.show()
Exemple #12
0
 def plotIsosurface(self, brain, label = None, contourVals = [], opacity = 0.1, cmap='autumn'):
     ''' plot an isosurface using Mayavi, almost the same as skull plotting '''
     
     if not(label):
         label = self.getAutoLabel()        
     
     if contourVals == []:            
         s = mlab.contour3d(brain.iso, opacity = opacity, colormap=cmap)
     else:
         s = mlab.contour3d(brain.iso, opacity = opacity, contours = contourVals, colormap=cmap)
         
     # get the object for editing
     self.isosurfacePlots[label] = s
Exemple #13
0
 def plotBackground(self, brain, label = None, contourVals = [3000,9000], opacity = 0.1, cmap='Spectral'):
     ''' plot the skull using Mayavi '''
     
     if not(label):
         label = self.getAutoLabel()        
     
     if contourVals == []:            
         s = mlab.contour3d(brain.background, opacity = opacity, colormap=cmap)
     else:
         s = mlab.contour3d(brain.background, opacity = opacity, contours = contourVals, colormap=cmap)
         
     # get the object for editing
     self.skullPlots[label] = s
Exemple #14
0
def plot_volume(nifti_file,v_color=(.98,.63,.48),v_opacity=.1, fliplr=False, newfig=False):
    """
    Render a volume from a .nii file
    Use fliplr option if scan has radiological orientation
    """
    import nibabel as nib
    if newfig:
        mlab.figure(bgcolor=(1, 1, 1), size=(400, 400))
    input = nib.load(nifti_file)
    input_d = input.get_data()
    d_shape = input_d.shape
    if fliplr:
        input_d = input_d[range(d_shape[0]-1,-1,-1), :, :]
    mlab.contour3d(input_d, color=v_color, opacity=v_opacity) # good natural color is (.98,.63,.48)
Exemple #15
0
    def plotSkull(self, brain, label = None, contourVals = [], opacity = 0.1, cmap='Spectral'):
        ''' plot the skull using Mayavi '''
      
        if not(label):
            label = self.getAutoLabel()        

        # remove old version        
        if not(label in self.skullPlots):
            self.skullPlots[label].remove()
        
        if contourVals == []:            
            self.skullPlots[label] = mlab.contour3d(brain.background, opacity = opacity, colormap=cmap)
        else:
            self.skullPlots[label] = mlab.contour3d(brain.background, opacity = opacity, contours = contourVals, colormap=cmap)
def calc():
    """
    The function that implements break-ups detection algorithm and
    write the data in a file. Input skeletons and graphs must correspond each
    other.
    """
    
    #input graphs
    data_gr = glob.glob('/path/graphs_largedom/*_1.gpickle')
    data_gr.sort()

    #input skeletons
    data_sk = glob.glob('/path/skeletons_largedom/*.h5')
    data_sk.sort()

    for i, j, w in zip(data_gr[:-1][::-1], data_sk[:-1][::-1], data_sk[1:][::-1]):
        g = nx.read_gpickle(i)

        #We simplify the graph
        g1 = remove_terminal_br(g)
        g1 = remove_nodes(g1)
        
        #We use labeled branches arrays, skeletons, distans transfrom. All are of the same shape.
        d = tb.openFile(j, mode='r')
        bran1 = np.copy(d.root.branches1)
        skel1 = np.copy(d.root.skel) #this 'current' skeletons are used only for visualization.
        thick = np.copy(d.root.dist)
        d.close()
        
        #Skeletons shifted in time by one step.
        d = tb.openFile(w, mode='r')
        skel2 = np.copy(d.root.skel)
        d.close()
        
        b, pos = branches_map(g1, skel2, bran1, thick)
        
        #Visualization of break-ups if necessary.
        mlab.figure(1, bgcolor=(1,1,1), size=(1500,1500))
        mlab.contour3d(skel1, colormap='hot')
        mask = np.zeros_like(skel1)
        for k in b:
            sl = b[k]            
            mask[sl] = (bran1[sl] == k)
        mlab.contour3d(mask.astype('uint8'))
        
        np.save('/path/breakups/' + j[41:-3] + '_1.npy', b)  #j[41:-3] must be replaced according to the path
        np.save('/path/breakups/' + j[41:-3] + '_pos.npy', pos)
        mlab.savefig('/path/breakups/' + j[41:-3] + '_1.png')
        mlab.close()
Exemple #17
0
def make3dHist(data):
    # n, m, l = data.shape
    # results = np.zeros((n*l,3))
    # for i in range(n):
    #     for j in range(m):
    #         results[i*l:(i+1)*l,j] = data[i,j,:]

    # H, edges = np.histogramdd(results, bins = (100,100,100))
    # print H.shape
    # data = earthSpherify(data)
    mlab.contour3d(data)
    data = data / np.max(data) * 3.74
    print "Still fine"
    mlab.pipeline.volume(mlab.pipeline.scalar_field(data))
    mlab.show()
Exemple #18
0
    def plotIsosurface(self, brain, label=None, contourVals=[], opacity=0.1, cmap="autumn"):
        """ plot an isosurface using Mayavi, almost the same as skull plotting """

        if not (label):
            label = self.getAutoLabel()

        if label in self.isosurfacePlots:
            self.isosurfacePlots[label].remove()

        if contourVals == []:
            self.isosurfacePlots[label] = mlab.contour3d(brain.iso, opacity=opacity, colormap=cmap)
        else:
            self.isosurfacePlots[label] = mlab.contour3d(
                brain.iso, opacity=opacity, contours=contourVals, colormap=cmap
            )
Exemple #19
0
def visual_test2():
    """
    Compute and display expansions of sparse spherical harmonic function.
    """
    
    grid_dimesions = (30, 30, 30)
    grid_center = np.array(grid_dimesions) / 2.0
    radii = np.arange(2.0, 10.0)
    L_max = 25
    
    shg = SphHarmGrid(grid_dimesions, grid_center, radii, L_max)
    
    r = 7
    for ell in range(1,5):
         sparse = np.zeros((shg.num_radii, shg.L_max, 2 * shg.L_max + 1))
         
         m = 1
         sparse[r,ell,m] = 1.0
         #sparse[3,ell,m] = 1.0
         
         sph_harm = shg.expand_sph_harm(sparse)
         print 'plotting l=%d, m=%d || %s' % (ell, m, str(sph_harm.shape))
         
         plot_grid = np.zeros_like(sph_harm.real)
         plot_grid[ sph_harm.real > 1e-6 ] = 1.0
         plot_grid[ sph_harm.real < -1e-6 ] = -1.0
         
         s = mlab.contour3d( plot_grid, contours=5, line_width=1.0,
                             transparent=True )
         mlab.show()
    
    return
def plot_isosurface(crystal):
    filename = './output/potentialfield.txt'
    data = np.genfromtxt(filename, delimiter='\t')
    size = np.round((len(data))**(1/3))
    X = np.reshape(data[:,0], (size,size,size))
    Y = np.reshape(data[:,1], (size,size,size))
    Z = np.reshape(data[:,2], (size,size,size))
    DeltaU = np.reshape(data[:,3], (size,size,size))
    average = np.average(crystal.coordinates[:,0])
    start = average - crystal.a
    end = average + crystal.a
    coords1 = np.array([[start, start, start]])
    coords2 = np.array([[end, end, end]])
    array1 = np.repeat(coords1,len(crystal.coordinates),axis=0)
    array2 = np.repeat(coords2,len(crystal.coordinates),axis=0)
    basefilter1 = np.greater(crystal.coordinates,array1)
    basefilter2 = np.less(crystal.coordinates,array2)
    basefilter = np.nonzero(np.all(basefilter1*basefilter2, axis=1))
    base = crystal.coordinates[basefilter]   

    mlab.figure(bgcolor=(1, 1, 1), fgcolor=(1, 1, 1), size=(2048,2048))
    dataset = mlab.contour3d(X, Y, Z, DeltaU, contours=[3.50],color=(1,0.25,0))
    scatter = mlab.points3d(base[:,0], 
                            base[:,1], 
                            base[:,2],
                            color=(0.255,0.647,0.88),
                            resolution=24, 
                            scale_factor=1.0, 
                            opacity=0.40)
    mlab.view(azimuth=17, elevation=90, distance=10, focalpoint=[average,average-0.2,average])
    mlab.draw()
    savename = './output/3Dpotential.png'
    mlab.savefig(savename, size=(2048,2048))
    mlab.show()
def showDsweep():
    k_s_sweep = [10**(x-5) for x in range(10)]
    sl_div_diam_sweep = [5.0*(x+1)/1000 for x in range(20)]
    vol_ratio_sweep = [5.0*(x+1)/100 for x in range(10)]    
    
    Dmsd = numpy.load(data_dir + "/D_numpy.npy")
    kDa = 1.660538921e-30;
    mass = 40.0*kDa; 
    viscosity = 8.9e-4; 
    diameter = 5e-9; 
    T = 300.0; 
    Dbase = k_b*T/(3.0*numpy.pi*viscosity*diameter);
    Dmsd = Dmsd/Dbase
    
    mlab.figure(1, size=(800, 800), fgcolor=(1, 1, 1),
                                    bgcolor=(0.5, 0.5, 0.5))
    mlab.clf()
    contours = numpy.arange(0.01,2,0.2).tolist()
    obj = mlab.contour3d(Dmsd,contours=contours,transparent=True,vmin=contours[0],vmax=contours[-1])
    outline = mlab.outline(color=(.7, .7, .7),extent=(0,10,0,20,0,10))
    axes = mlab.axes(outline, color=(.7, .7, .7),
            nb_labels = 5,
            ranges=(k_s_sweep[0], k_s_sweep[-1], sl_div_diam_sweep[0], sl_div_diam_sweep[-1], vol_ratio_sweep[0], vol_ratio_sweep[-1]), 
            xlabel='spring stiffness', 
            ylabel='step length',
            zlabel='volume ratio')
    mlab.colorbar(obj,title='D',nb_labels=5)

    mlab.show()
def vortexCylinder(): #VERTICAL STACK OF 2D FIELDS....3D FIELD
    """
    """
    from vortexCore import vortexCore2
    from lambda2 import lambda2_3d
    
    gamma = 1 #strength of the vortex.
    Rcore = 18 #radious of the vortex core.
    s = 20 #size parameter of the field x*y points.
    h = 3 #min is 1
    q = N.array([[0,0,0]]) #point where the vortex will be located
    
    [z,y,x] = N.mgrid[0:1,-s:s+1, -s:s+1]
    [Z,Y,X] = N.mgrid[-h:h+1,-s:s+1, -s:s+1]
    [W,V,U] = N.zeros_like([Z,Y,X],dtype=float)
    for i in range(len(Z)):
        #vortexCore2(X,Y,C,Rcore,gamma):
        [U_temp,V_temp] = vortexCore2(x[0],y[0],q,Rcore,gamma)
        
        U[i]=U_temp
        V[i]=V_temp
    
    L2 = lambda2_3d(X,Y,Z,U,V,W)
    #print L2[3]
    #vF=mlab.quiver3d(Z,Y,X,W,V,U)
    Lamda2 = mlab.contour3d(Z,Y,X,L2,transparent=True)
    mlab.show()
    return
Exemple #23
0
def plotIsosurface(figure, values, variables, contour_value=0.0001, color=(0,0,1)):
    from mayavi import mlab
    x, y, z = variables
    if isinstance(color, str):
        color = {'blue': (0,0,1), 'red':(1,0,0)}[color]
    surf = mlab.contour3d(x,y,z,values, contours=[contour_value], color=color)

    return mlab
def demo(smoothed = False):
    from mayavi import mlab
    from mayavi.mlab import points3d, contour3d, plot3d
    
    random.seed(0)
    Nw = 15
    xx, yy = randomSphereSampleMatrix(Nw = Nw, Nsamples = 50)

    indexX, indexY, indexZ = mgrid[0:Nw,0:Nw,0:Nw]

    cubeEdges = array([[0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0],
                       [0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0],
                       [0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1]])
    cubeEdges *= Nw

    for ii in range(10):
        fig = mlab.gcf()
        #fig.scene.disable_render = True

        mlab.clf(fig)
        #from tvtk.api import tvtk
        #fig.scene.interactor.interactor_style = tvtk.InteractorStyleTerrain()
        #mlab.clf()
        plot3d(cubeEdges[0,:], cubeEdges[1,:], cubeEdges[2,:], color=(.5,.5,.5),
               line_width = 0,
               representation = 'wireframe',
               opacity = 1)
        thisShape = xx[ii,:]
        if smoothed:
            contour3d(reshape(thisShape, (Nw,Nw,Nw)), contours=[.5], color=(1,1,1))
        else:
            points3d(indexX.flatten()[thisShape > 0],
                     indexY.flatten()[thisShape > 0],
                     indexZ.flatten()[thisShape > 0],
                     ones(sum(thisShape > 0)) * .9,
                     color = (1,1,1),
                     mode = 'cube',
                     scale_factor = 1.0)

        mlab.view(57.15, 75.55, 50.35, (7.5, 7.5, 7.5)) # nice view

        filename = 'test_%02d.png' % ii
        mlab.savefig(filename)    #, size=(800,800))

        if raw_input('Saved %s, enter to continue (q to quit)...' % filename) == 'q':
            return
def void(i, figure, show = False):
    datos2 = np.copy(datos)
    datos2[datos!=i] = 0
    contour = mlab.contour3d(datos2, contours=2)
    #mlab.pipeline.volume(mlab.pipeline.scalar_field(datos), vmin=0)
    if show:
	mlab.show()
    return contour
Exemple #26
0
def scatter_contour(nodes,vals,**kwargs):
  pts = 100j
  xmin,xmax = np.min(nodes[:,0]),np.max(nodes[:,0])
  ymin,ymax = np.min(nodes[:,1]),np.max(nodes[:,1])
  zmin,zmax = np.min(nodes[:,2]),np.max(nodes[:,2])
  x,y,z = np.mgrid[xmin:xmax:pts, ymin:ymax:pts, zmin:zmax:pts]
  f = griddata(nodes, vals, (x,y,z),method='linear')
  p = mlab.contour3d(x,y,z,f,**kwargs)
  mlab.colorbar(p)
Exemple #27
0
def mayavi_demo2():
  
    """
    This function is a practice for the mayavi package in python
    """
    # function
    x = np.linspace(-10,10,100)
    y = np.linspace(-10,10,100)
    z = x*np.sin(x)*np.sin(y)
    
    # mayavi plot
    mlab.figure(1,bgcolor=(1, 1, 1), fgcolor=(0, 0, 0))
    mlab.contour3d(x,y,z)
    mlab.axes(extent=[-10,10,-10,10,-10,10], \
                  x_axis_visibility=False, \
                  y_axis_visibility=False, \
                  z_axis_visibility=False)
    mlab.move(1,0,0)  
    mlab.show()
Exemple #28
0
def plot_path(points, rock):
    path_rock = np.ones(rock.shape)
    for (x, y, z) in points:
        path_rock[x][y][z] = 0
    @mlab.animate
    def anim():
        f = mlab.gcf()
        while 1:
            f.scene.camera.azimuth(1)
            f.scene.render()
            yield
                
    mlab.figure(bgcolor=(1,1,1)) # Set bkg color
    mlab.contour3d(rock, 
                   color = (0,0,0),
                   contours = 2,
                   opacity = .2 + .8/rock.shape[0]) # Draw pores for 3d, changed froo .20 * 100 / self.shape[0]
    mlab.contour3d(path_rock)
    a = anim()
Exemple #29
0
def topographyFrom3D(
        data,
        contour_value=None,
        z_range=None,
        ):
    from mayavi import mlab
    values, xyz = data
    x, y, z = xyz
    values = values.copy()
    value_max = np.max(values, axis=(0,1))
    value_min = np.min(values, axis=(0,1))
    valid_span =  value_max.min(), value_min.max()
    if contour_value is None:
        if valid_span[0] > valid_span[1]:
            contour_value = valid_span[0]
        else:
            contour_value = np.exp(np.log(valid_span).mean())

    if not z_range is None:
        take_max = value_max > contour_value
        take_min = value_min < contour_value
        arg_shift = take_max.sum() - 1
        zmax = z[0, 0, arg_shift + 1]
        zmin = z[0, 0, arg_shift] - z_range

        take = z < zmin
        values[take] = 2*contour_value
        take = z > zmax
        values[take] = 0

    surf = mlab.contour3d(x,y,z, values, contours=[contour_value])
    surface_points = contourToArray(surf)
    x, y, z = surface_points

    if not z_range is None:
        maxi = z.max()
        mini = maxi - z_range

        take1 = z > mini
        take2 = z < maxi
        take = np.logical_and(take1, take2)
        surface_points = surface_points[:,take]

    xi = np.linspace(x.min(), x.max(), 4000)
    yi = np.linspace(y.min(), y.max(), 4000)
    x, y, z = surface_points
    if len(z) > 100:
        zi = griddata((x, y), z, (xi[None,:], yi[:,None]), method='cubic')
    else:
        zi = None
    zi[zi > zmax] = zmax
    zi[np.isnan(zi)] = (zmax + zmin)/2.0

    return (xi, yi, zi), (zmin, zmax)
Exemple #30
0
	def surface3d(self,filename,times=2):
		_times = times
		dot_index = filename.find('.mat')
		_filename = filename[0:dot_index]
		pmat = sciMat.loadmat(_filename+'.mat')
		da = np.tile(pmat['ADens'],[_times,_times,_times])
		db = np.tile(pmat['BDens'],[_times,_times,_times])
		d = da.shape
		dim = (d[0]+2,d[1]+2,d[2]+2)
		dA = np.zeros((dim[0],dim[1],dim[2]))
		dB = np.zeros((dim[0],dim[1],dim[2]))

		dA[1:-1,1:-1,1:-1] = np.tile(pmat['ADens'],[_times,_times,_times])
		dB[1:-1,1:-1,1:-1] = np.tile(pmat['BDens'],[_times,_times,_times])

		sX, sY, sZ = float(pmat['sizeZ']), \
				float(pmat['sizeY']), \
				float(pmat['sizeX'])

		X = np.zeros((dim[0],dim[1],dim[2]))
		Y = np.zeros((dim[0],dim[1],dim[2]))
		Z = np.zeros((dim[0],dim[1],dim[2]))

		x,y,z = np.arange(0,dim[0]),np.arange(0,dim[1]),np.arange(0,dim[2])
		x = sX * _times / dim[0] * x
		y = sY * _times / dim[1] * y
		z = sZ * _times / dim[2] * z

		for (i,j) in np.ndindex(dim[1],dim[2]):
			X[:,i,j] = x
		for (i,j) in np.ndindex(dim[0],dim[2]):
			Y[i,:,j] = y
		for (i,j) in np.ndindex(dim[0],dim[1]):
			Z[i,j,:] = z

# 		mlab.engine.current_scene.scene.off_screen_rendering = True
#		mlab.options.offscreen = True
		mlab.clf()
		mlab.contour3d(X,Y,Z,dB,color=self.c_r,contours=self.cont)	
		mlab.contour3d(X,Y,Z,dA,color=self.c_g,contours=self.cont)	
		mlab.savefig(_filename+'.png')
Exemple #31
0
    def modb_on_surface(self,
                        s=1,
                        ntheta=64,
                        nphi=64,
                        plot=True,
                        show=False,
                        outxyz=None,
                        full=False,
                        alpha=1,
                        mayavi=True):
        #first attempt will use trisurface, let's see how it looks
        r = np.zeros([nphi, ntheta])
        z = np.zeros([nphi, ntheta])
        x = np.zeros([nphi, ntheta])
        y = np.zeros([nphi, ntheta])
        b = np.zeros([nphi, ntheta])

        if full:
            divval = 1
        else:
            divval = self.nfp

        theta = np.linspace(0, 2 * np.pi, num=ntheta)
        phi = np.linspace(0, 2 * np.pi / divval, num=nphi)

        for phii in range(nphi):
            p = phi[phii]
            for ti in range(ntheta):
                th = theta[ti]
                r[phii, ti] = self.r_at_point(s, th, p)
                z[phii, ti] = self.z_at_point(s, th, p)
                x[phii, ti] += r[phii, ti] * np.cos(p)
                y[phii, ti] += r[phii, ti] * np.sin(p)
                b[phii, ti] = self.modb_at_point(s, th, p)

        my_col = cm.jet((b - np.min(b)) / (np.max(b) - np.min(b)))

        if plot and (not use_mayavi or not mayavi):
            fig = plt.figure()
            ax = fig.add_subplot(111, projection='3d')
            #my_col = cm.jet((b-np.min(b))/(np.max(b)-np.min(b)))

            ax.plot_surface(x, y, z, facecolors=my_col, norm=True, alpha=alpha)
            #set axis to equal
            max_range = np.array(
                [x.max() - x.min(),
                 y.max() - y.min(),
                 z.max() - z.min()]).max() / 2.0

            mid_x = (x.max() + x.min()) * 0.5
            mid_y = (y.max() + y.min()) * 0.5
            mid_z = (z.max() + z.min()) * 0.5
            ax.set_xlim(mid_x - max_range, mid_x + max_range)
            ax.set_ylim(mid_y - max_range, mid_y + max_range)
            ax.set_zlim(mid_z - max_range, mid_z + max_range)

            if show:
                plt.show()

        elif plot and use_mayavi and mayavi:
            mlab.figure(bgcolor=(1.0, 1.0, 1.0), size=(800, 600))
            mlab.contour3d(x, y, z, b)
            if show:
                mlab.show()

        if outxyz is not None:
            wf = open(outxyz, 'w')
            for phii in range(nphi):
                for ti in range(ntheta):
                    s = (str(x[phii, ti]) + '\t' + str(y[phii, ti]) + '\t' +
                         str(z[phii, ti]) + '\n')
                    wf.write(s)
        return [x, y, z, b]
rangesize=100
boxes=100j

VX, VY, VZ = np.mgrid[-rangesize:rangesize:boxes, -rangesize:rangesize:boxes, -rangesize:rangesize:boxes]
positions = np.vstack([VX.ravel(), VY.ravel(), VZ.ravel()])
dens = np.reshape(np.exp(kde_fit.score_samples(positions.T)), VX.shape)

binsize = 2*rangesize/(boxes.imag)
w = int(boxes.imag/2)

#Visualize the density estimate as isosurfaces
figure = mlab.figure('myfig')
figure.scene.disable_render = True # Super duper trick
#mlab.contour3d(VX, VY, VZ, dens, contours=[0.25*10**-5,0.5*10**-5,1*10**-5,2*10**-5,2.5*10**-5,3*10**-5], opacity=0.3, colormap = 'Blues', figure = figure)
mlab.contour3d(VX, VY, VZ, dens, contours=[0.1*10**-4,0.5*10**-4,1*10**-4,1.5*10**-4,2*10**-4,2.5*10**-4], opacity=0.3, vmin=np.min(dens), vmax=np.max(dens), colormap = 'Reds', figure = figure)
mlab.axes(xlabel='U (km/s)', ylabel='V (km/s)', zlabel='W (km/s)', nb_labels = 3, figure = figure)
#mlab.quiver3d(x, y, z, vx, vy, vz)

#mlab.axes(extent = [-650, 650, -650, 650, -650, 650], ranges = [-650, 650, -650, 650, -650, 650], nb_labels = 7, figure = figure)
#mlab.points3d(vx, vy, vz, np.full(len(vx),1), scale_factor = 1, color=(1,1,1), figure = figure)
mlab.points3d(vx_OD1, vy_OD1, vz_OD1, np.full(len(x_OD1),1), scale_factor = 1, color=(0,1,0), figure = figure)
mlab.points3d(vx_OD2, vy_OD2, vz_OD2, np.full(len(x_OD2),1), scale_factor = 1, color=(0,0,1), figure = figure)
#mlab.points3d(vx_OD3, vy_OD3, vz_OD3, np.full(len(x_OD3),1), scale_factor = 1, color=(0,0,1), figure = figure)
#mlab.points3d(vx_OD4, vy_OD4, vz_OD4, np.full(len(x_OD4),1), scale_factor = 1, color=(1,1,1), figure = figure)
figure.scene.disable_render = False # Super duper trick
mlab.show()

"""
fig, axs = plt.subplots(1, 3, sharey=True, tight_layout=True)
Exemple #33
0
def plotData3DContour(a):
    mlab.contour3d(a,contours=4, transparent=True, vmin=0.2, vmax=0.8)
Exemple #34
0
z = np.append(z, df2['Center of Mass (Bounding box): Z (px)'])
zmax = np.amax(z)
zmin = np.amin(z)
z = (z-zmin)/(zmax-zmin)

values = np.array([x, y, z])

kde = stats.gaussian_kde(values)

xmin, ymin, zmin = values.T.min(axis=0)
xmax, ymax, zmax = values.T.max(axis=0)

xi, yi, zi = np.mgrid[xmin:xmax:70j, ymin:ymax:70j, zmin:zmax:70j]

coords = np.vstack([item.ravel() for item in [xi, yi, zi]])
density = kde(coords).reshape(xi.shape)

print (np.amin(density), np.amax(density))


#maxid = np.where(density == np.amax(density))
#maxid = np.argmax(density)
#print (coords.shape, maxid)

#Characterstics of contour plot
mlab.contour3d(xi, yi, zi, density, contours=20, vmin=0, vmax=15,
               opacity=0.4)
mlab.axes()
mlab.show()

Exemple #35
0
data=np.random.multivariate_normal(mu,sigma,1000)
values = data.T

kde = stats.gaussian_kde(values)

# Create a regular 3D grid with 50 points in each dimension
xmin, ymin, zmin = data.min(axis=0)
xmax, ymax, zmax = data.max(axis=0)
xi, yi, zi = np.mgrid[xmin:xmax:50j, ymin:ymax:50j, zmin:zmax:50j]

# Evaluate the KDE on a regular grid...
coords = np.vstack([item.ravel() for item in [xi, yi, zi]])
density = kde(coords).reshape(xi.shape)

# Visualize the density estimate as isosurfaces
mlab.contour3d(xi, yi, zi, density, opacity=0.5)
mlab.axes()
mlab.show()

# Pickling shiz
import cPickle
with open(r"/media/chet/hdd/seismic/NZ/clustering/nlloc_dets_Sherburn_km_mat.npy", 'rb') as f:
    dist_mat = cPickle.load(f)

with open(r"/media/chet/hdd/seismic/NZ/clustering/nlloc_dets_Sherburn_linkage.npy", 'wb') as f:
    cPickle.dump(Z, f)

catN = []
catS = []
for i, ev in enumerate(catalog):
    if ev.preferred_origin().latitude < -38.580367:
Exemple #36
0
        random_state=42,
        metric="euclidean",
        output_metric=torus_euclidean_grad,
        init="spectral",
        min_dist=0.15,  # requires adjustment since the torus has limited space
        verbose=True,
    ).fit(X_train)

    mlab.clf()
    x, y, z = np.mgrid[-3:3:50j, -3:3:50j, -3:3:50j]

    # Plot a torus
    R = 2
    r = 1
    values = (R - np.sqrt(x ** 2 + y ** 2)) ** 2 + z ** 2 - r ** 2
    mlab.contour3d(x, y, z, values, color=(1.0, 1.0, 1.0), contours=[0])

    # torus angles -> 3D
    x = (R + r * np.cos(trans.embedding_[:, 0])) * np.cos(trans.embedding_[:, 1])
    y = (R + r * np.cos(trans.embedding_[:, 0])) * np.sin(trans.embedding_[:, 1])
    z = r * np.sin(trans.embedding_[:, 0])

    pts = mlab.points3d(
        x, y, z, y_train, colormap="spectral", scale_mode="none", scale_factor=0.1
    )

    mlab.show()

if "sphere" in target_spaces:
    # embed onto a sphere
    trans = umap.UMAP(
Exemple #37
0
        # 计算哪个小球被选取
        point_id = int(picker.point_id / glyph_points.shape[0])  # int向下取整
        if point_id != -1:  # 如果没有小球被选取,则point_id = -1
            # 找到与此红色小球相关的坐标
            x, y, z = x1[point_id], y1[point_id], z1[point_id]
            # 将外框移到小球上
            outline.bounds = (x - 0.1, x + 0.1,
                              y - 0.1, y + 0.1,
                              z - 0.1, z + 0.1)


picker = figure.on_mouse_pick(picker_callback)
mlab.title('Click on red balls')
mlab.show()
'''
'''
x, y, z = np.ogrid[-10:10:20j, -10:10:20j, -10:10:20j]
s = np.sin(x*y*z)/(x*y*z)

mlab.contour3d(s)
mlab.show()
'''
'''
mlab.pipeline.image_plane_widget(mlab.pipeline.scalar_field(s), plane_orientation='x_axes', slice_index=10,)
mlab.pipeline.image_plane_widget(mlab.pipeline.scalar_field(s),plane_orientation='y_axes', slice_index=10,)
mlab.outline()
'''
'''
x, y, z = np.ogrid[-10:10:20j, -10:10:20j, -10:10:20j]
s = np.sin(x * y * z) / (x * y * z)
Exemple #38
0
"""
===============
Fermi surface
===============

"""

from mayavi import mlab
from fplore import FPLORun

run = FPLORun("../example_data/yrs")
level_indices = run.band.bands_at_energy()
energy_data = run.band.data['e'][..., level_indices]

axes, grid_idx = run.band.reshape_gridded_data()
data = energy_data[grid_idx]  # reshape to grid

mlab.figure()

for i, level_idx in enumerate(level_indices):
    mlab.contour3d(data[..., i], contours=[0], opacity=0.4)

mlab.show()
Exemple #39
0

def configure_logger():
    root_logger = logging.getLogger()
    root_logger.setLevel(logging.INFO)
    handler = logging.StreamHandler()
    formatter = logging.Formatter(
        fmt='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
    handler.setFormatter(formatter)
    root_logger.addHandler(handler)


def download_array(blob: storage.Blob) -> np.ndarray:
    in_stream = io.BytesIO()
    blob.download_to_file(in_stream)
    in_stream.seek(0)  # Read from the start of the file-like object
    return np.load(in_stream)


if __name__ == '__main__':
    configure_logger()
    client = storage.Client(project='elvo-198322')
    bucket = storage.Bucket(client, name='elvos')

    in_blob: storage.Blob
    for in_blob in bucket.list_blobs(prefix='numpy/'):
        logging.info(f'downloading {in_blob.name}')
        arr = download_array(in_blob)
        mlab.contour3d(arr)
        mlab.show()
Exemple #40
0
def contour3d(isovalues,
              colors,
              fid=1,
              atoms=None,
              data=None,
              box=None,
              origin=None,
              filename=None):
    mlab.figure(bgcolor=(0, 0, 0), size=(350, 350))
    #mlab.clf()
    if filename is not None:
        fobj = open(filename, 'r')
        dt = aic.read_cube(fobj, read_data=True)
        atoms, origin, data = [dt[key] for key in ['atoms', 'origin', 'data']]
        box = atoms.cell
    else:
        assert atoms is not None
        assert data is not None
        assert box is not None
        if len(box.shape) == 1:
            _box = np.eye(3)
            _box[np.diag_indices_from(_box)] = box
            box = _box
        if origin is None: origin = np.zeros(3)

    _zs = atoms.numbers
    na = len(_zs)
    # get bonds
    newm = RawMol(_zs, atoms.positions)
    newm.connect()
    bonds = [ list(edge) for edge in \
                np.array( list( np.where(np.triu(newm.g)>0) ) ).T ]

    box0 = np.zeros((3, 3))
    box0[np.diag_indices_from(box0)] = np.diag(box)
    assert np.all(box0 == box), '#ERROR: not a cubic box?'

    grids = data.shape
    scales = np.array(data.shape) / np.diag(box)
    scale_av = np.mean(scales)

    # rescale the position of the atoms
    _coords = np.array([(atoms.positions[i] - origin) * scales
                        for i in range(na)])

    nzs = []
    zsu = []
    coords = []
    for i, zi in enumerate(_zs):
        if zi in zsu:
            idx = zsu.index(zi)
            coords[idx] += [_coords[i]]
        else:
            zsu.append(zi)
            coords.append([_coords[i]])
    nzu = len(zsu)

    objs = []
    for i in range(nzu):
        Z = zsu[i]
        coords_i = coords[i]
        ox, oy, oz = list(map(np.array, zip(*coords_i)))
        ai = mlab.points3d(ox,
                           oy,
                           oz,
                           scale_factor=covalent_radii[Z] * scale_av,
                           resolution=20,
                           color=tuple(cpk_colors[Z]))
        objs.append(ai)

    # The bounds between the atoms, we use the scalar information to give
    # color
    for bond in bonds:
        coords_b = _coords[bond]
        ox, oy, oz = list(map(np.array, zip(*coords_b)))
        obj = mlab.plot3d(ox,
                          oy,
                          oz, [1, 2],
                          tube_radius=0.05 * scale_av,
                          color=(0.5, 0.5, 0.5))
        objs.append(obj)
    for i, val in enumerate(isovalues):
        color = dc[colors[i]]
        obj = mlab.contour3d(data, contours=[val], opacity=0.25,
                             color=color)  #(1,0,0))
        objs.append(obj)
    objs.append(obj)

    # https://gitlab.com/chaffra/ase/blob/master/ase/visualize/mlab.py
    # Do some tvtk magic in order to allow for non-orthogonal unit cells:
    #polydata = obj.actor.actors[0].mapper.input
    #pts = np.array(polydata.points) - 1
    # Transform the points to the unit cell:
    #polydata.points = np.dot(pts, box / np.array(data.shape)[:, np.newaxis])

    #mlab.axes(x_axis_visibility=True) #,y_axis_visibility=True)
    #mlab.axes(xlabel='X', ylabel='Y', zlabel='Z') #Display axis
    obj = mlab.orientation_axes()
    objs.append(obj)

    return objs[0]
    def plot(self, labels=False, show=True):
        '''
        This function plots 2D and 3D models
        :param labels:
        :param show: If True, the plots are displayed at the end of this call. If False, plt.show() should be called outside this function
        :return:
        '''
        if self.k == 3:
            import mayavi.mlab as mlab

            predictFig = mlab.figure(figure='predict')
            errorFig = mlab.figure(figure='error')
            if self.testfunction:
                truthFig = mlab.figure(figure='test')
            dx = 1
            pts = 25j
            X, Y, Z = np.mgrid[0:dx:pts, 0:dx:pts, 0:dx:pts]
            scalars = np.zeros(X.shape)
            errscalars = np.zeros(X.shape)
            for i in range(X.shape[0]):
                for j in range(X.shape[1]):
                    for k1 in range(X.shape[2]):
                        errscalars[i][j][k1] = self.predicterr_normalized(
                            [X[i][j][k1], Y[i][j][k1], Z[i][j][k1]])
                        scalars[i][j][k1] = self.predict_normalized(
                            [X[i][j][k1], Y[i][j][k1], Z[i][j][k1]])

            if self.testfunction:
                tfscalars = np.zeros(X.shape)
                for i in range(X.shape[0]):
                    for j in range(X.shape[1]):
                        for k1 in range(X.shape[2]):
                            tfplot = tfscalars[i][j][k1] = self.testfunction(
                                [X[i][j][k1], Y[i][j][k1], Z[i][j][k1]])
                plot = mlab.contour3d(tfscalars,
                                      contours=15,
                                      transparent=True,
                                      figure=truthFig)
                plot.compute_normals = False

            # obj = mlab.contour3d(scalars, contours=10, transparent=True)
            plot = mlab.contour3d(scalars,
                                  contours=15,
                                  transparent=True,
                                  figure=predictFig)
            plot.compute_normals = False
            errplt = mlab.contour3d(errscalars,
                                    contours=15,
                                    transparent=True,
                                    figure=errorFig)
            errplt.compute_normals = False
            if show:
                mlab.show()

        if self.k == 2:

            fig = pylab.figure(figsize=(8, 6))
            samplePoints = zip(*self.X)
            # Create a set of data to plot
            plotgrid = 61
            x = np.linspace(self.normRange[0][0],
                            self.normRange[0][1],
                            num=plotgrid)
            y = np.linspace(self.normRange[1][0],
                            self.normRange[1][1],
                            num=plotgrid)

            # x = np.linspace(0, 1, num=plotgrid)
            # y = np.linspace(0, 1, num=plotgrid)
            X, Y = np.meshgrid(x, y)

            # Predict based on the optimized results

            zs = np.array([
                self.predict([x, y]) for x, y in zip(np.ravel(X), np.ravel(Y))
            ])
            Z = zs.reshape(X.shape)
            # Z = (Z*(self.ynormRange[1]-self.ynormRange[0]))+self.ynormRange[0]

            #Calculate errors
            zse = np.array([
                self.predict_var([x, y])
                for x, y in zip(np.ravel(X), np.ravel(Y))
            ])
            Ze = zse.reshape(X.shape)

            spx = (self.X[:, 0] * (self.normRange[0][1] - self.normRange[0][0])
                   ) + self.normRange[0][0]
            spy = (self.X[:, 1] * (self.normRange[1][1] - self.normRange[1][0])
                   ) + self.normRange[1][0]
            contour_levels = 25

            ax = fig.add_subplot(222)
            CS = pylab.contourf(X, Y, Ze, contour_levels)
            pylab.colorbar()
            pylab.plot(spx, spy, 'ow')

            ax = fig.add_subplot(221)
            if self.testfunction:
                # Setup the truth function
                zt = self.testfunction(np.array(zip(np.ravel(X), np.ravel(Y))))
                ZT = zt.reshape(X.shape)
                CS = pylab.contour(X,
                                   Y,
                                   ZT,
                                   contour_levels,
                                   colors='k',
                                   zorder=2)

            # contour_levels = np.linspace(min(zt), max(zt),50)
            if self.testfunction:
                contour_levels = CS.levels
                delta = np.abs(contour_levels[0] - contour_levels[1])
                contour_levels = np.insert(contour_levels, 0,
                                           contour_levels[0] - delta)
                contour_levels = np.append(contour_levels,
                                           contour_levels[-1] + delta)

            CS = plt.contourf(X, Y, Z, contour_levels, zorder=1)
            pylab.plot(spx, spy, 'ow', zorder=3)
            pylab.colorbar()

            ax = fig.add_subplot(212, projection='3d')
            # fig = plt.gcf()
            #ax = fig.gca(projection='3d')
            ax.plot_surface(X, Y, Z, rstride=3, cstride=3, alpha=0.4)
            if self.testfunction:
                ax.plot_wireframe(X, Y, ZT, rstride=3, cstride=3)
            if show:
                pylab.show()
import numpy as np
from mayavi import mlab
from scpy2.tvtk import fix_mayavi_bugs
fix_mayavi_bugs()

x, y, z = np.ogrid[-2:2:40j, -2:2:40j, -2:0:40j]
s = 2/np.sqrt((x-1)**2 + y**2 + z**2) + 1/np.sqrt((x+1)**2 + y**2 + z**2)

surface = mlab.contour3d(s, contours=4, transparent=True)
surface.contour.maximum_contour = 15
surface.contour.number_of_contours = 10
surface.actor.property.opacity = 0.4
mlab.figure()

mlab.pipeline.volume(mlab.pipeline.scalar_field(s))
mlab.figure()

field = mlab.pipeline.scalar_field(s)
mlab.pipeline.volume(field, vmin=1.5, vmax=10)
cut = mlab.pipeline.scalar_cut_plane(field.children[0], plane_orientation="y_axes")
cut.enable_contours = True
cut.contour.number_of_contours = 40
mlab.gcf().scene.background = (0.8, 0.8, 0.8)
mlab.show()
Exemple #43
0
        mlab.points3d(interp_coords[0],
                      interp_coords[1],
                      u,
                      scale_factor=.8,
                      color=(1, 0, 0))
        mlab.show()
        mlab.close()

    if example3D is True:
        ''' 3D plot '''
        import os
        os.environ['ETS_TOOLKIT'] = 'qt4'
        os.environ['QT_API'] = 'pyqt'
        from mayavi import mlab
        # random field instance
        rf = RandomField(distr_type='Gauss',
                         lacor_arr=np.array([5.0, 4.0, 2.0]),
                         nDgrid=[
                             np.linspace(0.0, 20., 20),
                             np.linspace(0.0, 30., 30),
                             np.linspace(0.0, 40., 40)
                         ])
        rand_field_3D = rf.random_field
        x, y, z = rf.nDgrid
        cx, cy, cz = np.mgrid[x[0]:x[-1]:complex(0, len(x)),
                              y[0]:y[-1]:complex(0, len(y)),
                              z[0]:z[-1]:complex(0, len(z))]
        mlab.contour3d(cx, cy, cz, rand_field_3D, contours=7, transparent=True)
        mlab.show()
        mlab.close()
Exemple #44
0
import sdf
import numpy as np
import constant as const
from mayavi import mlab
data = sdf.read('Documents/data/2800.sdf', dict=True)
var1 = data['Electric Field/Ey'].data
bz = var1
k_bz = np.fft.fft(bz, axis=0)
delta_k = 3.14 / const.delta_x / (const.Nx / 2)
k_bz2 = k_bz * 1
k_n = []
for n in range(0, const.Nx):
    mi = 3e8 / 0.1e12  #limit_min
    ma = 3e8 / 10e12  #limit_max
    if 2 * 3.14 / ma > n * delta_k and n * delta_k > 2 * 3.14 / mi:
        k_n.append(n)
k_bz2[0:k_n[0], :, :] = 0  #k_bz.argmin()
k_bz2[k_n[-1]:-k_n[-1], :, :] = 0  #k_bz.argmin()
k_bz2[-k_n[0]:, :, :] = 0  #k_bz.argmin()
var1 = np.fft.ifft(k_bz2, axis=0).real
mlab.contour3d(var1)
mlab.show()
Exemple #45
0
                                                         ) * v / 2.0 + rho
g1 = lambda rho, u, v: epsilon * (a * (1 - u) - eta(rho + 1))
g2 = lambda rho, u, v: epsilon * (b * (1 - v) - eta(rho - 1))
# Initial conditions
u[0] = 0.8
v[0] = 0.8
rho[0] = -0.1

for i in range(T - 1):
    rho[i + 1] = rho[i] + h * f(rho[i], u[i], v[i])
    u[i + 1] = u[i] + h * g1(rho[i], u[i], v[i])
    v[i + 1] = v[i] + h * g2(rho[i], u[i], v[i])
    time[i + 1] = time[i] + h

ux, vx, rhox = np.mgrid[-1:2:50j, -1:2:50j, -1.5:1.5:50j]
values = -rhox**3 - (rhox + 1.0) * ux / 2.0 - (rhox - 1.0) * vx / 2.0 + rhox
mlab.contour3d(ux, vx, rhox, values, contours=[0], opacity=0.5)
mlab.axes()
mlab.xlabel('u')
mlab.ylabel('v')
mlab.zlabel('rho')
mlab.plot3d(u, v, rho, tube_radius=0.02, line_width=2.0)

print('Mean u: ', np.mean(u))
print('Mean v: ', np.mean(v))

plt.plot(time, u, label='u')
plt.plot(time, v, label='v')
plt.legend()
plt.show(block=False)
mlab.show()
# plot 3D isosurface (perspective view) #
#########################################
grid_qx, grid_qz, grid_qy = np.mgrid[0:2 * z_pixel_FOV * voxel_size:voxel_size,
                                     0:2 * y_pixel_FOV * voxel_size:voxel_size,
                                     0:2 * x_pixel_FOV * voxel_size:voxel_size]
extent = [
    0, 2 * z_pixel_FOV * voxel_size, 0, 2 * y_pixel_FOV * voxel_size, 0,
    2 * x_pixel_FOV * voxel_size
]
# in CXI convention, z is downstream, y vertical and x outboard

myfig = mlab.figure(bgcolor=(1, 1, 1), fgcolor=(0, 0, 0))
mlab.contour3d(grid_qx,
               grid_qz,
               grid_qy,
               amp[numz // 2 - z_pixel_FOV:numz // 2 + z_pixel_FOV,
                   numy // 2 - y_pixel_FOV:numy // 2 + y_pixel_FOV,
                   numx // 2 - x_pixel_FOV:numx // 2 + x_pixel_FOV],
               contours=[threshold_isosurface],
               color=(0.7, 0.7, 0.7))
mlab.view(
    azimuth=0, elevation=50, distance=3 *
    field_of_view[0])  # azimut is the rotation around z axis of mayavi (x)
mlab.roll(0)

ax = mlab.axes(extent=extent,
               line_width=2.0,
               nb_labels=int(1 + field_of_view[0] / tick_spacing))
mlab.savefig(homedir + 'S' + str(scan) + '-perspective_labels.png',
             figure=myfig)
ax.label_text_property.opacity = 0.0
ax.title_text_property.opacity = 0.0
Exemple #47
0
    def saveFigure(self, name=None):
        '''
        Similar to plot, except that figures are saved to file
        :param name: the file name of the plot image
        '''
        if self.k == 3:
            import mayavi.mlab as mlab

            mlab.options.offscreen = True
            predictFig = mlab.figure(figure='predict')
            mlab.clf(figure='predict')
            errorFig = mlab.figure(figure='error')
            mlab.clf(figure='error')
            if self.testfunction:
                truthFig = mlab.figure(figure='test')
                mlab.clf(figure='test')
            dx = 1
            pts = 75j
            X, Y, Z = np.mgrid[0:dx:pts, 0:dx:pts, 0:dx:pts]
            scalars = np.zeros(X.shape)
            errscalars = np.zeros(X.shape)
            for i in range(X.shape[0]):
                for j in range(X.shape[1]):
                    for k1 in range(X.shape[2]):
                        errscalars[i][j][k1] = self.predicterr_normalized(
                            [X[i][j][k1], Y[i][j][k1], Z[i][j][k1]])
                        scalars[i][j][k1] = self.predict_normalized(
                            [X[i][j][k1], Y[i][j][k1], Z[i][j][k1]])

            if self.testfunction:
                tfscalars = np.zeros(X.shape)
                for i in range(X.shape[0]):
                    for j in range(X.shape[1]):
                        for k1 in range(X.shape[2]):
                            tfscalars[i][j][k1] = self.testfunction(
                                [X[i][j][k1], Y[i][j][k1], Z[i][j][k1]])
                mlab.contour3d(tfscalars,
                               contours=15,
                               transparent=True,
                               figure=truthFig,
                               compute_normals=False)

            # obj = mlab.contour3d(scalars, contours=10, transparent=True)
            pred = mlab.contour3d(scalars,
                                  contours=15,
                                  transparent=True,
                                  figure=predictFig)
            pred.compute_normals = False
            errpred = mlab.contour3d(errscalars,
                                     contours=15,
                                     transparent=True,
                                     figure=errorFig)
            errpred.compute_normals = False
            mlab.savefig('%s_prediction.wrl' % name, figure=predictFig)
            mlab.savefig('%s_error.wrl' % name, figure=errorFig)
            if self.testfunction:
                mlab.savefig('%s_actual.wrl' % name, figure=truthFig)
            mlab.close(all=True)
        if self.k == 2:
            samplePoints = list(zip(*self.X))
            # Create a set of data to plot
            plotgrid = 61
            x = np.linspace(0, 1, num=plotgrid)
            y = np.linspace(0, 1, num=plotgrid)
            X, Y = np.meshgrid(x, y)

            # Predict based on the optimized results

            zs = np.array([
                self.predict_normalized([x, y])
                for x, y in zip(np.ravel(X), np.ravel(Y))
            ])
            Z = zs.reshape(X.shape)
            Z = (
                Z *
                (self.ynormRange[1] - self.ynormRange[0])) + self.ynormRange[0]

            # Calculate errors
            zse = np.array([
                self.predicterr_normalized([x, y])
                for x, y in zip(np.ravel(X), np.ravel(Y))
            ])
            Ze = zse.reshape(X.shape)

            if self.testfunction:
                # Setup the truth function
                zt = self.testfunction(
                    np.array(
                        list(
                            zip(
                                np.ravel((X * (self.normRange[0][1] -
                                               self.normRange[0][0])) +
                                         self.normRange[0][0]),
                                np.ravel((Y * (self.normRange[1][1] -
                                               self.normRange[1][0])) +
                                         self.normRange[1][0])))))
                ZT = zt.reshape(X.shape)

            # Plot real world values
            X = (X * (self.normRange[0][1] - self.normRange[0][0])
                 ) + self.normRange[0][0]
            Y = (Y * (self.normRange[1][1] - self.normRange[1][0])
                 ) + self.normRange[1][0]
            spx = (self.X[:, 0] * (self.normRange[0][1] - self.normRange[0][0])
                   ) + self.normRange[0][0]
            spy = (self.X[:, 1] * (self.normRange[1][1] - self.normRange[1][0])
                   ) + self.normRange[1][0]
            fig = plt.figure(figsize=(8, 6))
            # contour_levels = np.linspace(min(zt), max(zt),50)
            contour_levels = 15
            plt.plot(spx, spy, 'ow')
            cs = plt.colorbar()

            if self.testfunction:
                pass
            plt.plot(spx, spy, 'ow')

            cs = plt.colorbar()
            plt.plot(spx, spy, 'ow')

            ax = fig.add_subplot(212, projection='3d')
            ax.plot_surface(X, Y, Z, rstride=3, cstride=3, alpha=0.4)

            if self.testfunction:
                ax.plot_wireframe(X, Y, ZT, rstride=3, cstride=3)
        if name:
            plt.savefig(name)
        else:
            plt.savefig('pyKrigingResult.png')
Exemple #48
0
#!/usr/bin/env mayavi2

import numpy as np


def V(x, y, z):
    """ A 3D sinusoidal lattice with a parabolic confinement. """
    return np.cos(10 * x) + np.cos(10 * y) + np.cos(
        10 * z) + 2 * (x**2 + y**2 + z**2)


X, Y, Z = np.mgrid[-2:2:100j, -2:2:100j, -2:2:100j]
V(X, Y, Z)

from mayavi import mlab
mlab.contour3d(X, Y, Z, V)


def gradient(f, x, y, z, d=0.01):
    """ Return the gradient of f in (x, y, z). """
    fx = f(x + d, y, z)
    fx_ = f(x - d, y, z)
    fy = f(x, y + d, z)
    fy_ = f(x, y - d, z)
    fz = f(x, y, z + d)
    fz_ = f(x, y, z - d)
    return (fx - fx_) / (2 * d), (fy - fy_) / (2 * d), (fz - fz_) / (2 * d)


Vx, Vy, Vz = gradient(V, X[50, ::3, ::3], Y[50, ::3, ::3], Z[50, ::3, ::3])
mlab.quiver3d(X[50, ::3, ::3],
Exemple #49
0
    with open(interpfn, 'rb') as fn:
        egrid = pkl.load(fn)

# Plot the result
if method == 'scatter':
    # Draw the energy as scatterplot
    plt.scatter3d()
elif method == 'isosurfaces':
    print 'plotting isosurfaces...'
    maxe = np.max(egrid.ravel())
    levels = [maxe, 0.5 * maxe, 0.25 * maxe] 
    
    size = sz_from_resolution(args.resolution)
    print 'size = ', size
    fig = mlab.figure(fgcolor=(0,0,0), bgcolor=(1,1,1), size=size)
    mlab.contour3d(egrid, transparent=True) # , contours=levels)
    
    # exp = tvtk.GL2PSExporter(file_format='pdf', sort='bsp', compress=1)
    # fig.scene.save_gl2ps(fnfig + '.pdf', exp)

    # Sideview
    # mlab.view(45, 70, 100.0)
    mlab.savefig(fnfig + '_' + str(int(args.resolution)) + '_trans.png', magnification='auto') 
    
    fig = mlab.figure(fgcolor=(0,0,0), bgcolor=(1,1,1), size=size)
    mlab.contour3d(egrid, transparent=False) # , contours=levels)
    # mlab.view(45, 70, 100.0)
    mlab.savefig(fnfig + '_' + str(int(args.resolution)) + '.png', magnification='auto') 
    
    # size = sz_from_resolution(600)
    # mlab.savefig(fnfig + '_600.png', magnification='auto', size=size)
Exemple #50
0
rmax = np.amax(rhof)
rmin = np.amin(rhof)

x = np.linspace(0., dsizex, ncel_pic, endpoint=False)
y = np.linspace(0., dsizey, ncel_pic, endpoint=False)
z = np.linspace(0., dsizez, ncel_pic, endpoint=False)

Y, X, Z = np.meshgrid(x, y, z)

## Generate 3D contour plot of final density with Mayavi ##
mlab.figure(bgcolor=(1, 1, 1), fgcolor=(0, 0, 0), size=(1024, 768))
mlab.contour3d(X,
               Y,
               Z,
               rhof / np.mean(rhof),
               contours=32,
               opacity=.5,
               colormap='jet',
               vmax=np.amax(rhof) / np.mean(rhof),
               vmin=np.amin(rhof) / np.mean(rhof))
mlab.colorbar(orientation='vertical')
mlab.view(azimuth=30, elevation=60, distance='auto')
mlab.axes()
mlab.savefig('MayaviFrames/Cyclotron3D_nc' + str(ncx) + '_nppc' +
             str(N_per_sparse_cell) + '_final.png',
             size=(640, 480))

mlab.show()

plt.show()
Exemple #51
0
import math

cell_size = mp.Vector3(2, 2, 2)

geometry = [  #mp.Block(center=mp.Vector3(0,0,0), size=cell_size, material=mp.air),
    mp.Ellipsoid(material=mp.metal,
                 size=mp.Vector3(2, 0.5, 0.5),
                 e1=mp.Vector3(1, 1, 1),
                 e2=mp.Vector3(-1, 1, -1),
                 e3=mp.Vector3(-2, 1, 1))
]

sim = mp.Simulation(resolution=50, cell_size=cell_size, geometry=geometry)

sim.init_sim()

eps_data = sim.get_epsilon()
#eps_data = sim.get_array()

#sim.plot3D(eps_data)

#from mayavi import mlab
#s = mlab.contour3d()
#mlab.show()
#mlab.savefig(filename='test2.png')

from mayavi import mlab
s = mlab.contour3d(eps_data, colormap="hsv")
#mlab.show()
mlab.savefig('Ellipsoid3D.pdf')
Exemple #52
0
        x, y = sur.ParamGrid()
        ax.scatter(x, y, s=2)
        plt.show()

    else:
        sur = Hemisphere()
        c = CoarseGrid(sur)
        g = c.grid(40, [-2, -2, -2], [2, 2, 2])
        b = c.bandwidth(3., 1.)
        mask = c.mask(g, b)
        c.build_index_mappers(mask)
        fig = mlab.figure()
        scalars = np.ones_like(mask, dtype=np.int)
        scalars[mask] = 2.
        s = mlab.points3d(g[0].ravel(),
                          g[1].ravel(),
                          g[2].ravel(),
                          scalars.ravel(),
                          scale_factor=0.01,
                          transparent=True)
        s = mlab.contour3d(g[0],
                           g[1],
                           g[2],
                           scalars,
                           opacity=0.7,
                           contours=2,
                           color=(0.2, 0.2, 0.2))
        x, y, z = sur.ParamGrid()
        s2 = mlab.mesh(x, y, z, color=(0.2, 0.8, 0.2))
        mlab.show()
Exemple #53
0
def show_contour(img):
    from mayavi import mlab
    mlab.contour3d(img, colormap='gray')