def processImage(self, fileBuffer): # tmp_name = uuid.uuid4().__str__() + ".png" try: image = Image.open(fileBuffer) image.thumbnail(self.size) converted = image.convert("L") # converted = ImageEnhance.Contrast(converted).enhance(1.1) # converted = ImageEnhance.Brightness(converted).enhance(1.1) converted = ImageEnhance.Sharpness(converted).enhance(1.4) # image = np.array(converted) image = matplotlib.image.pil_to_array(converted) binary_adaptive = threshold_adaptive(image, 40, offset=10) figsize = [ x / float(self._dpi) for x in (binary_adaptive.shape[1], binary_adaptive.shape[0]) ] fig = Figure(figsize=figsize, dpi=self._dpi, frameon=False) canvas = FigureCanvasAgg(fig) fig.figimage(binary_adaptive) output = StringIO() fig.savefig(output, format='png') output.seek(0) self.outfiles.append(output) except IOError: self.invalidFiles.append(fileBuffer)
def visualize_array(src, cmap="gray", f_name=None): """ :param src: image source array [c, h, w] :param cmap: :return: depth image visualized by selected color map (matplotlib.image object) """ if isinstance(src, np.ndarray): src = src elif isinstance(src, torch.Tensor): src = src.data.numpy() else: raise NotImplementedError() from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure fig = Figure(dpi=100, frameon=False) canvas = FigureCanvas(fig) if src.shape[0] == 1: im = fig.figimage(src[0], cmap=cmap, resize=True) else: im = fig.figimage(src.transpose(1, 2, 0), resize=True) if f_name is not None: fig.savefig(f_name, dpi=100, transparent=True) return fig else: return fig
def processImage(self, fileBuffer): # tmp_name = uuid.uuid4().__str__() + ".png" try: image = Image.open(fileBuffer) image.thumbnail(self.size) converted = image.convert("L") # converted = ImageEnhance.Contrast(converted).enhance(1.1) # converted = ImageEnhance.Brightness(converted).enhance(1.1) converted = ImageEnhance.Sharpness(converted).enhance(1.4) # image = np.array(converted) image = matplotlib.image.pil_to_array(converted) binary_adaptive = threshold_adaptive(image, 40, offset=10) figsize = [x / float(self._dpi) for x in (binary_adaptive.shape[1], binary_adaptive.shape[0])] fig = Figure(figsize=figsize, dpi=self._dpi, frameon=False) canvas = FigureCanvasAgg(fig) fig.figimage(binary_adaptive) output = StringIO() fig.savefig(output, format='png') output.seek(0) self.outfiles.append(output) except IOError: self.invalidFiles.append(fileBuffer)
class GraphFrame(wx.Frame): def __init__(self, maze_width=70, maze_height=70, magnification=8): wx.Frame.__init__(self, None, -1, 'Maze Generator') self.Bind(wx.EVT_CLOSE, self.OnClose, self) self.running = False self.maze_width = maze_width self.maze_height = maze_height self.magnification = magnification sizer = wx.BoxSizer(wx.VERTICAL) hSizer = wx.BoxSizer(wx.HORIZONTAL) sizer.Add(hSizer) btnStart = wx.Button(self, -1, "Start") self.Bind(wx.EVT_BUTTON, self.OnStart, btnStart) hSizer.Add(btnStart) btnStop = wx.Button(self, -1, "Stop") self.Bind(wx.EVT_BUTTON, self.OnStop, btnStop) hSizer.Add(btnStop) self.fig = Figure() self.canvas = FigureCanvasWxAgg(self, -1, self.fig) sizer.Add(self.canvas, 1, wx.LEFT|wx.TOP|wx.GROW) self.SetSizer(sizer) self.SetSize((800, 500)) def OnClose(self, evt): self.running = False self.plot_thread.join() evt.Skip() def OnStart(self, evt): self.Plot() def OnStop(self, evt): self.running = False def Plot(self): if self.running: return def thread(): self.running = True for m in maze(self.maze_width, self.maze_height): if not self.running: break wx.CallAfter(self.plot_data, magnify(m, magnification=self.magnification)) time.sleep(0.05) self.plot_thread = threading.Thread(target=thread) self.plot_thread.start() def plot_data(self, snapshot): self.fig.clear() self.fig.figimage(snapshot, 0, 0, cmap=plt.cm.binary) self.canvas.draw()
def save_as_plt(self, fname, pixel_array=None, vmin=None, vmax=None, cmap=None, format=None, origin=None): """ This method saves the image from a numpy array using matplotlib :param fname: Location and name of the image file to be saved. :param pixel_array: Numpy pixel array, i.e. ``numpy()`` return value :param vmin: matplotlib vmin :param vmax: matplotlib vmax :param cmap: matplotlib color map :param format: matplotlib format :param origin: matplotlib origin This method will return True if successful """ from matplotlib.backends.backend_agg \ import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure from pylab import cm if pixel_array is None: pixel_array = self.numpy() if cmap is None: cmap = cm.bone fig = Figure(figsize=pixel_array.shape[::-1], dpi=1, frameon=False) canvas = FigureCanvas(fig) fig.figimage(pixel_array, cmap=cmap, vmin=vmin, vmax=vmax, origin=origin) fig.savefig(fname, dpi=1, format=format) return True
def plot(self, fig: Figure): fig.figimage( self.logo_img, xo=(self.img_width * self.dpi - self.logo_img.shape[1]) / 2, yo=(self.img_height * self.dpi - self.logo_img.shape[0]) / 2, alpha=0.4, )
def save_as_plt(self, fname, pixel_array=None, vmin=None, vmax=None, cmap=None, format=None, origin=None): """ This method saves the image from a numpy array using matplotlib :param fname: Location and name of the image file to be saved. :param pixel_array: Numpy pixel array, i.e. ``numpy()`` return value :param vmin: matplotlib vmin :param vmax: matplotlib vmax :param cmap: matplotlib color map :param format: matplotlib format :param origin: matplotlib origin This method will return True if successful """ from matplotlib.backends.backend_agg \ import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure from pylab import cm if pixel_array is None: pixel_array = self.numpy if cmap is None: cmap = cm.bone fig = Figure(figsize=pixel_array.shape[::-1], dpi=1, frameon=False) canvas = FigureCanvas(fig) fig.figimage(pixel_array, cmap=cmap, vmin=vmin, vmax=vmax, origin=origin) fig.savefig(fname, dpi=1, format=format) return True
def _save_figure(img, filename): from matplotlib.backends.backend_agg import FigureCanvasAgg from matplotlib.figure import Figure fig = Figure(frameon=False) FigureCanvasAgg(fig) fig.figimage(img, resize=True) fig.savefig(filename)
def imsave(fname, arr, vmin=None, vmax=None, cmap=None, format=None, origin=None): """ Saves a 2D :class:`numpy.array` as an image with one pixel per element. The output formats available depend on the backend being used. Arguments: *fname*: A string containing a path to a filename, or a Python file-like object. If *format* is *None* and *fname* is a string, the output format is deduced from the extension of the filename. *arr*: A 2D array. Keyword arguments: *vmin*/*vmax*: [ None | scalar ] *vmin* and *vmax* set the color scaling for the image by fixing the values that map to the colormap color limits. If either *vmin* or *vmax* is None, that limit is determined from the *arr* min/max value. *cmap*: cmap is a colors.Colormap instance, eg cm.jet. If None, default to the rc image.cmap value. *format*: One of the file extensions supported by the active backend. Most backends support png, pdf, ps, eps and svg. *origin* [ 'upper' | 'lower' ] Indicates where the [0,0] index of the array is in the upper left or lower left corner of the axes. Defaults to the rc image.origin value. """ from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure fig = Figure(figsize=arr.shape[::-1], dpi=1, frameon=False) canvas = FigureCanvas(fig) fig.figimage(arr, cmap=cmap, vmin=vmin, vmax=vmax, origin=origin) fig.savefig(fname, dpi=1, format=format)
def imsave(fname, arr, vmin=None, vmax=None, cmap='gray', format=None, origin=None): from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure fig = Figure(figsize=arr.shape[::-1], dpi=1, frameon=False) canvas = FigureCanvas(fig) fig.figimage(arr, cmap=cmap, vmin=vmin, vmax=vmax, origin=origin) fig.savefig(fname, dpi=1, format=format)
def imsave(fname, arr, vmin=None, vmax=None, cmap=None, format=None, origin=None): from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure fig = Figure(figsize=arr.shape[::-1], dpi=1, frameon=False) canvas = FigureCanvas(fig) fig.figimage(arr, cmap=cmap, vmin=vmin, vmax=vmax, origin=origin) fig.savefig(fname, dpi=1, format=format)
class MyCanvas(FigureCanvas): def __init__(self, parent=None, width=5, height=4, dpi=100): plt.rcParams['font.family'] = ['SimHei'] plt.rcParams['axes.unicode_minus'] = False self.fig = Figure(figsize=(width, height), dpi=dpi) super().__init__(self.fig) self.setParent(parent) self.setSizePolicy(QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) self.updateGeometry() def start_static_plot(self, picture, flag='gray'): if flag == 'gray': self.fig.suptitle('灰度图像') self.fig.figimage(picture, resize=True, cmap='gray') elif flag == 'D3D': self.fig.suptitle('3D图像') self.axes = self.fig.add_subplot(1, 1, 1, projection='3d') self.D3D = picture.copy() self.pictureheight3D, self.picturewidth3D = self.D3D.shape[:2] self.x3D = np.arange(0, self.picturewidth3D, 1) self.y3D = np.arange(0, self.pictureheight3D, 1) self.x3D, self.y3D = np.meshgrid(self.x3D, self.y3D) self.D3D = cv2.flip(self.D3D, 0) self.axes.plot_surface(self.x3D, self.y3D, self.D3D[self.y3D, self.x3D], rstride=2, cstride=2, cmap='rainbow') elif flag == 'contour': self.fig.suptitle('等温线图像') self.axes = self.fig.add_subplot(1, 1, 1) self.contour = picture.copy() self.pictureheight, self.picturewidth = self.contour.shape[:2] self.xcontour = np.arange(0, self.picturewidth, 1) self.ycontour = np.arange(0, self.pictureheight, 1) self.xcontour, self.ycontour = np.meshgrid(self.xcontour, self.ycontour) self.contour = cv2.flip(self.contour, 0) self.contourline = self.axes.contour(self.xcontour, self.ycontour, self.contour[self.ycontour, self.xcontour], 10, colors='black', linewidths=1) self.axes.clabel(self.contourline, inline=True, inline_spacing=5, fontsize=10, fmt='%.1f') self.axes.contourf(self.xcontour, self.ycontour, self.contour[self.ycontour, self.xcontour], 10, cmap='rainbow') elif flag == 'original': self.fig.suptitle('原始图像') self.fig.figimage(picture, resize=True)
def saveImage(file_path, img, vmin=None, vmax=None, cmap=None, format=None, origin=None): """ Save numpy array to disk as image. """ from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure fig = Figure(figsize=img.shape[::-1], dpi=1, frameon=False) FigureCanvas(fig) fig.figimage(img, cmap=cmap, vmin=vmin, vmax=vmax, origin=origin) fig.savefig(file_path, dpi=1, format=format)
def save_array_as_image(filename, array, colourmap=None, format=None, dpi=1, vmin=None, vmax=None, origin=None): from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure from matplotlib import cm figure = Figure(figsize=array.shape[::-1], dpi=1, frameon=False) # canvas = FigureCanvas(figure) # essential even though it isn't used FigureCanvas(figure) # essential even though it isn't used figure.figimage(array, cmap=cm.get_cmap(colourmap), vmin=vmin, vmax=vmax, origin=origin) figure.savefig(filename, dpi=dpi, format=format)
def simulate(x, y, alpha, beta, gamma): img = Image.open('./public/population-density.png') width = img.size[0]//6 height = img.size[1]//6 img = img.resize((width, height)) img = 255 - np.asarray(img) S_0 = img[:,:,1] I_0 = np.zeros_like(S_0) I_0[int(height * y), int(width * x)] = 1 R_0 = np.zeros_like(S_0) T = 900 # final time dt = 1 # time increment N = int(T/dt) + 1 # number of time-steps t = np.linspace(0.0, T, N) # time discretization # initialize the array containing the solution for each time-step u = np.empty((N, 3, S_0.shape[0], S_0.shape[1])) u[0][0] = S_0 u[0][1] = I_0 u[0][2] = R_0 theCM = cm.get_cmap("Reds") theCM._init() alphas = np.abs(np.linspace(0, 1, theCM.N)) theCM._lut[:-3,-1] = alphas # Compute data for n in range(N-1): u[n+1] = euler_step(u[n], f, dt, beta, gamma, alpha) keyFrames = [] frames = 60.0 # upper limit on keyframes for i in range(0, N-1, int(N/frames)): fig = Figure() fig.figimage(img, resize=True) fig.figimage(u[i][1], vmin=0, cmap=theCM) canvas = FigureCanvas(fig) canvas.draw() rows, cols = canvas.get_width_height() keyFrames.append(np.fromstring(canvas.tostring_rgb(), dtype=np.uint8).reshape(cols, rows, 3)) # Couldn't figure out a way to use BytesIO directly p = os.path.join(os.getenv('DATA_DIR'), "generated", uuid.uuid4().hex + ".mp4") imageio.mimsave(p, keyFrames, fps=5) return p
def imsave(fname, arr, vmin=None, vmax=None, cmap=None, format=None, origin=None, dpi=100): """ Save an array as in image file. The output formats available depend on the backend being used. Arguments: *fname*: A string containing a path to a filename, or a Python file-like object. If *format* is *None* and *fname* is a string, the output format is deduced from the extension of the filename. *arr*: An MxN (luminance), MxNx3 (RGB) or MxNx4 (RGBA) array. Keyword arguments: *vmin*/*vmax*: [ None | scalar ] *vmin* and *vmax* set the color scaling for the image by fixing the values that map to the colormap color limits. If either *vmin* or *vmax* is None, that limit is determined from the *arr* min/max value. *cmap*: cmap is a colors.Colormap instance, e.g., cm.jet. If None, default to the rc image.cmap value. *format*: One of the file extensions supported by the active backend. Most backends support png, pdf, ps, eps and svg. *origin* [ 'upper' | 'lower' ] Indicates where the [0,0] index of the array is in the upper left or lower left corner of the axes. Defaults to the rc image.origin value. *dpi* The DPI to store in the metadata of the file. This does not affect the resolution of the output image. """ from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure # Fast path for saving to PNG if (format == 'png' or format is None or isinstance(fname, six.string_types) and fname.lower().endswith('.png')): image = AxesImage(None, cmap=cmap, origin=origin) image.set_data(arr) image.set_clim(vmin, vmax) image.write_png(fname) else: fig = Figure(dpi=dpi, frameon=False) FigureCanvas(fig) fig.figimage(arr, cmap=cmap, vmin=vmin, vmax=vmax, origin=origin, resize=True) fig.savefig(fname, dpi=dpi, format=format, transparent=True)
def _build_image(data, cmap='gray'): """Build an image encoded in base64. """ import matplotlib.pyplot as plt from matplotlib.figure import Figure from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas figsize = data.shape[::-1] if figsize[0] == 1: figsize = tuple(figsize[1:]) data = data[:, :, 0] fig = Figure(figsize=figsize, dpi=1.0, frameon=False) FigureCanvas(fig) cmap = getattr(plt.cm, cmap, plt.cm.gray) fig.figimage(data, cmap=cmap) output = BytesIO() fig.savefig(output, dpi=1.0, format='png') return output.getvalue().encode('base64')
def __init__(self, parent=None, width=5.35984, height=2.37743, dpi=100): fig = Figure(figsize=(width, height), dpi=dpi) self.axes = fig.add_subplot( 111 ) #1x1x1 grid;see https://stackoverflow.com/questions/3584805/in-matplotlib-what-does-the-argument-mean-in-fig-add-subplot111 im = Image.open("map.png") im = im.resize((416, 183)) fig.figimage(im, xo=67, yo=26) #maybe i'll just resize image and reset origin lol self.axes.patch.set_alpha(0) #self.axes is of the class AxesSubplot. FigureCanvas.__init__(self, fig) self.setParent(parent) FigureCanvas.setSizePolicy(self, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Expanding) FigureCanvas.updateGeometry(self)
def imsave(fname, arr, **kwargs): from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure from matplotlib.colors import ColorConverter as CC C = CC() import pylab if pylab.isinteractive(): i_was_on = True pylab.ioff() else: i_was_on = False fig = Figure(figsize=arr.shape[::-1], dpi=1, frameon=False) canvas = FigureCanvas(fig) if 'background' in kwargs.keys(): if kwargs['background'] != 'transparent': [r,g,b] = C.to_rgb(kwargs['background']) BG = numpy.ones(shape=(arr.shape[0],arr.shape[1],3)) BG[:,:,0] = r BG[:,:,1] = g BG[:,:,2] = b fig.figimage(BG) fig.figimage(arr, xo = kwargs.get('xo',0), yo = kwargs.get('yo',0), alpha = kwargs.get('alpha',None), norm = kwargs.get('norm',None), cmap = kwargs.get('cmap',None), vmin = kwargs.get('vmin',None), vmax = kwargs.get('vmax',None), origin = kwargs.get('origin',None)) fig.savefig(fname, dpi=1, format = kwargs.get('format',None)) if i_was_on: pylab.ion()
def save(filename, np_array, png=False): """ saves numpy array as bitmap and/or png image. A list of details may be included to save relevant info about the images in a CSV file of the same name. By default only a bitmap is produced. Parameters ---------- filename : string Filename (without extension). np_array : numpy.array 2D numpy array (dtype=uint8) representing grayscale image to save. png : bool By default, a bmp file is produced. If png=True, a png file will be retained along with the bitmap. """ value_min = 0 value_max = 255 color_map = 'gray' fig = Figure(figsize=np_array.shape[::-1], dpi=1, frameon=False) fig.canvas = FigureCanvas(fig) fig.figimage(np_array, cmap=color_map, vmin=value_min, vmax=value_max, origin=None) fig.savefig(filename, dpi=1, format=None) # save bitmap (convert from PNG) img = PIL.Image.open(filename + '.png') if len(img.split()) == 4: # prevent IOError: cannot write mode RGBA as BMP r, g, b, a = img.split() img = PIL.Image.merge("RGB", (r, g, b)) greyscale = img.convert("L") # L indicates PIL's greyscale mode greyscale.save(filename + '.bmp') # delete PNG if not png: os.remove(filename + '.png')
def imsave(fname, arr, vmin=None, vmax=None, cmap=None, format=None, origin=None, dpi=100): """ Save an array as in image file. The output formats available depend on the backend being used. Arguments: *fname*: A string containing a path to a filename, or a Python file-like object. If *format* is *None* and *fname* is a string, the output format is deduced from the extension of the filename. *arr*: An MxN (luminance), MxNx3 (RGB) or MxNx4 (RGBA) array. Keyword arguments: *vmin*/*vmax*: [ None | scalar ] *vmin* and *vmax* set the color scaling for the image by fixing the values that map to the colormap color limits. If either *vmin* or *vmax* is None, that limit is determined from the *arr* min/max value. *cmap*: cmap is a colors.Colormap instance, eg cm.jet. If None, default to the rc image.cmap value. *format*: One of the file extensions supported by the active backend. Most backends support png, pdf, ps, eps and svg. *origin* [ 'upper' | 'lower' ] Indicates where the [0,0] index of the array is in the upper left or lower left corner of the axes. Defaults to the rc image.origin value. *dpi* The DPI to store in the metadata of the file. This does not affect the resolution of the output image. """ from matplotlib.backends.backend_agg import FigureCanvasAgg as FigureCanvas from matplotlib.figure import Figure figsize = [x / float(dpi) for x in (arr.shape[1], arr.shape[0])] fig = Figure(figsize=figsize, dpi=dpi, frameon=False) canvas = FigureCanvas(fig) im = fig.figimage(arr, cmap=cmap, vmin=vmin, vmax=vmax, origin=origin) fig.savefig(fname, dpi=dpi, format=format)
def plot(fileName, conversionType): try: fn = backendInputFits+fileName+".fits" sig_fract = 5.0 percent_fract = 0.01 hdulist = pyfits.open(fn) img_data_raw = hdulist[0].data width = float(img_data_raw.shape[1])/100 height = float(img_data_raw.shape[0])/100 hdulist.close() img_data_raw = numpy.array(img_data_raw, dtype=float) sky, num_iter = sky_mean_sig_clip(img_data_raw, sig_fract, percent_fract, max_iter=1) img_data = img_data_raw - sky min_val = 0.0 #plotting if(conversionType == "Power"): new_img = power(img_data, power_index=3.0, scale_min = min_val) Rotated_Plot = ndimage.rotate(new_img, 180) Flipped_Plot = np.fliplr(Rotated_Plot) fig = Figure(figsize=(width, height)) fig.figimage(Flipped_Plot, cmap='gray') resultFile = conversionType+"_"+fileName canvas = FigureCanvas(fig) canvas.print_figure(frontendInputFits+resultFile+".png") elif(conversionType == "Linear"): new_img = linear(img_data, scale_min = min_val) Rotated_Plot = ndimage.rotate(new_img, 180) Flipped_Plot = np.fliplr(Rotated_Plot) fig = Figure(figsize=(width, height)) fig.figimage(Flipped_Plot, cmap='gray') resultFile = conversionType+"_"+fileName canvas = FigureCanvas(fig) canvas.print_figure(frontendInputFits+resultFile+".png") elif(conversionType == "Hist"): new_img = histeq(img_data_raw, num_bins=256) Rotated_Plot = ndimage.rotate(new_img, 180) Flipped_Plot = np.fliplr(Rotated_Plot) fig = Figure(figsize=(width, height)) fig.figimage(Flipped_Plot, cmap='gray') resultFile = conversionType+"_"+fileName canvas = FigureCanvas(fig) canvas.print_figure(frontendInputFits+resultFile+".png") looper=1 while(looper<100): time.sleep(1) if os.path.isfile(frontendInputFits+resultFile+".png"): break else: looper = looper + 1 continue except(RuntimeError, TypeError, NameError): print 'errors in convertPlots function'
def put_emotion_thumbnail_on_figure(self, image_plt_object: AxesImage, plt_figure: Figure): generated_image_left_start_in_fig_width = image_plt_object.clipbox.intervalx.min( ) generated_image_right_end_in_fig_width = image_plt_object.clipbox.intervalx.max( ) generated_image_width_pixel_size = generated_image_right_end_in_fig_width - generated_image_left_start_in_fig_width generated_image_top_in_fig_height = image_plt_object.clipbox.intervaly.max( ) generated_image_bottom_in_fig_height = image_plt_object.clipbox.intervaly.min( ) generated_image_height_pixel_size = generated_image_top_in_fig_height - generated_image_bottom_in_fig_height if self.emotion_thumbnail_image is not None: emotion_thumbnail_width = self.emotion_thumbnail_image.size[0] emotion_thumbnail_height = self.emotion_thumbnail_image.size[1] emotion_thumbnail_percentage_value_height_margin = 4 emotion_thumbnail_percentage_value_width_margin = 4 emotion_thumbnail_height_pixel_margin = generated_image_height_pixel_size * ( emotion_thumbnail_percentage_value_height_margin / 100) emotion_thumbnail_height_pixel_position = ( generated_image_top_in_fig_height - emotion_thumbnail_height ) - emotion_thumbnail_height_pixel_margin # We remove the thumbnail height and the margin from the fig height because the bottom position is 0 of height and we want the thumbnail to go down from the top emotion_thumbnail_width_pixel_margin = generated_image_width_pixel_size * ( emotion_thumbnail_percentage_value_width_margin / 100) emotion_thumbnail_width_pixel_position = generated_image_left_start_in_fig_width + emotion_thumbnail_width_pixel_margin # We add the margin from the fig width because the left start position is 0 of width and we want to move the thumbnail to the right and we do not need to also add the thumbnail width plt_thumbnail_image_object = plt_figure.figimage( self.emotion_thumbnail_image, emotion_thumbnail_width_pixel_position, emotion_thumbnail_height_pixel_position) return plt_thumbnail_image_object return None
class Chart(object): """ Convenience wrapper around a Matplotlib figure """ file_types = MIME_TYPES.keys() def __init__(self, width: int, height: int, storage: Storage=LocalStorage(), style: str='newsworthy', language: str='en-GB'): """ :param width: width in pixels :param height: height in pixels :param storage: storage object that will handle file saving. Default LocalStorage() class will save a file the working dir. :param style: a predefined style or the path to a custom style file :param language: a BCP 47 language tag (eg `en`, `sv-FI`) """ # P U B L I C P R O P E R T I E S # The user can alter these at any time self.data = DataList() # A list of datasets self.annotate_trend = True # Print out values at points on trendline? self.trendline = [] # List of x positions, or data points self.labels = [] # Optionally one label for each dataset self.annotations = [] # Manually added annotations self.interval = None # yearly|quarterly|monthly|weekly|daily # We will try to guess interval based on the data, # but explicitly providing a value is safer. Used for finetuning. self.show_ticks = True # toggle category names, dates, etc self.subtitle = None self.note = None self.xlabel = None self.ylabel = None self.caption = None self.highlight = None self.decimals = None # number of decimals to show in annotations, value ticks, etc # None means automatically chose the best number self.logo = None # Path to image that will be embedded in the caption area # Can also be set though a style property self.color_fn = None # Custom coloring function # P R I V A T E P R O P E R T I E S # Properties managed through getters/setters self._title = None self._units = "count" # Calculated properties self._annotations = [] # Automatically added annotations self._storage = storage self._w, self._h = int(width), int(height) self._style = loadstyle(style) # Standardize and check if language tag is a valid BCP 47 tag self._language = standardize_tag(language) self._locale = Locale.parse(self._language.replace("-", "_")) # Dynamic typography self._title_font = FontProperties() self._title_font.set_family(self._style["title_font"]) self._title_font.set_size(self._style["figure.titlesize"]) self._title_font.set_weight(self._style["figure.titleweight"]) self._fig = Figure() FigureCanvas(self._fig) self.ax = self._fig.add_subplot(111) # self._fig, self.ax = plt.subplots() self.value_axis = self.ax.yaxis self.category_axis = self.ax.xaxis # Calculate size in inches self._set_size(width, height) # Chart elements. Made available for fitting. self._title_elem = None self._subtitle_elem = None self._note_elem = None self._caption_elem = None self._logo_elem = None def _set_size(self, w, h=None): """ Set figure size, in pixels """ dpi = self._fig.get_dpi() real_width = float(w) / dpi if h is None: real_height = self._fig.get_figheight() else: real_height = float(h) / dpi self._fig.set_size_inches(real_width, real_height) def _get_value_axis_formatter(self): return self._get_formatter(self.units) def _get_formatter(self, units): formatter = Formatter(self._language, decimals=self.decimals, scale="celsius") if units == "percent": return FuncFormatter(formatter.percent) elif units == "degrees": return FuncFormatter(formatter.temperature_short) else: return FuncFormatter(formatter.number) def _get_annotation_formatter(self): return self._get_formatter(self.units) def _text_rel_height(self, obj): """ Get the relative height of a text object to the whole canvas. Will try and guess even if wrap=True. """ if not obj.get_wrap(): # No autowrapping, use default bbox checking return self._rel_height(obj) self._fig.canvas.draw() # Draw text to find out how big it is t = obj.get_text() r = self._fig.canvas.renderer w, h, d = r.get_text_width_height_descent(t, obj._fontproperties, ismath=False) num_lines = len(obj._get_wrapped_text().split("\n")) return (h * num_lines) / float(self._h) def _rel_height(self, obj): """ Get the relative height of a chart object to the whole canvas. """ self._fig.canvas.draw() # We must draw the canvas to know all sizes bbox = obj.get_window_extent() return bbox.height / float(self._h) def _color_by(self, *args, **kwargs): """Color by some rule. Role of args and and kwargs are determined by the color rule. """ color_name = None rule = self.color_fn if rule == "positive_negative": value = args[0] color_name = color_fn.positive_negative(value) elif rule == "warm_cold": value = args[0] color_name = color_fn.warm_cold(value) else: raise ValueError("Unknown color rule: {}".format(rule)) if color_name in ["strong", "neutral", "positive", "negative", "warm", "cold"]: c = self._style[color_name + "_color"] else: c = color_name return c def _annotate_point(self, text, xy, direction, offset=12, **kwargs): """Add a label to a given point. :param text: text content of label :param xy: coordinates to annotate :param direction: placement of annotation. ("up", "down", "left", "right") :param kwags: any params accepted by plt.annotate """ # TODO: Offset should maybe rather be a function of the font size, # but then we'd need to handle reltive fontsizes (ie "smaller") as well. bg_color = self._style.get("figure.facecolor", "white") opts = { "fontsize": self._style["annotation.fontsize"], "textcoords": "offset pixels", "path_effects": outline(bg_color), } if direction == "up": opts["verticalalignment"] = "bottom" opts["horizontalalignment"] = "center" opts["xytext"] = (0, offset) elif direction == "down": opts["verticalalignment"] = "top" opts["horizontalalignment"] = "center" opts["xytext"] = (0, -offset) elif direction == "left": opts["verticalalignment"] = "center" opts["horizontalalignment"] = "right" opts["xytext"] = (-offset, 0) elif direction == "right": opts["verticalalignment"] = "center" opts["horizontalalignment"] = "left" opts["xytext"] = (offset, 0) else: msg = f"'{direction}' is an unknown direction for an annotation" raise Exception(msg) # Override default opts if passed to the function opts.update(kwargs) ann = self.ax.annotate(text, xy=xy, **opts) # ann = self.ax.text(text, xy[0], xy[1]) self._annotations.append(ann) return ann def _add_caption(self, caption, hextent=None): """Add a caption. Supports multiline input. Hextent is the left/right extent, e.g. to avoid overlapping a logo """ # Wrap=true is hardcoded to use the extent of the whole figure # Our workaround is to resize the figure, draw the text to find the # linebreaks, and then restore the original width! if hextent is None: hextent = (0, self._w) self._set_size(hextent[1] - hextent[0]) x1 = hextent[0] / self._w text = self._fig.text(x1, 0.01, caption, color=self._style["neutral_color"], wrap=True, fontsize=self._style["caption.fontsize"]) self._fig.canvas.draw() wrapped_text = text._get_wrapped_text() text.set_text(wrapped_text) self._set_size(self._w) self._caption_elem = text def _add_title(self, title_text): """Add a title.""" # y=1 wraps title heavily, hence .9999 text = self._fig.suptitle(title_text, wrap=True, x=0, y=.99999, horizontalalignment="left", multialignment="left", fontproperties=self._title_font) self._title_elem = text def _add_subtitle(self, subtitle_text): y_pos = 1 - self._title_rel_height text = self._fig.text(0, y_pos, subtitle_text, wrap=True, verticalalignment="top", linespacing=1.4, fontsize=self._style["subtitle.fontsize"]) self._fig.canvas.draw() wrapped_text = text._get_wrapped_text() text.set_text(wrapped_text) self._set_size(self._w) self._subtitle_elem = text def _add_note(self, note_text): y_pos = self._footer_rel_height text = self._fig.text(0, y_pos, note_text, wrap=True, fontsize=self._style["note.fontsize"]) self._fig.canvas.draw() wrapped_text = text._get_wrapped_text() text.set_text(wrapped_text) self._set_size(self._w) self._note_elem = text def _add_xlabel(self, label): """Adds a label to the x axis.""" self.ax.set_xlabel(label) def _add_ylabel(self, label): """Adds a label to the y axis.""" self.ax.set_ylabel(label) def _add_data(self): """ Plot data to the chart. Typically defined by a more specific subclass """ pass # raise NotImplementedError("This method should be overridden") def _apply_changes_before_rendering(self): """ To ensure consistent rendering, we call this method just before rendering file(s). This is where all properties are applied. """ # Apply all changes, in the correct order for consistent rendering self._fig.tight_layout() if len(self.data): self._add_data() if not self.show_ticks: self.category_axis.set_visible(False) else: # Remove dublicated labels (typically a side effect of using # few decimals while having a lot of values in a small range) pass """ self._fig.canvas.draw() tl = [x.get_text() for x in self.value_axis.get_ticklabels()] print(tl) tl = [x if tl[i-1] != x else "" for (i, x) in enumerate(tl)] print(tl) self.value_axis.set_ticklabels(tl) """ for a in self.annotations: self._annotate_point(a["text"], a["xy"], a["direction"]) if self.ylabel is not None: self._add_ylabel(self.ylabel) if self.xlabel is not None: self._add_xlabel(self.xlabel) if self.title is not None: self._add_title(self.title) if self.subtitle is not None: self._add_subtitle(self.subtitle) # fit ticks etc. self._fig.tight_layout() logo = self._style.get("logo", self.logo) caption_hextent = None # set this if adding a logo if logo: im = Image.open(logo) # scale down image if needed to fit new_width = min(self._w, im.size[0]) new_height = new_width * (im.size[1] / im.size[0]) im.thumbnail((new_width, new_height), Image.ANTIALIAS) # Position if self._locale.text_direction == "rtl": logo_im = self._fig.figimage(im, 0, 0) ext = logo_im.get_extent() caption_hextent = (ext[1], self._w) else: logo_im = self._fig.figimage(im, self._w - im.size[0], 0) ext = logo_im.get_extent() caption_hextent = (0, ext[0]) self._logo_elem = logo_im if self.caption is not None: # Add caption without image self._add_caption(self.caption, hextent=caption_hextent) if self.note is not None: self._add_note(self.note) # Fit header header_height = 0 if self._title_elem: header_height += self._title_rel_height if self._subtitle_elem: header_height += self._subtitle_rel_height self._fig.subplots_adjust(top=1 - header_height) # Fit area below chart try: tick_label_height = max([self._text_rel_height(lbl) for lbl in self.ax.get_xticklabels()]) except ValueError: # handle charts without ticks tick_label_height = 0 sub_canvas_height = ( # ticks labels tick_label_height # some padding + 30 / self._h # chart notes (if any) + self._note_rel_height # chart caption and logo (if any) + self._footer_rel_height ) self._fig.subplots_adjust(bottom=sub_canvas_height) @classmethod def init_from(cls, args: dict, storage=LocalStorage(), style: str="newsworthy", language: str='en-GB'): """Create a chart from a Python object.""" if not ("width" in args and "height" in args): raise Exception("The settings object must include an explicit width and height") chart = cls(args["width"], args["height"], storage=storage, style=style, language=language) # Get everything from args that is a public attribute in Chart, # except data and labels. class_attrs = vars(chart) for k, v in args.items(): if (not k.startswith("_")) and \ (k in class_attrs) and \ (k not in ["data", "labels", "type", "ymin", "ymax", "title", "units"]): setattr(chart, k, v) if "data" in args: for data in args["data"].copy(): chart.data.append(data) if "labels" in args: for label in args["labels"].copy(): chart.labels.append(label) # Special handling for setters if "title" in args: chart.title = args["title"] if "units" in args: chart.units = args["units"] if "type" in args: chart.type = args["type"] if "ymin" in args: chart.ymin = args["ymin"] if "ymax" in args: chart.ymax = args["ymax"] if "ticks" in args: chart.ticks = args["ticks"] return chart def render(self, key: str, img_format: str): """Render file, and send to storage.""" # Apply all changes, in the correct order for consistent rendering self._apply_changes_before_rendering() # Save plot in memory, to write it directly to storage buf = BytesIO() self._fig.savefig(buf, format=img_format) buf.seek(0) self._storage.save(key, buf, img_format) def render_all(self, key: str): """ Render all available formats """ # Apply all changes, in the correct order for consistent rendering self._apply_changes_before_rendering() for file_format in self.file_types: if file_format == "dw": continue # Save plot in memory, to write it directly to storage buf = BytesIO() self._fig.savefig(buf, format=file_format) buf.seek(0) self._storage.save(key, buf, file_format) @property def title(self): """ A user could have manipulated the fig property directly, so check for a title there as well. """ if self._title is not None: return self._title elif self._fig._suptitle: return self._fig._suptitle.get_text() else: return None @title.setter def title(self, title: str): self._title = title @property def units(self): return self._units @units.setter def units(self, val: str): """ Units, used for number formatting. Note that 'degrees' is designed for temperature degrees. In some languages there are typographical differences between angles and short temperature notation (e.g. 45° vs 45 °). """ allowed_units = ["count", "percent", "degrees"] if val in allowed_units: self._units = val # By default no decimals if unit is “count” if self.decimals is None and self._units == "count": self.decimals = 0 else: raise ValueError("Supported units are: {}".format(allowed_units)) @property def _title_rel_height(self): rel_height = 0 if self._title_elem: rel_height += self._text_rel_height(self._title_elem) # Adds a fixes margin below rel_height += 30 / self._h return rel_height @property def _subtitle_rel_height(self): rel_height = 0 if self._subtitle_elem: rel_height += self._text_rel_height(self._subtitle_elem) # Adds a fixes margin below rel_height += 30 / self._h return rel_height @property def _note_rel_height(self): rel_height = 0 if self._note_elem: rel_height += self._text_rel_height(self._note_elem) # Adds a fixes margin below rel_height += 10 / self._h return rel_height @property def _footer_rel_height(self): footer_elem_heights = [0] if self._logo_elem: # Assuming the logo is place at fixed bottom logo_height = self._logo_elem.get_extent()[3] footer_elem_heights.append(logo_height / self._h) if self._caption_elem: # Increase the bottom padding by the height of the text bbox caption_height = self._text_rel_height(self._caption_elem) footer_elem_heights.append(caption_height) footer_height = max(footer_elem_heights) footer_height += 15 / self._h return footer_height def __str__(self): # Return main title or id if self.title is not None: return self.title else: return str(id(self)) def __repr__(self): # Use type(self).__name__ to get the right class name for sub classes return "<{cls}: {name} ({h} x {w})>".format(cls=type(self).__name__, name=str(self), w=self._w, h=self._h)
def train(self, sess, config): """ Training the GAN """ print('initializing...opt') d_opt = self.d_opt g_opt = self.g_opt try: init = tf.global_variables_initializer() sess.run(init) except AttributeError: init = tf.intializer_all_varialble() sess.run(init) print('initializing...var') # g_summaries = [self.d_fake_summary, # self.d_fake_loss_summary, # self.g_loss_summary, # self.g_l2_loss_summary, # self.g_loss_adv_summary, # self.generated_wav_summary] # d_summaries = [self.d_loss_summary, self.d_real_summary, self.d_real_loss_summary, self.high_wav_summary] # if hasattr(self, 'alpha_summ'): # g_summaries += self.alpha_summ # self.g_sum = tf.summary.merge(g_summaries) # self.d_sum = tf.summary.merge(d_summaries) if not os.path.exists(os.path.join(config.save_path, 'train')): os.makedirs(os.path.join(config.save_path, 'train')) self.writer = tf.summary.FileWriter( os.path.join(config.save_path, 'train'), self.sess.graph) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) sample_low, sample_high, sample_z = self.sess.run( [self.gt_low[0], self.gt_high[0], self.zz_A[0]], feed_dict={ self.is_valid: False, self.is_train: True, self.is_mismatch: False }) v_sample_low, v_sample_high, v_sample_z = self.sess.run( [self.gt_low[0], self.gt_high[0], self.zz_A[0]], feed_dict={ self.is_valid: True, self.is_train: False, self.is_mismatch: False }) print('sample low shape: ', sample_low.shape) print('sample high shape: ', sample_high.shape) print('sample z shape: ', sample_z.shape) save_path = config.save_path counter = 0 # count of num of samples num_examples = 0 for record in tf.python_io.tf_record_iterator(self.tfrecords): num_examples += 1 print("total num of patches in tfrecords", self.tfrecords, ": ", num_examples) # last samples # batch num num_batches = num_examples / self.batch_size print('batches per epoch: ', num_batches) if self.load(self.save_path): print('load success') else: print('load failed') batch_idx = 0 current_epoch = 0 batch_timings = [] g_losses = [] d_A_losses = [] d_B_losses = [] g_adv_losses = [] g_l1_losses_BAB = [] g_l1_losses_AB = [] g_l1_losses_ABA = [] g_l1_losses_BA = [] try: while not coord.should_stop(): start = timeit.default_timer() if counter % config.save_freq == 0: for d_iter in range(self.disc_updates): _d_opt, d_A_loss, d_B_loss = self.sess.run( [d_opt, self.d_A_losses[0], self.d_B_losses[0]], feed_dict={ self.is_valid: False, self.is_train: True, self.is_mismatch: True }) _d_opt, d_A_loss, d_B_loss = self.sess.run( [d_opt, self.d_A_losses[0], self.d_B_losses[0]], feed_dict={ self.is_valid: False, self.is_train: True, self.is_mismatch: False }) #_d_sum, d_fake_loss, d_real_loss = self.sess.run( # [self.d_sum, self.d_fake_losses[0], self.d_real_losses[0]], feed_dict={self.is_valid: False}) if self.d_clip_weights: self.sess.run(self.d_clip, feed_dict={ self.is_valid: False, self.is_train: True }) #_g_opt, _g_sum, g_adv_loss, g_l2_loss = self.sess.run([g_opt, self.g_sum, self.g_adv_losses[0], self.g_l2_losses[0]], feed_dict={self.is_valid:False}) _g_opt, g_adv_loss, g_AB_loss, g_BA_loss, g_ABA_loss, g_BAB_loss = self.sess.run( [ g_opt, self.g_adv_losses[0], self.g_losses_AB[0], self.g_losses_BA[0], self.g_l1_losses_ABA[0], self.g_l1_losses_BAB[0] ], feed_dict={ self.is_valid: False, self.is_train: True, self.is_mismatch: True }) _g_opt, g_adv_loss, g_AB_loss, g_BA_loss, g_ABA_loss, g_BAB_loss = self.sess.run( [ g_opt, self.g_adv_losses[0], self.g_losses_AB[0], self.g_losses_BA[0], self.g_l1_losses_ABA[0], self.g_l1_losses_BAB[0] ], feed_dict={ self.is_valid: False, self.is_train: True, self.is_mismatch: False }) # _phase_opt, phase_loss = self.sess.run([phase_opt, self.phase_losses[0]], feed_dict={self.is_valid:False,self.is_train: True}) else: for d_iter in range(self.disc_updates): _d_opt, d_A_loss, d_B_loss = self.sess.run( [d_opt, self.d_A_losses[0], self.d_B_losses[0]], feed_dict={ self.is_valid: False, self.is_train: True, self.is_mismatch: True }) _d_opt, d_A_loss, d_B_loss = self.sess.run( [d_opt, self.d_A_losses[0], self.d_B_losses[0]], feed_dict={ self.is_valid: False, self.is_train: True, self.is_mismatch: False }) #d_fake_loss, d_real_loss = self.sess.run( # [self.d_fake_losses[0], self.d_real_losses[0]], feed_dict={self.is_valid: False}) if self.d_clip_weights: self.sess.run(self.d_clip, feed_dict={ self.is_valid: False, self.is_train: True }) _g_opt, g_adv_loss, g_AB_loss, g_BA_loss, g_ABA_loss, g_BAB_loss = self.sess.run( [ g_opt, self.g_adv_losses[0], self.g_losses_AB[0], self.g_losses_BA[0], self.g_l1_losses_ABA[0], self.g_l1_losses_BAB[0] ], feed_dict={ self.is_valid: False, self.is_train: True, self.is_mismatch: True }) _g_opt, g_adv_loss, g_AB_loss, g_BA_loss, g_ABA_loss, g_BAB_loss = self.sess.run( [ g_opt, self.g_adv_losses[0], self.g_losses_AB[0], self.g_losses_BA[0], self.g_l1_losses_ABA[0], self.g_l1_losses_BAB[0] ], feed_dict={ self.is_valid: False, self.is_train: True, self.is_mismatch: False }) # _phase_opt, phase_loss = self.sess.run([phase_opt, self.phase_losses[0]], feed_dict={self.is_valid:False,self.is_train: True}) end = timeit.default_timer() batch_timings.append(end - start) d_A_losses.append(d_A_loss) d_B_losses.append(d_B_loss) g_adv_losses.append(g_adv_loss) g_l1_losses_BAB.append(g_BAB_loss) # clean - reverb - clean g_l1_losses_AB.append(g_AB_loss) # reverb - clean g_l1_losses_ABA.append(g_ABA_loss) # reverb - clean - reverb g_l1_losses_BA.append(g_BA_loss) # clean - reverb print( '{}/{} (epoch {}), d_A_loss = {:.5f}, ' 'd_B_loss = {:.5f}, ' #d_nfk_loss = {:.5f}, ' 'g_adv_loss = {:.5f}, g_AB_loss = {:.5f}, g_BAB_loss = {:.5f}, ' 'g_BA_loss = {:.5f}, g_ABA_loss = {:.5f}, ' ' time/batch = {:.5f}, ' 'mtime/batch = {:.5f}'.format( counter, config.epoch * num_batches, current_epoch, d_A_loss, d_B_loss, g_adv_loss, g_AB_loss, g_BAB_loss, g_BA_loss, g_ABA_loss, end - start, np.mean(batch_timings))) batch_idx += 1 counter += 1 if (counter) % 2000 == 0 and (counter) > 0: self.save(config.save_path, counter) if (counter % config.save_freq == 0) or (counter == 1): # self.writer.add_summary(_g_sum, counter) # self.writer.add_summary(_d_sum, counter) #feed_dict = {self.gt_high[0]:v_sample_high, self.gt_low[0]:v_sample_low, self.zz[0]:v_sample_z, self.is_valid:True} s_A, s_B, s_reverb, s_gt, r_phase, f_phase = self.sess.run( [ self.GG_A[0][0, :, :, :], self.GG_B[0][0, :, :, :], self.gt_low[0][0, :, :, :], self.gt_high[0][0, :, :, :], self.ori_phase_[0][0, :, :, :], self.rev_phase_[0][0, :, :, :] ], feed_dict={ self.is_valid: True, self.is_train: False, self.is_mismatch: False }) if not os.path.exists(save_path + '/wav'): os.makedirs(save_path + '/wav') if not os.path.exists(save_path + '/txt'): os.makedirs(save_path + '/txt') if not os.path.exists(save_path + '/spec'): os.makedirs(save_path + '/spec') print(str(counter) + 'th finished') x_AB = s_A x_BA = s_B x_reverb = s_reverb x_gt = s_gt Sre = self.get_spectrum(x_reverb).reshape(512, 128) Sgt = self.get_spectrum(x_gt).reshape(512, 128) SAB = self.get_spectrum(x_AB).reshape(512, 128) SBA = self.get_spectrum(x_BA).reshape(512, 128) S = np.concatenate((Sre, Sgt, SAB, SBA), axis=1) fig = Figure(figsize=S.shape[::-1], dpi=1, frameon=False) canvas = FigureCanvas(fig) fig.figimage(S, cmap='jet') fig.savefig(save_path + '/spec/' + 'valid_batch_index' + str(counter) + '-th_pr.png') x_pr = librosa.istft(self.inv_magphase(s_A, f_phase)) librosa.output.write_wav( save_path + '/wav/' + str(counter) + '_AB(dereverb).wav', x_pr, 16000) x_pr = librosa.istft(self.inv_magphase(s_B, r_phase)) librosa.output.write_wav( save_path + '/wav/' + str(counter) + '_BA(reverb).wav', x_pr, 16000) x_lr = librosa.istft(self.inv_magphase(s_reverb, f_phase)) librosa.output.write_wav( save_path + '/wav/' + str(counter) + '_reverb.wav', x_lr, 16000) x_hr = librosa.istft(self.inv_magphase(s_gt, r_phase)) librosa.output.write_wav( save_path + '/wav/' + str(counter) + '_orig.wav', x_hr, 16000) s_AB, s_BA, s_reverb, s_gt = self.sess.run( [ self.GG_A[0][0, :, :, :], self.GG_B[0][0, :, :, :], self.gt_low[0][0, :, :, :], self.gt_high[0][0, :, :, :] ], feed_dict={ self.is_valid: False, self.is_train: True, self.is_mismatch: False }) x_AB = s_AB x_BA = s_BA x_reverb = s_reverb x_gt = s_gt Sre = self.get_spectrum(x_reverb).reshape(512, 128) Sgt = self.get_spectrum(x_gt).reshape(512, 128) SAB = self.get_spectrum(x_AB).reshape(512, 128) SBA = self.get_spectrum(x_BA).reshape(512, 128) S = np.concatenate((Sre, Sgt, SAB, SBA), axis=1) fig = Figure(figsize=S.shape[::-1], dpi=1, frameon=False) canvas = FigureCanvas(fig) fig.figimage(S, cmap='jet') fig.savefig(save_path + '/spec/' + 'train_batch_index' + str(counter) + '-th_pr.png') #np.savetxt(os.path.join(save_path, '/txt/d_real_losses.txt'), d_real_losses) #np.savetxt(os.path.join(save_path, '/txt/d_fake_losses.txt'), d_fake_losses) #np.savetxt(os.path.join(save_path, '/txt/g_adv_losses.txt'), g_adv_losses) #np.savetxt(os.path.join(save_path, '/txt/g_l2_losses.txt'), g_l2_losses) if batch_idx >= num_batches: current_epoch += 1 #reset batch idx batch_idx = 0 if current_epoch >= config.epoch: print(str(self.epoch), ': epoch limit') print('saving last model at iteration', str(counter)) self.save(config.save_path, counter) # self.writer.add_summary(_g_sum, counter) # self.writer.add_summary(_d_sum, counter) break except tf.errors.InternalError: print('InternalError') pass except tf.errors.OutOfRangeError: print('done training') pass finally: coord.request_stop() coord.join(threads)
def image_preview(request, id=0, size=0): print('image_preview', id, size) image = Images.objects.get(id=id) filename = image.filename filename = posixpath.join(settings.BASE_DIR, filename) data = fits.getdata(filename, -1).astype(np.double) header = fits.getheader(filename, -1) if request.GET.has_key('size'): size = int(request.GET.get('size', 0)) if not request.GET.has_key('raw'): if image.type not in ['masterdark', 'masterflat']: dark = None if image.type not in ['dark', 'zero']: cdark = find_calibration_image(image, 'masterdark') if cdark is not None: dark = fits.getdata(cdark.filename, -1) if dark is not None: data, header = calibrate.calibrate( data, header, dark=dark) # Subtract dark and linearize # data -= dark if image.type not in ['masterflat', 'flat']: cflat = find_calibration_image(image, 'masterflat') if cflat is not None: flat = fits.getdata(cflat.filename, -1) idx = flat > 0.5 data[idx] *= np.median(flat[idx]) / flat[idx] ldata = data else: ldata, lheader = data, header if size: data = rescale(data, size / data.shape[1], mode='reflect', multichannel=False, anti_aliasing=True, preserve_range=True) figsize = (data.shape[1], data.shape[0]) fig = Figure(facecolor='white', dpi=72, figsize=(figsize[0] / 72, figsize[1] / 72)) limits = np.percentile(ldata[np.isfinite(ldata)], [2.5, float(request.GET.get('qq', 99.75))]) fig.figimage(data, vmin=limits[0], vmax=limits[1], origin='lower', cmap=request.GET.get('cmap', 'Blues_r')) canvas = FigureCanvas(fig) response = HttpResponse(content_type='image/jpeg') canvas.print_jpg(response) return response
def reduce(getDarkFrames, getBiasFrames, getFlatFields, getRawFrames, sessionId): try: sig_fract = 5.0 percent_fract = 0.01 min_val = 0.0 #Open Dark Frames data List = getDarkFrames reference_dark_image = 'None' dataList = [] if List != []: for file in List: dataList.append( openFile(backendInputFits + sessionId + "_Dark_" + file)) reference_dark_image = medianImage(dataList) #Open Bias Frames data List = getBiasFrames reference_bias_image = 'None' if List != []: dataList = [] for file in List: dataList.append( openFile(backendInputFits + sessionId + "_Bias_" + file)) reference_bias_image = medianImage(dataList) #Open Flat Fields data List = getFlatFields reference_flat_image = 'None' if List != []: dataList = [] for file in List: dataList.append( openFileAndNormalize(backendInputFits + sessionId + "_Flat_" + file)) reference_flat_image = medianImage(dataList) #Open Raw Images Data and Reduce List = getRawFrames if List != []: for file in List: dataImage = openFile(backendInputFits + sessionId + "_Raw_" + file) #reference dark frame exists dark_corrected_image = 'None' if reference_dark_image != 'None': dark_corrected_image = dataImage - reference_dark_image #reference dark frame does not exist but reference bias frame exists bias_corrected_image = 'None' if reference_dark_image == 'None' and reference_bias_image != 'None': bias_corrected_image = dataImage - reference_bias_image #reference dark frame exists and reference bias frame exists if reference_dark_image != 'None' and reference_bias_image != 'None': bias_corrected_image = dark_corrected_image - reference_bias_image #dark corrected image exists and flat exists if dark_corrected_image != 'None' and reference_flat_image != 'None' and bias_corrected_image == 'None': final_image = dark_corrected_image / reference_flat_image #bias corrected image exists and flat exists if bias_corrected_image != 'None' and reference_flat_image != 'None': final_image = bias_corrected_image / reference_flat_image #reference flat field does not exist but bias corrected image exists if bias_corrected_image != 'None' and reference_flat_image == 'None': final_image = bias_corrected_image #reference flat field does not exist and only dark corrected image exists if dark_corrected_image != 'None' and reference_flat_image == 'None' and bias_corrected_image == 'None': final_image = dark_corrected_image #reference flat field exists and raw image exists if bias_corrected_image == 'None' and reference_flat_image != 'None' and dark_corrected_image == 'None': final_image = dataImage / reference_flat_image #reference flat field does not exist and only raw image exists if bias_corrected_image == 'None' and reference_flat_image == 'None' and dark_corrected_image == 'None': final_image = dataImage width = float(final_image.shape[1]) / 100 height = float(final_image.shape[0]) / 100 if os.path.exists(backendOutputFits + "Processed_" + file): os.remove(backendOutputFits + "Processed_" + file) pyfits.append(backendOutputFits + "Processed_" + file, final_image) sky, num_iter = sky_mean_sig_clip(final_image, sig_fract, percent_fract, max_iter=1) img_data = final_image - sky new_img = linear(img_data, scale_min=min_val) Rotated_Plot = ndimage.rotate(new_img, 180) Flipped_Plot = np.fliplr(Rotated_Plot) fig = Figure(figsize=(width, height)) fig.figimage(Flipped_Plot, cmap='gray') canvas = FigureCanvas(fig) specialCharacterPosition = file.index('.') fileWithoutExtension = str(file[:specialCharacterPosition]) canvas.print_figure(frontendInputFits + "Linear_" + sessionId + "_Processed_" + fileWithoutExtension + ".png") except: print 'error in reduce function'
class App: '''Tkinter GUI application''' def __init__(self, root, files, img_width, img_height, islabeled): self.current_index = 0 self.files_keys = files.keys() self.files = files self.img_width, self.img_height = img_width, img_height self.gt_labels = False self.manual_thresh = StringVar() self.just_set_thresh = False self.manual_thresh.trace("w", self.manual_thresh_change) self.make_widgets(root, img_width, img_height, islabeled) self.load_files() def make_widgets(self, root, img_width, img_height, islabeled): # enclosing frame frame = Frame(root) frame.grid(padx=10, pady=10) # canvas self.f = Figure(figsize=(img_width / 100.0, img_height / 100.0), dpi=100) self.canvas = FigureCanvasTkAgg(self.f, master=frame) self.canvas.show() self.canvas.get_tk_widget().grid(column=0, row=1, rowspan=5) # other widgets self.filename_label = Label(frame, text="Filename") self.filename_label.grid(column=0, row=0) self.roi_slider = Scale(frame, from_=100, to=0, orient=VERTICAL, length=400, command=self.roi_slider_change) self.roi_slider.grid(column=1, row=1, rowspan=4, padx=25) self.image_slider = Scale(frame, from_=0, to=100, orient=HORIZONTAL, length=400, command=self.image_slider_change) self.image_slider.grid(column=0, row=6) self.cutoff_label = Label(frame, text="set threshold value:") self.cutoff_label.grid(column=2, row=1) self.cutoff_entry = Entry(frame, textvariable=self.manual_thresh) self.cutoff_entry.grid(column=3, row=1) self.max_thresh_label = Label(frame, text="current threshold value:") self.max_thresh_label.grid(column=2, row=2) self.max_thresh_value_label = Label(frame, text="0") self.max_thresh_value_label.grid(column=3, row=2) self.save_button = Button(frame, text="Save Displayed ROIs", command=self.save_button_press) self.save_button.grid(column=2, columnspan=2, row=3) prev_next_frame = Frame(frame) prev_next_frame.grid(column=2, columnspan=2, row=4) self.next_image_button = Button(prev_next_frame, text="Next Image", command=self.next_image_button_press) self.next_image_button.grid(column=1, row=0, sticky=W) self.prev_image_button = Button(prev_next_frame, text="Previous Image", state=DISABLED, command=self.prev_image_button_press) self.prev_image_button.grid(column=0, row=0, sticky=E) self.index_label = Label(prev_next_frame, text=self.make_index_label()) self.index_label.grid(column=0, columnspan=2, row=1) if islabeled: self.gt_labels_button = Button( frame, text="Show/Hide Ground Truth Labels", command=self.gt_labels_button_press) else: self.gt_labels_button = Button( frame, text="Show/Hide Ground Truth Labels", state=DISABLED, command=self.gt_labels_button_press) self.gt_labels_button.grid(column=2, columnspan=2, row=5) def load_files(self): '''load a new image and corresponding ROIs''' current_files = self.files[self.files_keys[self.current_index]] self.filename_label.config(text=self.files_keys[self.current_index]) self.image = load_stack(current_files[0]) self.image_slider.config(to=self.image.shape[0] - 1) self.image_slider.set(0) self.image_index = 0 self.convnet_rois = np.load(current_files[1])['rois'] self.convnet_roi_probs = np.load(current_files[1])['roi_probabilities'] self.indexed_roi_probs = sorted( [(v, i) for i, v in enumerate(self.convnet_roi_probs)], reverse=True) assert (self.convnet_rois.shape[0] == self.convnet_roi_probs.shape[0]) self.roi_slider.config(from_=self.convnet_rois.shape[0]) if self.manual_thresh.get().strip() == "": self.roi_slider.set(self.convnet_rois.shape[0]) self.roi_index = self.convnet_rois.shape[0] else: new_index = self.convnet_rois.shape[0] for j, (p, ind) in enumerate(self.indexed_roi_probs): if p < float(self.manual_thresh.get()): new_index = j break self.roi_index = new_index self.just_set_thresh = True self.roi_slider.set(new_index) if current_files[2] is not None: self.gt_rois = load_rois(current_files[2], self.img_width, self.img_height) self.gt_rois = self.gt_rois.max(axis=0) self.draw_canvas() def draw_canvas(self): '''draw current image and selected ROIs''' self.f.clf() overlay = np.zeros((self.image.shape[1], self.image.shape[2], 3)) overlay[:, :, 0] = self.image[self.image_index, :, :] overlay[:, :, 1] = self.image[self.image_index, :, :] overlay[:, :, 2] = self.image[self.image_index, :, :] current_roi_indices = [ i for (v, i) in self.indexed_roi_probs[0:self.roi_index] ] if len(current_roi_indices) > 0: cutoff = self.indexed_roi_probs[self.roi_index - 1][0] self.max_thresh_value_label.config(text=">= {:.3f}".format(cutoff)) current_rois_mask = self.convnet_rois[current_roi_indices].max( axis=0) overlay[:, :, 2][current_rois_mask == 1] = 1 else: cutoff = self.indexed_roi_probs[0][0] self.max_thresh_value_label.config(text="> {:.3f}".format(cutoff)) if self.gt_labels: overlay[:, :, 0][self.gt_rois == 1] = 1 self.f.figimage(overlay) self.canvas.draw() def roi_slider_change(self, value): '''callback for threshold value slider''' self.roi_index = int(value) if self.manual_thresh.get() != "" and not self.just_set_thresh: self.manual_thresh.set("") self.just_set_thresh = False self.draw_canvas() def image_slider_change(self, value): '''callback for image sequence slider''' self.image_index = int(value) self.draw_canvas() def save_button_press(self): '''callback to save currently selected ROIs''' current_roi_indices = [ i for (v, i) in self.indexed_roi_probs[0:self.roi_index] ] current_rois = self.convnet_rois[current_roi_indices] current_files = self.files[self.files_keys[self.current_index]] new_file = current_files[1][0:-4] + "_MANUAL.npz" np.savez_compressed(new_file, rois=current_rois) print "saved as " + new_file def make_index_label(self): '''returns current image index as fraction string''' return str(self.current_index + 1) + "/" + str(len(self.files_keys)) def next_image_button_press(self): '''callback for next image button''' if self.current_index < len(self.files_keys) - 1: self.current_index += 1 self.index_label.config(text=self.make_index_label()) self.load_files() if self.current_index == len(self.files_keys) - 1: self.next_image_button.config(state=DISABLED) if self.current_index > 0: self.prev_image_button.config(state=NORMAL) def prev_image_button_press(self): '''callback for previous image button''' if self.current_index > 0: self.current_index -= 1 self.index_label.config(text=self.make_index_label()) self.load_files() if self.current_index == 0: self.prev_image_button.config(state=DISABLED) if self.current_index < len(self.files_keys) - 1: self.next_image_button.config(state=NORMAL) def gt_labels_button_press(self): '''callback for show/hide ground truth ROIs button''' self.gt_labels = not self.gt_labels self.draw_canvas() def manual_thresh_change(self, *args): '''callback for manual thresholsd entry''' if self.manual_thresh.get().strip() != "": new_index = self.convnet_rois.shape[0] for j, (p, ind) in enumerate(self.indexed_roi_probs): if p < float(self.manual_thresh.get()): new_index = j break self.roi_index = new_index self.just_set_thresh = True self.roi_slider.set(new_index) self.draw_canvas()
def image_cutout(request, id=0, size=0, mode='view'): image = Images.objects.get(id=id) filename = image.filename filename = posixpath.join(settings.BASE_DIR, filename) data = fits.getdata(filename, -1) header = fits.getheader(filename, -1) cdark = find_calibration_image(image, 'masterdark') if cdark is not None: dark = fits.getdata(cdark.filename, -1) if cdark is not None: dark = fits.getdata(cdark.filename, -1) else: cbias, cdc = find_calibration_image( image, 'bias'), find_calibration_image(image, 'dcurrent') if cbias is not None and cdc is not None: bias = fits.getdata(cbias.filename, -1) dc = fits.getdata(cdc.filename, -1) dark = bias + image.exposure * dc else: dark = None if dark is not None: data, header = calibrate.calibrate( data, header, dark=dark) # Subtract dark and linearize cflat = find_calibration_image(image, 'masterflat') if cflat is not None: flat = fits.getdata(cflat.filename, -1) data *= np.median(flat) / flat ra, dec, sr = float(request.GET.get('ra')), float( request.GET.get('dec')), float(request.GET.get('sr')) wcs = WCS(header) x0, y0 = wcs.all_world2pix(ra, dec, sr) r0 = sr / np.hypot(wcs.pixel_scale_matrix[0, 0], wcs.pixel_scale_matrix[0, 1]) crop, cropheader = utils.crop_image(data, x0, y0, r0, header) if mode == 'download': s = StringIO() fits.writeto(s, crop, cropheader) response = HttpResponse(s.getvalue(), content_type='application/octet-stream') response[ 'Content-Disposition'] = 'attachment; filename=crop_' + os.path.split( filename)[-1] response['Content-Length'] = len(s.getvalue()) return response if size: if size > crop.shape[1]: crop = rescale(crop, size / crop.shape[1], mode='reflect', multichannel=False, anti_aliasing=False, order=0) else: crop = rescale(crop, size / crop.shape[1], mode='reflect', multichannel=False, anti_aliasing=True) figsize = (crop.shape[1], crop.shape[0]) fig = Figure(facecolor='white', dpi=72, figsize=(figsize[0] / 72, figsize[1] / 72)) if np.any(np.isfinite(crop)): limits = np.percentile(crop[np.isfinite(crop)], [0.5, float(request.GET.get('qq', 99.75))]) fig.figimage(crop, vmin=limits[0], vmax=limits[1], origin='lower', cmap=request.GET.get('cmap', 'Blues_r')) canvas = FigureCanvas(fig) response = HttpResponse(content_type='image/jpeg') canvas.print_jpg(response) return response
class App: '''Tkinter GUI application''' def __init__(self, root, fname, img_width, img_height): self.fname = fname self.root = root self.rname = self.fname[0:-4] + 'dF.npz' self.img_width, self.img_height = img_width, img_height self.manual_thresh = StringVar() self.just_set_thresh = False self.manual_thresh.trace("w", self.manual_thresh_change) self.image = self.getIm() #self.image = load_stack(self.fname) self.convnet_rois = np.load(self.rname)['rois'] self.convnet_roi_probs = np.load(self.rname)['roi_probabilities'] self.roi_index = self.convnet_rois.shape[0] self.indexed_roi_probs = sorted( [(v, i) for i, v in enumerate(self.convnet_roi_probs)], reverse=True) self.image_index = 10 self.make_widgets(root, img_width, img_height) self.draw_canvas() def getIm(self): im = io.imread(self.fname) im = np.divide(im, np.mean(im)) return im def make_widgets(self, root, img_width, img_height): # enclosing frame frame = Frame(root) frame.grid(padx=10, pady=10) # canvas self.f = Figure(figsize=(img_width / 100.0, img_height / 100.0), dpi=100) self.canvas = FigureCanvasTkAgg(self.f, master=frame) self.canvas.show() self.canvas.get_tk_widget().grid(column=0, row=1, rowspan=5) # other widgets self.filename_label = Label(frame, text="Filename") self.filename_label.grid(column=0, row=0) self.roi_slider = Scale(frame, from_=self.convnet_rois.shape[0] - 1, to=0, orient=VERTICAL, length=400, command=self.roi_slider_change) self.roi_slider.grid(column=1, row=1, rowspan=4, padx=25) self.image_slider = Scale(frame, from_=0, to=self.image.shape[0] - 1, orient=HORIZONTAL, length=400, command=self.image_slider_change) self.image_slider.grid(column=0, row=6) self.save_button = Button(frame, text="Save Displayed ROIs", command=self.save_button_press) self.save_button.grid(column=2, columnspan=2, row=3) prev_next_frame = Frame(frame) prev_next_frame.grid(column=2, columnspan=2, row=4) def draw_canvas(self): '''draw current image and selected ROIs''' self.f.clf() frame = Frame(self.root) frame.grid(padx=10, pady=10) self.image_slider = Scale(frame, from_=0, to=self.image.shape[0] - 1, orient=HORIZONTAL, length=400, command=self.image_slider_change) overlay = np.zeros((self.image.shape[1], self.image.shape[2], 3)) overlay[:, :, 0] = self.image[self.image_index, :, :] overlay[:, :, 1] = self.image[self.image_index, :, :] overlay[:, :, 2] = self.image[self.image_index, :, :] current_roi_indices = [ i for (v, i) in self.indexed_roi_probs[0:self.roi_index] ] if len(current_roi_indices) > 0: print(self.roi_index - 1) cutoff = self.indexed_roi_probs[self.roi_index - 1][0] current_rois_mask = self.convnet_rois[current_roi_indices].max( axis=0) overlay[:, :, 2][current_rois_mask == 1] = 1 else: cutoff = self.indexed_roi_probs[0][0] self.f.figimage(overlay) self.canvas.draw() def roi_slider_change(self, value): '''callback for threshold value slider''' self.roi_index = int(value) if self.manual_thresh.get() != "" and not self.just_set_thresh: self.manual_thresh.set("") self.just_set_thresh = False self.draw_canvas() def image_slider_change(self, value): '''callback for image sequence slider''' self.image_index = int(value) self.draw_canvas() def save_button_press(self): '''callback to save currently selected ROIs''' current_roi_indices = [ i for (v, i) in self.indexed_roi_probs[0:self.roi_index] ] current_rois = self.convnet_rois[current_roi_indices] new_file = self.fname[0:-4] + "_ROIsManual.csv" self.saveROIsAsCSV(current_rois, new_file) #np.savez_compressed(new_file, rois=current_rois) print "saved as " + new_file def saveROIsAsCSV(self, rois, fname): dim = rois.shape outArr = np.zeros([dim[0], 4]) #minX, minY, maxX, maxY for x in range(dim[0]): #make a 1d array that sums elements across the first dim temp1 = np.sum(rois[x, :, :], axis=0) #dim 1 temp2 = np.sum(rois[x, :, :], axis=1) #dim 2 #now find the first and last nonzero elements in these 1ds temp1nz = np.nonzero(temp1) temp2nz = np.nonzero(temp2) outArr[x, :] = [ temp1nz[0][0], temp2nz[0][0], temp1nz[-1][-1], temp2nz[-1][-1] ] np.savetxt(fname, outArr, delimiter=',', fmt='%i') def manual_thresh_change(self, *args): '''callback for manual thresholsd entry''' if self.manual_thresh.get().strip() != "": new_index = self.convnet_rois.shape[0] for j, (p, ind) in enumerate(self.indexed_roi_probs): if p < float(self.manual_thresh.get()): new_index = j break self.roi_index = new_index self.just_set_thresh = True self.roi_slider.set(new_index) self.draw_canvas(root)
import utils import numpy as np import pytesseract from PIL import Image import pdb import cv2 root = tkinter.Tk() root.wm_title("Embedding in Tk") img = utils.get_board('/Users/Alex/Desktop/Summer-2019/scrabble/labels.txt', 12) im = Image.fromarray(img) im = pytesseract.image_to_boxes(im) fig = Figure(figsize=(5, 5), dpi=100) t = np.arange(0, 3, .01) fig.figimage(img, 0) canvas = FigureCanvasTkAgg(fig, master=root) # A tk.DrawingArea. canvas.draw() canvas.get_tk_widget().pack(side=tkinter.TOP, fill=tkinter.BOTH, expand=1) toolbar = NavigationToolbar2Tk(canvas, root) toolbar.update() canvas.get_tk_widget().pack(side=tkinter.TOP, fill=tkinter.BOTH, expand=1) def on_key_press(event): print("you pressed {}".format(event.key)) key_press_handler(event, canvas, toolbar) canvas.mpl_connect("key_press_event", on_key_press)
return S ## --- COULEURS --- noir = cm.Greys jaune = cm.gnuplot ## --- AFFICHAGE --- matrice = Matrice(l) #Initialisation de la matrice fen = Tk.Tk() # Fenêtre Tk principale f = Figure(figsize=(l / resolution, l / resolution), dpi=resolution) # Figure d'affichage Matplotlib img = f.figimage(matrice.val, cmap=noir) # Création de l'objet image # Graphique du nombre de cellules vivantes g = Figure(figsize=(4, 4), dpi=resolution) graph = g.add_subplot(111) graph.plot(np.arange(len(matrice.nb)), matrice.nb) canvas1 = FigureCanvasTkAgg(f, master=fen) # Création d'un canvas Tk/Matplotlib canvas1.show() canvas1.get_tk_widget().pack(side=Tk.LEFT, fill=Tk.BOTH, expand=1) canvas2 = FigureCanvasTkAgg( g, master=fen) # Création d'un deuxième canvas Tk/Matplotlib canvas2.show() canvas2.get_tk_widget().pack(side=Tk.LEFT)
def train(self, sess, config): """ Training the GAN """ print ('initializing...opt') d_opt = self.d_opt g_opt = self.g_opt try: init = tf.global_variables_initializer() sess.run(init) except AttributeError: init = tf.intializer_all_varialble() sess.run(init) print ('initializing...var') g_summaries = [self.d_fake_summary, self.d_fake_loss_summary, self.g_loss_summary, self.g_l2_loss_summary, self.g_loss_adv_summary, self.generated_wav_summary, self.generated_audio_summary] d_summaries = [self.d_loss_summary, self.d_real_summary, self.d_real_loss_summary, self.nonreverb_audio_summary, self.nonreverb_wav_summary] if hasattr(self, 'alpha_summ'): g_summaries += self.alpha_summ self.g_sum = tf.summary.merge(g_summaries) self.d_sum = tf.summary.merge(d_summaries) if not os.path.exists(os.path.join(config.save_path, 'train')): os.makedirs(os.path.join(config.save_path, 'train')) self.writer = tf.summary.FileWriter(os.path.join(config.save_path, 'train'), self.sess.graph) coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) sample_reverb, sample_nonreverb, sample_z = self.sess.run([self.gt_reverb[0], self.gt_nonreverb[0], self.zz[0]], feed_dict={self.is_valid:False}) v_sample_reverb, v_sample_nonreverb, v_sample_z = self.sess.run([self.gt_reverb[0], self.gt_nonreverb[0], self.zz[0]], feed_dict={self.is_valid: True, self.is_train: False}) print ('sample reverb shape: ', sample_reverb.shape) print ('sample nonreverb shape: ', sample_nonreverb.shape) print ('sample z shape: ', sample_z.shape) save_path = config.save_path counter = 0 # count of num of samples num_examples = 0 for record in tf.python_io.tf_record_iterator(self.tfrecords): num_examples += 1 print ("total num of patches in tfrecords", self.tfrecords,": ", num_examples) # last samples # batch num num_batches = num_examples / self.batch_size print ('batches per epoch: ', num_batches) if self.load(self.save_path): print ('load success') else: print ('load failed') batch_idx = 0 current_epoch = 0 batch_timings = [] g_losses = [] d_fake_losses = [] d_real_losses = [] g_adv_losses = [] g_l2_losses = [] try: while not coord.should_stop(): start = timeit.default_timer() if counter % config.save_freq == 0: for d_iter in range(self.disc_updates): _d_opt, _d_sum, d_fake_loss, d_real_loss = self.sess.run([d_opt, self.d_sum, self.d_fake_losses[0], self.d_real_losses[0]], feed_dict={self.is_valid:False, self.is_train: True}) #_d_sum, d_fake_loss, d_real_loss = self.sess.run( # [self.d_sum, self.d_fake_losses[0], self.d_real_losses[0]], feed_dict={self.is_valid: False}) if self.d_clip_weights: self.sess.run(self.d_clip, feed_dict={self.is_valid:False,self.is_train: True}) #_g_opt, _g_sum, g_adv_loss, g_l2_loss = self.sess.run([g_opt, self.g_sum, self.g_adv_losses[0], self.g_l2_losses[0]], feed_dict={self.is_valid:False}) _g_opt, _g_sum, g_adv_loss, g_l2_loss = self.sess.run([g_opt, self.g_sum, self.g_adv_losses[0], self.g_l2_losses[0]], feed_dict={self.is_valid:False,self.is_train: True}) else: for d_iter in range(self.disc_updates): _d_opt, d_fake_loss, d_real_loss = self.sess.run([d_opt, self.d_fake_losses[0], self.d_real_losses[0]], feed_dict={self.is_valid:False,self.is_train: True}) #d_fake_loss, d_real_loss = self.sess.run( # [self.d_fake_losses[0], self.d_real_losses[0]], feed_dict={self.is_valid: False}) if self.d_clip_weights: self.sess.run(self.d_clip, feed_dict={self.is_valid:False,self.is_train: True}) #_g_opt, g_adv_loss, g_l2_loss = self.sess.run([g_opt, self.g_adv_losses[0], self.g_l2_losses[0]], feed_dict={self.is_valid:False}) _g_opt, g_adv_loss, g_l2_loss = self.sess.run([g_opt, self.g_adv_losses[0], self.g_l2_losses[0]], feed_dict={self.is_valid:False,self.is_train: True}) end = timeit.default_timer() batch_timings.append(end - start) d_fake_losses.append(d_fake_loss) d_real_losses.append(d_real_loss) g_adv_losses.append(g_adv_loss) g_l2_losses.append(g_l2_loss) print('{}/{} (epoch {}), d_rl_loss = {:.5f}, ' 'd_fk_loss = {:.5f}, '#d_nfk_loss = {:.5f}, ' 'g_adv_loss = {:.5f}, g_l1_loss = {:.5f},' ' time/batch = {:.5f}, ' 'mtime/batch = {:.5f}'.format(counter, config.epoch * num_batches, current_epoch, d_real_loss, d_fake_loss, g_adv_loss, g_l2_loss, end - start, np.mean(batch_timings))) batch_idx += 1 counter += 1 if (counter) % 2000 == 0 and (counter) > 0: self.save(config.save_path, counter) if (counter) % config.save_freq == 0: self.writer.add_summary(_g_sum, counter) self.writer.add_summary(_d_sum, counter) #feed_dict = {self.gt_nonreverb[0]:v_sample_nonreverb, self.gt_reverb[0]:v_sample_reverb, self.zz[0]:v_sample_z, self.is_valid:True} canvas_w, s_reverb, s_nonreverb = self.sess.run([self.GG[0], self.gt_reverb[0], self.gt_nonreverb[0]], feed_dict={self.is_valid:True,self.is_train: False}) if not os.path.exists(save_path+'/wav'): os.makedirs(save_path + '/wav') if not os.path.exists(save_path + '/txt'): os.makedirs(save_path + '/txt') if not os.path.exists(save_path + '/spec'): os.makedirs(save_path + '/spec') print ('max :', np.max(canvas_w[0]), 'min :', np.min(canvas_w[0])) if self.pre_emphasis>0: canvas_w = self.de_emphasis(canvas_w, self.pre_emphasis) s_reverb = self.de_emphasis(s_reverb, self.pre_emphasis) s_nonreverb = self.de_emphasis(s_nonreverb, self.pre_emphasis) x_pr = canvas_w.flatten() x_pr = x_pr[:int(len(x_pr)/8)] x_lr = s_reverb.flatten()[:len(x_pr)] x_hr = s_nonreverb.flatten()[:len(x_pr)] Sl = self.get_spectrum(x_lr, n_fft=2048) Sh = self.get_spectrum(x_hr, n_fft=2048) Sp = self.get_spectrum(x_pr, n_fft=2048) S = np.concatenate((Sl.reshape(Sh.shape[0], Sh.shape[1]), Sh, Sp), axis=1) fig = Figure(figsize=S.shape[::-1], dpi=1, frameon=False) canvas = FigureCanvas(fig) fig.figimage(S, cmap='jet') fig.savefig(save_path + '/spec/' + 'valid_batch_index' + str(counter) + '-th_pr.png') librosa.output.write_wav(save_path + '/wav/'+str(counter)+'_dereverb.wav', x_pr, 16000) librosa.output.write_wav(save_path + '/wav/'+str(counter)+'_reverb.wav', x_lr, 16000) librosa.output.write_wav(save_path + '/wav/'+str(counter)+'_orig.wav', x_hr, 16000) canvas_w, s_reverb, s_nonreverb = self.sess.run([self.GG[0],self.gt_reverb[0], self.gt_nonreverb[0]], feed_dict={self.is_valid:False, self.is_train: True}) print ('max :', np.max(canvas_w[0]), 'min :', np.min(canvas_w[0])) x_pr = canvas_w.flatten() x_pr = x_pr[:int(len(x_pr)/8)] x_lr = s_reverb.flatten()[:len(x_pr)] x_hr = s_nonreverb.flatten()[:len(x_pr)] Sl = self.get_spectrum(x_lr, n_fft=2048) Sh = self.get_spectrum(x_hr, n_fft=2048) Sp = self.get_spectrum(x_pr, n_fft=2048) S = np.concatenate((Sl.reshape(Sh.shape[0], Sh.shape[1]), Sh, Sp), axis=1) fig = Figure(figsize=S.shape[::-1], dpi=1, frameon=False) canvas = FigureCanvas(fig) fig.figimage(S, cmap='jet') fig.savefig(save_path + '/spec/' + 'train_batch_index' + str(counter) + '-th_pr.png') #np.savetxt(os.path.join(save_path, '/txt/d_real_losses.txt'), d_real_losses) #np.savetxt(os.path.join(save_path, '/txt/d_fake_losses.txt'), d_fake_losses) #np.savetxt(os.path.join(save_path, '/txt/g_adv_losses.txt'), g_adv_losses) #np.savetxt(os.path.join(save_path, '/txt/g_l2_losses.txt'), g_l2_losses) if batch_idx >= num_batches: current_epoch += 1 #reset batch idx batch_idx = 0 if current_epoch >= config.epoch: print (str(self.epoch),': epoch limit') print ('saving last model at iteration',str(counter)) self.save(config.save_path, counter) self.writer.add_summary(_g_sum, counter) self.writer.add_summary(_d_sum, counter) break except tf.errors.OutOfRangeError: print('done training') pass finally: coord.request_stop() coord.join(threads)
def image_preview(request, id=0, size=0): image = Images.objects.get(id=id) filename = image.filename filename = posixpath.join(settings.BASE_DIR, filename) data = fits.getdata(filename, -1) header = fits.getheader(filename, -1) if 'size' in request.GET: size = int(request.GET.get('size', 0)) if not 'raw' in request.GET: if image.type not in ['masterdark', 'masterflat', 'bias', 'dcurrent']: dark = None if image.type not in ['dark', 'zero']: cdark = find_calibration_image(image, 'masterdark') if cdark is not None: dark = fits.getdata(cdark.filename, -1) else: cbias, cdc = find_calibration_image( image, 'bias'), find_calibration_image(image, 'dcurrent') if cbias is not None and cdc is not None: bias = fits.getdata(cbias.filename, -1) dc = fits.getdata(cdc.filename, -1) dark = bias + image.exposure * dc if dark is not None: data, header = calibrate.calibrate( data, header, dark=dark) # Subtract dark and linearize if image.type not in ['flat1']: cflat = find_calibration_image(image, 'masterflat') if cflat is not None: flat = fits.getdata(cflat.filename, -1) data *= np.median(flat) / flat else: data, header = calibrate.crop_overscans(data, header) ldata = data else: ldata, lheader = calibrate.crop_overscans(data, header, subtract=False) if size: data = rescale(data, size / data.shape[1], mode='reflect', multichannel=False, anti_aliasing=True, preserve_range=True) figsize = (data.shape[1], data.shape[0]) fig = Figure(facecolor='white', dpi=72, figsize=(figsize[0] / 72, figsize[1] / 72)) limits = np.percentile(ldata[np.isfinite(ldata)], [2.5, float(request.GET.get('qq', 99.75))]) fig.figimage(data, vmin=limits[0], vmax=limits[1], origin='lower', cmap=request.GET.get('cmap', 'Blues_r')) canvas = FigureCanvas(fig) response = HttpResponse(content_type='image/jpeg') canvas.print_jpg(response) return response
class Interface(): def __init__(self, root, board, opp_type): self.board = board self.opponent = opp_type(self.board) self.root = root self.root.wm_title("ChessDisplay") self.f = Figure(figsize=(4, 4), dpi=100) self.ax1 = self.f.add_subplot(111) self.ax1.axis('off') self.dx = 56.5 self.x_offset = 125.0 self.dy = -56.0 self.y_offset = 540.0 img_dir = "../imgs/" img = image.imread(img_dir + 'board.gif') self.ax1.imshow(img) self.pieces_plot_list = [] self.white_p = image.imread(img_dir + 'white_p.png') self.black_p = image.imread(img_dir + 'black_p.png') self.white_r = image.imread(img_dir + 'white_r.png') self.black_r = image.imread(img_dir + 'black_r.png') self.white_n = image.imread(img_dir + 'white_n.png') self.black_n = image.imread(img_dir + 'black_n.png') self.white_b = image.imread(img_dir + 'white_b.png') self.black_b = image.imread(img_dir + 'black_b.png') self.white_q = image.imread(img_dir + 'white_q.png') self.black_q = image.imread(img_dir + 'black_q.png') self.white_k = image.imread(img_dir + 'white_k.png') self.black_k = image.imread(img_dir + 'black_k.png') self.piece_dict = { 'P': self.white_p, 'p': self.black_p, 'R': self.white_r, 'r': self.black_r, 'N': self.white_n, 'n': self.black_n, 'B': self.white_b, 'b': self.black_b, 'Q': self.white_q, 'q': self.black_q, 'K': self.white_k, 'k': self.black_k } self.canvas = FigureCanvasTkAgg(self.f, master=root) self.canvas.draw() self.canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) self._update_plot() self.canvas._tkcanvas.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1) self.q_button = Tk.Button(master=self.root, text='Quit', command=self._quit, width=10) self.q_button.pack(side=Tk.RIGHT, padx=10, pady=10) self.m_label = Tk.Label(master=self.root, text='Your move:') self.m_label.pack(side=Tk.LEFT, padx=5, pady=10) self.m_entry = Tk.Entry(master=self.root, width=25) self.m_entry.pack(side=Tk.LEFT, padx=5, pady=10) self.m_button = Tk.Button(master=self.root, text='Move', command=self._move, width=10) self.m_button.pack(side=Tk.LEFT, padx=5, pady=10) Tk.mainloop() def _update_plot(self): FEN_rep = self.board.fen() for piece in self.pieces_plot_list: piece.remove() ix = 0 iy = 0 self.pieces_plot_list = [] for char in FEN_rep: # End of piece list if (char == ' '): break # Onto next rank if (char == '/'): iy += 1 ix = 0 continue # Empty squares if (char.isdigit()): ix += int(char) # There is a piece! else: ix += 1 piece = self.f.figimage(self.piece_dict[char], self.dx * ix + self.x_offset, self.dy * iy + self.y_offset) self.pieces_plot_list.append(piece) self.canvas.draw() def _move(self): self.proposed_move = self.m_entry.get() try: self.board.push_san(self.proposed_move) legal_move = True except: legal_move = False if (legal_move): if (self.board.is_game_over()): self.ax1.text(0.5 * self.ax1.get_xlim()[-1], 0.5 * self.ax1.get_ylim()[-1], "Game Over", ha='center', va='center') else: self.board.push(self.opponent.move()) if (self.board.is_game_over()): self.ax1.text(0.5 * self.ax1.get_xlim()[-1], 0.5 * self.ax1.get_ylim()[-1], "Game Over", ha='center', va='center') self.m_entry.delete(0, 'end') self._update_plot() def _quit(self): self.root.quit() # stops mainloop self.root.destroy() # this is necessary on Windows to prevent