old_boxSlicer.py @ 0bd125d

ESS_GUIESS_GUI_DocsESS_GUI_batch_fittingESS_GUI_bumps_abstractionESS_GUI_iss1116ESS_GUI_iss879ESS_GUI_iss959ESS_GUI_openclESS_GUI_orderingESS_GUI_sync_sascalccostrafo411magnetic_scattrelease-4.1.1release-4.1.2release-4.2.2release_4.0.1ticket-1009ticket-1094-headlessticket-1242-2d-resolutionticket-1243ticket-1249ticket885unittest-saveload

Last change on this file since 0bd125d was 0d9dae8, checked in by Gervaise Alina <gervyh@…>, 16 years ago

add a new module containing common classes that I used often:
sans.guiframe.utils

remove event slicer and add it in sans.guicoom.events,
modified slicer for those events

Property mode set to 100644

File size: 31.7 KB

Rev	Line
[0d9dae8]	1	#TODO: the line slicer should listen to all 2DREFRESH events, get the data and slice it
	2	# before pushing a new 1D data update.
	3
	4	#
	5	#TODO: NEED MAJOR REFACTOR
	6	#
	7
	8
	9	# Debug printout
	10	import math
	11	import wx
	12	from copy import deepcopy
	13
	14	from BaseInteractor import _BaseInteractor
	15	from sans.guicomm.events import NewPlotEvent, StatusEvent,SlicerParameterEvent,EVT_SLICER_PARS
	16
	17
	18	def find_intersection(a1= 2, a2= -0.5,b1= 1,b2= 1 ):
	19	""" @ return x, y coordinates of an intersection between 2 lines
	20	@param a1: the slope of the first line
	21	@param a2 : the slope of the 2nd line
	22	@param b1 : line intercept of the 1 st line
	23	@param b2 : line intercept of the 2 nd ligne
	24	@note 1st line equation is y= a1x +b1 ; 2nd line equation is y= a2x +b2
	25	"""
	26	x= ( b2- b1) /(a1- a2)
	27	y= ( -a2b1 + a1b2 )/(a1 -a2)
	28	return x, y
	29	class BoxInteractor(_BaseInteractor):
	30	"""
	31	Select an annulus through a 2D plot
	32	"""
	33	def __init__(self,base,axes,color='black', zorder=3,
	34	x_min=0.0025, x_max=0.0025, y_min=0.0025, y_max=0.0025):
	35
	36	_BaseInteractor.__init__(self, base, axes, color=color)
	37	self.markers = []
	38	self.axes = axes
	39	self.qmax = self.base.qmax
	40	self.connect = self.base.connect
	41	self.xmin= -1* x_min
	42	self.ymin= -1* y_min
	43
	44	self.xmax= x_max
	45	self.ymax= y_max
	46
	47	self.theta2= math.pi/3
	48	## Number of points on the plot
	49	self.nbins = 20
	50	self.count=0
	51	self.error=0
	52	self.main_line = LineInteractor(self, self.base.subplot,color='orange',
	53	zorder=zorder, ymin=y_min ,ymax=y_max,
	54	theta= self.theta2)
	55	self.main_line.qmax = self.base.qmax
	56	self.left_line = VerticalLine(self, self.base.subplot,color='blue',
	57	zorder=zorder,
	58	mline= self.main_line,
	59	ymin= self.ymin ,
	60	ymax= self.ymax ,
	61	xmin=self.xmin,
	62	xmax=self.xmin,
	63	theta2= self.theta2)
	64	self.left_line.qmax = self.base.qmax
	65
	66	self.right_line= VerticalLine(self, self.base.subplot,color='black',
	67	zorder=zorder,
	68	mline= self.main_line,
	69	ymin= self.ymin ,
	70	ymax= self.ymax,
	71	xmin= self.xmax,
	72	xmax= self.xmax,
	73	theta2= self.theta2)
	74	self.right_line.qmax = self.base.qmax
	75
	76	self.top_line= HorizontalLine(self, self.base.subplot,color='green',
	77	zorder=zorder,
	78	mline= self.main_line,
	79	xmin=self.right_line.x1,
	80	xmax=self.left_line.x1,
	81	ymin=self.right_line.y1,
	82	ymax=self.left_line.y1)
	83	self.top_line.qmax= self.base.qmax
	84
	85	self.bottom_line= HorizontalLine(self, self.base.subplot,color='gray',
	86	zorder=zorder,
	87	mline= self.main_line,
	88	xmin=self.right_line.x2,
	89	xmax=self.left_line.x2,
	90	ymin=self.right_line.y2,
	91	ymax=self.left_line.y2)
	92	self.bottom_line.qmax= self.base.qmax
	93
	94	self.update()
	95	#self._post_data()
	96
	97	# Bind to slice parameter events
	98	self.base.parent.Bind(EVT_SLICER_PARS, self._onEVT_SLICER_PARS)
	99
	100
	101	def _onEVT_SLICER_PARS(self, event):
	102	#printEVT("AnnulusSlicer._onEVT_SLICER_PARS")
	103	event.Skip()
	104	if event.type == self.__class__.__name__:
	105	#self.set_params(event.params)
	106	self.base.update()
	107
	108	def update_and_post(self):
	109	self.update()
	110	self._post_data()
	111
	112	def save_data(self, path, image, x, y):
	113	output = open(path, 'w')
	114
	115	data_x, data_y = self.get_data(image, x, y)
	116
	117	output.write("<phi> <average>\n")
	118	for i in range(len(data_x)):
	119	output.write("%g %g\n" % (data_x[i], data_y[i]))
	120	output.close()
	121
	122	def set_layer(self, n):
	123	self.layernum = n
	124	self.update()
	125
	126	def clear(self):
	127	self.clear_markers()
	128
	129
	130	self.main_line.clear()
	131	#self.base.connect.disconnect()
	132	self.base.parent.Unbind(EVT_SLICER_PARS)
	133
	134	def update(self):
	135	"""
	136	Respond to changes in the model by recalculating the profiles and
	137	resetting the widgets.
	138	"""
	139
	140	if self.main_line.has_move:
	141
	142	self.main_line.update()
	143	self.left_line.update(
	144	xmin= self.xmin,
	145	xmax= self.xmin,
	146	ymin= self.ymin,
	147	ymax=self.ymax
	148	)
	149	self.right_line.update(
	150	xmin= self.xmax,
	151	xmax= self.xmax,
	152	ymin= self.ymin,
	153	ymax=self.ymax)
	154	self.top_line.update(xmin= self.right_line.x1,
	155	xmax= self.left_line.x1,
	156	ymin= self.right_line.y1,
	157	ymax= self.left_line.y1)
	158	self.bottom_line.update(xmin= self.right_line.x2,
	159	xmax= self.left_line.x2,
	160	ymin= self.right_line.y2,
	161	ymax= self.left_line.y2)
	162	if self.top_line.has_move:
	163	print "top has moved",self.left_line.slope, self.top_line.slope
	164	x2, y2= find_intersection(a1= self.left_line.slope,
	165	a2= self.top_line.slope,
	166	b1= self.left_line.b,
	167	b2= self.top_line.b )
	168	print "x, y max: ",x2,y2
	169	x1, y1= find_intersection(a1= self.right_line.slope,
	170	a2= self.top_line.slope,
	171	b1= self.right_line.b,
	172	b2= self.top_line.b )
	173	print "x, y min: ",x1 ,y1
	174	self.top_line.update(xmin= x2,
	175	ymin= y2,
	176	xmax= x1,
	177	ymax= y1)
	178
	179	self.bottom_line.update(xmin= -x2,
	180	ymin= -y2,
	181	xmax= -x1,
	182	ymax= -y1)
	183	self.left_line.update(xmin= -x1,
	184	ymin= -y1,
	185	xmax= x2,
	186	ymax= y2,
	187	translation= True)
	188	self.right_line.update(
	189	xmin= -x2,
	190	ymin= -y2,
	191	xmax= x1,
	192	ymax= y1,
	193	translation= True)
	194	print "top has moved",self.left_line.slope, self.top_line.slope
	195	x2, y2= find_intersection(a1= self.main_line.slope,
	196	a2= self.top_line.slope,
	197	b1= self.main_line.b,
	198	b2= self.top_line.b )
	199	print "main x, y max: ",x2,y2
	200	x1, y1= find_intersection(a1= self.main_line.slope,
	201	a2= self.bottom_line.slope,
	202	b1= self.main_line.b,
	203	b2= self.bottom_line.b )
	204	print "main x, y min: ",x1,y1
	205	self.main_line.update(x1= -x2,
	206	y1= -y2,
	207	x2= x2,
	208	y2= y2,
	209	translation= True)
	210	if self.bottom_line.has_move:
	211
	212	print "bottom has moved",self.left_line.slope, self.bottom_line.slope
	213	x2, y2= find_intersection(a1= self.left_line.slope,
	214	a2= self.bottom_line.slope,
	215	b1= self.left_line.b,
	216	b2= self.bottom_line.b )
	217	print "x, y max: ",x2,y2
	218	x1, y1= find_intersection(a1= self.right_line.slope,
	219	a2= self.bottom_line.slope,
	220	b1= self.right_line.b,
	221	b2= self.bottom_line.b )
	222	print "x, y min: ",x1 ,y1
	223	self.bottom_line.update(xmin= x2,
	224	ymin= y2,
	225	xmax= x1,
	226	ymax= y1)
	227
	228	self.top_line.update(xmin= -x2,
	229	ymin= -y2,
	230	xmax= -x1,
	231	ymax= -y1)
	232	self.left_line.update(xmin= -x1,
	233	ymin= -y1,
	234	xmax= x2,
	235	ymax= y2,
	236	translation= True)
	237	self.right_line.update(
	238	xmin= -x2,
	239	ymin= -y2,
	240	xmax= x1,
	241	ymax= y1,
	242	translation= True)
	243	print "bottom has moved",self.left_line.slope, self.bottom_line.slope
	244	x2, y2= find_intersection(a1= self.main_line.slope,
	245	a2= self.bottom_line.slope,
	246	b1= self.main_line.b,
	247	b2= self.bottom_line.b )
	248	print "main x, y max: ",x2,y2
	249	x1, y1= find_intersection(a1= self.main_line.slope,
	250	a2= self.top_line.slope,
	251	b1= self.main_line.b,
	252	b2= self.top_line.b )
	253	print "main x, y min: ",x1,y1
	254	self.main_line.update(x1= -x2,
	255	y1= -y2,
	256	x2= x2,
	257	y2= y2,
	258	translation= True)
	259	if self.left_line.has_move:
	260	print "left_line has moved",self.left_line.slope, self.top_line.slope
	261	x2, y2= find_intersection(a1= self.left_line.slope,
	262	a2= self.top_line.slope,
	263	b1= self.left_line.b,
	264	b2= self.top_line.b )
	265	print "main x, y max: ",x2,y2
	266	x1, y1= find_intersection(a1= self.left_line.slope,
	267	a2= self.bottom_line.slope,
	268	b1= self.left_line.b,
	269	b2= self.bottom_line.b )
	270	self.left_line.update(xmin = x1,
	271	xmax = x2,
	272	ymin= y1,
	273	ymax= y2,
	274	translation=True)
	275
	276	self.right_line.update(xmin = -x1,
	277	xmax = -x2,
	278	ymin= -y1,
	279	ymax= -y2,
	280	translation=True)
	281
	282	self.bottom_line.update(xmin= x1,
	283	ymin= y1,
	284	xmax= -x2,
	285	ymax= -y2)
	286
	287	self.top_line.update(xmin= x2,
	288	ymin= y2,
	289	xmax= -x1,
	290	ymax= -y1)
	291	print "initial xmin", self.xmin
	292	self.xmin= math.sqrt(math.pow((self.main_line.x2 - self.left_line.x2),2)\
	293	+math.pow((self.main_line.y2 - self.left_line.y2),2))
	294
	295	print "new xmin ", self.xmin, self.main_line.x2 , self.left_line.x2
	296	if self.right_line.has_move:
	297	print "right_line has moved",self.right_line.slope, self.top_line.slope
	298	x2, y2= find_intersection(a1= self.right_line.slope,
	299	a2= self.top_line.slope,
	300	b1= self.right_line.b,
	301	b2= self.top_line.b )
	302	print "main x, y max: ",x2,y2
	303	x1, y1= find_intersection(a1= self.right_line.slope,
	304	a2= self.bottom_line.slope,
	305	b1= self.right_line.b,
	306	b2= self.bottom_line.b )
	307	self.right_line.update(xmin = x1,
	308	xmax = x2,
	309	ymin= y1,
	310	ymax= y2,
	311	translation=True)
	312
	313	self.left_line.update(xmin = -x1,
	314	xmax = -x2,
	315	ymin= -y1,
	316	ymax= -y2,
	317	translation=True)
	318
	319	self.bottom_line.update(xmin= x1,
	320	ymin= y1,
	321	xmax= -x2,
	322	ymax= -y2)
	323
	324	self.top_line.update(xmin= x2,
	325	ymin= y2,
	326	xmax= -x1,
	327	ymax= -y1)
	328
	329	print "initial xmax", self.xmax
	330	self.xmax= math.sqrt(math.pow((self.main_line.x2 - self.right_line.x2),2)\
	331	+math.pow((self.main_line.y2 - self.right_line.y2),2))
	332	print "new xmax",self.xmax
	333	def save(self, ev):
	334	"""
	335	Remember the roughness for this layer and the next so that we
	336	can restore on Esc.
	337	"""
	338	self.base.freeze_axes()
	339	self.inner_circle.save(ev)
	340	self.outer_circle.save(ev)
	341
	342	def _post_data(self):
	343	# Compute data
	344	#data = self.base.data2D
	345	#from DataLoader.manipulations import Boxavg
	346	#radius = math.sqrt(math.pow(self.qmax,2)+math.pow(self.qmax,2))
	347	#x_min= self.left_line.xmin
	348	#x_max= self.right_line.xmax
	349	#y_min= self.bottom_line.y
	350	#y_max= self.top_line.y
	351	#box = Boxavg (x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max)
	352
	353	#self.count, self.error= box(self.base.data2D)
	354
	355	print "post data"
	356
	357
	358	def moveend(self, ev):
	359	self.base.thaw_axes()
	360
	361	# Post paramters
	362	event = SlicerParameterEvent()
	363	event.type = self.__class__.__name__
	364	#event.params = self.get_params()
	365	wx.PostEvent(self.base.parent, event)
	366
	367	self._post_data()
	368
	369	def restore(self):
	370	"""
	371	Restore the roughness for this layer.
	372	"""
	373	self.inner_circle.restore()
	374	self.outer_circle.restore()
	375
	376	def move(self, x, y, ev):
	377	"""
	378	Process move to a new position, making sure that the move is allowed.
	379	"""
	380	pass
	381
	382	def set_cursor(self, x, y):
	383	pass
	384
	385	def get_params(self):
	386	params = {}
	387	params["x1"]= self.xmax
	388	params["y1"]= self.ymin
	389	params["x2"]= self.xmin
	390	params["y2"]= self.ymax
	391	params["phi"] = self.main_line.theta
	392	return params
	393
	394	def set_params(self, params):
	395	self.xmax = params["x1"]
	396	self.ymin = params["y1"]
	397	self.xmin = params["x2"]
	398	self.ymax = params["y2"]
	399	theta = params["theta"]
	400	print "theta setparams",theta
	401	self.main_line.update(radius1= math.fabs(self.ymax), radius2= math.fabs(self.ymin), theta= theta)
	402	self.left_line.update(xmin= -1*self.xmin)
	403	self.right_line.update(xmin= self.xmax)
	404
	405	self.top_line.update(xmin= self.right_line.x1,
	406	xmax= self.left_line.x1,
	407	ymin= self.right_line.y1,
	408	ymax= self.left_line.y1)
	409	self.bottom_line.update(xmin= self.right_line.x2,
	410	xmax= self.left_line.x2,
	411	ymin= self.right_line.y2,
	412	ymax= self.left_line.y2)
	413	self._post_data()
	414	def freeze_axes(self):
	415	self.base.freeze_axes()
	416
	417	def thaw_axes(self):
	418	self.base.thaw_axes()
	419
	420	def draw(self):
	421	self.base.draw()
	422
	423	class HorizontalLine(_BaseInteractor):
	424	"""
	425	Select an annulus through a 2D plot
	426	"""
	427	def __init__(self,base,axes,color='black', zorder=5,mline=None,ymin=None, ymax=None, y=0.5,
	428	xmin=0.0,xmax=0.5,
	429	theta2= math.pi/3 ):
	430
	431	_BaseInteractor.__init__(self, base, axes, color=color)
	432	self.markers = []
	433	self.axes = axes
	434	self.x1= xmax
	435	self.save_x1= xmax
	436
	437	self.x2= xmin
	438	self.save_x2= xmin
	439
	440	self.y1= ymax
	441	self.save_y1= ymax
	442
	443	self.y2= ymin
	444	self.save_y2= ymin
	445	self.mline= mline
	446	self.line = self.axes.plot([self.x1,self.x2],
	447	[self.y1,self.y2],
	448	linestyle='-', marker='',
	449	color=self.color,
	450	visible=True)[0]
	451
	452	self.slope= -1/math.tan(self.mline.theta)
	453	self.b= self.y1- self.slope* self.x1
	454	self.save_b= self.b
	455	print "slope from point",(self.y2- self.y1)/(self.x2- self.x1)
	456	print "my slope horizontal", self.slope
	457	print "b from point ", self.y2- self.slope*self.x2, self.b
	458	self.npts = 20
	459	self.has_move=False
	460	self.connect_markers([self.line])
	461	self.update()
	462
	463	def set_layer(self, n):
	464	self.layernum = n
	465	self.update()
	466
	467	def clear(self):
	468	self.clear_markers()
	469	try:
	470
	471	self.line.remove()
	472	except:
	473	# Old version of matplotlib
	474	for item in range(len(self.axes.lines)):
	475	del self.axes.lines[0]
	476
	477	def get_radius(self):
	478
	479	return 0
	480
	481	def update(self,xmin=None, xmax=None,ymin=None,ymax=None, mline=None,translation=False):
	482	"""
	483	Draw the new roughness on the graph.
	484	"""
	485	self.slope= -1/math.tan(self.mline.theta)
	486	if xmin !=None:
	487	self.x2 = xmin
	488	if xmax !=None:
	489	self.x1 = xmax
	490	if ymin !=None:
	491	self.y2 = ymin
	492	if ymax != None:
	493	self.y1 = ymax
	494	self.b= self.y1- self.slope * self.x1
	495	self.line.set(xdata=[self.x1,self.x2],
	496	ydata=[self.y1,self.y2])
	497
	498
	499
	500	def save(self, ev):
	501	"""
	502	Remember the roughness for this layer and the next so that we
	503	can restore on Esc.
	504	"""
	505	self.save_x1= self.x1
	506	self.save_x2= self.x2
	507
	508	self.save_y1= self.y1
	509	self.save_y2= self.y2
	510	self.save_b= self.b
	511
	512	self.base.freeze_axes()
	513
	514	def moveend(self, ev):
	515
	516	self.has_move=False
	517	self.base.moveend(ev)
	518
	519	def restore(self):
	520	"""
	521	Restore the roughness for this layer.
	522	"""
	523	self.x1 = self.save_x1
	524	self.x2 = self.save_x2
	525	self.y1 = self.save_y1
	526	self.y2 = self.save_y2
	527	self.b = self.save_b
	528
	529	def move(self, x, y, ev):
	530	"""
	531	Process move to a new position, making sure that the move is allowed.
	532	"""
	533	print "horizontal move x y ", x, y
	534	self.b = y - (-1/self.mline.slope) *x
	535	self.has_move=True
	536	self.base.base.update()
	537
	538	def set_cursor(self, x, y):
	539	self.move(x, y, None)
	540	self.update()
	541
	542
	543	def get_params(self):
	544	params = {}
	545	params["radius"] = self.x1
	546	#params["theta"] = self.xmax
	547	return params
	548
	549	def set_params(self, params):
	550
	551	x = params["radius"]
	552	self.set_cursor(x, self._inner_mouse_y)
	553
	554
	555
	556
	557	class VerticalLine(_BaseInteractor):
	558	"""
	559	Select an annulus through a 2D plot
	560	"""
	561	def __init__(self,base,axes,color='black', zorder=5, mline=None, ymin=0.0,
	562	ymax=0.5,xmin=-0.5,xmax=0.5,
	563	theta2= math.pi/3 ):
	564
	565	_BaseInteractor.__init__(self, base, axes, color=color)
	566	self.markers = []
	567	self.axes = axes
	568
	569	self.theta2 = mline.theta
	570	self.mline =mline
	571	self.xmin= xmin
	572	self.x1= mline.x1 + xmin*math.cos(math.pi/2 - self.theta2)
	573	self.x2= mline.x2 + xmin*math.cos(math.pi/2 - self.theta2)
	574	self.y1= mline.y1 - xmin*math.sin(math.pi/2 - self.theta2)
	575	self.y2= mline.y2 - xmin*math.sin(math.pi/2 - self.theta2)
	576	self.line = self.axes.plot([self.x1,self.x2],[self.y1,self.y2],
	577	linestyle='-', marker='',
	578	color=self.color,
	579	visible=True)[0]
	580
	581
	582	self.slope= math.tan(self.mline.theta)
	583	print "vertical line intercetp ",self.y2- self.slopeself.x2, self.y1- self.slope self.x1
	584
	585	self.b = self.y1- self.slope* self.x1
	586	self.has_move=False
	587	self.connect_markers([self.line])
	588	self.update()
	589
	590	def set_layer(self, n):
	591	self.layernum = n
	592	self.update()
	593
	594	def clear(self):
	595	self.clear_markers()
	596	try:
	597
	598	self.line.remove()
	599	except:
	600	# Old version of matplotlib
	601	for item in range(len(self.axes.lines)):
	602	del self.axes.lines[0]
	603
	604
	605	def get_radius(self):
	606	return 0
	607
	608	def update(self,xmin=None,xmax=None,ymin=None, ymax=None, opline=None,translation=False):
	609	"""
	610	Draw the new roughness on the graph.
	611	"""
	612
	613	self.slope= math.tan(self.mline.theta)
	614	if translation:
	615	if xmin!=None:
	616	self.x2=xmin
	617	self.xmin= xmin
	618	if xmax!=None:
	619	self.x1=xmax
	620	if ymin!=None:
	621	self.y2=ymin
	622	if ymax!=None:
	623	self.y1=ymax
	624	self.line.set(xdata=[self.x1,self.x2],
	625	ydata=[self.y1,self.y2])
	626	self.b= self.y1- self.slope * self.x1
	627	return
	628
	629	self.x1= self.mline.x1 + self.xmin*math.cos(math.pi/2 - self.mline.theta)
	630	self.x2= self.mline.x2 + self.xmin*math.cos(math.pi/2 - self.mline.theta)
	631	self.y1= self.mline.y1 - self.xmin*math.sin(math.pi/2 - self.mline.theta)
	632	self.y2= self.mline.y2 - self.xmin*math.sin(math.pi/2 - self.mline.theta)
	633	self.line.set(xdata=[self.x1,self.x2],
	634	ydata=[self.y1,self.y2])
	635	print "update slope ", (self.y2-self.y1)/(self.x2- self.x1)
	636	#print "main slope", math.tan(self.mline.theta)
	637
	638	def save(self, ev):
	639	"""
	640	Remember the roughness for this layer and the next so that we
	641	can restore on Esc.
	642	"""
	643	self.save_x1= self.x1
	644	self.save_x2= self.x2
	645	self.save_y1= self.y1
	646	self.save_y2= self.y2
	647
	648	self.base.freeze_axes()
	649
	650	def moveend(self, ev):
	651
	652	self.has_move=False
	653	self.base.moveend(ev)
	654
	655	def restore(self):
	656	"""
	657	Restore the roughness for this layer.
	658	"""
	659	self.x1 = self.save_x1
	660	self.x2 = self.save_x2
	661	self.y1 = self.save_y1
	662	self.y2= self.save_y2
	663
	664
	665	def move(self, x, y, ev):
	666	"""
	667	Process move to a new position, making sure that the move is allowed.
	668	"""
	669	self.has_move=True
	670
	671	# compute the b intercept of the vertical line
	672	self.b=y - self.mline.slope * x
	673
	674
	675	self.base.base.update()
	676
	677
	678	def set_cursor(self, x, y):
	679	self.move(x, y, None)
	680	self.update()
	681
	682
	683	def get_params(self):
	684	params = {}
	685	params["x"] = self.xmin
	686	params["ymin"] = self.ymin
	687	params["ymax"] = self.ymax
	688	return params
	689
	690	def set_params(self, params):
	691	"""
	692	Draw a vertical line given some value of params
	693	@param params: a dictionary containing value for x, ymin , ymax to draw
	694	a vertical line
	695	"""
	696	x = params["x"]
	697	ymin = params["ymin"]
	698	ymax = params["ymax"]
	699	#self.set_cursor(x, self._inner_mouse_y)
	700	self.update(self,x =x,ymin =ymin, ymax =ymax)
	701
	702
	703
	704	class LineInteractor(_BaseInteractor):
	705	"""
	706	Select an annulus through a 2D plot
	707	"""
	708	def __init__(self,base,axes,color='black', zorder=5, ymin=1.0,ymax=1.0,theta=math.pi/4):
	709
	710	_BaseInteractor.__init__(self, base, axes, color=color)
	711	self.markers = []
	712	self.axes = axes
	713
	714	self.save_theta = theta
	715	self.theta= theta
	716
	717	self.radius1 = math.fabs(ymax)
	718	self.radius2 = math.fabs(ymin)
	719	self.scale = 10.0
	720
	721	# Inner circle
	722	self.x1= self.radius1*math.cos(self.theta)
	723	self.y1= self.radius1*math.sin(self.theta)
	724	self.x2= -1self.radius2math.cos(self.theta)
	725	self.y2= -1self.radius2math.sin(self.theta)
	726
	727	self.line = self.axes.plot([self.x1,self.x2],[self.y1,self.y2],
	728	linestyle='-', marker='',
	729	color=self.color,
	730	visible=True)[0]
	731	self.slope= math.tan(self.theta)
	732	self.b= math.fabs(self.y1- self.slope * self.x1)
	733	print "intercept main",math.fabs(self.y2- self.slope * self.x2),math.fabs(self.y1- self.slope * self.x1)
	734	self.npts = 20
	735	self.has_move=False
	736	self.connect_markers([self.line])
	737	self.update()
	738
	739	def set_layer(self, n):
	740
	741	self.layernum = n
	742	self.update()
	743
	744	def clear(self):
	745	"""
	746	Remove the line of the plot
	747	"""
	748	self.clear_markers()
	749	try:
	750	self.line.remove()
	751	except:
	752	# Old version of matplotlib
	753	for item in range(len(self.axes.lines)):
	754	del self.axes.lines[0]
	755
	756
	757
	758	def get_delta_angle(self):
	759	"""
	760	return difference between initial angle and the final angle during
	761	rotation
	762	"""
	763	return self.theta - self.save_theta
	764
	765	def update(self,x1=None,
	766	y1=None,
	767	x2=None,
	768	y2=None,
	769	translation=False,
	770	xmin=None,vline=None, theta=None,radius1=None,radius2=None):
	771	"""
	772	Draw a line given and angle relative to the x-axis and a radius
	773	@param theta: the angle realtive to the x-axis
	774	@param radius: the distance between the center and one end of the line
	775	"""
	776	if translation:
	777	if x1 !=None:
	778	self.x1= x1
	779	if x2 !=None:
	780	self.x2= x2
	781	if y1 !=None:
	782	self.y1= y1
	783	if y2 !=None:
	784	self.y2= y2
	785
	786	self.line.set(xdata=[self.x1,self.x2], ydata=[self.y1,self.y2])
	787	self.radius1= math.fabs(self.x1/math.cos(self.theta))
	788	self.radius2= math.fabs(self.x2/math.cos(self.theta))
	789	print "radius 1, radius2", self.radius1, self.radius2
	790	return
	791
	792	if theta !=None:
	793	self.theta= theta
	794	if radius1 !=None:
	795	self.radius1 =radius1
	796	if radius2 !=None:
	797	self.radius2 =radius2
	798	#print "update main line", math.degrees(self.theta),self.radius1, self.radius2
	799	#print "smain radius 1 2", self.radius1, self.radius2
	800	self.x1= self.radius1*math.cos(self.theta)
	801	self.y1= self.radius1*math.sin(self.theta)
	802	self.x2= -1self.radius2math.cos(self.theta)
	803	self.y2= -1self.radius2math.sin(self.theta)
	804	print "init mainline sintercept ", self.y1 - math.tan(self.theta)*self.x1,\
	805	self.y2 - math.tan(self.theta)*self.x2
	806	#print "main line slope ", (self.y2- self.y1)/(self.x2- self.x1)
	807	#print "theta", math.tan(self.theta)
	808	self.line.set(xdata=[self.x1,self.x2], ydata=[self.y1,self.y2])
	809
	810
	811
	812	def save(self, ev):
	813	"""
	814	Remember the roughness for this layer and the next so that we
	815	can restore on Esc.
	816	"""
	817	self.save_theta= self.theta
	818	self.base.freeze_axes()
	819
	820	def moveend(self, ev):
	821
	822	self.has_move=False
	823	self.base.moveend(ev)
	824
	825	def restore(self):
	826	"""
	827	Restore the roughness for this layer.
	828	"""
	829	self.theta = self.save_theta
	830
	831	def move(self, x, y, ev):
	832	"""
	833	Process move to a new position, making sure that the move is allowed.
	834	"""
	835	self.theta= math.atan2(y,x)
	836	self.slope= math.tan(self.theta)
	837	self.b= y - self.slope *x
	838
	839	print "main move slope , theta, b", self.slope, self.theta, self.b
	840
	841	#print "main_line previous theta --- next theta ",math.degrees(self.save_theta),math.degrees(self.theta)
	842	self.has_move=True
	843	self.base.base.update()
	844
	845
	846	def set_cursor(self, x, y):
	847
	848	self.move(x, y, None)
	849	self.update()
	850
	851
	852	def get_params(self):
	853	"""
	854	return params a dictionary containing values of paramters necessary to draw
	855	this line
	856	"""
	857	params = {}
	858	params["ymax"] = self.radius1
	859	params["ymin"] = self.radius2
	860	params["theta"] = self.theta
	861	return params
	862
	863	def set_params(self, params):
	864	"""
	865	Draw the line given value contains by params
	866	@param params: dictionary containing name of parameters and their values
	867	"""
	868	radius1 = params["ymax"]
	869	radius2 = params["ymin"]
	870	theta = params["theta"]
	871	self.update(x, theta= theta , radius1 = radius1 ,radius2 = radius2)
	872
	873
	874
	875
	876

Note: See TracBrowser for help on using the repository browser.

SasView

source: sasview/guiframe/local_perspectives/plotting/old_boxSlicer.py @ 0bd125d

Download in other formats: