Esempio n. 1
0
def plot_data_lines(lidar, results=None, offset=None, cells=None, intensity=None):
    """
    Plot point cloud and boundaries
    @return: None
    """
    fig = plt.figure()
    plt.set_cmap('rainbow')
    plt.title("Final Product")
    ax = fig.add_subplot(111, projection='3d')  #, axisbg='black')
    # colors = (lidar[ELE] / lidar[ELE].max()) * 255
    colors = lidar[INT] #/255.
    ax.scatter(lidar[LAT], lidar[LONG], zs=lidar[ELE], zdir='z', marker='+', c=colors, s=1)
    ax.set_xlabel('X Label')
    ax.set_ylabel('Y Label')
    ax.set_zlabel('Z Label')

    m = np.std(lidar[ELE])

    print lidar[LAT].max(), lidar[LONG].max()

    inter_results = grid_to_map_lines(cells, offset, results)
    for line in inter_results:
        xc1, xc2, yc1, yc2, zc1, zc2 = line[0][0],line[0][1],line[1][0],line[1][1],line[2][0],line[2][1]
        ax.plot([xc1, xc2], [yc1, yc2], zs=[zc1+m, zc2+m], zdir='z')
    # plt.savefig("demo.png")

    plt.show()
    return inter_results
def plot_band_array(band_array,refl_extent,colorlimit,ax=plt.gca(),title='',cbar ='on',cmap_title='',colormap='spectral'):
    
    '''plot_band_array reads in and plots a single band of a reflectance array
    --------
    Parameters
    --------
        band_array: flightline array of reflectance values, created from h5refl2array function
        refl_extent: extent of reflectance data to be plotted (xMin, xMax, yMin, yMax) - use metadata['extent'] from h5refl2array function
        colorlimit: range of values to plot (min,max). Best to look at the histogram of reflectance values before plotting to determine colorlimit.
        ax: optional, default = current axis
        title: string, optional; plot title
        cmap_title: string, optional; colorbar title
        colormap: string, optional; see https://matplotlib.org/examples/color/colormaps_reference.html for list of colormaps
    --------
    Returns 
    --------
        plots flightline array of single band of reflectance data
    --------
    See Also
    --------
    plot_subset_band:
        plots a subset of a full flightline reflectance band array 
    Example:
    --------
    plot_band_array(SERC_b56_clean,sercRefl_md['extent'],(0,0.3),ax,title='SERC Band 56 Reflectance',cmap_title='Reflectance',colormap='spectral') ''' 
    
    plot = plt.imshow(band_array,extent=refl_extent,clim=colorlimit); 
    if cbar == 'on':
        cbar = plt.colorbar(plot,aspect=40); plt.set_cmap(colormap); 
        cbar.set_label(cmap_title,rotation=90,labelpad=20)
    plt.title(title); ax = plt.gca(); 
    ax.ticklabel_format(useOffset=False, style='plain'); #do not use scientific notation #
    rotatexlabels = plt.setp(ax.get_xticklabels(),rotation=90); #rotate x tick labels 90 degrees
Esempio n. 3
0
def findall2(all_trees,all_files):
    #show 10 candidates    
    k=10    
    for files in all_files:
        for f in files:
            temp={'ds':[],'ids':[],'files':[]}
            fsg=getHash3(f)
            for tree in all_trees:
                ds,ids=tree.query(fsg,k)
                temp['ds'].append(ds)
                temp['ids'].append(ids)
                temp['files'].append(files) 
            
            id_sort=np.argsort(temp['ds'])
            sort_d=temp['ds'][id_sort[0:k]]
            sort_ids=temp['ids'][id_sort[0:k]]
            sort_files=temp['files'][id_sort[0:k]]
            plt.figure(1)  
            for i in xrange(k):
                print "%03d dis: %.3f %s"%(sort_ids[i],sort_d[i],sort_files[i])
                plt.subplot(2,5,i+1)
                plt.title("%03d dis: %.3f"%(sort_ids[i],sort_d[i]),fontsize=10)
                im_icon=np.array(Image.open(sort_files[i]).convert('L'))
                plt.imshow(im_icon)
                plt.axis('off')
            plt.set_cmap('gray')    
            plt.show()        
            plt.ginput(1)
Esempio n. 4
0
def plotTwoContours(contour, contour2, diffmap, mapName1="map1", mapName2="map2", colormap="jet", plot_scalebar=False):
        #DEBUG:
        #max_range = 0.07
        max_range = max(diffmap.max(),abs(diffmap.min()))
	norm = colors.Normalize(vmin=-max_range, vmax=max_range) 
	print('max_range is '+str(max_range))
	title = mapName1+' - '+mapName2
	filename = title+'.pdf'
	fig = plt.figure()
	plt.title(title)
        plt.hold(True)
	plt.imshow(diffmap, origin='upper', norm=norm)
        ax = plt.axes()
        if plot_scalebar:
            addScaleBar(ax)
        else:
            scaleTicks(ax)
        #if(colormap == "rwb")
        plt.set_cmap(colormap)
	plt.colorbar()
	plt.contour(contour, [0], colors='r')
	#plt.contour(image2, [0], colors='b')
	plt.contour(contour2, [0], colors='b')
	plt.hold(False)
	plt.savefig(filename)
        #plt.show()
	return diffmap
Esempio n. 5
0
def dim_sensitivity_plot(x, Y, fname, show_legend=True):

    plt.rc('text', usetex=True)
    plt.rc('font', family='serif')

    plt.figure(figsize=(3, 3))
    plt.xlabel('$d$', size=FONTSIZE)
    plt.ylabel('ROC AUC', size=FONTSIZE)

    plt.set_cmap('Set2')

    lines = []
    for i, label in enumerate(KEYS):
        line_data = Y.get(label)

        if line_data is None:
            continue
        
        line, = plt.plot(x, line_data, label=label, marker=MARKERS[i],
                         markersize=0.5 * FONTSIZE, color=COLORS[i])
        lines.append(line)



    if show_legend:
        plt.legend(handles=lines)
        plt.legend(loc='lower right')
    plt.xscale('log', basex=2)
    plt.xticks(x, [str(y) for y in x], size=FONTSIZE)
    plt.yticks(size=FONTSIZE)
    plt.tight_layout()

    plt.savefig(fname)
Esempio n. 6
0
def display_data(images, order='F'):
    # Select as many images as can neatly fit in a square display.
    w = int(math.sqrt(len(images)))
    h = int(len(images) / w)
    images = images[:w*h]
    print("Displaying images in a {}x{} array.".format(h, w))

    size = int(math.sqrt(images[0].shape[0]))

    combined_image = np.zeros((size * h, size * w))

    for i in range(h):
        for j in range(w):
            image = images[i * w + j]
            start_x = i * size;
            start_y = j * size;
            combined_image[start_y:(start_y + size),
                           start_x:(start_x + size)] = image.reshape((size, size), order=order)

    # NOTE: IF this is failing to display anything, there's a known issue on Ubuntu.
    # See:
    # http://www.pyimagesearch.com/2015/08/24/resolved-matplotlib-figures-not-showing-up-or-displaying/
    plt.set_cmap('gray')
    plt.axis('off')
    plt.imshow(combined_image, interpolation='nearest')
    plt.show()
Esempio n. 7
0
def main():
	for unitFile in os.listdir(sourceFolder):
		if os.path.isdir(sourceFolder+unitFile):			
			unitName = unitFile.rsplit('_', 1)[0]
			print unitName
			staMatrixFile = scipy.io.loadmat(sourceFolder+unitFile+'/stavisual_lin_array_'+unitName+'.mat')
			staMatrix = staMatrixFile['STAarray_lin']
			xLength = staMatrix.shape[0]
			yLength = staMatrix.shape[1]
			zLength = staMatrix.shape[2]
			for zAxis in range(zLength):
				print 'desde disco'
				
				fig = plt.figure()
				fig.set_size_inches(1, 1)
				data = staMatrix[:,:,zAxis]
				#plt.pcolormesh( staMatrix[:,:,zAxis],vmin = 0,vmax = 255, cmap=cm.jet )
				ax = plt.Axes(fig, [0., 0., 1., 1.])
				ax.set_axis_off()
				fig.add_axes(ax)
				plt.set_cmap(cm.jet)
				ax.imshow(data, aspect = 'auto')
				plt.savefig(outputFolder+unitName+str(zAxis)+".png",format='png',dpi=31)
				plt.close()
			
	return 0
Esempio n. 8
0
def doubleslit(b=0.1,a=0.4,lambda_1=632,z=0.5):
    """
    Return a Young's doubleslit(Frauhofer Diffraction)
    Input:
    --------------------------------
    b: slit of width in mm
    a: slit separation of in mm
    lambda_1: wavelength in nm
    z: slit-to-screen distance in m.
    """
    lambda_1 = float(lambda_1)
    theta = __np__.linspace(-0.04,0.04,1000)
    theta1 = __np__.ones(100)
    [theta,theta1] = __np__.meshgrid(theta,theta1)
    beta = __np__.pi*(b/1000)/(lambda_1/(10**9))*__sin__(theta)
    alpha = __np__.pi*(a/1000)/(lambda_1/(10**9))*__sin__(theta)
    y = 4*(__sin__(beta)**2/(beta**2)*__cos__(alpha)**2)
    fig = __plt__.figure(1,figsize=(12,8), dpi=80)
    __plt__.imshow(-y)
    __plt__.set_cmap('Greys')
    __plt__.show()
    
    theta = __np__.linspace(-0.04,0.04,1000)
    beta = __np__.pi*(b/1000)/(lambda_1/(10**9))*__sin__(theta)
    alpha = __np__.pi*(a/1000)/(lambda_1/(10**9))*__sin__(theta)
    y = 4*(__sin__(beta)**2/(beta**2)*__cos__(alpha)**2)
    y1 = 4*__sin__(beta)**2/(beta**2)
    fig = __plt__.figure(2,figsize=(12, 8), dpi=80)
    __plt__.plot(theta*z*1000,y)
    __plt__.plot(theta*z*1000,y1,"g--")
    __plt__.show()
Esempio n. 9
0
def _vis_readout_maps(outputs, global_step, output_dir, metric_summary, N):
  # outputs is [gt_map, pred_map]:
  if N >= 0:
    outputs = outputs[:N]
  N = len(outputs)

  plt.set_cmap('jet')
  fig, axes = utils.subplot(plt, (N, outputs[0][0].shape[4]*2), (5,5))
  axes = axes.ravel()[::-1].tolist()
  for i in range(N):
    gt_map, pred_map = outputs[i]
    for j in [0]:
      for k in range(gt_map.shape[4]):
        # Display something like the midpoint of the trajectory.
        id = np.int(gt_map.shape[1]/2)

        ax = axes.pop();
        ax.imshow(gt_map[j,id,:,:,k], origin='lower', interpolation='none',
                  vmin=0., vmax=1.)
        ax.set_axis_off();
        if i == 0: ax.set_title('gt_map')

        ax = axes.pop();
        ax.imshow(pred_map[j,id,:,:,k], origin='lower', interpolation='none',
                  vmin=0., vmax=1.)
        ax.set_axis_off();
        if i == 0: ax.set_title('pred_map')

  file_name = os.path.join(output_dir, 'readout_map_{:d}.png'.format(global_step))
  with fu.fopen(file_name, 'w') as f:
    fig.savefig(f, bbox_inches='tight', transparent=True, pad_inches=0)
  plt.close(fig)
Esempio n. 10
0
def make_spectrogram(dat, npts, fs=333333.3, winwidth=None,
                     window=None, fstart=0, fstop=120000, fstep=5000,
                     cmap='gist_heat_r', **kwargs):
    tstep = int(round(dat.shape[0] / float(npts)))
    winwidth = winwidth or tstep
    if window:
        windowa = np.linspace(0, 1, winwidth)
        windowa = np.concatenate([window, window[::-1]])
    nft = winwidth + 1
    ind = np.arange(fstart, fstop, fstep)
    ind = nft * ind / (fs / 2.0)
    ind = ind.astype(np.int32)[::-1]
    xind = np.arange(winwidth, dat.shape[0] - winwidth, tstep).astype(np.int32)
    ft = np.zeros((xind.shape[0], ind.shape[0]))
    for i in range(xind.shape[0]):
        d = dat[xind[i] - winwidth:xind[i] + winwidth]
        #warning, very strange behavior of rfft for 2d arrays,
        #even if shape is Nx1 or 1xN.
        if window:
            d = d * windowa
        d = np.fft.rfft(d)
        ft[i, :] = abs(d[ind][range(d[ind].shape[0] - 1, -1, -1)])
    plt.imshow(ft.transpose(), aspect='auto')
    if cmap:
        plt.set_cmap(cmap)
    return ft
Esempio n. 11
0
    def plot_summary(self):
        import matplotlib
        import matplotlib.pyplot as plt

        fig = plt.figure(figsize=(10,8)) 
        ax = plt.axes((0.08, 0.08, 0.87, 0.80)) 
        plt.set_cmap("Spectral") 
        
        # Get all candidates and sort by sigma
        allcands = self.get_all_cands()
        sigmas = Num.array([c.sigma for c in allcands])
        isort = sigmas.argsort()
        sigmas = sigmas[isort]
        freqs = Num.array([c.f for c in allcands])[isort]
        dms = Num.array([c.DM for c in allcands])[isort]
        numharms = Num.array([c.numharm for c in allcands])[isort]

        # Plot the all candidates 
        plt.scatter(freqs, dms, s=8+sigmas**1.7, c=Num.log2(numharms), \
                                marker='o', alpha=0.7, zorder=-1) 
  
        # Add colorbar 
        fmtr = matplotlib.ticker.FuncFormatter(lambda x, pos: "%d" % 2**x) 
        cb = plt.colorbar(ticks=(0,1,2,3,4), format=fmtr) 
        cb.set_label("Num harmonics summed") 
         
        plt.xscale('log', base=10.0) 
        plt.xlim(0.5, 10000) 
        plt.ylim(-10, 1200) 
        plt.xlabel("Freq (Hz)") 
        plt.ylabel(r"DM (pc cm$^{-3}$)") 
        return fig
Esempio n. 12
0
def compare_spectra():
    import mywfc3.stgrism as st
    import unicorn
    
    ### Fancy colors
    import seaborn as sns
    import matplotlib.pyplot as plt
    cmap = sns.cubehelix_palette(as_cmap=True, light=0.95, start=0.5, hue=0.4, rot=-0.7, reverse=True)
    cmap.name = 'sns_rot'
    plt.register_cmap(cmap=cmap)
    sns.set_style("ticks", {"ytick.major.size":3, "xtick.major.size":3})
    plt.set_cmap('sns_rot')
    #plt.gray()
    
    fig = st.compare_methods(x0=787, y0=712, v=np.array([-1.5,4])*0.6, NX=180, NY=40, direct_off=100, final=True, mask_lim = 0.02)
    #fig.tight_layout()
    unicorn.plotting.savefig(fig, '/tmp/compare_model_star.pdf', dpi=300)

    fig = st.compare_methods(x0=485, y0=332, v=np.array([-1.5,4])*0.2, NX=180, NY=40, direct_off=100, final=True, mask_lim = 0.1)
    unicorn.plotting.savefig(fig, '/tmp/compare_model_galaxy.pdf', dpi=300)

    fig = st.compare_methods(x0=286, y0=408, v=np.array([-1.5,4])*0.08, NX=180, NY=40, direct_off=100, final=True, mask_lim = 0.1)
    unicorn.plotting.savefig(fig, '/tmp/compare_model_galaxy2.pdf', dpi=300)

    fig = st.compare_methods(x0=922, y0=564, v=np.array([-1.5,4])*0.2, NX=180, NY=40, direct_off=100, final=True, mask_lim = 0.15)
    unicorn.plotting.savefig(fig, '/tmp/compare_model_galaxy3.pdf', dpi=300)
Esempio n. 13
0
def produce_regions(masks, visualize=False):
    """given the proposal segmentation masks for an image as a [width, height, proposal_num]
    matrix outputs all regions in the image"""
    width, height, n_prop = masks.shape
    t = ('u8,'*int(np.math.ceil(float(n_prop) / 64)))[:-1]
    bv = np.zeros((width, height), dtype=np.dtype(t))
        
    for i in range(n_prop):
        m = masks[:, :, i]
        a = 'f%d' % (i / 64)    
        h = m * np.long(2 ** (i % 64))
        if n_prop >= 64:
            bv[a] += h
        else:
            bv += h


    un = np.unique(bv)
    regions = np.zeros((width, height), dtype="uint16")
    for i, e in enumerate(un):
        regions[bv == e] = i
    if visualize:
        plt.figure()
        plt.imshow(regions)
        plt.set_cmap('prism')
        plt.colorbar()
    return regions
Esempio n. 14
0
def show_network(images, side_length, sample=1):
    """
    Expects images to be (n_pixels, n_images).  n_pixels should be == side_length ** 2
    """
    n_images = int(images.shape[1] * sample)
    cols = int(math.sqrt(n_images))
    rows = math.ceil(n_images / cols)
    # padding
    image_size = side_length + 1
    output = np.zeros((image_size * rows, image_size * cols))
    image_mask = np.random.randint(0, images.shape[1], n_images)
    norm = Normalize()
    for i, img in enumerate(image_mask):
        this_image = images[:, img].reshape((side_length, side_length)).copy()
        # Center and normalize
        this_image -= this_image.mean()
        this_image = norm(this_image)
        # Get offsets
        offset_col = image_size * (i % cols)
        offset_col_end = offset_col + image_size - 1
        offset_row = image_size * (math.floor(i / cols))
        offset_row_end = offset_row + image_size - 1
        output[offset_row:offset_row_end, offset_col:offset_col_end] = this_image

    pyplot.imshow(output)
    pyplot.set_cmap(cm.gray)
    pyplot.show()
Esempio n. 15
0
def getHash(im_file):
    im = np.array(Image.open(im_file).convert('L'))
    f=np.fft.fft2(im)
    rmax,cmax=f.shape    
    sg_r=np.zeros((2*wd,wd))
    sg_r[0:wd,:]=np.abs(f.real[0:wd,0:wd])
    sg_r[wd:2*wd,:]=np.abs(f.real[rmax-wd:rmax,0:wd])
    sg_i=np.zeros((2*wd,wd))
    sg_i[0:wd,:]=np.abs(f.imag[0:wd,0:wd])
    sg_i[wd:2*wd,:]=np.abs(f.imag[rmax-wd:rmax,0:wd])
    
    bsg=np.zeros((2*wd,2*wd-2),dtype=bool)
    bsg[:,0:wd-1]=sg_r[:,0:wd-1]<sg_r[:,1:wd]
    bsg[:,wd-1:2*wd-2]=sg_i[:,0:wd-1]<sg_i[:,1:wd]
    
    return bsg
    
    f2=np.zeros((rmax,cmax))+1j*np.zeros((rmax,cmax))
    
    f2.real[0:wd,0:wd-1]=bsg[0:wd,0:wd-1]
    f2.imag[wd:2*wd,0:wd-1]=bsg[0:wd,wd-1:2*wd-2]
    f2.real[rmax-wd:rmax,0:wd-1]=bsg[wd:2*wd,0:wd-1]
    f2.imag[rmax-wd:rmax,0:wd-1]=bsg[wd:2*wd,wd-1:2*wd-2]
    #plt.close("all")
    plt.figure()
    plt.imshow(bsg,interpolation='none')
    plt.set_cmap("gray")
Esempio n. 16
0
def example_dct2():
    import scipy.ndimage as sn
    import matplotlib.pyplot as plt
    name = os.path.join(path, 'autumn.gif')
    rgb = np.asarray(sn.imread(name), dtype=np.float16)
    # np.fft.fft(rgb)
    print(np.max(rgb), np.min(rgb))
    plt.set_cmap('jet')
    J = dctn(rgb)
    irgb = idctn(J)
    print(np.abs(rgb-irgb).max())
    plt.imshow(np.log(np.abs(J)))
    # plt.colorbar() #colormap(jet), colorbar
    plt.show('hold')
    v = np.percentile(np.abs(J.ravel()), 10.0)
    print(len(np.flatnonzero(J)), v)
    J[np.abs(J) < v] = 0
    print(len(np.flatnonzero(J)))
    plt.imshow(np.log(np.abs(J)))
    plt.show('hold')
    K = idctn(J)
    print(np.abs(rgb-K).max())
    plt.figure(1)
    plt.imshow(rgb)
    plt.figure(2)
    plt.imshow(K, vmin=0, vmax=255)
    plt.show('hold')
def test_mask_loss_sobel():
    th_mask, th_img = T.tensor4(), T.tensor4()
    ml = mask_loss_sobel(th_mask, th_img)
    mask_loss = theano.function([th_mask, th_img],
                                [ml.loss] + list(ml.sobel_mask) +
                                list(ml.sobel_img))

    mask_idx = next(masks(1))
    image_ok = 0.5 * np.ones_like(mask_idx)
    image_ok[mask_idx > MASK["IGNORE"]] = 1
    image_ok[mask_idx < MASK["BACKGROUND_RING"]] = 0

    print()
    loss, sobel_mask_x, sobel_mask_y, sobel_img_x, sobel_img_y = \
        mask_loss(mask_idx, image_ok)
    plt.set_cmap('gray')
    plt.subplot(221)
    plt.imshow(sobel_mask_x[0, 0])
    plt.subplot(222)
    plt.imshow(sobel_mask_y[0, 0])
    plt.colorbar()
    plt.subplot(223)
    plt.imshow(sobel_img_x[0, 0])
    plt.subplot(224)
    plt.imshow(sobel_img_y[0, 0])
    plt.colorbar()
    plt.savefig("mask_loss_sobel.png")
    print()
    print("mask_loss: {}".format(mask_loss(mask_idx, image_ok)))
    assert loss == 0
def start():
    if SHOW_INTEGRATION_PATH:
        show_complex_plain()
        plt.set_cmap('gray')
    else:
        plt.set_cmap('jet')

    if not SHOW_INTEGRATION_PATH:
        E_s, saddle_distance, dd_evaluated = steepest_descent()
        mask = ask_for_mask(E_s, saddle_distance, dd_evaluated)
    else:
        E_s = 0
        mask = np.zeros((2,2))

    E_i, new_mask = integration_method(E_s, mask)

    if not SHOW_INTEGRATION_PATH:
        E = plot(E_i, E_s, mask, new_mask)
        dct = copy(locals())
        dct.update(copy(globals()))
        if FILENAME:
            vars_to_save = ['E', 'E_i', 'E_s', 'saddle_distance', 'dd_evaluated',
                'mask', 'LIMITS', 'RESOLUTION', 'N_ROOTS', 'N_SADDLES', 'THRESHOLDS',
                'NUM_WEIGHTS', 'SHOW_INTEGRATION_PATH', 'CALCULATE_ARC_EVERY_N_STEPS',
                'N_THREADS', 'D', 'ORDER']
            savemat(FILENAME, {
                key: dct[key] for key in vars_to_save
            })
    else:
        E = None

    return E, E_i, E_s
    def __init__(self, global_counter, path_to_mha=None, how_many_from_one=1, saving_path='./test_data/'):
        if path_to_mha is None:
            raise NameError(' missing .mha path ')
        self.images = []
        for i in range(0, len(path_to_mha)):
            self.images.append(np.array(sitk.GetArrayFromImage(sitk.ReadImage(path_to_mha[i]))))

        mkdir_p(saving_path)
        plt.set_cmap('gray')
        while how_many_from_one > 0:
            image_to_save = np.zeros((5,
                                      216,
                                      160))
            rand_value = rnd.randint(30, len(self.images[0]) - 30)
            for i in range(0, len(path_to_mha)):
                try:
                    image_to_save[i] = self.images[i][rand_value]
                except:
                    print('ahi')
                    print(self.images[i][rand_value].shape)
                    print(type(self.images))
                    print(type(self.images))
                    print('*')
                    continue
            print(image_to_save.shape)
            image_to_save = image_to_save.reshape((216 * 5, 160))
            print(image_to_save.shape)
            # image_to_save = resize(image_to_save, (5*216, 160), mode='constant')
            # image_to_save = image_to_save.resize(5*216, 160)
            plt.imsave(saving_path + str(global_counter) + '.png',
                       image_to_save)
            global_counter += 1
            how_many_from_one -= 1
Esempio n. 20
0
def displayData(X):
    width = 20
    rows, cols = 10, 10
    out = zeros((width * rows, width * cols))
    m = X.shape[0]  # データ数

    # 5000個のデータセットから適当に100個選ぶ
    rand_indices = random.permutation(m)[0: rows * cols]

    counter = 0
    for y in range(0, rows):
        for x in range(0, cols):
            start_x = x * width
            start_y = y * width
            out[start_x: start_x + width, start_y: start_y + width] = X[rand_indices[counter]].reshape(width, width).T
            counter += 1

    img = scipy.misc.toimage(out)
    figure = pyplot.figure()
    pyplot.tick_params(labelbottom="off")
    pyplot.tick_params(labelleft="off")
    pyplot.set_cmap(pyplot.gray())
    axes = figure.add_subplot(111)
    axes.imshow(img)
    pyplot.savefig("digits.png")
Esempio n. 21
0
def scattergrid(points,sizes=[],colors=[]):
    """
    Plots a scatter graphic in a X,Y axes with sized symbols.

    Input:
     - points  <[(,)]> : a list of tuples of X,Y datapoints
     - sizes   <[]>    : a list of numbers for symbols sizing
     - colors  <[]>    : a list of numbers for symbols colors
    
    Output:
     - fig  <pyplot.figure()>  : A matplotlib figure instance
        Save (fig.savefig()) or show (fig.show()) the object.

    ---
    """

    if len(points) != len(sizes)  and  len(sizes) != 0:
        return False;

    RA,DEC = zip(*points);
    RA_min = min(RA);
    RA_max = max(RA);
    DEC_min = min(DEC);
    DEC_max = max(DEC);

    ra_ = abs(RA_max-RA_min)/20
    dec_ = abs(DEC_max-DEC_min)/20

    sizes = np.asarray(sizes)
    sizes = 100 * (sizes-sizes.min()) / (sizes.max()-sizes.min())
    sizes = sizes.astype('uint32').tolist();

    x,y = zip(*points);
    
    # Sort the data just to get it(the plot) right done when 
    # 'scatter' run through datasets.
    tosort_ = zip(sizes,colors,x,y);
    tosort_.sort();
    tosort_.reverse();
    sizes,colors,x,y = zip(*tosort_);
    #
    
    plt.set_cmap('hot');
    fig = plt.figure();
    ax = fig.add_subplot(111);
    ax.patch.set_facecolor('0.9');
    ax.grid(True);
    ax.set_xlabel('RA');
    ax.set_ylabel('DEC');
#    ax.set_title('Massive objects scatter (position) plot')

    ax.scatter(x,y,s=sizes,c=colors,marker='o',edgecolor='black',alpha=0.75)


    s2 = [sizes[0],sizes[-1]]
    x2 = [1,1]
    y2 = [1,2]
#    fig.show();

    return fig;
Esempio n. 22
0
 def _plot_single_map1(self, path, cmap, signo, dist_map, threshold, constrained, stretch, colorMap, suffix):
     import matplotlib.pyplot as plt
     if path != None:
         plt.ioff()
     grad = self.get_single_map(signo, cmap, dist_map, threshold, constrained, stretch)
     plt.imshow(grad, interpolation='none')
     plt.set_cmap(colorMap)
     cbar = plt.colorbar()
     cbar.set_ticks([])
     if path != None:
         if suffix == None:
             fout = osp.join(path, '{0}_{1}.png'.format(self.label, signo))
         else:
             fout = osp.join(path, '{0}_{1}_{2}.png'.format(self.label, signo, suffix))
         try:
             plt.savefig(fout)
         except IOError:
             raise IOError('in classifiers.output, no such file or directory: {0}'.format(path))
     else:
         if suffix == None:
             plt.title('{0} - EM{1}'.format(self.label, signo))
         else:
             plt.title('{0} - EM{1} - {2}'.format(self.label, signo, suffix))
         plt.show()
     plt.close()
Esempio n. 23
0
    def plot_reals(self, nr=25, hardcopy=0, hardcopy_filename='reals', nanval=-997799, filternan=1):
        import matplotlib.pyplot as plt
        import matplotlib.gridspec as gridspec
        import numpy as np
        from scipy import squeeze
        
        
        nx, ny, nz = self.par['simulation_grid_size']
        
        nr = np.min((self.par['n_real'], nr))
        nsp = int(np.ceil(np.sqrt(nr)))

        fig = plt.figure(1)
        sp = gridspec.GridSpec(nsp, nsp, wspace=0.1, hspace=0.1)
        plt.set_cmap('hot')
        for i in range(0, nr):
            ax1 = plt.Subplot(fig, sp[i])
            fig.add_subplot(ax1)
            if filternan==1:
                self.sim[i][self.sim[i]==nanval] = np.nan
                
            D=squeeze(np.transpose(self.sim[i]))
            plt.imshow(D, extent=[self.x[0], self.x[-1], self.y[0], self.y[-1]], interpolation='none')
            plt.title("Real %d" % (i + 1))

        fig.suptitle(self.method + ' - ' + self.parameter_filename, fontsize=16)
        if (hardcopy):
            plt.savefig(hardcopy_filename)

        plt.show(block=False)
Esempio n. 24
0
 def set_cmap(self, i):
     """Set colormap."""
     if 0 <= i < len(self.cmaps):
         name = self.cmaps[i]
         if self.is_reverse_cmap:
             name = dwi.plot.reverse_cmap(name)
         plt.set_cmap(name)
def tracestackedslab(infile,depthinc=5,llinc=((6371*np.pi)/360),cval=0.5):
	'''
	Takes a netcdf file containing a stacked, normed profiles and attempts to contour what might be a slab - can use this to estimate dip, profile etc
	The values of depthinc and llinc are defaults from the Ritsema code, which creates slices over angles of 180 degrees
	and with a depth increment of 5 km

	This produces a map showing the slice and contours in stacked velocity perturbation at a chosen level (typically 0.5)
	'''

	Mantlebase = 2895

	infile = Dataset(infile, model='r')

	filevariables = infile.variables.keys()

	#Get data from the netCDF file
	depths = infile.variables['y'][:]
	lengths = infile.variables['x'][:]
	data = infile.variables['z'][:][:]

	infile.close()

	#print np.shape(data)
	#print np.shape(lengths)
	#print np.shape(depths)

	#Use image processing suite to find contours
	contours = measure.find_contours(data,cval)

	#Various plotting commands to produce the figure
	fig, ax = plt.subplots()

	thousandkm = int((Mantlebase-1000)/depthinc)
	sixsixtykm = int((Mantlebase-660)/depthinc)

	plt.set_cmap('jet_r')

	ax.imshow(data, interpolation='linear',aspect='auto')

	ax.plot([0,len(lengths)],[thousandkm,thousandkm],'k--',label='1000km')
	ax.plot([0,len(lengths)],[sixsixtykm,sixsixtykm],'k-',label='660km')

	for n, contour in enumerate(contours):
		if n == 0:
			ax.plot(contour[:, 1], contour[:, 0], 'r-', linewidth=2,label='contour at %g' %cval)
		else:
			ax.plot(contour[:, 1], contour[:, 0], 'r-', linewidth=2)


	ax.set_ylim([0,len(depths)])
	ax.set_xlim([len(lengths),0])
	ax.set_title('Stacked slab image from netCDF')
	plt.xlabel('Cross section x increment')
	plt.ylabel('Cross section depth increment')
	plt.legend(loc='best')

	#plt.gca().invert_yaxis()
	#plt.gca().invert_xaxis()

	plt.show(block=False)
Esempio n. 26
0
def visualize_matrix(matrix, n_imgs, imgsize, outputfile, cmap="gray", dpi=150):
    """

    """
    n_h,n_w = layout_shape(n_imgs)
    
    receptive_fields = numpy.zeros((n_h * imgsize, n_w * imgsize), dtype=theano.config.floatX)
    
    for i in range(n_h):
        for j in range(n_w):
            img = matrix[i * n_w + j]
            img = img.reshape((imgsize, imgsize))
            receptive_fields[i * imgsize: (i + 1) * imgsize, j * imgsize: (j + 1) * imgsize] = img
    
    fig = plt.figure()
    
    ax = fig.add_subplot(1,1,1)
    xticks = numpy.arange(0, n_w * imgsize, imgsize)                                              
    yticks = numpy.arange(0, n_h * imgsize, imgsize)
    ax.set_xticks(xticks)
    ax.set_xticklabels([i for (i,x) in enumerate(xticks)])
    ax.set_yticks(yticks)
    ax.set_yticklabels([i for (i,y) in enumerate(yticks)])
    ax.grid(which="both", linestyle='-')
    
    plt.set_cmap(cmap)
    plt.imshow(receptive_fields)
    plt.savefig(outputfile, dpi=dpi)
Esempio n. 27
0
def testModel(modelFilename, testData, size):
    

    # Create shared data
    test_x, test_y = make_shared(testData, size)
    
    # Load the model
    persistence = PersistenceManager()
    persistence.set_filename(modelFilename)
    x, y, classifier = persistence.load_model()
    
    # Create prediction function.
    pred_func = theano.function(inputs = [],
                                outputs = [classifier.y_pred, classifier.errors(y)],
                                givens = {x:test_x, y:test_y})    


    preds = pred_func()
    print("prediction done")

    plt.set_cmap('gray')    
    for i in range(len(testData)):
        s = testData[i]
        print("Dist: {0}".format(preds[1][i]))        
        normalizedCoords = preds[0][i]
        px = np.round(normalizedCoords[0] * s.width)
        py = np.round(normalizedCoords[1] * s.height)

        pxCopy = s.getAnnotated()
        pxCopy[py, px] = 0.85*np.max(pxCopy)

        plt.imshow(pxCopy)
        plt.show()    
Esempio n. 28
0
    def plot1(self, img, path=None, mask=None, interpolation='none', colorMap='jet', suffix=''):
        import matplotlib.pyplot as plt
        if path != None:
            plt.ioff()

        if isinstance(mask, np.ndarray):
            img = img[:,:] * mask

        plt.imshow(img, interpolation=interpolation)
        plt.set_cmap(colorMap)
        cbar = plt.colorbar()
        cbar.set_ticks([])
        if path != None:
            if suffix == None:
                fout = osp.join(path, '{0}.png'.format(self.label))
            else:
                fout = osp.join(path, '{0}_{1}.png'.format(self.label, suffix))
            try:
                plt.savefig(fout)
            except IOError:
                raise IOError('in classifiers.output, no such file or directory: {0}'.format(path))
        else:
            if suffix == None:
                plt.title('{0}'.format(self.label))
            else:
                plt.title('{0} - {1}'.format(self.label, suffix))
            plt.show()

        plt.close()
def plot_topography(grid, elev):
    ''' 
    This function takes the DEM read in below and plots the
    elevations for visualization purposes.
    '''
    # Get a 2D array version of the elevations for plotting purposes
    elev_raster = grid.node_vector_to_raster(elev,True)
    
    # Everything below plots the topography and sampling points
    levels = []
    # To better create a colorbar...
    x_up = 2475
    while x_up !=2600:
        levels.append(x_up)
        x_up+=1
    plt.figure('Topography')
    plt.contourf(elev_raster, levels, colors='k')
    plt.set_cmap('bone')
    plt.colorbar()
    
    # To plot the study node and outlet node on the DEM...
    plt.plot([122],[140],'cs', label= 'Study Node')
    plt.plot([152],[230], 'wo', label= 'Outlet')
    
    plt.legend(loc=3)
Esempio n. 30
0
 def show(self):
     import matplotlib.pyplot as plt
     print("number of images: {}".format(len(self.I)))    
     for i in xrange(len(self.jsonfiles)):
         f=open(self.jsonfiles[i],"r")
         js=json.loads(f.read())
         f.close()
         
         ##init and show
         img_path=''
         if js['path'][0:2]=='./':
             img_path= rootdir + js['path'][1:]
         elif js['path'][0]=='/':
             img_path= rootdir + js['path']
         else:
             img_path= rootdir + '/' +js['path'] 
             
         print(img_path)
         im=np.array(Image.open(img_path).convert('L'))
         plt.hold(False)        
         plt.imshow(im)
         plt.hold(True)
         for j in range(self.size):
             #samples[x]=[0_class,1_img, 2_row, 3_column]^T
             if self.samples[1,j]==i:
                 plt.text(self.samples[3,j], self.samples[2,j], "%03d"%self.samples[0,j], fontsize=12,color='red')
                 #plt.plot(self.samples[3,j],self.samples[2,j],markers[self.samples[0,j]])
         plt.set_cmap('gray')
         plt.show()
         plt.ginput(1)
     plt.close('all')
Esempio n. 31
0
                    tmp = inn.lat[j, i] + 40.
                    tmp = np.float64(tmp)
                    lbrei = myround(tmp)
                    if lbrei >= 0 and lbrei <= 80 and inn.vke.mask[k, j,
                                                                   i] == False:
                        lbrei = np.int64(lbrei)
                        amoc[k, lbrei] = amoc[k, lbrei] - inn.vke[
                            k, j, i] * dlxv[j, i] * ddue[k, j, i] * 1025.
                        amoc_count[k, lbrei] = amoc_count[k, lbrei] + 1

write.write_depth_meridional("amoc_untouched_v3.nc", amoc, 'amoc', y, z)

amoc_old = amoc.copy()
amoc_untouched = amoc.copy()
for kb in range(1, amoc.shape[0] - 2):
    #if abs(np.mean(amoc[:,kb])) > 1.:
    amoc[kb, :] = amoc[kb - 1, :] + amoc[kb, :]
amoc_down = amoc.copy()

amoc = amoc_old.copy()
for kb in range(amoc.shape[0] - 2, -1, -1):
    #if abs(np.mean(amoc[:,kb])) > 1.:
    amoc[kb, :] = amoc[kb + 1, :] + amoc[kb, :]
amoc_up = amoc.copy()

f1 = plt.figure()
plt.set_cmap('coolwarm')
v = np.linspace(-3e10, 3e10, 100, endpoint=True)
plt.contourf(y, -z, amoc, v, extend="both")
plt.colorbar()
# Add y-axis label
plt.ylabel('Temperatures')
# Add label for color bar
plt.colorbar().ax.set_title('Longtitude')
# Save plot as image file
plt.savefig('lat_temps_long.png')
# Show plot
plt.show()

plt.scatter(long, temps, c=lat)
plt.xlabel('Longitude')
plt.ylabel('Temperatures')
plt.colorbar().ax.set_title('Latitude')
# Set colormap to the selected one
# See more colormap selection in the reference at the end of Exercise 5
plt.set_cmap('RdBu')
plt.savefig('long_temps_lat.png')
plt.show()

# P6

import csv
import matplotlib.pyplot as plt


def read_file(file_name):
    data = []
    with open(file_name, 'r', encoding='ISO-8859-1') as f:
        rows = csv.DictReader(f)
        for r in rows:
            data.append(r)
Esempio n. 33
0
def setup(center_freq, sample_rate, final):
    def power(val):
        p = abs(val**2)
        pdb = math.log10(p)
        return (pdb)

    ##SDR Setup Commands
    power = np.vectorize(power)
    fname = center_freq / 1e9
    name = str('{:.3f}Ghz'.format(fname))
    sdr = adi.Pluto("ip:192.168.2.1")
    sdr.sample_rate = int(sample_rate)
    sdr.rx_rf_bandwidth = int(
        sample_rate)  # filter cutoff, just set it to the same as sample rate
    sdr.rx_lo = int(center_freq)
    sdr.rx_buffer_size = 1024  # this is the buffer the Pluto uses to buffer samples

    ##Sampling Signal at Carrier Freq
    samples = sdr.rx()
    freqx = np.linspace(int(-sample_rate // 2 + center_freq),
                        int(sample_rate // 2 + center_freq), int(1024))
    frq = np.fft.fft(samples)
    freq = np.fft.fftshift(frq)

    sig_avg = signal.find_peaks(filter(
        b, a, freq), height=10000)  #Detecting Required Amplitude Peaks
    print(
        'Size:', sig_avg[0].size
    )  #if(tuple!=empty)->then Adjust OffsetCorrection->then append in final[]
    if (sig_avg[0].size > 0):
        print("Active Band:{}Ghz".format(name))
        temp = np.array(sig_avg[0])
        print("Signal Avg:", temp)
        for i in range(0, temp.size):
            temp[i] = temp[i] * (sample_rate / 1000) + center_freq
        print("Signal Avg:", temp)
        final = np.concatenate((final, temp))

    ##Storing Dataframe in .csv format
    store = pd.DataFrame(
        freq)  # Storing Dataframe using PANDAS -> IMPORT TO TX IN PANDAS
    store.to_csv(name + "-Dataframe.png")
    store = pd.DataFrame(
        sig_avg[0])  # Storing Dataframe using PANDAS -> IMPORT TO TX IN PANDAS
    store.to_csv(name + "-Peaks_Dataframe.png")

    ##Plotting Frequency Response			#freq1=power(freq)
    plt.plot(freqx, freq)  #plt.plot(freq)
    plt.xlim((-10, 1030))
    plt.ylim((-10000, 55000))
    plt.xlabel('Frequency(Base Freq+Offset*10)Hz')
    plt.ylabel('Amplitude of Signal')
    plt.title("Frequency Amplitude:" + name)  #for Single TimeFrame
    plt.savefig(name + "-FA.png")  #plt.show()
    plt.close()
    samplegroup = []  #Ploting Waterfall Diagram
    for _ in range(1000):
        samples = sdr.rx()
        frq = np.fft.fft(samples)
        freq = np.fft.fftshift(frq)  #freq=power(freq)
        samplegroup.append(abs(freq))
    plt.imshow(samplegroup)
    plt.set_cmap('hot')
    plt.xlabel('Frequency(Base Freq+offset*10)Hz')
    plt.title("Waterfall Diagram:" + name)  #for 1000ms TimeFrame
    plt.savefig(name + "-WD.png")  #plt.show()
    plt.close()
    return final
def plot_corr(df, size=11):
    plt.set_cmap('YlOrRd')
    plt.figure(figsize=(size, size))
    sns.heatmap(df.corr())
    plt.show()
rSC = np.zeros(shape=(len(livePSTHs),len(livePSTHs), len(ori))) #preallocate
for rowind,rowkey in enumerate(livePSTHs.keys()): #loop over rows (units)
    for colind,colkey in enumerate(livePSTHs.keys()): #loop over columns (same units)
        for orind,oo in enumerate(ori): #loop over orientations
            rSC[rowind,colind,orind],dummy = sc.pearsonr(livePSTHs[rowkey][oo][11:211], 
               livePSTHs[colkey][oo][11:211]) #noise correlation ONLY OVER STIM (11:211))
globalMean = np.mean(rSC)


# %% Plot correlations

#important for resizing colorbar!!
from mpl_toolkits.axes_grid1 import make_axes_locatable

plt.set_cmap('jet')

fig=plt.figure(facecolor='w')
for orind,oo in enumerate(ori):
    ax = fig.add_subplot(1,numOris,orind+1)
    img=ax.imshow(rSC[:,:,orind])
#    ax.axis('equal')
    
    # create an axes on the right side of ax. The width of cax will be 5%
    # of ax and the padding between cax and ax will be fixed at 0.05 inch.
    divider = make_axes_locatable(ax)
    cax = divider.append_axes("right", size="5%", pad=0.05)

    plt.colorbar(img, cax=cax)

    ax.set_title('Orientation: '+str(oo)+'\xb0')
Esempio n. 36
0
def plotCCDMap2d(ax, ccdOffsets, parArray, cbLabel, loHi=None):
    """
    Plot CCD map with Chebyshev fits for each CCD

    parameters
    ----------
    ax: plot axis object
    ccdOffsets: ccdOffset recarray
    parArray: float array (nCCD, nPars)
    cbLabel: string
       Color bar label
    loHi: tuple [2], optional
       (lo, hi) or else scaling is computed from data.
    """

    import matplotlib.pyplot as plt
    import matplotlib.colors as colors
    import matplotlib.cm as cmx

    cm = plt.get_cmap('rainbow')
    plt.set_cmap('rainbow')

    plotRARange = [
        ccdOffsets['DELTA_RA'].min() - ccdOffsets['RA_SIZE'].max() / 2.,
        ccdOffsets['DELTA_RA'].max() + ccdOffsets['RA_SIZE'].max() / 2.
    ]
    plotDecRange = [
        ccdOffsets['DELTA_DEC'].min() - ccdOffsets['DEC_SIZE'].max() / 2.,
        ccdOffsets['DELTA_DEC'].max() + ccdOffsets['DEC_SIZE'].max() / 2.
    ]

    # compute central values...
    centralValues = np.zeros(ccdOffsets.size)

    for i in range(ccdOffsets.size):
        field = Cheb2dField(ccdOffsets['X_SIZE'][i], ccdOffsets['Y_SIZE'][i],
                            parArray[i, :])
        centralValues[i] = -2.5 * np.log10(field.evaluateCenter()) * 1000.0

    if (loHi is None):
        st = np.argsort(centralValues)

        lo = centralValues[st[int(0.02 * st.size)]]
        hi = centralValues[st[int(0.98 * st.size)]]
    else:
        lo = loHi[0]
        hi = loHi[1]

    cNorm = colors.Normalize(vmin=lo, vmax=hi)
    scalarMap = cmx.ScalarMappable(norm=cNorm, cmap=cm)

    Z = [[0, 0], [0, 0]]
    levels = np.linspace(lo, hi, num=150)
    CS3 = plt.contourf(Z, levels, cmap=cm)

    ax.clear()

    ax.set_xlim(plotRARange[0] - 0.05, plotRARange[1] + 0.05)
    ax.set_ylim(plotDecRange[0] - 0.05, plotDecRange[1] + 0.05)
    ax.set_xlabel(r'$\delta\,\mathrm{R.A.}$', fontsize=16)
    ax.set_ylabel(r'$\delta\,\mathrm{Dec.}$', fontsize=16)
    ax.tick_params(axis='both', which='major', labelsize=14)

    for k in range(ccdOffsets.size):
        xValues = np.linspace(0.0, ccdOffsets['X_SIZE'][i], 50)
        yValues = np.linspace(0.0, ccdOffsets['Y_SIZE'][i], 50)

        xGrid = np.repeat(xValues, yValues.size)
        yGrid = np.tile(yValues, xValues.size)

        field = Cheb2dField(ccdOffsets['X_SIZE'][i], ccdOffsets['Y_SIZE'][i],
                            parArray[k, :])
        zGrid = -2.5 * np.log10(
            np.clip(field.evaluate(xGrid, yGrid), 0.1, None)) * 1000.0

        # This seems to be correct
        extent = [
            ccdOffsets['DELTA_RA'][k] -
            ccdOffsets['RASIGN'][k] * ccdOffsets['RA_SIZE'][k] / 2.,
            ccdOffsets['DELTA_RA'][k] +
            ccdOffsets['RASIGN'][k] * ccdOffsets['RA_SIZE'][k] / 2.,
            ccdOffsets['DELTA_DEC'][k] -
            ccdOffsets['DECSIGN'][k] * ccdOffsets['DEC_SIZE'][k] / 2.,
            ccdOffsets['DELTA_DEC'][k] +
            ccdOffsets['DECSIGN'][k] * ccdOffsets['DEC_SIZE'][k] / 2.
        ]

        zGridPlot = zGrid.reshape(xValues.size, yValues.size)
        if ccdOffsets['XRA'][k]:
            zGridPlot = zGridPlot.T

        plt.imshow(zGridPlot,
                   interpolation='bilinear',
                   origin='lower',
                   extent=extent,
                   norm=cNorm)

    cb = None
    cb = plt.colorbar(CS3, ticks=np.linspace(lo, hi, 5))

    cb.set_label('%s' % (cbLabel), fontsize=14)

    return None
Esempio n. 37
0
            max_E_ind = np.argmax(gammae)

    max_E_ind = np.argmax(gammae)
    #if you want to track particles lower down the energy list
    #gammae[max_E_ind] = 0
    print('highest gamma we have:')
    print(gammae[max_E_ind])

    #max_E_ind = np.argmax(gammae) # 2nd most energetic particle
    max_E_proc_val = proce[max_E_ind]
    max_E_ind_val = inde[max_E_ind]

    print("index , proc")
    print(max_E_ind_val, max_E_proc_val)

    plt.set_cmap("viridis")
    gamma_list = []
    t_list = []
    u_list = []
    v_list = []
    w_list = []
    #t_max = 350

    EoverB_list = []
    wpar_list = []
    for t in range(
            1, 40, 1
    ):  #in some cases the high E particle is injected later in time, so it'
        t_list.append(t)
        t_string = '%03d' % t
Esempio n. 38
0
@author: stewjo
"""

import matplotlib.pyplot as plt
import numpy as np

A = np.random.rand(128, 128)
A[:, :] = 0.0
A[30:40, 0] = 100
A[-1, 115:120] = -100
A[0, 70:80] = -100
A[60:80, -1] = 100

# Display it
p = plt.imshow(A, interpolation='nearest')
plt.set_cmap('OrRd')
plt.pause(1)

eps = 0.9
for t in range(200000):
    Aold = np.copy(A)
    """A[1:-2,1:-2] =  (1-eps)*Aold[1:-2,1:-2] + eps*( A[0:-3,1:-2]+A[2:-1,1:-2]+A[1:-2,0:-3]+A[1:-2,2:-1])/4.0
    """
    #Same as: ???
    for i in range(1, 127):
        for j in range(1, 127):
            A[i, j] = (1 - eps) * Aold[i, j] + eps * (Aold[i, j - 1] + Aold[
                i, j + 1] + Aold[i - 1, j] + Aold[i + 1, j]) / 4.0

    A[:, 0] = A[:, 1]
    A[:, -1] = A[:, -2]
Esempio n. 39
0
trained_file = data.lbp_frontal_face_cascade_filename()

# Initialize the detector cascade.
detector = Cascade(trained_file)

img = data.astronaut()
img = skimage.io.imread("WIN_20200110_17_15_25_Pro.jpg")

detected = detector.detect_multi_scale(img=img,
                                       scale_factor=1.2,
                                       step_ratio=1,
                                       min_size=(60, 60),
                                       max_size=(123, 123))

plt.imshow(img)
img_desc = plt.gca()
plt.set_cmap('gray')

for patch in detected:

    print(patch)

    img_desc.add_patch(
        patches.Rectangle((patch['c'], patch['r']),
                          patch['width'],
                          patch['height'],
                          fill=False,
                          color='r',
                          linewidth=2))

plt.show()
Esempio n. 40
0
import scipy
import torch
from sklearn.cluster import KMeans

base_uri = '/Users/juanjogarau/Documents/MIT/HackMIT2017/png_maps'
img_path = os.path.join(base_uri, '1_0.png')

img = Image.open(img_path).convert('L')

pix = np.array(img) * 1. / 255.
pix = (pix < 0.7).astype(int)

corners = np.array(corner_peaks(corner_harris(pix), min_distance=1))

plt.figure()
plt.set_cmap('gray_r')
plt.imshow(pix)
plt.scatter(corners[:,1], corners[:,0], s=1)

aux = np.zeros(pix.shape)
for corner in corners:
    aux[corner[0], corner[1]] = 1

selem_mat = np.ones((12,12))

for _ in range(5):
    aux = dilation(aux)
plt.figure()
plt.set_cmap('gray_r')
plt.imshow(aux)
Esempio n. 41
0
def Gdcm_image(filepath):
    lstFilesDCM = []
    DcmName = []
    for dirName, subdirList, fileList in sorted(os.walk(filepath)):
        fileList = natsorted(fileList)
        for filename in fileList:
            if ".dcm" in filename.lower():  # 判断文件是否为dicom文件
                lstFilesDCM.append(os.path.join(dirName, filename))  # 加入到列表中
                DcmName.append(filename)
    reader = sitk.ImageSeriesReader()
    dicom_names = reader.GetGDCMSeriesFileNames(filepath)
    reader.SetFileNames(dicom_names)
    image = reader.Execute()
    image_arr = sitk.GetArrayFromImage(image)
    image_arr = image_arr.transpose()
    ConstOrigin = image.GetOrigin()
    ConstPixelSpacing = image.GetSpacing()
    ConstPixelDims = numpy.shape(image_arr)

    image_1 = int(ConstPixelDims[0] // 2)
    image_2 = int(ConstPixelDims[1] // 2)
    image_3 = int(ConstPixelDims[2] // 2)

    x = numpy.arange(0.0, (ConstPixelDims[0] + 1) * ConstPixelSpacing[0],
                     ConstPixelSpacing[0])
    y = numpy.arange(0.0, (ConstPixelDims[1] + 1) * ConstPixelSpacing[1],
                     ConstPixelSpacing[1])
    z = numpy.arange(0.0, (ConstPixelDims[2] + 1) * ConstPixelSpacing[2],
                     ConstPixelSpacing[2])

    fig1 = pyplot.figure(dpi=300)
    pyplot.axes().set_aspect('equal', 'datalim')
    pyplot.set_cmap(pyplot.gray())
    pyplot.pcolormesh(
        x, y,
        numpy.flipud(image_arr[:, :, image_3]).transpose())  # 第三个维度表示现在展示的是第几层
    pyplot.axis('off')
    buffer_ = io.BytesIO()
    pyplot.savefig(buffer_, format='png')
    buffer_.seek(0)
    img1 = PIL.Image.open(buffer_)
    img_arr1 = numpy.asarray(img1)
    buffer_.close()

    fig2 = pyplot.figure(dpi=300)
    pyplot.axes().set_aspect('equal', 'datalim')
    pyplot.set_cmap(pyplot.gray())
    pyplot.pcolormesh(y, z,
                      numpy.fliplr(numpy.rot90((image_arr[image_1, :, :]), 3)))
    pyplot.axis('off')
    buffer_ = io.BytesIO()
    pyplot.savefig(buffer_, format='png')
    buffer_.seek(0)
    img2 = PIL.Image.open(buffer_)
    img_arr2 = numpy.asarray(img2)
    buffer_.close()

    fig3 = pyplot.figure(dpi=300)
    pyplot.axes().set_aspect('equal', 'datalim')
    pyplot.set_cmap(pyplot.gray())
    pyplot.pcolormesh(x, z,
                      numpy.fliplr(numpy.rot90((image_arr[:, image_2, :]), 3)))
    pyplot.axis('off')
    buffer_ = io.BytesIO()
    pyplot.savefig(buffer_, format='png')
    buffer_.seek(0)
    img3 = PIL.Image.open(buffer_)
    img_arr3 = numpy.asarray(img3)
    buffer_.close()

    pyplot.figure(figsize=(3, 1), dpi=300)
    pyplot.subplot(131)
    pyplot.imshow(img_arr1)
    pyplot.title('AxialSlice', fontsize=4, y=0.9)
    pyplot.axis('off')
    pyplot.xticks([])
    pyplot.yticks([])
    pyplot.subplot(132)
    pyplot.imshow(img_arr2)
    pyplot.title('CoronalSlice', fontsize=4, y=0.9)
    pyplot.axis('off')
    pyplot.xticks([])
    pyplot.yticks([])
    pyplot.subplot(133)
    pyplot.imshow(img_arr3)
    pyplot.title('SagitalSlice', fontsize=4, y=0.9)
    pyplot.axis('off')
    pyplot.xticks([])
    pyplot.yticks([])
    pyplot.tight_layout(pad=0.5, w_pad=2)
    pyplot.subplots_adjust(wspace=0, hspace=0)
    pyplot.savefig(filepath + '/' + 'image.jpg')
    pyplot.show()

    Array_vtk = numpy_support.numpy_to_vtk(image_arr.ravel('F'),
                                           deep=True,
                                           array_type=vtk.VTK_FLOAT)
    imagedata = vtk.vtkImageData()
    imagedata.SetOrigin(ConstOrigin)
    imagedata.SetSpacing(ConstPixelSpacing)
    imagedata.SetDimensions(ConstPixelDims)
    imagedata.GetPointData().SetScalars(Array_vtk)
    origin = numpy.array(ConstOrigin)
    ConstPixelSpacing = numpy.array(ConstPixelSpacing)
    ConstPixelDims = numpy.array(ConstPixelDims)
    center = origin + (ConstPixelSpacing * ConstPixelDims / 2)
    DirectionCosines_x = (0, 0, 1, 0, 1, 0, -1, 0, 0)
    DirectionCosines_y = (1, 0, 0, 0, 0, -1, 0, 1, 0)
    DirectionCosines_z = (1, 0, 0, 0, 1, 0, 0, 0, 1)

    def mip_x():
        ImageSlab = vtk.vtkImageSlabReslice()
        ImageSlab.SetInputData(imagedata)
        ImageSlab.SetResliceAxesOrigin(center)
        ImageSlab.SetResliceAxesDirectionCosines(DirectionCosines_x)
        ImageSlab.SetSlabThickness(ConstPixelSpacing[0] * ConstPixelDims[0])
        ImageSlab.SetBlendModeToMax()
        ImageSlab.SetSlabResolution(ConstPixelSpacing[0])
        ImageSlab.Update()
        image = ImageSlab.GetOutput()
        m = image.GetDimensions()
        vtk_data = image.GetPointData().GetScalars()
        arr = numpy_support.vtk_to_numpy(vtk_data).reshape(m[1], m[0])
        arr = (arr - numpy.min(arr)) / (
            (numpy.max(arr) - numpy.min(arr)) / 255)
        width = ConstPixelDims[1]
        height = int(ConstPixelDims[2] *
                     (ConstPixelSpacing[2] / ConstPixelSpacing[1]))
        dim = (width, height)
        resized = cv2.resize(numpy.rot90(arr, 1),
                             dim,
                             interpolation=cv2.INTER_AREA)
        # cv2.imwrite( path + name +'.jpg', resized)
        return resized

    def mip_y():
        ImageSlab = vtk.vtkImageSlabReslice()
        ImageSlab.SetInputData(imagedata)
        ImageSlab.SetResliceAxesOrigin(center)
        ImageSlab.SetResliceAxesDirectionCosines(DirectionCosines_y)
        ImageSlab.SetSlabThickness(ConstPixelSpacing[1] * ConstPixelDims[1])
        ImageSlab.SetBlendModeToMax()
        ImageSlab.SetSlabResolution(ConstPixelSpacing[1])
        ImageSlab.Update()
        image = ImageSlab.GetOutput()
        m = image.GetDimensions()
        vtk_data = image.GetPointData().GetScalars()
        arr = numpy_support.vtk_to_numpy(vtk_data).reshape(m[1], m[0])
        arr = (arr - numpy.min(arr)) / (
            (numpy.max(arr) - numpy.min(arr)) / 255)
        width = int(ConstPixelDims[2] *
                    (ConstPixelSpacing[2] / ConstPixelSpacing[0]))
        height = ConstPixelDims[0]
        dim = (width, height)
        resized = cv2.resize(numpy.rot90(arr, -1),
                             dim,
                             interpolation=cv2.INTER_AREA)
        # cv2.imwrite( path + name +'.jpg', resized)
        return resized

    def mip_z():
        ImageSlab = vtk.vtkImageSlabReslice()
        ImageSlab.SetInputData(imagedata)
        ImageSlab.SetResliceAxesOrigin(center)
        ImageSlab.SetResliceAxesDirectionCosines(DirectionCosines_z)
        ImageSlab.SetSlabThickness(ConstPixelSpacing[2] * ConstPixelDims[2])
        ImageSlab.SetBlendModeToMax()
        ImageSlab.SetSlabResolution(ConstPixelSpacing[2])
        ImageSlab.Update()
        image = ImageSlab.GetOutput()
        m = image.GetDimensions()
        vtk_data = image.GetPointData().GetScalars()
        arr = numpy_support.vtk_to_numpy(vtk_data).reshape(m[1], m[0])
        arr = (arr - numpy.min(arr)) / (
            (numpy.max(arr) - numpy.min(arr)) / 255)
        # cv2.imwrite( path + name +'.jpg', arr)
        return arr

    pyplot.figure(figsize=(3, 1), dpi=300)
    pyplot.subplot(131)
    pyplot.imshow(numpy.rot90(mip_z(), 2), cmap='gray')
    pyplot.title('AxialSlice_MIP', fontsize=4, y=1.1)
    pyplot.xticks([])
    pyplot.yticks([])
    pyplot.subplot(132)
    pyplot.imshow(mip_x(), cmap='gray')
    pyplot.title('CoronalSlice_MIP', fontsize=4, y=1.1)
    pyplot.xticks([])
    pyplot.yticks([])
    pyplot.subplot(133)
    pyplot.imshow(numpy.rot90(mip_y(), 1), cmap='gray')
    pyplot.title('SagitalSlice_MIP', fontsize=4, y=1.1)
    pyplot.xticks([])
    pyplot.yticks([])
    pyplot.tight_layout(pad=1.3, w_pad=2)
    pyplot.subplots_adjust(wspace=0, hspace=0)
    pyplot.savefig(filepath + '/' + 'MIP_image.jpg')
    pyplot.show()
    return None
Esempio n. 42
0
    hidden_l7 = np.load(
        '/home/aurora/workspaces/PycharmProjects/tensorflow/L_SoftMax_TensorFlow/data/hidden_m7.npy'
    )
    labels_l7 = np.load(
        '/home/aurora/workspaces/PycharmProjects/tensorflow/L_SoftMax_TensorFlow/data/labels_m7.npy'
    )

    hidden_l8 = np.load(
        '/home/aurora/workspaces/PycharmProjects/tensorflow/L_SoftMax_TensorFlow/data/hidden_m8.npy'
    )
    labels_l8 = np.load(
        '/home/aurora/workspaces/PycharmProjects/tensorflow/L_SoftMax_TensorFlow/data/labels_m8.npy'
    )

    plt.set_cmap('hsv')
    plt.subplot(241)
    m1 = plt.scatter(hidden[:, 0],
                     hidden[:, 1],
                     c=labels,
                     label='m=1, test_acc=0.9811')
    plt.legend(handles=[m1],
               bbox_to_anchor=(0., 1.02, 1., .102),
               loc=3,
               mode="expand",
               borderaxespad=0.)

    plt.subplot(242)
    m2 = plt.scatter(hidden_l2[:, 0],
                     hidden_l2[:, 1],
                     c=labels_l2,
#Loading Dataset
iris = np.loadtxt('iris.csv', delimiter=',')
x, y = iris[:, :4], iris[:, 4].astype(
    np.int
)  # x: (observations x attributes) matrix, y: classes (1: setosa, 2: versicolor, 3: virginica)
x.shape
y.shape

#Dimensionality reduction by Principal Component Analysis (PCA)
pca = mlpy.PCA()  # new PCA instance
pca.learn(x)  # learn from data
z = pca.transform(x, k=2)  # embed x into the k=2 dimensional subspace
z.shape

#Plot the principal components:
plt.set_cmap(plt.cm.Paired)
fig1 = plt.figure(1)
title = plt.title("PCA on iris dataset")
plot = plt.scatter(z[:, 0], z[:, 1], c=y)
labx = plt.xlabel("First component")
laby = plt.ylabel("Second component")
plt.show()

#Learning by Kernel Support Vector Machines (SVMs) on principal components:
linear_svm = mlpy.LibSvm(kernel_type='linear')  # new linear SVM instance
linear_svm.learn(z, y)  # learn from principal components

#For plotting purposes, we build the grid where we will compute the predictions (zgrid):
xmin, xmax = z[:, 0].min() - 0.1, z[:, 0].max() + 0.1
ymin, ymax = z[:, 1].min() - 0.1, z[:, 1].max() + 0.1
xx, yy = np.meshgrid(np.arange(xmin, xmax, 0.01), np.arange(ymin, ymax, 0.01))
Esempio n. 44
0
        ),
    )
    grid = ImageGrid(fig, 111, nrows_ncols=(4, ncols), axes_pad=0.1)

    fig2, axp = plt.subplots(
        dpi=150,
        figsize=(plot_size * ncols, 4),
        subplotpars=mpl.figure.SubplotParams(
            bottom=0.1,
            left=0.025,
            right=0.975,
            top=0.925,
        ),
    )

    plt.set_cmap("inferno")

    for (i, p), l, col in zip(enumerate(psfs), labels, grid.axes_column):
        print(p)
        p = p.PSF
        p /= p.max()

        psf_plot_style = dict(norm=mpl.colors.PowerNorm(gam),
                              interpolation=interpolation,
                              cmap="Greys_r")

        col[0].imshow(p.max(1), **psf_plot_style)
        col[1].imshow(p.max(0), **psf_plot_style)

        col[0].set_title(l)
Esempio n. 45
0
def showimage(img):
    if img.ndim == 3:
        img = img[:, :, ::-1]
    plt.set_cmap('jet')
    plt.imshow(img, vmin=0, vmax=0.2)
Esempio n. 46
0
def Get_image(filepath):
    lstFilesDCM = []
    DcmName = []
    for dirName, subdirList, fileList in sorted(os.walk(filepath)):
        fileList = natsorted(fileList)
        for filename in fileList:
            if ".dcm" in filename.lower():  # 判断文件是否为dicom文件
                lstFilesDCM.append(os.path.join(dirName, filename))  # 加入到列表中
                DcmName.append(filename)

    gap = len(DcmName) - 1
    file_one = pydicom.read_file(lstFilesDCM[0], force=True)
    z_one = file_one.ImagePositionPatient[2]
    file_tow = pydicom.read_file(lstFilesDCM[gap], force=True)
    z_tow = file_tow.ImagePositionPatient[2]
    columns = file_one.Columns
    row = file_one.Rows
    ConstPixelDims = (int(row), int(columns), len(lstFilesDCM))
    if z_one > z_tow:
        slice_gap = (z_one - z_tow) / gap
        ConstOrigin = (file_tow.ImagePositionPatient[0],
                       file_tow.ImagePositionPatient[1],
                       file_tow.ImagePositionPatient[2])
        ConstPixelSpacing = (float(file_tow.PixelSpacing[0]),
                             float(file_tow.PixelSpacing[1]), float(slice_gap))
    else:
        slice_gap = (z_tow - z_one) / gap
        ConstOrigin = (file_one.ImagePositionPatient[0],
                       file_one.ImagePositionPatient[1],
                       file_one.ImagePositionPatient[2])
        ConstPixelSpacing = (float(file_one.PixelSpacing[0]),
                             float(file_one.PixelSpacing[1]), float(slice_gap))
    image_1 = int(ConstPixelDims[0] // 2)
    image_2 = int(ConstPixelDims[1] // 2)
    image_3 = int(ConstPixelDims[2] // 2)
    x = numpy.arange(
        0.0, (ConstPixelDims[0] + 1) * ConstPixelSpacing[0],
        ConstPixelSpacing[0])  # 0到(第一个维数加一*像素间的间隔),步长为constpixelSpacing
    y = numpy.arange(0.0, (ConstPixelDims[1] + 1) * ConstPixelSpacing[1],
                     ConstPixelSpacing[1])  #
    z = numpy.arange(0.0, (ConstPixelDims[2] + 1) * ConstPixelSpacing[2],
                     ConstPixelSpacing[2])  #
    ArrayDicom = numpy.zeros(ConstPixelDims, dtype=file_one.pixel_array.dtype)

    # 遍历所有的dicom文件,读取图像数据,存放在numpy数组中
    for filenameDCM in lstFilesDCM:
        ds = pydicom.read_file(filenameDCM)
        ArrayDicom[:, :, lstFilesDCM.index(filenameDCM)] = ds.pixel_array

    pyplot.figure(dpi=300)
    pyplot.axes().set_aspect('equal', 'datalim')
    pyplot.set_cmap(pyplot.gray())
    pyplot.pcolormesh(x, y,
                      numpy.flipud(ArrayDicom[:, :,
                                              image_3]))  # 第三个维度表示现在展示的是第几层
    pyplot.axis('off')
    buffer_ = io.BytesIO()
    pyplot.savefig(buffer_, format='png')
    buffer_.seek(0)
    img1 = PIL.Image.open(buffer_)
    img_arr1 = numpy.asarray(img1)
    buffer_.close()

    pyplot.figure(dpi=300)
    pyplot.axes().set_aspect('equal', 'datalim')
    pyplot.set_cmap(pyplot.gray())
    pyplot.pcolormesh(
        y, z, numpy.fliplr(numpy.rot90((ArrayDicom[image_1, :, :]), 3)))
    pyplot.axis('off')
    buffer_ = io.BytesIO()
    pyplot.savefig(buffer_, format='png')
    buffer_.seek(0)
    img2 = PIL.Image.open(buffer_)
    img_arr2 = numpy.asarray(img2)
    buffer_.close()

    pyplot.figure(dpi=300)
    pyplot.axes().set_aspect('equal', 'datalim')
    pyplot.set_cmap(pyplot.gray())
    pyplot.pcolormesh(
        x, z, numpy.fliplr(numpy.rot90((ArrayDicom[:, image_2, :]), 3)))
    pyplot.axis('off')
    buffer_ = io.BytesIO()
    pyplot.savefig(buffer_, format='png')
    buffer_.seek(0)
    img3 = PIL.Image.open(buffer_)
    img_arr3 = numpy.asarray(img3)
    buffer_.close()

    pyplot.figure(figsize=(3, 1), dpi=300)
    pyplot.subplot(131)
    pyplot.imshow(img_arr1)
    pyplot.title('AxialSlice', fontsize=4, y=0.9)
    pyplot.axis('off')
    pyplot.xticks([])
    pyplot.yticks([])
    pyplot.subplot(132)
    pyplot.imshow(img_arr2)
    pyplot.title('CoronalSlice', fontsize=4, y=0.9)
    pyplot.axis('off')
    pyplot.xticks([])
    pyplot.yticks([])
    pyplot.subplot(133)
    pyplot.imshow(img_arr3)
    pyplot.title('SagitalSlice', fontsize=4, y=0.9)
    pyplot.axis('off')
    pyplot.xticks([])
    pyplot.yticks([])
    pyplot.tight_layout(pad=0.5, w_pad=2)
    pyplot.subplots_adjust(wspace=0, hspace=0)
    pyplot.savefig(filepath + '/' + 'image.jpg')
    pyplot.show()

    Array_vtk = numpy_support.numpy_to_vtk(ArrayDicom.ravel('F'),
                                           deep=True,
                                           array_type=vtk.VTK_FLOAT)
    imagedata = vtk.vtkImageData()
    imagedata.SetOrigin(ConstOrigin)
    imagedata.SetSpacing(ConstPixelSpacing)
    imagedata.SetDimensions(ConstPixelDims)
    imagedata.GetPointData().SetScalars(Array_vtk)
    origin = numpy.array(ConstOrigin)
    ConstPixelSpacing = numpy.array(ConstPixelSpacing)
    ConstPixelDims = numpy.array(ConstPixelDims)
    center = origin + (ConstPixelSpacing * ConstPixelDims / 2)
    DirectionCosines_x = (0, 0, 1, 0, 1, 0, -1, 0, 0)
    DirectionCosines_y = (1, 0, 0, 0, 0, -1, 0, 1, 0)
    DirectionCosines_z = (1, 0, 0, 0, 1, 0, 0, 0, 1)

    def mip_x():
        ImageSlab = vtk.vtkImageSlabReslice()
        ImageSlab.SetInputData(imagedata)
        ImageSlab.SetResliceAxesOrigin(center)
        ImageSlab.SetResliceAxesDirectionCosines(DirectionCosines_x)
        ImageSlab.SetSlabThickness(ConstPixelSpacing[0] * ConstPixelDims[0])
        ImageSlab.SetBlendModeToMax()
        ImageSlab.SetSlabResolution(ConstPixelSpacing[0])
        ImageSlab.Update()
        image = ImageSlab.GetOutput()
        m = image.GetDimensions()
        vtk_data = image.GetPointData().GetScalars()
        arr = numpy_support.vtk_to_numpy(vtk_data).reshape(m[1], m[0])
        arr = (arr - numpy.min(arr)) / (
            (numpy.max(arr) - numpy.min(arr)) / 255)
        width = columns
        height = int(
            len(lstFilesDCM) * (ConstPixelSpacing[2] / ConstPixelSpacing[1]))
        dim = (width, height)
        resized = cv2.resize(numpy.rot90(arr, 1),
                             dim,
                             interpolation=cv2.INTER_AREA)
        return resized

    def mip_y():
        ImageSlab = vtk.vtkImageSlabReslice()
        ImageSlab.SetInputData(imagedata)
        ImageSlab.SetResliceAxesOrigin(center)
        ImageSlab.SetResliceAxesDirectionCosines(DirectionCosines_y)
        ImageSlab.SetSlabThickness(ConstPixelSpacing[1] * ConstPixelDims[1])
        ImageSlab.SetBlendModeToMax()
        ImageSlab.SetSlabResolution(ConstPixelSpacing[1])
        ImageSlab.Update()
        image = ImageSlab.GetOutput()
        m = image.GetDimensions()
        vtk_data = image.GetPointData().GetScalars()
        arr = numpy_support.vtk_to_numpy(vtk_data).reshape(m[1], m[0])
        arr = (arr - numpy.min(arr)) / (
            (numpy.max(arr) - numpy.min(arr)) / 255)
        width = int(
            len(lstFilesDCM) * (ConstPixelSpacing[2] / ConstPixelSpacing[0]))
        height = row
        dim = (width, height)
        resized = cv2.resize(numpy.rot90(arr, -1),
                             dim,
                             interpolation=cv2.INTER_AREA)
        # cv2.imwrite( path +'/'+ name +'.jpg', resized)
        return resized

    def mip_z():
        ImageSlab = vtk.vtkImageSlabReslice()
        ImageSlab.SetInputData(imagedata)
        ImageSlab.SetResliceAxesOrigin(center)
        ImageSlab.SetResliceAxesDirectionCosines(DirectionCosines_z)
        ImageSlab.SetSlabThickness(ConstPixelSpacing[2] * ConstPixelDims[2])
        ImageSlab.SetBlendModeToMax()
        ImageSlab.SetSlabResolution(ConstPixelSpacing[2])
        ImageSlab.Update()
        image = ImageSlab.GetOutput()
        m = image.GetDimensions()
        vtk_data = image.GetPointData().GetScalars()
        arr = numpy_support.vtk_to_numpy(vtk_data).reshape(m[1], m[0])
        arr = (arr - numpy.min(arr)) / (
            (numpy.max(arr) - numpy.min(arr)) / 255)
        arr = numpy.rot90(arr, -1)
        # cv2.imwrite(path+'/'+name+'.jpg', numpy.rot90(arr, -1))
        return arr

    pyplot.figure(figsize=(3, 1), dpi=300)
    pyplot.subplot(131)
    pyplot.imshow(mip_z(), cmap='gray')
    pyplot.title('AxialSlice_MIP', fontsize=4, y=1.1)
    pyplot.xticks([])
    pyplot.yticks([])
    pyplot.subplot(132)
    pyplot.imshow(mip_x(), cmap='gray')
    pyplot.title('CoronalSlice_MIP', fontsize=4, y=1.1)
    pyplot.xticks([])
    pyplot.yticks([])
    pyplot.subplot(133)
    pyplot.imshow(numpy.rot90(mip_y(), 1), cmap='gray')
    pyplot.title('SagitalSlice_MIP', fontsize=4, y=1.1)
    pyplot.xticks([])
    pyplot.yticks([])
    pyplot.tight_layout(pad=1.3, w_pad=2)
    pyplot.subplots_adjust(wspace=0, hspace=0)
    pyplot.savefig(filepath + '/' + 'MIP_image.jpg')
    pyplot.show()
    return None
Esempio n. 47
0
    plt.xlabel("time (sec)")
    plt.margins(0, .1)

    # make the phase plot
    plt.subplot(133)
    plt.grid(alpha=.5)
    plt.plot(Y, dY, alpha=.5, lw=.5, color=cm(abf.sweep / abf.sweeps))
    plt.title("phase plot")
    plt.ylabel("dV (mV/ms)")
    plt.xlabel("V (mV)")
    plt.margins(.1, .1)

    # tighten up the figure
    plt.tight_layout()


if __name__ == "__main__":
    #abf=swhlab.ABF(R"X:\Data\SCOTT\2017-07-13 OXT-Tom OneOff\17713015.abf")
    abf = swhlab.ABF(R"X:\Data\SCOTT\2017-07-13 OXT-Tom OneOff\17713013.abf")

    plt.figure(figsize=(12, 4))
    for sweep in abf.setsweeps():
        #if sweep<abf.sweeps-1: continue
        print("plotting sweep", sweep, '...')
        plt.set_cmap('winter')
        drawPhasePlot(abf)
    plt.savefig("phase_%s.png" % abf.ID, dpi=300)
    plt.show()

    plt.close('all')
    print("DONE")
Esempio n. 48
0
#Load spacing values (in mm)
ConstPixelSpacing = (float(Ref_CT.PixelSpacing[1]),
                     float(Ref_CT.PixelSpacing[0]),
                     float(Ref_CT.SliceThickness))

x = np.arange(0.0, (ConstPixelDims[0] + 1) * ConstPixelSpacing[0],
              ConstPixelSpacing[0])
y = np.arange(-(ConstPixelDims[1] + 1) * ConstPixelSpacing[1], 0.0,
              ConstPixelSpacing[1])
z = np.arange(0.0, (ConstPixelDims[2] + 1) * ConstPixelSpacing[2],
              ConstPixelSpacing[2])

ArrayDicom = np.zeros(ConstPixelDims, dtype=Ref_CT.pixel_array.dtype)

for i, DCMfile in enumerate(CT_slide):
    ArrayDicom[:, :, i] = DCMfile.pixel_array
"""
 plt.figure(dpi=300)
 plt.axes().set_aspect('equal', 'datalim')
 plt.set_cmap(plt.gray())
 plt.pcolormesh(x, y, np.flipud(ArrayDicom[:, :, 50]))
 plt.show()
"""
ResArray = ndinter.zoom(ArrayDicom, ConstPixelSpacing, order=1)
plt.figure(dpi=300)
plt.axes().set_aspect('equal', 'datalim')
plt.set_cmap(plt.gray())
#plt.pcolormesh(x, y, ResArray[:, :, 150]))
plt.imshow(ResArray[:, :, 100])

plt.show()
def plot2D(result,
           par1,
           par2,
           colorMap=getColorMap(),
           labelSize=15,
           fontSize=10,
           axisHandle=None,
           showImediate=True):
    """ 
    This function constructs a 2 dimensional marginal plot of the posterior
    density. This is the same plot as it is displayed in plotBayes in an
    unmodifyable way.

    The result struct is passed as result.
    par1 and par2 should code the two parameters to plot:
        0 = threshold
        1 = width
        2 = lambda
        3 = gamma
        4 = eta
        
    Further plotting options may be passed.
    """
    # convert strings to dimension number
    par1, label1 = _utils.strToDim(str(par1))
    par2, label2 = _utils.strToDim(str(par2))

    assert (
        par1 != par2
    ), 'par1 and par2 must be different numbers to code for the parameters to plot'

    if axisHandle == None:
        axisHandle = plt.gca()

    try:
        plt.axes(axisHandle)
    except TypeError:
        raise ValueError('Invalid axes handle provided to plot in.')

    plt.set_cmap(colorMap)

    marg, _, _ = marginalize(result, np.array([par1, par2]))

    if par1 > par2:
        marg = marg.T

    if 1 in marg.shape:
        if len(result['X1D'][par1]) == 1:
            plotMarginal(result, par2)
        else:
            plotMarginal(result, par2)
    else:
        e = [result['X1D'][par2][0], result['X1D'][par2][-1], \
             result['X1D'][par1][0], result['X1D'][par1][-1]]
        plt.imshow(marg, extent=e)
        plt.ylabel(label1, fontsize=labelSize)
        plt.xlabel(label2, fontsize=labelSize)

    plt.tick_params(direction='out', right='off', top='off')
    for side in ['top', 'right']:
        axisHandle.spines[side].set_visible(False)
    plt.ticklabel_format(style='sci', scilimits=(-2, 4))
    if (showImediate):
        plt.show(0)
Esempio n. 50
0
    # いらすとやの画像はアルファチャンネルがあるのでこれをまず白にする
    # ImageMagickの convert -flatten x.png y.png に対応
    img = cv2.imread(path, cv2.IMREAD_UNCHANGED)
    #    if img.shape[2] == 4:
    #        mask = img[:,:,3] == 0
    #        img[mask] = [255] * 4
    #        img = cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # ノイズ除去が必要なら
    # gray = cv2.fastNlMeansDenoising(gray, h=20)
    # 白い部分を膨張させる
    dilated = cv2.dilate(gray, kernel, iterations=1)
    # 差をとる
    diff = cv2.absdiff(dilated, gray)  # 白黒反転して2値化
    _, contour = cv2.threshold(255 - diff, 240, 255, cv2.THRESH_BINARY)
    # あるいは
    #contour = cv2.adaptiveThreshold(255 - diff, 255,
    #        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
    #        cv2.THRESH_BINARY, 7, 8)
    return contour


# plt.close("all")
# plt.figure(figsize=[8, 8])
plt.set_cmap("gray")
# plt.clf()
contour = makecontour("IMG_3147.PNG")
plt.imshow(contour)
cv2.imwrite("190831a.png", contour)

FIG = plt.figure(figsize=(30,25))

AuG_type = 'AuGMEnT'
tit_aug = 'AuGMEnT'

d = 3
S = d+2

savestr = 'DATA/'+AuG_type+'_'+task+'_'+'distr'+str(d)+'_weights_Vm.txt'
X_a3 = np.loadtxt(savestr)

plt.subplot(2,3,1)
plt.pcolor(np.flipud(X_a3),edgecolors='k', linewidths=1)
plt.set_cmap('bwr')		
cb = plt.colorbar()
cb.ax.tick_params(labelsize=fontLabel)
tit = tit_aug+' (L='+str(d+2)+')'
plt.title(tit,fontweight="bold",fontsize=fontTitle)
plt.xticks(np.linspace(0.5,M-0.5,M,endpoint=True),mem_vec_c,fontsize=fontTicks)
plt.yticks(np.linspace(0.5,2*S-0.5,2*S,endpoint=True),np.flipud(cues_vec_3),fontsize=fontTicks)
plt.ylabel('Transient Unit Labels', fontsize=fontLabel)

d = 8
S = d+2
savestr = 'DATA/'+AuG_type+'_'+task+'_'+'distr'+str(d)+'_weights_Vm.txt'
X_a8 = np.loadtxt(savestr)

plt.subplot(2,3,4)
plt.pcolor(np.flipud(X_a8),edgecolors='k', linewidths=1)
fig = plt.figure(figsize=(2, 4))
gs = GridSpec(2, 1, figure=fig)
ax = []

#ax_rthist=fig.add_subplot(gs[5:7,0:4])
#ax2_rthist=fig.add_subplot(gs[1:3,12:])
#ax2_bthist=fig.add_subplot(gs[7:,6:12])
frames_to_plot = [49, 50]
for ind, crframe in enumerate(frames_to_plot):
    try:
        ax.append(fig.add_subplot(gs[ind, 0]))
    except:
        pdb.set_trace()

for crind in np.arange(len(file_names)):
    plt.set_cmap('viridis')
    dt = util.read_in_tif(data_path + file_names[crind])
    for ind, crframe in enumerate(frames_to_plot):
        #mean_xy=np.mean(dt['tifstack'],axis=0)
        #mean_z=np.mean(dt['tifstack'],axis=1)
        imshowobj = ax[ind].imshow(dt['tifstack'][crframe, :, :])
        #imshowobj.set_clim(20,28)
        fpl.adjust_spines(ax[ind], [])
        ax[ind].set_xlim(200, 1150)
        ax[ind].set_ylim(50, 200)
        #microns_mean_z=np.shape(mean_z)[1]*microns_per_pixel
        #ax.plot([970,970+20/microns_per_pixel],[775,775],'w')
    #aspect_ratio=microns_mean_z/100.
    #imshowobj2=ax2.imshow(mean_z)
    #imshowobj2.set_clim(14.6,16.5)
    #fpl.adjust_spines(ax2,[])
Esempio n. 53
0
    def _visualize(self, data, out_name):
        from matplotlib import pyplot as plt

        plt.set_cmap('viridis')
        plot_and_save(out_name, nlp.plot_design_matrix, data)
Esempio n. 54
0
    def bias_plot2D(self, mod, ctx: Context, spotfilter, tag):
        sf_d, g2d_d = self.simflux_fit(mod, ctx, spotfilter=spotfilter)
        shift = sf_d.get_xyI()[:, [0, 1]] - g2d_d.get_xyI()[:, [0, 1]]
        pos = g2d_d.get_xyI()

        rms = np.sqrt(np.mean(shift**2, 0))
        print(
            f"RMS x shift={rms[0]*self.pixelsize}, y shift={rms[1]*self.pixelsize}"
        )

        shape = self.locs.get_image_size()
        w = 100

        print(f"running 2D bias fit over {len(pos)} points")

        gridshape = [w, w]

        #        statfn = 'median'

        def median_mincount(x, minsize):
            if len(x) < minsize:
                return np.nan
            return np.median(x)

        def rms_mincount(x, minsize):
            if len(x) < minsize:
                return np.nan
            return np.sqrt(np.mean(x**2))

        statfn = lambda x: median_mincount(x, 20)
        metric = 'Median bias'
        #       statfn = lambda x: rms_mincount(x,20)
        #        metric='RMS'
        scatter = True

        clustergrid = [w, w]
        xysx = fitpoints2D.hist2d_statistic_points(pos[:, 0],
                                                   pos[:, 1],
                                                   shift[:, 0],
                                                   shape,
                                                   clustergrid,
                                                   statistic=statfn)
        xysy = fitpoints2D.hist2d_statistic_points(pos[:, 0],
                                                   pos[:, 1],
                                                   shift[:, 1],
                                                   shape,
                                                   clustergrid,
                                                   statistic=statfn)

        rms_x = np.sqrt(np.mean(xysx[:, 2]**2))
        rms_y = np.sqrt(np.mean(xysy[:, 2]**2))
        print(
            f"RMS clusters x shift={rms_x*self.pixelsize}, y shift={rms_y*self.pixelsize}"
        )

        print(f"2D bias plot: plotting {len(xysx)} clusters")

        plt.figure(figsize=figsize)
        plt.hist([xysx[:, 2] * self.pixelsize, xysy[:2] * self.pixelsize],
                 label=['X bias', 'Y bias'],
                 range=[-50, 50],
                 bins=50)
        plt.title('SMLM-SIMFLUX difference histogram')
        plt.xlabel(
            'Mean difference between SMLM and SIMFLUX within one cluster [nm]')
        plt.legend()
        plt.savefig(self.outdir + tag + "bias-hist.svg")
        plt.savefig(self.outdir + tag + "bias-hist.png")

        xysx[:, 2] = np.clip(xysx[:, 2], -1, 1)
        xysy[:, 2] = np.clip(xysy[:, 2], -1, 1)

        img_x, coeff_x = fitpoints2D.fitlsq(xysx[:, 0], xysy[:, 1], xysx[:, 2],
                                            shape, gridshape)
        img_y, coeff_y = fitpoints2D.fitlsq(xysy[:, 0], xysy[:, 1], xysy[:, 2],
                                            shape, gridshape)

        plt.figure(figsize=figsize)
        plt.set_cmap('viridis')
        #        plt.imshow(img_x, origin='lower',extent=[0,shape[1],0,shape[0]])
        s = self.pixelsize / 1000
        sc = self.pixelsize
        if scatter:
            plt.scatter(s * xysx[:, 0], s * xysx[:, 1], c=sc * xysx[:, 2])
        cb = plt.colorbar()
        cb.set_label('Bias in X [nm]')
        plt.clim([-20, 20])
        plt.xlabel(u'X position in FOV [um]')
        plt.ylabel(u'Y position in FOV [um]')
        plt.title(f'{metric} in X over FOV')
        plt.savefig(self.outdir + tag + "x-bias-fov.png")
        plt.savefig(self.outdir + tag + "x-bias-fov.svg")

        plt.figure(figsize=figsize)
        #       plt.imshow(img_y, origin='lower',  extent=[0,shape[1],0,shape[0]])
        if scatter:
            plt.scatter(s * xysy[:, 0], s * xysy[:, 1], c=sc * xysy[:, 2])
        cb = plt.colorbar()
        cb.set_label('Bias in Y [nm]')
        plt.clim([-20, 20])
        plt.xlabel(u'X position in FOV [um]')
        plt.ylabel(u'Y position in FOV [um]')
        plt.title(f'{metric} in Y over FOV')
        plt.savefig(self.outdir + tag + "y-bias-fov.png")
        plt.savefig(self.outdir + tag + "y-bias-fov.svg")
Esempio n. 55
0
    def _view_matrix(self, matrix, figsize, colormap, colorbar, bestmatches,
                     bestmatchcolors, labels, zoom, filename):
        """Internal function to plot a map with best matching units and labels.
        """
        if zoom is None:
            zoom = ((0, self._n_rows), (0, self._n_columns))
        if figsize is None:
            figsize = (8, 8 / float(zoom[1][1] / zoom[0][1]))
        fig = plt.figure(figsize=figsize)
        if self._grid_type == "hexagonal":
            offsets = _hexplot(
                matrix[zoom[0][0]:zoom[0][1], zoom[1][0]:zoom[1][1]], fig,
                colormap)
            filtered_bmus = self.filter_array(self.bmus, zoom)
            filtered_bmus[:, 0] = filtered_bmus[:, 0] - zoom[1][0]
            filtered_bmus[:, 1] = filtered_bmus[:, 1] - zoom[0][0]
            bmu_coords = np.zeros(filtered_bmus.shape)
            for i, (row, col) in enumerate(filtered_bmus):
                bmu_coords[i] = offsets[col * zoom[1][1] + row]
        else:
            plt.imshow(matrix[zoom[0][0]:zoom[0][1], zoom[1][0]:zoom[1][1]],
                       aspect='auto')
            plt.set_cmap(colormap)
            bmu_coords = self.filter_array(self.bmus, zoom)
            bmu_coords[:, 0] = bmu_coords[:, 0] - zoom[1][0]
            bmu_coords[:, 1] = bmu_coords[:, 1] - zoom[0][0]
        if colorbar:
            cmap = cm.ScalarMappable(cmap=colormap)
            cmap.set_array(matrix)
            plt.colorbar(cmap, orientation='horizontal', shrink=0.5)

        if bestmatches:
            if bestmatchcolors is None:
                if self.clusters is None:
                    colors = "white"
                else:
                    colors = []
                    for bm in self.bmus:
                        colors.append(self.clusters[bm[1], bm[0]])
                    colors = self.filter_array(colors, zoom)
            else:
                colors = self.filter_array(bestmatchcolors, zoom)
            plt.scatter(bmu_coords[:, 0], bmu_coords[:, 1], c=colors)

        if labels is not None:
            for label, col, row in zip(self.filter_array(labels, zoom),
                                       bmu_coords[:, 0], bmu_coords[:, 1]):
                if label is not None:
                    plt.annotate(label,
                                 xy=(col, row),
                                 xytext=(10, -5),
                                 textcoords='offset points',
                                 ha='left',
                                 va='bottom',
                                 bbox=dict(boxstyle='round,pad=0.3',
                                           fc='white',
                                           alpha=0.8))
        plt.axis('off')
        if filename is not None:
            plt.savefig(filename)
        else:
            plt.show()
        return plt
Esempio n. 56
0
    f['t'] = cum

l = {
    key: [item[key] for item in d]
    for key in list(
        reduce(lambda x, y: x.union(y), (set(dicts.keys()) for dicts in d)))
}

print("Lap length = %s m" % str(round(l['dist'][-1], 2)))
print("Lap time = %s s" % str(round(l['t'][-1], 4)))
print("Max velocity = %s m/s" % str(round(max(l['vel']), 3)))
print("Max lateral accel = %s g" % str(round(max(l['A_lat']) / G, 3)))
print("Max longitudinal accel = %s g" % str(round(max(l['A_long']) / G, 3)))
print("Min longitudinal accel = %s g" % str(round(min(l['A_long']) / G, 3)))

if plot_mode == "track":
    plt.set_cmap('cool')
    plt.scatter(l['x'],
                l['y'],
                c=[min(max(d, -30), 30) for i, d in enumerate(l['vel'])],
                s=1)
    plt.axis('equal')
    plt.colorbar()
    plt.show()
elif plot_mode == "time":
    plt.scatter([x for i, x in enumerate(l['t'])][:2000],
                [d for i, d in enumerate(l['vel'])][:2000],
                label="vel")
    plt.legend(loc='best')
    plt.show()
Esempio n. 57
0
# Plot the decision boundary. For that, we will asign a color to each
# point in the mesh [x_min, m_max]x[y_min, y_max].
x_min, x_max = X[:, 0].min() - .5, X[:, 0].max(
) + .5  #Defines min and max on the x-axis
y_min, y_max = X[:, 1].min() - .5, X[:, 1].max(
) + .5  #Defines min and max on the y-axis
h = (x_max - x_min) / 300  # step size in the mesh to plot entire areas
xx, yy = np.meshgrid(np.arange(x_min, x_max, h),
                     np.arange(y_min, y_max, h))  #Defines meshgrid
Z = vector.predict(np.c_[xx.ravel(), yy.ravel(
)])  #Uses the calibrated model knn and running on "fake" data in meshgrid

# Put the result into a color plot
Z = Z.reshape(xx.shape)  #Reshape for matplotlib
plt.figure(1)  #create one figure
plt.set_cmap(plt.cm.Paired)  #Picks color for
plt.pcolormesh(xx, yy, Z)  #Plot for the data

# Plot also the training points
colormap = np.array(
    ['white',
     'black'])  #BGive two colors based on values of 0 and 1 from HW6_Data
plt.scatter(
    X[:, 0], X[:, 1], c=colormap[Y]
)  #Plot the data as a scatter plot, note that the color changes with Y.

plt.xlabel("X1")  #Adding axis labels
plt.ylabel("X2")
plt.xlim(xx.min(), xx.max())  #Setting limits of axes
plt.ylim(yy.min(), yy.max())
plt.xticks(())  #Removing tick marks
Esempio n. 58
0
def display_data(X, example_width=None):
    # DISPLAYDATA Display 2D data in a nice grid
    #   [h, display_array] = DISPLAYDATA(X, example_width) displays 2D data
    #   stored in X in a nice grid. It returns the figure handle h and the
    #   displayed array if requested.

    # closes previously opened figure. preventing a
    # warning after opening too many figures
    plt.close()

    # creates new figure
    plt.figure()

    # turns 1D X array into 2D
    if X.ndim == 1:
        X = np.reshape(X, (-1, X.shape[0]))

    # Set example_width automatically if not passed in
    if not example_width or not 'example_width' in locals():
        example_width = int(round(math.sqrt(X.shape[1])))

    # Gray Image
    plt.set_cmap("gray")

    # Compute rows, cols
    m, n = X.shape
    example_height = int(n / example_width)

    # Compute number of items to display
    display_rows = int(math.floor(math.sqrt(m)))
    display_cols = int(math.ceil(m / display_rows))

    # Between images padding
    pad = 1

    # Setup blank display
    len1 = int(pad + display_rows * (example_height + pad))
    len2 = pad + display_cols * (example_width + pad)
    display_array = -np.ones((len1, len2))

    # Copy each example into a patch on the display array
    curr_ex = 1
    for j in range(1, display_rows + 1):
        for i in range(1, display_cols + 1):
            if curr_ex > m:
                break

            # Copy the patch

            # Get the max value of the patch to normalize all examples
            max_val = max(abs(X[curr_ex - 1, :]))
            rows = pad + (j - 1) * (example_height + pad) + np.array(
                range(example_height))
            cols = pad + (i - 1) * (example_width + pad) + np.array(
                range(example_width))

            # Basic (vs. advanced) indexing/slicing is necessary so that we look can assign
            # 	values directly to display_array and not to a copy of its subarray.
            # 	from stackoverflow.com/a/7960811/583834 and
            # 	bytes.com/topic/python/answers/759181-help-slicing-replacing-matrix-sections
            # Also notice the order="F" parameter on the reshape call - this is because python's
            #	default reshape function uses "C-like index order, with the last axis index
            #	changing fastest, back to the first axis index changing slowest" i.e.
            #	it first fills out the first row/the first index, then the second row, etc.
            #	matlab uses "Fortran-like index order, with the first index changing fastest,
            #	and the last index changing slowest" i.e. it first fills out the first column,
            #	then the second column, etc. This latter behaviour is what we want.
            #	Alternatively, we can keep the deault order="C" and then transpose the result
            #	from the reshape call.
            display_array[rows[0]:rows[-1] + 1, cols[0]:cols[-1] +
                          1] = np.reshape(X[curr_ex - 1, :],
                                          (example_height, example_width),
                                          order="F") / max_val
            curr_ex += 1

        if curr_ex > m:
            break

    # Display Image
    h = plt.imshow(display_array, vmin=-1, vmax=1)

    # Do not show axis
    plt.axis('off')

    plt.show()

    return h, display_array
import matplotlib.pyplot as plt
import matplotlib
import pandas as pd
from mpl_toolkits.mplot3d import Axes3D
import numpy as np
import math as mth
from itertools import product, combinations
from matplotlib import rc
# activate latex text rendering
rc('text', usetex=True)

#set rc parameters for plotting
matplotlib.rcParams.update({'font.size': 60})
matplotlib.rcParams['axes.labelpad'] = 70
plt.rcParams["font.family"] = "Times New Roman"
plt.set_cmap("jet")

#import data to be plotted
data = pd.read_csv(r'C:\Users\Theo\PartIII\FINAL_LatticeSpinsT05.csv')
Lattice = pd.DataFrame(data, columns=['i', 'j', 'k', 'Spin'])
data = pd.read_csv(r'C:\Users\Theo\PartIII\FINAL_LatticeT05.csv')
LatticeSize = pd.DataFrame(data, columns=['i', 'j', 'k', 'Spin Flips'])
data = pd.read_csv(r'C:\Users\Theo\PartIII\FINAL_NearestNeighbourT05.csv')
LatticeNeighbours = pd.DataFrame(data, columns=['i', 'j', 'k', 'Neighbours'])

#assign gif and ax for full lattice plot
fig = plt.figure()
ax = plt.axes(projection="3d")

#convert lattice indexing to cartesian coordinates
x_coord = (Lattice['i'] + Lattice['j'])
Esempio n. 60
0
    def train(self, plotmode=False):

        pbar = tqdm(total=self.max_iter)
        pbar.update(self.global_iter)

        out = False

        running_loss_terminal_display = 0.0  # running loss for the trainstats (gathered and pickeled)

        running_loss_trainstats = 0.0  # running loss for the trainstats (gathered and pickeled)
        """ /begin of non-generic part (might need to be adapted for different models / data)"""
        running_recon_loss_trainstats = 0.0
        running_pred_loss_trainstats = 0.0
        plot_total_loss = []
        plot_recon_loss = []
        plot_pred_loss = []

        while not out:
            for [
                    samples, latents
            ] in self.train_loader:  # not sure how long the train_loader spits out data (possibly infinite?)

                self.global_iter += 1
                if not plotmode:
                    pbar.update(1)

                self.net.zero_grad()

                # get current batch and push to device
                img_batch, _ = samples.to(self.device), latents.to(self.device)

                # in VAE, input = output/target
                if self.modeltype == 'inertiaAE':
                    input_batch = img_batch
                    output_batch = img_batch

                predicted_batch, mu, mu_enc, mu_pred = self.net(input_batch)

                recon_loss = self.reconstruction_loss(x=output_batch,
                                                      x_recon=predicted_batch)
                pred_loss = self.prediction_loss(mu, mu_pred)

                actLoss = self.loss(recon_loss=recon_loss)

                actLoss.backward()
                self.optim.step()

                running_loss_terminal_display += actLoss.item()

                running_loss_trainstats += actLoss.item()
                running_recon_loss_trainstats += recon_loss.item()
                running_pred_loss_trainstats += pred_loss.item()

                # update gather object with training information
                if self.global_iter % self.trainstats_gather_step == 0:
                    running_loss_trainstats = running_loss_trainstats / self.trainstats_gather_step
                    running_recon_loss_trainstats = running_recon_loss_trainstats / self.trainstats_gather_step
                    running_pred_loss_trainstats = running_pred_loss_trainstats / self.trainstats_gather_step
                    self.gather.insert(
                        iter=self.global_iter,
                        total_loss=running_loss_trainstats,
                        target=output_batch[0].detach().cpu().numpy(),
                        reconstructed=predicted_batch[0].detach().cpu().numpy(
                        ),
                        recon_loss=running_recon_loss_trainstats,
                        pred_loss=running_pred_loss_trainstats,
                    )
                    running_loss_trainstats = 0.0
                    running_recon_loss_trainstats = 0.0
                    running_pred_loss_trainstats = 0.0

                    if plotmode:  # plot mini-batches
                        plot_total_loss.append(actLoss.item())
                        plot_recon_loss.append(recon_loss.item())
                        plot_pred_loss.append(pred_loss.item())
                        # PLOT!
                        clear_output(wait=True)
                        fig = plt.figure(figsize=(10, 8))

                        plt.subplot(4, 3, 1)
                        plt.plot(plot_total_loss)
                        plt.xlabel('minibatches')
                        plt.title('Total loss')

                        plt.subplot(4, 3, 2)
                        plt.plot(plot_recon_loss)
                        plt.xlabel('minibatches')
                        plt.title('Reconstruction training loss')

                        plt.subplot(4, 3, 3)
                        plt.plot(plot_pred_loss)
                        plt.xlabel('minibatches')
                        plt.title('Prediction training loss')

                        #                         import ipdb; ipdb.set_trace()

                        plt.subplot(4, 3, 4)
                        plt.imshow(input_batch[0][1][0].detach().cpu().numpy())
                        plt.set_cmap('gray')

                        plt.subplot(4, 3, 5)
                        plt.imshow(input_batch[0][4][0].detach().cpu().numpy())
                        plt.set_cmap('gray')

                        plt.subplot(4, 3, 6)
                        plt.imshow(input_batch[0][7][0].detach().cpu().numpy())
                        plt.set_cmap('gray')

                        plt.subplot(4, 3, 7)
                        plt.imshow(
                            predicted_batch[0][1][0].detach().cpu().numpy())
                        plt.set_cmap('gray')

                        plt.subplot(4, 3, 8)
                        plt.imshow(
                            predicted_batch[0][4][0].detach().cpu().numpy())
                        plt.set_cmap('gray')

                        plt.subplot(4, 3, 9)
                        plt.imshow(
                            predicted_batch[0][7][0].detach().cpu().numpy())
                        plt.set_cmap('gray')

                        plt.subplot(4, 3, 10)
                        img = plt.imshow(
                            (input_batch[0][1][0] -
                             predicted_batch[0][1][0]).detach().cpu().numpy())
                        plt.set_cmap('bwr')
                        colorAxisNormalize(fig.colorbar(img))

                        plt.subplot(4, 3, 11)
                        img = plt.imshow(
                            (input_batch[0][4][0] -
                             predicted_batch[0][4][0]).detach().cpu().numpy())
                        plt.set_cmap('bwr')
                        colorAxisNormalize(fig.colorbar(img))

                        plt.subplot(4, 3, 12)
                        img = plt.imshow(
                            (input_batch[0][7][0] -
                             predicted_batch[0][7][0]).detach().cpu().numpy())
                        plt.set_cmap('bwr')
                        colorAxisNormalize(fig.colorbar(img))

                        plt.tight_layout()
                        plt.show()
                """ /end of non-generic part"""

                if not plotmode and self.global_iter % self.display_step == 0:
                    pbar.write('iter:{}, loss:{:.3e}'.format(
                        self.global_iter,
                        running_loss_terminal_display / self.display_step))
                    running_loss_terminal_display = 0.0

                if self.global_iter % self.save_step == 0:
                    self.save_checkpoint(self.ckpt_name)
                    pbar.write('Saved checkpoint(iter:{})'.format(
                        self.global_iter))
                    self.gather.save_data_dict()

                if self.global_iter >= self.max_iter:
                    out = True
                    break

        pbar.write("[Training Finished]")
        pbar.close()