def parse_fits_files(fits_file_name_list, progress_bar=True): fits_noise_list = [] for file_index, file_name in enumerate(fits_file_name_list): # Read the input file ######### fits_images_dict, fits_metadata_dict = images.load_benchmark_images( file_name) # Get images ################## input_img = fits_images_dict["input_image"] reference_img = fits_images_dict["reference_image"] pure_noise_image = input_img - reference_img fits_noise_list.append(pure_noise_image) # Progress bar ################ if progress_bar: num_files = len(fits_file_name_list) relative_steps = math.ceil(num_files / 100.) if (file_index % relative_steps) == 0: progress_str = "{:.2f}% ({}/{})".format( (file_index + 1) / num_files * 100, file_index + 1, num_files) print(progress_str) return fits_noise_list
def main(): # PARSE OPTIONS ########################################################### parser = argparse.ArgumentParser(description="Plot a FITS file.") parser.add_argument("--quiet", "-q", action="store_true", help="Don't show the plot, just save it") parser.add_argument("--output", "-o", default=None, metavar="FILE", help="The output file path (image file)") parser.add_argument("fileargs", nargs=1, metavar="FILE", help="The files image to process (FITS).") args = parser.parse_args() quiet = args.quiet output = args.output input_file_path = args.fileargs[0] # READ THE INPUT FILE ##################################################### fits_images_dict, fits_metadata_dict = images.load_benchmark_images( input_file_path) reference_img = fits_images_dict["reference_image"] pixels_position = fits_images_dict["pixels_position"] # ASSESS OR PRINT THE CLEANED IMAGE ####################################### fig, ax1 = plt.subplots(nrows=1, ncols=1, figsize=(9, 9)) common.plot_image_meter(ax1, reference_img, pixels_position, "Reference image") common.plot_ellipse_shower_on_image_meter(ax1, reference_img, pixels_position) # PLOT AND SAVE ########################################################### base_file_path = os.path.basename(input_file_path) base_file_path = os.path.splitext(base_file_path)[0] if output is None: output = "{}.png".format(base_file_path) plt.savefig(output, bbox_inches='tight') if not quiet: plt.show()
def parse_fits_files(fits_file_name): # Read the input file ######### fits_images_dict, fits_metadata_dict = images.load_benchmark_images( fits_file_name) # Get images ################## input_img = fits_images_dict["input_image"] reference_img = fits_images_dict["reference_image"] pure_noise_image = input_img - reference_img return pure_noise_image, fits_metadata_dict
def selection_changed_callback(self, file_name): file_path = os.path.join(self.input_directory_path, file_name) # Read the selected file ######### fits_images_dict, fits_metadata_dict = images.load_benchmark_images(file_path) # Fill the dict ############### text = "File: {}\n\n".format(file_path) for key in sorted(fits_metadata_dict): text += "{}: {}\n".format(key, fits_metadata_dict[key]) # Update the widget ########### self.desc_textview.get_buffer().set_text(text)
def parse_fits_files(dir_name, fits_file_name_list): fits_metadata_list = [] # Parse the input files mc_energy_unit = None for file_index, file_name in enumerate(fits_file_name_list): metadata_dict = {} # Read the input file ######### fits_images_dict, fits_metadata_dict = images.load_benchmark_images( os.path.join(dir_name, file_name)) # Fill the dict ############### if mc_energy_unit is None: mc_energy_unit = fits_metadata_dict["mc_energy_unit"] # TODO else: if mc_energy_unit != fits_metadata_dict["mc_energy_unit"]: raise Exception("Inconsistent data") metadata_dict["event_id"] = fits_metadata_dict["event_id"] metadata_dict["tel_id"] = fits_metadata_dict["tel_id"] metadata_dict["mc_energy"] = fits_metadata_dict["mc_energy"] metadata_dict["npe"] = fits_metadata_dict["npe"] metadata_dict["file_name"] = file_name fits_metadata_list.append(metadata_dict) # Progress bar ################ num_files = len(fits_file_name_list) relative_steps = math.ceil(num_files / 100.) if (file_index % relative_steps) == 0: progress_str = "{:.2f}% ({}/{})".format( (file_index + 1) / num_files * 100, file_index + 1, num_files) print(progress_str) return fits_metadata_list
def export_pixel_mask(input_file_path, output_file_path): fits_images_dict, fits_metadata_dict = images.load_benchmark_images( input_file_path) mask = fits_images_dict["pixels_mask"].astype(np.uint8, copy=True) images.save(mask, output_file_path)
if dir_item_path.lower().endswith('.fits') and os.path.isfile( dir_item_path): input_file_path_list.append(dir_item_path) print("The input directory contains {} FITS files.".format( len(input_file_path_list))) # SHUFFLE THE FILE LIST ####################################################### # shuffle the list to avoid having always the same tel_id random.shuffle(input_file_path_list) # COPY FILES IN THE RAMDISK ################################################### image_counter = 0 for input_file_path in input_file_path_list: if image_counter > NUM_IMAGES: break fits_images_dict, fits_metadata_dict = images.load_benchmark_images( input_file_path) if NPE_MIN <= fits_metadata_dict["npe"] <= NPE_MAX: print(image_counter, input_file_path) shutil.copy(input_file_path, OUTPUT_FILE_PATH) image_counter += 1 else: print("reject", input_file_path)
def main(): # PARSE OPTIONS ########################################################### parser = argparse.ArgumentParser(description="Plot a FITS file.") parser.add_argument("--quiet", "-q", action="store_true", help="Don't show the plot, just save it") parser.add_argument("--output", "-o", default=None, metavar="FILE", help="The output file path (image file)") parser.add_argument("fileargs", nargs="+", metavar="FILE", help="The files image to process (FITS)." "If fileargs is a directory," "all FITS files it contains are processed.") args = parser.parse_args() quiet = args.quiet output = args.output input_file_or_dir_path_list = args.fileargs # FETCH IMAGES ############################################################ for input_file_or_dir_path in input_file_or_dir_path_list: if os.path.isdir(input_file_or_dir_path): input_file_path_list = common.get_fits_files_list( input_directory_path) else: input_file_path_list = [input_file_or_dir_path] # Parse FITS files for input_file_path in input_file_path_list: # READ THE INPUT FILE ############################################# fits_images_dict, fits_metadata_dict = images.load_benchmark_images( input_file_path) input_img = fits_images_dict["input_image"] reference_img = fits_images_dict["reference_image"] if input_img.ndim != 2: raise Exception( "Unexpected error: the input FITS file should contain a 2D array." ) if reference_img.ndim != 2: raise Exception( "Unexpected error: the input FITS file should contain a 2D array." ) # ASSESS OR PRINT THE CLEANED IMAGE ############################### base_file_path = os.path.basename(input_file_path) base_file_path = os.path.splitext(base_file_path)[0] image_list = [input_img, reference_img] title_list = ["Input image", "Reference image"] if output is None: output = "{}.pdf".format(base_file_path) if not quiet: images.plot_list(image_list, title_list, fits_metadata_dict) print("Writing", output) images.mpl_save_list(image_list, output, title_list, fits_metadata_dict)
def main(): # PARSE OPTIONS ########################################################### parser = argparse.ArgumentParser(description="Plot a FITS file.") parser.add_argument("--quiet", "-q", action="store_true", help="Don't show the plot, just save it") parser.add_argument("--output", "-o", default=None, metavar="FILE", help="The output file path (image file)") parser.add_argument("fileargs", nargs=1, metavar="FILE", help="The files image to process (FITS).") args = parser.parse_args() quiet = args.quiet output = args.output input_file_path = args.fileargs[0] # READ THE INPUT FILE ##################################################### fits_images_dict, fits_metadata_dict = images.load_benchmark_images(input_file_path) reference_img = fits_images_dict["reference_image"] pixels_position = fits_images_dict["pixels_position"] ## MAKE MOCK DATA ################## #mean = [0, 0] #cov = [[.0305, .09], # [.01, .0305]] # #x, y = np.random.multivariate_normal(mean, cov, 50000).T ##counts, _, _ = np.histogram2d(x, y, bins=(xbins, ybins)) #counts, _, _ = np.histogram2d(x, y, bins=40) ##counts = counts.T # TODO check that #counts[counts < 100] = 0 #reference_img = counts #reference_img[0, 0] = 1 ## MAKE MOCK DATA ################## #mean = [0, 0] #cov = [[.05, .09], # [.01, .05]] # #x, y = np.random.multivariate_normal(mean, cov, 50000).T ##counts, _, _ = np.histogram2d(x, y, bins=(xbins, ybins)) #counts, _, _ = np.histogram2d(x, y, bins=40) ##counts = counts.T # TODO check that #counts[counts < 100] = 0 #reference_img = counts #reference_img[0, 0] = 1 ## MAKE MOCK DATA ################## #reference_img[reference_img > 0] = 0 #IY = 12 #reference_img[10, IY-2] = 1 #reference_img[10, IY-1] = 1 #reference_img[10, IY ] = 1 #reference_img[10, IY+1] = 1 #reference_img[10, IY+2] = 1 #reference_img[11, IY-2] = 2 #reference_img[11, IY-1] = 2 #reference_img[11, IY ] = 2 #reference_img[11, IY+1] = 2 #reference_img[11, IY+2] = 2 #reference_img[12, IY-2] = 1 #reference_img[12, IY-1] = 1 #reference_img[12, IY ] = 1 #reference_img[12, IY+1] = 1 ##reference_img[12, IY+2] = 1 # Keep it commented, Tailcut fails on symetric images... #################################### #reference_img[reference_img > 0] = 1 # simplify the image (black and white image) # ASSESS OR PRINT THE CLEANED IMAGE ####################################### fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2, figsize=(16, 9)) plot_image_meter(ax1, reference_img, pixels_position, "Reference image") plot_ellipse_shower_on_image_meter(ax1, reference_img, pixels_position) common.plot_perpendicular_hit_distribution(ax2, [reference_img], pixels_position) ax2.set_title("Perpendicular hit distribution") # PLOT AND SAVE ########################################################### base_file_path = os.path.basename(input_file_path) base_file_path = os.path.splitext(base_file_path)[0] if output is None: output = "{}.png".format(base_file_path) plt.savefig(output, bbox_inches='tight') if not quiet: plt.show()
def update_plots(self, data=None, save=False): # data is for event callers if self.current_file_path is not None: # Read the selected file ######### fits_images_dict, fits_metadata_dict = images.load_benchmark_images( self.current_file_path) input_img = fits_images_dict["input_image"] reference_img = fits_images_dict["reference_image"] pixels_position = fits_images_dict["pixels_position"] if input_img.ndim != 2: raise Exception( "Unexpected error: the input FITS file should contain a 2D array." ) if reference_img.ndim != 2: raise Exception( "Unexpected error: the input FITS file should contain a 2D array." ) if self.kill_isolated_pixels_on_ref: reference_img = scipy_kill_isolated_pixels(reference_img) # Tailcut ##################### #input_img_copy = copy.deepcopy(input_img) input_img_copy = input_img.astype('float64', copy=True) tailcut = tailcut_mod.Tailcut() initial_time = time.perf_counter() tailcut_cleaned_img = tailcut.clean_image( input_img_copy, high_threshold=10, low_threshold=5, kill_isolated_pixels=self.kill_isolated_pixels) tailcut_execution_time = time.perf_counter() - initial_time # Wavelets #################### #input_img_copy = copy.deepcopy(input_img) input_img_copy = input_img.astype('float64', copy=True) wavelets = wavelets_mod.WaveletTransform() option_string = self.wavelets_options_entry.get_text() print(option_string) initial_time = time.perf_counter() wavelets_cleaned_img = wavelets.clean_image( input_img_copy, kill_isolated_pixels=self.kill_isolated_pixels, input_image_scale=self.input_image_scale, offset_after_calibration=self.offset_after_calibration, verbose=True, raw_option_string=option_string) wavelets_execution_time = time.perf_counter() - initial_time # Execution time ############## print("Tailcut execution time: ", tailcut_execution_time) # TODO print("Wavelets execution time: ", wavelets_execution_time) # TODO # Tailcut scores ############## tailcut_title_suffix = "" try: tailcut_score_tuple, tailcut_score_name_tuple = assess_mod.assess_image_cleaning( input_img, tailcut_cleaned_img, reference_img, pixels_position, benchmark_method="all") if self.show_scores: tailcut_title_suffix += " (" for name, score in zip(tailcut_score_name_tuple, tailcut_score_tuple): if name == "e_shape": tailcut_title_suffix += " Es=" tailcut_title_suffix += "{:.2e}".format(score) elif name == "e_energy": tailcut_title_suffix += " Ee=" tailcut_title_suffix += "{:.2e}".format(score) elif name == "hillas_theta": tailcut_title_suffix += " Th=" tailcut_title_suffix += "{:.2f}".format(score) tailcut_title_suffix += " )" print("Tailcut:") for name in tailcut_score_name_tuple: print("{:>20}".format(name), end=" ") print() for score in tailcut_score_tuple: print("{:20.12f}".format(score), end=" ") print() except assess_mod.AssessError: print("Tailcut: ", str(assess_mod.AssessError)) # Wavelets scores ############# wavelets_title_suffix = "" try: wavelets_score_tuple, wavelets_score_name_tuple = assess_mod.assess_image_cleaning( input_img, wavelets_cleaned_img, reference_img, pixels_position, benchmark_method="all") if self.show_scores: wavelets_title_suffix += " (" for name, score in zip(wavelets_score_name_tuple, wavelets_score_tuple): if name == "e_shape": wavelets_title_suffix += " Es=" wavelets_title_suffix += "{:.2e}".format(score) elif name == "e_energy": wavelets_title_suffix += " Ee=" wavelets_title_suffix += "{:.2e}".format(score) elif name == "hillas_theta": wavelets_title_suffix += " Th=" wavelets_title_suffix += "{:.2f}".format(score) wavelets_title_suffix += " )" print("Wavelets:") for name in wavelets_score_name_tuple: print("{:>20}".format(name), end=" ") print() for score in wavelets_score_tuple: print("{:20.12f}".format(score), end=" ") print() except assess_mod.AssessError: print("Wavelets: ", str(assess_mod.AssessError)) # Update the widget ########### self.clear_figure() ax1 = self.fig.add_subplot(221) ax2 = self.fig.add_subplot(222) ax3 = self.fig.add_subplot(223) ax4 = self.fig.add_subplot(224) if self.plot_histogram: self._draw_histogram(ax1, input_img, "Input") self._draw_histogram(ax2, reference_img, "Reference") self._draw_histogram(ax3, tailcut_cleaned_img, "Tailcut" + tailcut_title_suffix) self._draw_histogram(ax4, wavelets_cleaned_img, "Wavelets" + wavelets_title_suffix) else: # AX1 ####### self._draw_image(ax1, input_img, "Input", pixels_position=pixels_position) # AX2 ####### self._draw_image(ax2, reference_img, "Reference", pixels_position=pixels_position) if self.plot_ellipse_shower: try: common.plot_ellipse_shower_on_image_meter( ax2, reference_img, pixels_position) except Exception as e: print(e) # AX3 ####### if self.plot_perpendicular_hit_distribution is not None: if self.use_ref_angle_for_perpendicular_hit_distribution: image_array = copy.deepcopy(reference_img) xx, yy = pixels_position[0], pixels_position[1] common_hillas_parameters = hillas_parameters_1( xx.flatten() * u.meter, yy.flatten() * u.meter, image_array.flatten()) else: common_hillas_parameters = None bins = np.linspace(-0.04, 0.04, 21) if self.plot_perpendicular_hit_distribution == "Tailcut": common.plot_perpendicular_hit_distribution( ax3, [reference_img, tailcut_cleaned_img], pixels_position, bins=bins, label_list=["Ref.", "Cleaned TC"], hist_type="step", common_hillas_parameters=common_hillas_parameters, plot_ratio=True) elif self.plot_perpendicular_hit_distribution == "Wavelet": common.plot_perpendicular_hit_distribution( ax3, [reference_img, wavelets_cleaned_img], pixels_position, bins=bins, label_list=["Ref.", "Cleaned WT"], hist_type="step", common_hillas_parameters=common_hillas_parameters, plot_ratio=True) ax3.set_title("Perpendicular hit distribution") ax3.set_xlabel("Distance to the shower axis (in meter)", fontsize=16) ax3.set_ylabel("Photoelectrons", fontsize=16) else: self._draw_image(ax3, tailcut_cleaned_img, "Tailcut" + tailcut_title_suffix, pixels_position=pixels_position) if self.plot_ellipse_shower: if self.plot_perpendicular_hit_distribution is None: try: # Show ellipse only if "perpendicular hit distribution" is off common.plot_ellipse_shower_on_image_meter( ax3, tailcut_cleaned_img, pixels_position) except Exception as e: print(e) # AX4 ####### if self.plot_perpendicular_hit_distribution == "Tailcut": self._draw_image(ax4, tailcut_cleaned_img, "Tailcut" + tailcut_title_suffix, pixels_position=pixels_position) if self.plot_ellipse_shower: if ( self.plot_perpendicular_hit_distribution is not None ) and self.use_ref_angle_for_perpendicular_hit_distribution: try: common.plot_ellipse_shower_on_image_meter( ax4, reference_img, pixels_position) except Exception as e: print(e) else: try: common.plot_ellipse_shower_on_image_meter( ax4, tailcut_cleaned_img, pixels_position) except Exception as e: print(e) else: self._draw_image(ax4, wavelets_cleaned_img, "Wavelets" + wavelets_title_suffix, pixels_position=pixels_position) if self.plot_ellipse_shower: if ( self.plot_perpendicular_hit_distribution is not None ) and self.use_ref_angle_for_perpendicular_hit_distribution: try: common.plot_ellipse_shower_on_image_meter( ax4, reference_img, pixels_position) except Exception as e: print(e) else: try: common.plot_ellipse_shower_on_image_meter( ax4, wavelets_cleaned_img, pixels_position) except Exception as e: print(e) plt.suptitle( "{:.3f} TeV ({} photoelectrons in reference image) - Event {} - Telescope {}" .format(fits_metadata_dict["mc_energy"], int(fits_metadata_dict["npe"]), fits_metadata_dict["event_id"], fits_metadata_dict["tel_id"]), fontsize=18) if save: output_file_path_base = "ev{}_tel{}".format( fits_metadata_dict["event_id"], fits_metadata_dict["tel_id"]) # TODO: add WT options if self.plot_histogram: output_file_path_base += "_hist" if self.plot_log_scale: output_file_path_base += "_log" ## Save in PDF #output_file_path = output_file_path_base + ".pdf" #print("Save", output_file_path) #plt.savefig(output_file_path, bbox_inches='tight') ## Save in SVG #output_file_path = output_file_path_base + ".svg" #print("Save", output_file_path) #plt.savefig(output_file_path, bbox_inches='tight') # Save in PNG output_file_path = output_file_path_base + ".png" print("Save", output_file_path) plt.savefig(output_file_path, bbox_inches='tight') else: self.fig.canvas.draw()
def main(): # PARSE OPTIONS ########################################################### parser = argparse.ArgumentParser(description="Plot a FITS file.") parser.add_argument("--quiet", "-q", action="store_true", help="Don't show the plot, just save it") parser.add_argument("--output", "-o", default=None, metavar="FILE", help="The output file path (image file)") parser.add_argument("fileargs", nargs="+", metavar="FILE", help="The files image to process (FITS)." "If fileargs is a directory," "all FITS files it contains are processed.") args = parser.parse_args() quiet = args.quiet output = args.output input_file_or_dir_path_list = args.fileargs # FETCH PIXELS POSITION ################################################### for input_file_or_dir_path in input_file_or_dir_path_list: if os.path.isdir(input_file_or_dir_path): input_file_path_list = common.get_fits_files_list( input_directory_path) else: input_file_path_list = [input_file_or_dir_path] # Parse FITS files for input_file_path in input_file_path_list: # READ THE INPUT FILE ############################################# fits_images_dict, fits_metadata_dict = images.load_benchmark_images( input_file_path) pixels_position = fits_images_dict["pixels_position"] # PLOT ############################################################ plt.scatter(pixels_position[0], pixels_position[1]) print(pixels_position[0], pixels_position[1]) print(pixels_position[0][0][0] - pixels_position[0][0][1]) print(pixels_position[1][0][0] - pixels_position[1][1][0]) # Save file and plot ######## base_file_path = os.path.basename(input_file_path) base_file_path = os.path.splitext(base_file_path)[0] if output is None: img_output = "{}.pdf".format(base_file_path) print("Writing", img_output) plt.savefig(img_output, bbox_inches='tight') if not quiet: plt.show()
def main(): # PARSE OPTIONS ########################################################### parser = argparse.ArgumentParser(description="Plot a FITS file.") parser.add_argument("--quiet", "-q", action="store_true", help="Don't show the plot, just save it") parser.add_argument("--output", "-o", default=None, metavar="FILE", help="The output file path (image file)") parser.add_argument("fileargs", nargs=1, metavar="FILE", help="The files image to process (FITS).") args = parser.parse_args() quiet = args.quiet output = args.output input_file_path = args.fileargs[0] # READ THE INPUT FILE ##################################################### fits_images_dict, fits_metadata_dict = images.load_benchmark_images( input_file_path) reference_img = fits_images_dict["reference_image"] pixels_position = fits_images_dict["pixels_position"] ## MAKE MOCK DATA ################## #mean = [0, 0] #cov = [[.0305, .09], # [.01, .0305]] # #x, y = np.random.multivariate_normal(mean, cov, 50000).T ##counts, _, _ = np.histogram2d(x, y, bins=(xbins, ybins)) #counts, _, _ = np.histogram2d(x, y, bins=40) ##counts = counts.T # TODO check that #counts[counts < 100] = 0 #reference_img1 = counts #reference_img1[0, 0] = 1 ## MAKE MOCK DATA ################## #mean = [0, 0] #cov = [[.05, .09], # [.01, .05]] # #x, y = np.random.multivariate_normal(mean, cov, 50000).T ##counts, _, _ = np.histogram2d(x, y, bins=(xbins, ybins)) #counts, _, _ = np.histogram2d(x, y, bins=40) ##counts = counts.T # TODO check that #counts[counts < 100] = 0 #reference_img2 = counts #reference_img2[0, 0] = 1 #################################### #bw_reference_img1 = np.copy(reference_img1) #bw_reference_img1[reference_img1 > 0] = 1 # simplify the image (black and white image) #bw_reference_img2 = np.copy(reference_img2) #bw_reference_img2[reference_img2 > 0] = 1 # simplify the image (black and white image) ################################### #pixels_position = rotate(pixels_position, math.pi) # ASSESS OR PRINT THE CLEANED IMAGE ####################################### fig, ((ax1, ax2, ax3), (ax4, ax5, ax6)) = plt.subplots(nrows=2, ncols=3, figsize=(16, 9)) ##plot_image(ax1, reference_img1, "Reference image") ##plot_ellipse_shower_on_image(ax1, reference_img1) #plot_image_meter(ax2, bw_reference_img1, pixels_position, "Reference image") #plot_ellipse_shower_on_image_meter(ax2, reference_img1, pixels_position) #plot_perpendicular_hit_distribution(ax3, ax2, bw_reference_img1, pixels_position, "Perpendicular hit distribution JD") ##plot_image(ax4, reference_img2, "Reference image") ##plot_ellipse_shower_on_image(ax4, reference_img2) #plot_image_meter(ax5, bw_reference_img2, pixels_position, "Reference image") #plot_ellipse_shower_on_image_meter(ax5, reference_img2, pixels_position) #plot_perpendicular_hit_distribution(ax6, ax5, bw_reference_img2, pixels_position, "Perpendicular hit distribution JD") plot_image_meter(ax2, reference_img, pixels_position, "Reference image") plot_ellipse_shower_on_image_meter(ax2, reference_img, pixels_position) plot_perpendicular_hit_distribution(ax3, ax2, reference_img, pixels_position, "Perpendicular hit distribution JD") plot_image_meter(ax5, reference_img, pixels_position, "Reference image") plot_ellipse_shower_on_image_meter(ax5, reference_img, pixels_position) plot_perpendicular_hit_distribution(ax6, ax5, reference_img, pixels_position, "Perpendicular hit distribution JD") #plot_image(ax4, bw_reference_img1, "Reference image") #plot_ellipse_shower_on_image(ax4, bw_reference_img1) #plot_image_meter(ax5, bw_reference_img1, pixels_position, "Reference image") #plot_perpendicular_hit_distribution(ax6, ax5, bw_reference_img1, pixels_position, "Perpendicular hit distribution") #a = np.array([[0, 1,], # [0, 2]]) #print(a) #print(rotate(a, -math.pi)) # PLOT AND SAVE ########################################################### base_file_path = os.path.basename(input_file_path) base_file_path = os.path.splitext(base_file_path)[0] if output is None: output = "{}.pdf".format(base_file_path) plt.savefig(output, bbox_inches='tight') if not quiet: plt.show()