def _resp_plot_default(self): # Create plotting components self.resp_plot_data = ArrayPlotData( time=self.time, inhale_times=self.resp_inhale_begin_times, inhale_values=self.resp_inhale_begin_values, exhale_times=self.resp_exhale_begin_times, exhale_values=self.resp_exhale_begin_values, filtered_resp=self.resp_signal, lpfilt_resp=self.lpfilt_resp) plot = Plot(self.resp_plot_data) plot.plot(("time", "filtered_resp"), color="blue", line_width=1) plot.plot(("time", "lpfilt_resp"), color="green", line_width=1) # Plot the inhalation peaks plot.plot(("inhale_times", "inhale_values"), type="scatter", marker="square") plot.plot(("exhale_times", "exhale_values"), type="scatter", marker="circle") plot.title = "Respiration" plot.title_position = "right" plot.title_angle = 270 plot.padding = 20 return plot
def _point_plots_default(self): """ Instead of defining these in __init__, only construct the plots when a ui is requested """ self.point_plotdata = ArrayPlotData( peak_times=self.physiodata.peak_times.flatten(), x_times=self.physiodata.x_indices - self.physiodata.dzdt_pre_peak, lvet=self.physiodata.lvet, pep=self.physiodata.pep) container = VPlotContainer(resizable="hv", bgcolor="lightgray", fill_padding=True, padding=10) for sig in ("pep", "x_times", "lvet"): temp_plt = Plot(self.point_plotdata) temp_plt.plot(("peak_times", sig), line_width=2) temp_plt.title = sig container.add(temp_plt) container.padding_top = 10 return container
def _karcher_plot_default(self): """ Instead of defining these in __init__, only construct the plots when a ui is requested """ self.interactive = True unreg_mean = self.global_ensemble.dzdt_signal # Temporarily fill in the karcher mean if not self.karcher_mean_calculated: karcher_mean = unreg_mean[self.dzdt_mask] else: karcher_mean = self.dzdt_karcher_mean self.karcher_plotdata = ArrayPlotData( time=self.global_ensemble.dzdt_time, unregistered_mean=self.global_ensemble.dzdt_signal, karcher_mean=karcher_mean, karcher_time=self.dzdt_karcher_mean_time) karcher_plot = Plot(self.karcher_plotdata) karcher_plot.plot(("time", "unregistered_mean"), line_width=1, color="lightblue") line_plot = karcher_plot.plot(("karcher_time", "karcher_mean"), line_width=3, color="blue")[0] # Create an overlay tool karcher_plot.datasources['karcher_time'].sort_order = "ascending" return karcher_plot
def _plot_default(self): plot = Plot(self.plotdata) if self.signal in ("tpr", "co", "sv"): rc_signal = "resp_corrected_" + self.signal if rc_signal in self.plotdata.arrays and self.plotdata.arrays[ rc_signal].size > 0: # Plot the resp-uncorrected version underneath plot.plot(("peak_times", self.signal), type="line", color="purple") signal = rc_signal signal = self.signal elif self.signal == "hr": plot.plot(("peak_times", self.signal), type="line", color="purple") signal = "mea_hr" else: signal = self.signal # Create the plot plot.plot(("peak_times", signal), type="line", color="blue") plot.plot(("peak_times", signal, "beat_type"), type="cmap_scatter", color_mapper=jet, name="my_plot", marker="circle", border_visible=False, outline_color="transparent", bg_color="white", index_sort="ascending", marker_size=3, fill_alpha=0.8) # Tweak some of the plot properties plot.title = self.signal #"Scatter Plot With Lasso Selection" plot.title_position = "right" plot.title_angle = 270 plot.line_width = 1 plot.padding = 20 # Right now, some of the tools are a little invasive, and we need the # actual ScatterPlot object to give to them my_plot = plot.plots["my_plot"][0] # Attach some tools to the plot self.selection = BeatSelection(component=my_plot) my_plot.active_tool = self.selection selection_overlay = RangeSelectionOverlay(component=my_plot) my_plot.overlays.append(selection_overlay) # Set up the trait handler for the selection self.selection.on_trait_change(self._selection_changed, 'selection_completed') return plot
def _z0_plot_default(self): self.z0_plot_data = ArrayPlotData(time=self.time, raw_data=self.raw_z0_signal, cleaned_data=self.resp_corrected_z0) plot = Plot(self.z0_plot_data) plot.plot(("time", "raw_data"), color="blue", line_width=1) plot.plot(("time", "cleaned_data"), color="green", line_width=1) plot.title = "z0" plot.title_position = "right" plot.title_angle = 270 plot.padding = 20 return plot
def _registration_plot_default(self): """ Instead of defining these in __init__, only construct the plots when a ui is requested """ unreg_mean = self.global_ensemble.dzdt_signal # Temporarily fill in the karcher mean if not self.karcher_mean_calculated: karcher_mean = unreg_mean[self.dzdt_mask] else: karcher_mean = self.dzdt_karcher_mean self.single_registration_plotdata = ArrayPlotData( karcher_time=self.dzdt_karcher_mean_time, karcher_mean=karcher_mean, registered_func=karcher_mean) self.single_plot = Plot(self.single_registration_plotdata) self.single_plot.plot(("karcher_time", "karcher_mean"), line_width=2, color="blue") self.single_plot.plot(("karcher_time", "registered_func"), line_width=2, color="maroon") if self.all_beats_registered_to_initial or \ self.all_beats_registered_to_mode: image_data = self.registered_functions.copy() else: image_data = self.dzdt_functions_to_warp.copy() # Create a plot of all the functions registered or not self.all_registration_plotdata = ArrayPlotData(image_data=image_data) self.all_plot = Plot(self.all_registration_plotdata) self.all_plot.img_plot("image_data", colormap=jet) return HPlotContainer(self.single_plot, self.all_plot)
def _image_plot_default(self): # for image plot img = self.ecg_matrix if self.ecg_matrix.size == 0: img = np.zeros((100, 100)) self.image_plot_data = ArrayPlotData(imagedata=img) plot = Plot(self.image_plot_data) self.image_selection_tool = ImageRangeSelector(component=plot, tool_mode="range", axis="value", always_on=True) plot.img_plot("imagedata", colormap=jet, name="plot1", origin="bottom left")[0] plot.overlays.append(self.image_selection_tool) return plot
def _dzdt_plot_default(self): """ Creates a plot of the ecg_ts data and the signals derived during the Pan Tomkins algorithm """ # Create plotting components self.dzdt_plot_data = ArrayPlotData( time=self.time, raw_data=self.raw_dzdt_signal, cleaned_data=self.resp_corrected_dzdt) plot = Plot(self.dzdt_plot_data) plot.plot(("time", "raw_data"), color="blue", line_width=1) plot.plot(("time", "cleaned_data"), color="green", line_width=1) plot.title = "dZ/dt" plot.title_position = "right" plot.title_angle = 270 plot.padding = 20 return plot
def _plot_default(self): # Create plotting components plotdata = ArrayPlotData(time=self.time, data=self.data) plot = Plot(plotdata) self.renderer = plot.plot(("time", "data"), color=self.line_color)[0] plot.title = self.name plot.title_position = "right" plot.title_angle = 270 plot.line_width = 1 plot.padding = 25 plot.width = 400 # Load the censor regions and add them to the plot for censor_region in self.censored_regions: # Make a censor region on the Timeseries object censor_region.plot = self.renderer censor_region.viz censor_region.set_limits(censor_region.start_time, censor_region.end_time) return plot
def _plot_default(self): """ Creates a plot of the ecg_ts data and the signals derived during the Pan Tomkins algorithm """ # Create plotting components self.plot_data = ArrayPlotData( time=self.ecg_time, raw_ecg=self.ecg_signal, qrs_power=self.qrs_power_signal, aux_signal=self.aux_signal, # Ensembleable peaks peak_times=self.peak_times, peak_values=self.peak_values, # Non-ensembleable, useful for HR, HRV dne_peak_times=self.dne_peak_times, dne_peak_values=self.dne_peak_values, # Threshold slider bar thr_times=np.array([self.ecg_time[0], self.ecg_time[-1]]), thr_vals=np.array([0, 0])) plot = Plot(self.plot_data, use_backbuffer=True) self.aux_trace = plot.plot(("time", "aux_signal"), color="purple", alpha=0.6, line_width=2)[0] self.qrs_power_trace = plot.plot(("time", "qrs_power"), color="blue", alpha=0.8)[0] self.ecg_trace = plot.plot(("time", "raw_ecg"), color="red", line_width=2)[0] # Load the censor regions and add them to the plot for n, (start, end) in enumerate(self.censored_intervals): censor_key = "censor%03d" % n self.censored_region_graphics.append( StaticCensoredInterval(component=self.qrs_power_trace, metadata_name=censor_key)) self.ecg_trace.overlays.append(self.censored_region_graphics[-1]) self.ecg_trace.index.metadata[censor_key] = start, end # Line showing self.threshold_trace = plot.plot(("thr_times", "thr_vals"), color="black", line_width=3)[0] # Plot for plausible peaks self.ppeak_vis = plot.plot(("dne_peak_times", "dne_peak_values"), type="scatter", marker="diamond")[0] # Make a scatter plot where you can edit the peaks self.peak_vis = plot.plot(("peak_times", "peak_values"), type="scatter")[0] self.scatter = plot.components[-1] self.peak_editor = PeakPickingTool(self.scatter) self.scatter.tools.append(self.peak_editor) # when the user adds or removes a point, automatically extract self.on_trait_event(self._change_peaks, "peak_editor.done_selecting") self.scatter.overlays.append( PeakPickingOverlay(component=self.scatter)) return plot