Exemple #1
0
def plot_gaps(plot, columns):
    """
	plot % of gaps at each position
	"""
    from plot_window import window_plot_convolve as plot_window
    #	plot_window([columns], len(columns)*.01, plot)
    plot_window([[100 - i for i in columns]], len(columns) * .01, plot)
def plot_gen(input_files, plot_labels, config_file):
    my_config_file = config_file
    if config_file == "auto":
        my_config_file = os.path.splitext(input_files[0])[0] + ".oplot"

    if (len(input_files) == 1):
        if os.path.splitext(input_files[0])[1] == ".plot":
            plot_file = input_files[0]
            cmd = 'gnuplot -persist ' + plot_file
            os.system(cmd)
            return

    global window
    global destroy
    if window != None:
        if window.shown == True:
            if destroy == True:
                window.input_files = input_files
                window.plot.load_data(input_files)
                window.plot.set_labels(plot_labels)
                window.plot.do_plot()
                window.plot.fig.canvas.draw()
                window.window.present()
                window.window.set_keep_above(True)
                return

    window = plot_window()
    window.init(input_files, plot_labels, my_config_file)
Exemple #3
0
def plot_gen(input_files,plot_labels,config_file):
	my_config_file=config_file
	if config_file=="auto":
		my_config_file=os.path.splitext(input_files[0])[0]+".oplot"

	if (len(input_files)==1):
		if os.path.splitext(input_files[0])[1]==".plot":
			plot_file=input_files[0]
			cmd = 'gnuplot -persist '+plot_file
			os.system(cmd)
			return

	global window
	global destroy
	if window!=None:
		if window.shown==True:
			if destroy==True:
				window.input_files=input_files
				window.plot.set_labels(plot_labels)
				window.plot.load_data(input_files,my_config_file)
				window.plot.do_plot()
				window.plot.fig.canvas.draw()
				window.window.present()
				window.window.set_keep_above(True)
				return

	window=plot_window()
	window.init(input_files,plot_labels,my_config_file)
    def plot(self, file_name):
        f = inp()
        f.load(file_name)
        files = f.lines[1:]

        window = plot_window()
        labels = []
        for f in files:
            rel_path = subtract_paths(get_sim_path(), f)
            rel_path = rel_path.replace("\\", "/")
            labels.append(rel_path)
        window.init(files, labels, "")
Exemple #5
0
	def __init__(
		self,
		parent,
		ref_scale=2.0,
		y_per_div=10,
		y_divs=8,
		ref_level=50,
		sample_rate=1,
		data_len=1024,
		update_rate=plot_window.DEFAULT_FRAME_RATE,
		average=False,
		avg_alpha=None,
		title='',
		size=plot_window.DEFAULT_WIN_SIZE,
		peak_hold=False,
		use_persistence=False,
		persist_alpha=None,
		**kwargs #do not end with a comma
	):
		#ensure avg alpha
		if avg_alpha is None:
			avg_alpha = 2.0/update_rate
		#ensure analog alpha
		if persist_alpha is None:
			actual_update_rate=float(sample_rate/data_len)/float(max(1,int(float((sample_rate/data_len)/update_rate))))
			#print "requested_specest_rate ",update_rate
			#print "actual_update_rate    ",actual_update_rate
			analog_cutoff_freq=0.5 # Hertz
			#calculate alpha from wanted cutoff freq
			persist_alpha = 1.0 - math.exp(-2.0*math.pi*analog_cutoff_freq/actual_update_rate)
		
		self._average = average
		self._avg_alpha = avg_alpha
		self._sample_rate = sample_rate
		
		#init
		gr.hier_block2.__init__(
			self,
			"plot_sink",
			gr.io_signature(1, 1, gr.sizeof_float*data_len),
			gr.io_signature(0, 0, 0),
		)
		#blocks
		msgq = gr.msg_queue(2)
		sink = gr.message_sink(gr.sizeof_float*data_len, msgq, True)
		
		#controller
		self.controller = pubsub()
		self.controller.subscribe(AVERAGE_KEY, self.set_average)
		self.controller.publish(AVERAGE_KEY, self.average)
		self.controller.subscribe(AVG_ALPHA_KEY, self.set_avg_alpha)
		self.controller.publish(AVG_ALPHA_KEY, self.avg_alpha)
		self.controller.subscribe(SAMPLE_RATE_KEY, self.set_sample_rate)
		self.controller.publish(SAMPLE_RATE_KEY, self.sample_rate)
		#start input watcher
		common.input_watcher(msgq, self.controller, MSG_KEY)
		#create window
		self.win = plot_window.plot_window(
			parent=parent,
			controller=self.controller,
			size=size,
			title=title,
			data_len=data_len,
			sample_rate_key=SAMPLE_RATE_KEY,
			y_per_div=y_per_div,
			y_divs=y_divs,
			ref_level=ref_level,
			average_key=AVERAGE_KEY,
			avg_alpha_key=AVG_ALPHA_KEY,
			peak_hold=peak_hold,
			msg_key=MSG_KEY,
			use_persistence=use_persistence,
			persist_alpha=persist_alpha,
		)
		common.register_access_methods(self, self.win)
		setattr(self.win, 'set_peak_hold', getattr(self, 'set_peak_hold')) #BACKWARDS
		self.wxgui_connect(self, sink)
Exemple #6
0
    def __init__(
            self,
            parent,
            ref_scale=2.0,
            y_per_div=10,
            y_divs=8,
            ref_level=50,
            sample_rate=1,
            data_len=1024,
            update_rate=plot_window.DEFAULT_FRAME_RATE,
            average=False,
            avg_alpha=None,
            title='',
            size=plot_window.DEFAULT_WIN_SIZE,
            peak_hold=False,
            use_persistence=False,
            persist_alpha=None,
            **kwargs  #do not end with a comma
    ):
        #ensure avg alpha
        if avg_alpha is None:
            avg_alpha = 2.0 / update_rate
        #ensure analog alpha
        if persist_alpha is None:
            actual_update_rate = float(sample_rate / data_len) / float(
                max(1, int(float((sample_rate / data_len) / update_rate))))
            #print "requested_specest_rate ",update_rate
            #print "actual_update_rate    ",actual_update_rate
            analog_cutoff_freq = 0.5  # Hertz
            #calculate alpha from wanted cutoff freq
            persist_alpha = 1.0 - math.exp(
                -2.0 * math.pi * analog_cutoff_freq / actual_update_rate)

        self._average = average
        self._avg_alpha = avg_alpha
        self._sample_rate = sample_rate

        #init
        gr.hier_block2.__init__(
            self,
            "plot_sink",
            gr.io_signature(1, 1, gr.sizeof_float * data_len),
            gr.io_signature(0, 0, 0),
        )
        #blocks
        msgq = gr.msg_queue(2)
        sink = blocks.message_sink(gr.sizeof_float * data_len, msgq, True)

        #controller
        self.controller = pubsub()
        self.controller.subscribe(AVERAGE_KEY, self.set_average)
        self.controller.publish(AVERAGE_KEY, self.average)
        self.controller.subscribe(AVG_ALPHA_KEY, self.set_avg_alpha)
        self.controller.publish(AVG_ALPHA_KEY, self.avg_alpha)
        self.controller.subscribe(SAMPLE_RATE_KEY, self.set_sample_rate)
        self.controller.publish(SAMPLE_RATE_KEY, self.sample_rate)
        #start input watcher
        common.input_watcher(msgq, self.controller, MSG_KEY)
        #create window
        self.win = plot_window.plot_window(
            parent=parent,
            controller=self.controller,
            size=size,
            title=title,
            data_len=data_len,
            sample_rate_key=SAMPLE_RATE_KEY,
            y_per_div=y_per_div,
            y_divs=y_divs,
            ref_level=ref_level,
            average_key=AVERAGE_KEY,
            avg_alpha_key=AVG_ALPHA_KEY,
            peak_hold=peak_hold,
            msg_key=MSG_KEY,
            use_persistence=use_persistence,
            persist_alpha=persist_alpha,
        )
        common.register_access_methods(self, self.win)
        setattr(self.win, 'set_peak_hold',
                getattr(self, 'set_peak_hold'))  #BACKWARDS
        self.wxgui_connect(self, sink)