Exemplo n.º 1
0
	def __add__(self, other):

		def wrap_none(depth, count):
			if depth == 1: nones = [None]*count
			elif depth == 2: nones = [[None]]*count
			return nones

		def wrap_side(inst, key, depth):
			try: side = inst.__dict__[key]
			except KeyError:
				count = len(inst.widgets)
				if key == 'widg_spans':
					try: count = len(lfu.flatten(inst.labels))
					except: pdb.set_trace()
				side = wrap_none(depth, count)
			return side

		dom_keys = self.__dict__.keys()
		sub_keys = other.__dict__.keys()
		all_keys = lfu.uniqfy(dom_keys + sub_keys)
		new_dict = {}
		for key in all_keys:
			depth = self._depth_lookup_[key]
			if depth == 0:
				try: new_item = self.__dict__[key]
				except KeyError: new_item = other.__dict__[key]
			elif depth == 1 or depth == 2:
				left = wrap_side(self, key, depth)
				right = wrap_side(other, key, depth)
				new_item = left + right
			else: print 'depth cant be >2'; pdb.set_trace()
			new_dict[key] = new_item

		new = interface_template_gui(**new_dict)
		return new
Exemplo n.º 2
0
	def decimate(fine, orders):

		def create_subrange(dex, num_values):
			lower = relev_mags[dex - 1]
			upper = relev_mags[dex]
			new = np.linspace(lower, upper, num_values)
			return [np.round(val, 20) for val in new]

		left  = locate(fine.bounds[0], orders)
		right = locate(fine.bounds[1], orders)
		if left == right:
			rng = range(2)
			relev_mags = [fine.bounds[0], fine.bounds[1]]

		else:
			rng = range(orders.index(left), orders.index(right) + 1)
			#many_orders = len(rng)
			relev_mags = orders[rng[0]:rng[-1] + 1]

		total_values = 20
		num_values = max([10, int(total_values/len(relev_mags))])
		new_axis = []
		for dex in range(1, len(relev_mags)):
			new_axis.extend([np.round(val, 20) for val in 
					create_subrange(dex, num_values)])

		new_axis = lfu.uniqfy(new_axis)
		#print 'NEW AXIS', new_axis
		if len(new_axis) == 0: pdb.set_trace()
		return new_axis
Exemplo n.º 3
0
	def __init__(self, data = [], axes = [], surfs = [], 
					label = 'another surface vector'):
		self.tag = 'surface'
		self.label = label
		self.data_scalars = [data for data in data if not data is self]
		self.axis_labels = axes
		self.axis_values = [scalars(label = dat.label, 
			scalars = lfu.uniqfy(dat.scalars)) for dat in 
			self.data_scalars if dat.label in self.axis_labels]
		self.axis_defaults = [da.scalars[0] for da in self.axis_values]
		self.surf_targets = surfs
		self.reduced = None
Exemplo n.º 4
0
	def make_surface(self, x_ax = '', y_ax = '', surf_target = ''):

		data = self.data_scalars
		daters = [dater.label for dater in data]
		are_ax = [label in self.axis_labels for label in daters]
		axes = [copy(dater) for dater, is_ax in 
					zip(data, are_ax) if is_ax]
		ax_labs = [ax.label for ax in axes]
		if not (x_ax in ax_labs and y_ax in ax_labs and 
				not x_ax == y_ax and surf_target in self.surf_targets):
			print 'chosen axes do not correspond to surface'
			print 'axes:\n', ax_labs, '\nsurfaces:\n', self.surf_targets
			return False

		surf = lfu.grab_mobj_by_name(surf_target, data)
		x_ax_dex = ax_labs.index(x_ax)
		y_ax_dex = ax_labs.index(y_ax)
		ax_slices = copy(self.axis_defaults)
		ax_slices[x_ax_dex] = None
		ax_slices[y_ax_dex] = None

		reduced = (axes, surf)
		in_slices = []
		for ax_dex, ax in enumerate(axes):
			if ax_slices[ax_dex] is None:
				in_slices.append([True for val in ax.scalars])

			else:
				in_slices.append([(val == ax_slices[ax_dex]) 
									for val in ax.scalars])

		in_every_slice = [(False not in row) for row in zip(*in_slices)]
		sub_surf = scalars_from_labels([surf_target])[0]
		sub_surf.scalars = [sur for sur, in_ in 
			zip(surf.scalars, in_every_slice) if in_]
		sub_axes = scalars_from_labels(self.axis_labels)
		for sub_ax, ax in zip(sub_axes, axes):
			sub_ax.scalars = lfu.uniqfy([val for val, in_ 
				in zip(ax.scalars, in_every_slice) if in_])

		self.reduced = (sub_axes, sub_surf)
		return True
Exemplo n.º 5
0
	def apply_reduction(self, unred):
		read = self.parent.parent.read['layout'].read
		flat = lfu.flatten(read['table'])
		well_cnt = len(flat)
		reduced = unred[:len(unred)-well_cnt]	#list of replicate averaged scalers
		con_offset = len(reduced)
		uniq = lfu.uniqfy(flat)
		layout = OrderedDict()
		for dex, key in enumerate(flat):
			if key in layout.keys(): layout[key].append(dex + con_offset)
			else: layout[key] = [dex + con_offset]
		new = lgeo.scalars_from_labels(layout.keys())
		for ndex, key in enumerate(layout.keys()):
			rel_dexes = layout[key]
			rel_dater = [unred[d] for d in rel_dexes]
			zi = zip(*[r.scalars for r in rel_dater])
			new[ndex].scalars = np.array([np.mean(z) for z in zi])
		reduced.extend(new)
		red = lfu.data_container(data = reduced)
		return red
Exemplo n.º 6
0
	def show_plot_color(self, *args, **kwargs):
		self.resolve_x_domain()
		self.resolve_y_domain()
		self.resolve_surf_target()
		ax = self.add_plot()
		try:
			surf_vector_dex = [hasattr(dater, 'reduced') 
				for dater in self._data_.data].index(True)

		except ValueError:
			print 'no surface_vector found!'; return

		surf_vect = self._data_.data[surf_vector_dex]
		made_surf = surf_vect.make_surface(
			x_ax = self.x_ax_title, y_ax = self.y_ax_title, 
							surf_target = self.surf_target)
		if not made_surf:
			print 'surface was not resolved'
			return

		self.title = self.surf_target
		ax.set_title(self.title)
		x_ax = lfu.grab_mobj_by_name(self.x_ax_title, 
								surf_vect.axis_values)
		y_ax = lfu.grab_mobj_by_name(self.y_ax_title, 
								surf_vect.axis_values)
		x = np.array(x_ax.scalars, dtype = float)
		y = np.array(y_ax.scalars, dtype = float)
		try:
			surf = np.array(surf_vect.reduced[1].scalars, 
					dtype = float).reshape(len(x), len(y))

		except ValueError:
			print 'not organized properly to colorplot...'
			return

		surf = surf.transpose()
		x_min, x_max = x.min(), x.max()
		y_min, y_max = y.min(), y.max()
		z_min, z_max = surf.min(), surf.max()
		#plt.xscale('log')
		#plt.yscale('log')

		delx = [x[i+1] - x[i] for i in range(len(x) - 1)]
		dely = [y[i+1] - y[i] for i in range(len(y) - 1)]
		xdels = lfu.uniqfy(delx)
		ydels = lfu.uniqfy(dely)
		if len(xdels) == 1 and len(ydels) == 1:
			pc_mesh = ax.imshow(surf, interpolation = 'bicubic', 
				cmap = plt.get_cmap('jet'), vmin = z_min, vmax = z_max, 
				#cmap = 'autumn', vmin = z_min, vmax = z_max, 
				origin = 'lower', extent = (x_min, x_max, y_min, y_max))
			#Acceptable interpolations are 'none', 'nearest', 'bilinear', 
			#'bicubic', 'spline16', 'spline36', 'hanning', 'hamming', 
			#'hermite', 'kaiser', 'quadric', 'catrom', 'gaussian', 
			#'bessel', 'mitchell', 'sinc', 'lanczos'

		else:
			print 'axes values are not evenly spaced; plot will be boxy'
			pc_mesh = ax.pcolormesh(x, y, surf, 
				cmap = plt.get_cmap('jet'), 
			#pc_mesh = ax.pcolormesh(x, y, surf, cmap = 'autumn', 
				shading = 'gouraud', vmin = z_min, vmax = z_max)

		ax.axis([x.min(), x.max(), y.min(), y.max()])
		ax.grid(True)
		self.figure.colorbar(pc_mesh)
		self.canvas.draw()