schain Commit - r108:181a583e8f11 · Jicamarca Repository

Esta version actualiza las librerias de ploteo para graficos RTI, Spectra y Scope, tambien se agregan metodos para procesamiento de Spectra y Voltage. En el caso de Voltage, en la Integracion Coherente se realiza indicando el tiempo de integracion en minutos.

Daniel Valdez -

r108:181a583e8f11

parent child

Context file:

r108:181a583e8f11

Collapse all files

schainpy/Graphics/BaseGraph.py +610 -575

This diff has been collapsed as it changes many lines, (1185 lines changed) Show them Hide them
	@@ -1,903 +1,938
	1	"""	1	"""
	2	Created on Feb 7, 2012	2	Created on Feb 7, 2012
	3		3
	4	@autor $Author$	4	@autor $Author$
	5	@version $Id$	5	@version $Id$
	6		6
	7	"""	7	"""
	8		8
	9	import numpy	9	import numpy
			10	import sys
			11	import time
			12	import datetime
			13	import time
	10	import plplot	14	import plplot
	11		15
			16
	12	def cmap1_init(colormap="gray"):	17	def cmap1_init(colormap="gray"):
	13		18
	14	if colormap == None:	19	if colormap == None:
	15	return	20	return
	16		21
	17	ncolor = None	22	ncolor = None
	18	rgb_lvl = None	23	rgb_lvl = None
	19		24
	20	# Routine for defining a specific color map 1 in HLS space.	25	# Routine for defining a specific color map 1 in HLS space.
	21	# if gray is true, use basic grayscale variation from half-dark to light.	26	# if gray is true, use basic grayscale variation from half-dark to light.
	22	# otherwise use false color variation from blue (240 deg) to red (360 deg).	27	# otherwise use false color variation from blue (240 deg) to red (360 deg).
	23		28
	24	# Independent variable of control points.	29	# Independent variable of control points.
	25	i = numpy.array((0., 1.))	30	i = numpy.array((0., 1.))
	26	if colormap=="gray":	31	if colormap=="gray":
	27	ncolor = 256	32	ncolor = 256
	28	# Hue for control points. Doesn't matter since saturation is zero.	33	# Hue for control points. Doesn't matter since saturation is zero.
	29	h = numpy.array((0., 0.))	34	h = numpy.array((0., 0.))
	30	# Lightness ranging from half-dark (for interest) to light.	35	# Lightness ranging from half-dark (for interest) to light.
	31	l = numpy.array((0.5, 1.))	36	l = numpy.array((0.5, 1.))
	32	# Gray scale has zero saturation	37	# Gray scale has zero saturation
	33	s = numpy.array((0., 0.))	38	s = numpy.array((0., 0.))
	34		39
	35	# number of cmap1 colours is 256 in this case.	40	# number of cmap1 colours is 256 in this case.
	36	plplot.plscmap1n(ncolor)	41	plplot.plscmap1n(ncolor)
	37	# Interpolate between control points to set up cmap1.	42	# Interpolate between control points to set up cmap1.
	38	plplot.plscmap1l(0, i, h, l, s)	43	plplot.plscmap1l(0, i, h, l, s)
	39		44
	40	return None	45	return None
	41		46
			47	if colormap == 'jet':
			48	ncolor = 256
			49	pos = numpy.zeros((ncolor))
			50	r = numpy.zeros((ncolor))
			51	g = numpy.zeros((ncolor))
			52	b = numpy.zeros((ncolor))
			53
			54	for i in range(ncolor):
			55	if(i <= 35.0/100*(ncolor-1)): rf = 0.0
			56	elif (i <= 66.0/100(ncolor-1)): rf = (100.0/31)i/(ncolor-1) - 35.0/31
			57	elif (i <= 89.0/100*(ncolor-1)): rf = 1.0
			58	else: rf = (-100.0/22)*i/(ncolor-1) + 111.0/22
			59
			60	if(i <= 12.0/100*(ncolor-1)): gf = 0.0
			61	elif(i <= 38.0/100(ncolor-1)): gf = (100.0/26)i/(ncolor-1) - 12.0/26
			62	elif(i <= 64.0/100*(ncolor-1)): gf = 1.0
			63	elif(i <= 91.0/100(ncolor-1)): gf = (-100.0/27)i/(ncolor-1) + 91.0/27
			64	else: gf = 0.0
			65
			66	if(i <= 11.0/100(ncolor-1)): bf = (50.0/11)i/(ncolor-1) + 0.5
			67	elif(i <= 34.0/100*(ncolor-1)): bf = 1.0
			68	elif(i <= 65.0/100(ncolor-1)): bf = (-100.0/31)i/(ncolor-1) + 65.0/31
			69	else: bf = 0
			70
			71	r[i] = rf
			72	g[i] = gf
			73	b[i] = bf
			74
			75	pos[i] = float(i)/float(ncolor-1)
			76
			77
			78	plplot.plscmap1n(ncolor)
			79	plplot.plscmap1l(1, pos, r, g, b)
			80
			81
			82
	42	if colormap=="br_green":	83	if colormap=="br_green":
	43	ncolor = 256	84	ncolor = 256
	44	# Hue ranges from blue (240 deg) to red (0 or 360 deg)	85	# Hue ranges from blue (240 deg) to red (0 or 360 deg)
	45	h = numpy.array((240., 0.))	86	h = numpy.array((240., 0.))
	46	# Lightness and saturation are constant (values taken from C example).	87	# Lightness and saturation are constant (values taken from C example).
	47	l = numpy.array((0.6, 0.6))	88	l = numpy.array((0.6, 0.6))
	48	s = numpy.array((0.8, 0.8))	89	s = numpy.array((0.8, 0.8))
	49		90
	50	# number of cmap1 colours is 256 in this case.	91	# number of cmap1 colours is 256 in this case.
	51	plplot.plscmap1n(ncolor)	92	plplot.plscmap1n(ncolor)
	52	# Interpolate between control points to set up cmap1.	93	# Interpolate between control points to set up cmap1.
	53	plplot.plscmap1l(0, i, h, l, s)	94	plplot.plscmap1l(0, i, h, l, s)
	54		95
	55	return None	96	return None
	56		97
	57	if colormap=="tricolor":	98	if colormap=="tricolor":
	58	ncolor = 3	99	ncolor = 3
	59	# Hue ranges from blue (240 deg) to red (0 or 360 deg)	100	# Hue ranges from blue (240 deg) to red (0 or 360 deg)
	60	h = numpy.array((240., 0.))	101	h = numpy.array((240., 0.))
	61	# Lightness and saturation are constant (values taken from C example).	102	# Lightness and saturation are constant (values taken from C example).
	62	l = numpy.array((0.6, 0.6))	103	l = numpy.array((0.6, 0.6))
	63	s = numpy.array((0.8, 0.8))	104	s = numpy.array((0.8, 0.8))
	64		105
	65	# number of cmap1 colours is 256 in this case.	106	# number of cmap1 colours is 256 in this case.
	66	plplot.plscmap1n(ncolor)	107	plplot.plscmap1n(ncolor)
	67	# Interpolate between control points to set up cmap1.	108	# Interpolate between control points to set up cmap1.
	68	plplot.plscmap1l(0, i, h, l, s)	109	plplot.plscmap1l(0, i, h, l, s)
	69		110
	70	return None	111	return None
	71		112
	72	if colormap == 'rgb' or colormap == 'rgb666':	113	if colormap == 'rgb' or colormap == 'rgb666':
	73		114
	74	color_sz = 6	115	color_sz = 6
	75	ncolor = color_szcolor_szcolor_sz	116	ncolor = color_szcolor_szcolor_sz
	76	pos = numpy.zeros((ncolor))	117	pos = numpy.zeros((ncolor))
	77	r = numpy.zeros((ncolor))	118	r = numpy.zeros((ncolor))
	78	g = numpy.zeros((ncolor))	119	g = numpy.zeros((ncolor))
	79	b = numpy.zeros((ncolor))	120	b = numpy.zeros((ncolor))
	80	ind = 0	121	ind = 0
	81	for ri in range(color_sz):	122	for ri in range(color_sz):
	82	for gi in range(color_sz):	123	for gi in range(color_sz):
	83	for bi in range(color_sz):	124	for bi in range(color_sz):
	84	r[ind] = ri/(color_sz-1.0)	125	r[ind] = ri/(color_sz-1.0)
	85	g[ind] = gi/(color_sz-1.0)	126	g[ind] = gi/(color_sz-1.0)
	86	b[ind] = bi/(color_sz-1.0)	127	b[ind] = bi/(color_sz-1.0)
	87	pos[ind] = ind/(ncolor-1.0)	128	pos[ind] = ind/(ncolor-1.0)
	88	ind += 1	129	ind += 1
	89	rgb_lvl = [6,6,6] #Levels for RGB colors	130	rgb_lvl = [6,6,6] #Levels for RGB colors
	90		131
	91	if colormap == 'rgb676':	132	if colormap == 'rgb676':
	92	ncolor = 676	133	ncolor = 676
	93	pos = numpy.zeros((ncolor))	134	pos = numpy.zeros((ncolor))
	94	r = numpy.zeros((ncolor))	135	r = numpy.zeros((ncolor))
	95	g = numpy.zeros((ncolor))	136	g = numpy.zeros((ncolor))
	96	b = numpy.zeros((ncolor))	137	b = numpy.zeros((ncolor))
	97	ind = 0	138	ind = 0
	98	for ri in range(8):	139	for ri in range(8):
	99	for gi in range(8):	140	for gi in range(8):
	100	for bi in range(4):	141	for bi in range(4):
	101	r[ind] = ri/(6-1.0)	142	r[ind] = ri/(6-1.0)
	102	g[ind] = gi/(7-1.0)	143	g[ind] = gi/(7-1.0)
	103	b[ind] = bi/(6-1.0)	144	b[ind] = bi/(6-1.0)
	104	pos[ind] = ind/(ncolor-1.0)	145	pos[ind] = ind/(ncolor-1.0)
	105	ind += 1	146	ind += 1
	106	rgb_lvl = [6,7,6] #Levels for RGB colors	147	rgb_lvl = [6,7,6] #Levels for RGB colors
	107		148
	108	if colormap == 'rgb685':	149	if colormap == 'rgb685':
	109	ncolor = 685	150	ncolor = 685
	110	pos = numpy.zeros((ncolor))	151	pos = numpy.zeros((ncolor))
	111	r = numpy.zeros((ncolor))	152	r = numpy.zeros((ncolor))
	112	g = numpy.zeros((ncolor))	153	g = numpy.zeros((ncolor))
	113	b = numpy.zeros((ncolor))	154	b = numpy.zeros((ncolor))
	114	ind = 0	155	ind = 0
	115	for ri in range(8):	156	for ri in range(8):
	116	for gi in range(8):	157	for gi in range(8):
	117	for bi in range(4):	158	for bi in range(4):
	118	r[ind] = ri/(6-1.0)	159	r[ind] = ri/(6-1.0)
	119	g[ind] = gi/(8-1.0)	160	g[ind] = gi/(8-1.0)
	120	b[ind] = bi/(5-1.0)	161	b[ind] = bi/(5-1.0)
	121	pos[ind] = ind/(ncolor-1.0)	162	pos[ind] = ind/(ncolor-1.0)
	122	ind += 1	163	ind += 1
	123	rgb_lvl = [6,8,5] #Levels for RGB colors	164	rgb_lvl = [6,8,5] #Levels for RGB colors
	124		165
	125	if colormap == 'rgb884':	166	if colormap == 'rgb884':
	126	ncolor = 884	167	ncolor = 884
	127	pos = numpy.zeros((ncolor))	168	pos = numpy.zeros((ncolor))
	128	r = numpy.zeros((ncolor))	169	r = numpy.zeros((ncolor))
	129	g = numpy.zeros((ncolor))	170	g = numpy.zeros((ncolor))
	130	b = numpy.zeros((ncolor))	171	b = numpy.zeros((ncolor))
	131	ind = 0	172	ind = 0
	132	for ri in range(8):	173	for ri in range(8):
	133	for gi in range(8):	174	for gi in range(8):
	134	for bi in range(4):	175	for bi in range(4):
	135	r[ind] = ri/(8-1.0)	176	r[ind] = ri/(8-1.0)
	136	g[ind] = gi/(8-1.0)	177	g[ind] = gi/(8-1.0)
	137	b[ind] = bi/(4-1.0)	178	b[ind] = bi/(4-1.0)
	138	pos[ind] = ind/(ncolor-1.0)	179	pos[ind] = ind/(ncolor-1.0)
	139	ind += 1	180	ind += 1
	140	rgb_lvl = [8,8,4] #Levels for RGB colors	181	rgb_lvl = [8,8,4] #Levels for RGB colors
	141		182
	142	if ncolor == None:	183	if ncolor == None:
	143	raise ValueError, "The colormap selected is not valid"	184	raise ValueError, "The colormap selected is not valid"
	144		185
	145	plplot.plscmap1n(ncolor)	186	plplot.plscmap1n(ncolor)
	146	plplot.plscmap1l(1, pos, r, g, b)	187	plplot.plscmap1l(1, pos, r, g, b)
	147		188
	148	return rgb_lvl	189	return rgb_lvl
	149		190
	150	def setColormap(colormap="~~br_green~~"):	191	def setColormap(colormap="jet"):
	151	cmap1_init(colormap)	192	cmap1_init(colormap)
	152		193
	153	class BaseGraph:	194	def initPlplot(indexPlot,ncol,nrow,winTitle,width,height):
	154	"""	195	plplot.plsstrm(indexPlot)
			196	plplot.plparseopts([winTitle],plplot.PL_PARSE_FULL)
			197	plplot.plsetopt("geometry", "%dx%d"%(widthncol,heightnrow))
			198	plplot.plsdev("xwin")
			199	plplot.plscolbg(255,255,255)
			200	plplot.plscol0(1,0,0,0)
			201	plplot.plinit()
			202	plplot.plspause(False)
			203	plplot.plssub(ncol,nrow)
	155		204
	156	"""	205	def clearData(objGraph):
	157	hasNotRange = True	206	objGraph.plotBox(objGraph.xrange[0], objGraph.xrange[1], objGraph.yrange[0], objGraph.yrange[1], "bc", "bc")
	158		207
	159	xrange = None	208	objGraph.setColor(15) #Setting Line Color to White
	160	yrange = None
	161	zrange = None
	162		209
	163	xlabel = None	210	if objGraph.datatype == "complex":
	164	ylabel = None	211	objGraph.basicXYPlot(objGraph.xdata,objGraph.ydata.real)
	165	title = None	212	objGraph.basicXYPlot(objGraph.xdata,objGraph.ydata.imag)
	166		213
	167	legends = None	214	if objGraph.datatype == "real":
			215	objGraph.basicXYPlot(objGraph.xdata,objGraph.ydata)
	168		216
	169	__name = None	217	objGraph.setColor(1) #Setting Line Color to Black
			218	# objGraph.setLineStyle(2)
			219	# objGraph.plotBox(objGraph.xrange[0], objGraph.xrange[1], objGraph.yrange[0], objGraph.yrange[1], "bcntg", "bc")
			220	# objGraph.setLineStyle(1)
	170		221
	171	__colormap = None	222	def setStrm(indexPlot):
	172	__colbox = None	223	plplot.plsstrm(indexPlot)
	173	__colleg = None
	174		224
	175	__xpos = None	225	def plFlush():
	176	__ypos = None	226	plplot.plflush()
	177		227
	178	__xopt = None #"bcnst"	228	def setPlTitle(pltitle,color):
	179	__yopt = None #"bcnstv"	229	setSubpages(1, 0)
			230	plplot.pladv(0)
			231	plplot.plvpor(0., 1., 0., 1.)
	180		232
	181	__xlpos = None	233	if color == "black":
	182	__ylpos = None	234	plplot.plcol0(1)
			235	if color == "white":
			236	plplot.plcol0(15)
			237
			238	plplot.plmtex("t",-1., 0.5, 0.5, pltitle)
	183		239
	184	__xrangeIsTime = False	240	def setSubpages(ncol,nrow):
			241	plplot.plssub(ncol,nrow)
	185		242
	186	#Advanced	243	class BaseGraph:
			244	__name = None
			245	__xpos = None
			246	__ypos = None
			247	__subplot = None
	187	__xg = None	248	__xg = None
	188	__yg = None	249	__yg = None
	189		250	xdata = None
	190	def __init__(self):	251	ydata = None
	191	"""	252	getGrid = True
	192		253	xaxisIsTime = False
	193	"""	254	deltax = None
	194	self.hasNotRange = True	255	xmin = None
	195		256	xmax = None
	196	self.xrange = None	257	def __init__(self,name,subplot,xpos,ypos,xlabel,ylabel,title,szchar,xrange,yrange,zrange=None,deltax=1.0):
	197	self.~~yrange~~ = ~~None~~	258	self.setName(name)
	198	self.zrange = None	259	self.setScreenPos(xpos, ypos)
	199		260	self.setLabels(xlabel,ylabel,title)
	200	self.xlabel = None	261	self.setSubPlot(subplot)
	201	self.ylabel = None	262	self.setSizeOfChar(szchar)
	202	self.title = None	263	self.setXYZrange(xrange,yrange,zrange)
	203		264	self.getGrid = True
	204	self.~~legends~~ = ~~Non~~e	265	self.xaxisIsTime = False
	205		266	self.deltax = deltax
	206	self.__name = None	267
	207		268	def setXYZrange(self,xrange,yrange,zrange):
	208	self.~~__colormap~~ = ~~Non~~e	269	self.xrange = xrange
	209	self.~~__colbox~~ = ~~Non~~e	270	self.yrange = yrange
	210	self.~~__colleg~~ = ~~None~~	271	self.zrange = zrange
	211
	212	self.__xpos = None
	213	self.__ypos = None
	214
	215	self.__xopt = None #"bcnst"
	216	self.__yopt = None #"bcnstv"
	217
	218	self.__xlpos = None
	219	self.__ylpos = None
	220
	221	self.__xrangeIsTime = False
	222
	223	#Advanced
	224	self.__xg = None
	225	self.__yg = None
	226		272
	227	def setName(self, name):	273	def setName(self, name):
	228	self.__name = name	274	self.__name = name
	229		275
	230	def setScreenPos(self, xpos, ypos):	276	def setScreenPos(self,xpos,ypos):
	231	self.__xpos = xpos	277	self.__xpos = xpos
	232	self.__ypos = ypos	278	self.__ypos = ypos
	233		279
	234	def setOpt(self, xopt, yopt):	280	def setXYData(self,xdata=None,ydata=None,datatype="real"):
	235	self.__xopt = xopt	281	if((xdata != None) and (ydata != None)):
	236	self.~~__yopt~~ = ~~yopt~~	282	self.xdata = xdata
	237		283	self.ydata = ydata
	238	def setXAxisAsTime(self):	284	self.datatype = datatype
	239	self.__xrangeIsTime = True
	240		285
			286	if((self.xdata == None) and (self.ydata == None)):
			287	return None
	241		288
	242	def setup(self, title=None, xlabel=None, ylabel=None, colormap=None):	289	return 1
	243	"""
	244	"""
	245	self.title = title
	246	self.xlabel = xlabel
	247	self.ylabel = ylabel
	248	self.__colormap = colormap
	249		290
	250	def plotBox(self, xmin, xmax, ymin, ymax, xopt=None, yopt=None, nolabels=False):
	251	"""
	252		291
	253	"""	292	def setLabels(self,xlabel=None,ylabel=None,title=None):
	254	if self.__xrangeIsTime:	293	if xlabel != None: self.xlabel = xlabel
	255	plplot.pltimefmt("%H:%M")	294	if ylabel != None: self.ylabel = ylabel
			295	if title != None: self.title = title
	256		296
	257	plplot.plvpor(self.__xpos[0], self.__xpos[1], self.__ypos[0], self.__ypos[1])	297	def setSubPlot(self,subplot):
	258	plplot.plwind(float(xmin),	298	self.__subplot = subplot
	259	float(xmax),
	260	float(ymin),
	261	float(ymax)
	262	)
	263
	264	if xopt == None: xopt = self.__xopt
	265	if yopt == None: yopt = self.__yopt
	266
	267	plplot.plbox(xopt, 0.0, 0, yopt, 0.0, 0)
	268		299
	269	if not(nolabels):	300	def setSizeOfChar(self,szchar):
	270	plplot.pllab(self.xlabel, self.ylabel, self.title)	301	self.__szchar = szchar
	271		302
			303	def setLineStyle(self,style):
			304	plplot.pllsty(style)
	272		305
	273	def colorbarPlot(self, xmin=0., xmax=1., ymin=0., ymax=1.):	306	def setColor(self,color):
	274	data = numpy.arange(256)	307	plplot.plcol0(color)
	275	data = numpy.reshape(data, (1,-1))
	276		308
	277	plplot.plimage(data,	309	def setXAxisAsTime(self,value=False):
	278	float(xmin),	310	self.xaxisIsTime = value
	279	float(xmax),
	280	float(ymin),
	281	float(ymax),
	282	0.,
	283	255.,
	284	float(xmin),
	285	float(xmax),
	286	float(ymin),
	287	float(ymax))
	288		311
	289	def basicXYPlot(self, x, y, xmin=None, xmax=None, ymin=None, ymax=None):	312	def basicLineTimePlot(self, x, y, xmin=None, xmax=None, ymin=None, ymax=None, colline=1):
	290		313
	291	if xmin == None: xmin = x[0]	314	if xmin == None: xmin = x[0]
	292	if xmax == None: xmax = x[-1]	315	if xmax == None: xmax = x[-1]
	293	if ymin == None: ymin = y[0]	316	if ymin == None: ymin = y[0]
	294	if ymax == None: ymax = y[-1]	317	if ymax == None: ymax = y[-1]
	295		318
			319	plplot.plcol0(colline)
	296	plplot.plline(x, y)	320	plplot.plline(x, y)
			321	plplot.plcol0(1)
	297		322
	298	def basicXYwithErrorPlot(self):	323	def basicXYPlot(self, x, y, xmin=None, xmax=None, ymin=None, ymax=None):
	299	pass
	300
	301	def basicLineTimePlot(self, x, y, xmin=None, xmax=None, ymin=None, ymax=None, colline=1):
	302		324
	303	if xmin == None: xmin = x[0]	325	if xmin == None: xmin = x[0]
	304	if xmax == None: xmax = x[-1]	326	if xmax == None: xmax = x[-1]
	305	if ymin == None: ymin = y[0]	327	if ymin == None: ymin = y[0]
	306	if ymax == None: ymax = y[-1]	328	if ymax == None: ymax = y[-1]
	307		329
	308	plplot.plcol0(colline)
	309	plplot.plline(x, y)	330	plplot.plline(x, y)
	310	plplot.plcol0(1)
	311		331
	312	def basicPcolorPlot(self, data, x, y, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None):	332	def basicPcolorPlot(self, data, x, y, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None):
	313	"""	333	"""
	314	"""	334	"""
	315	if xmin == None: xmin = x[0]	335	if xmin == None: xmin = x[0]
	316	if xmax == None: xmax = x[-1]	336	if xmax == None: xmax = x[-1]
	317	if ymin == None: ymin = y[0]	337	if ymin == None: ymin = y[0]
	318	if ymax == None: ymax = y[-1]	338	if ymax == None: ymax = y[-1]
	319	if zmin == None: zmin = numpy.nanmin(data)	339	if zmin == None: zmin = numpy.nanmin(data)
	320	if zmax == None: zmax = numpy.nanmax(data)	340	if zmax == None: zmax = numpy.nanmax(data)
	321		341
	322	plplot.plimage(data,	342	plplot.plimage(data,
	323	float(x[0]),	343	float(x[0]),
	324	float(x[-1]),	344	float(x[-1]),
	325	float(y[0]),	345	float(y[0]),
	326	float(y[-1]),	346	float(y[-1]),
	327	float(zmin),	347	float(zmin),
	328	float(zmax),	348	float(zmax),
	329	float(xmin),	349	float(xmin),
	330	float(xmax),	350	float(xmax),
	331	float(ymin),	351	float(ymin),
	332	float(ymax)	352	float(ymax)
	333	)	353	)
	334		354
	335	def __getBoxpltr(self, x, y, deltax=None, deltay=None):	355	def __getBoxpltr(self, x, y, deltax=None, deltay=None):
	336		356
	337	if not(len(x)>1 and len(y)>1):	357	if not(len(x)>0 and len(y)>0):
	338	raise ValueError, "x axis and y axis are empty"	358	raise ValueError, "x axis and y axis are empty"
	339		359
	340	if deltax == None: deltax = x[-1] - x[-2]	360	if deltax == None: deltax = x[-1] - x[-2]
	341	if deltay == None: deltay = y[-1] - y[-2]	361	if deltay == None: deltay = y[-1] - y[-2]
	342		362
	343	x1 = numpy.append(x, x[-1] + deltax)	363	x1 = numpy.append(x, x[-1] + deltax)
	344	y1 = numpy.append(y, y[-1] + deltay)	364	y1 = numpy.append(y, y[-1] + deltay)
	345		365
	346	xg = (numpy.multiply.outer(x1, numpy.ones(len(y1))))	366	xg = (numpy.multiply.outer(x1, numpy.ones(len(y1))))
	347	yg = (numpy.multiply.outer(numpy.ones(len(x1)), y1))	367	yg = (numpy.multiply.outer(numpy.ones(len(x1)), y1))
	348		368
	349	self.__xg = xg	369	self.__xg = xg
	350	self.__yg = yg	370	self.__yg = yg
	351		371
	352	def advPcolorPlot(self, data, x, y, zmin=0., zmax=0.):	372	return xg, yg
	353	"""
	354	"""
	355
	356	if self.__xg == None and self.__yg == None:
	357	self.__getBoxpltr(x, y)
	358
	359	plplot.plimagefr(data, x[0], x[-1], y[0], y[-1], 0., 0., zmin, zmax, plplot.pltr2, self.__xg, self.__yg)
	360
	361
	362	class LinearPlot:
	363
	364	linearGraphObj = BaseGraph()
	365
	366	__szchar = 1.0
	367
	368	__xrange = None
	369
	370	__yrange = None
	371
	372	__subpage = 0
	373	m_BaseGraph= BaseGraph()
	374		373
	375		374
			375	def advPcolorPlot(self, data, x, y, xmin=None, xmax=None, ymin=None, ymax=None, zmin=0., zmax=0., deltax=1.0, deltay=None, getGrid = True):
			376	if getGrid:
			377	xg, yg = self.__getBoxpltr(x, y, deltax, deltay)
			378	else:
			379	xg = self.__xg
			380	yg = self.__yg
	376		381
	377	def __init__(self):	382	plplot.plimagefr(data,
	378		383	float(xmin),
			384	float(xmax),
			385	float(ymin),
			386	float(ymax),
			387	0.,
			388	0.,
			389	float(zmin),
			390	float(zmax),
			391	plplot.pltr2,
			392	xg,
			393	yg)
	379		394
	380	key = "linearplot"
	381	self.linearGraphObj = BaseGraph()
	382	self.linearGraphObj.setName(key)
	383		395
	384	self.__subpage = 0	396	def colorbarPlot(self, xmin=0., xmax=1., ymin=0., ymax=1.):
			397	data = numpy.arange(256)
			398	data = numpy.reshape(data, (1,-1))
	385		399
	386	def __iniSubpage(self):	400	plplot.plimage(data,
			401	float(xmin),
			402	float(xmax),
			403	float(ymin),
			404	float(ymax),
			405	0.,
			406	255.,
			407	float(xmin),
			408	float(xmax),
			409	float(ymin),
			410	float(ymax))
	387		411
	388	if plplot.plgdev() == '':	412	def plotBox(self, xmin, xmax, ymin, ymax, xopt, yopt, nolabels=False):
	389	raise ValueError, "Plot device has not been initialize"
	390		413
	391	plplot.pl~~adv~~(self.__s~~ubpage~~)	414	plplot.plschr(0.0,self.__szchar-0.05)
	392	plplot.pl~~schr~~(~~0.0~~, self.__s~~zchar~~)	415	plplot.pladv(self.__subplot)
			416	plplot.plvpor(self.__xpos[0], self.__xpos[1], self.__ypos[0], self.__ypos[1])
			417	plplot.plwind(float(xmin), # self.xrange[0]
			418	float(xmax), # self.xrange[1]
			419	float(ymin), # self.yrange[0]
			420	float(ymax) # self.yrange[1]
			421	)
	393		422
	394	setColormap()
	395		423
	396	def setScreenPos(self, width='small'):
	397		424
	398	if width == 'small':	425	if self.xaxisIsTime:
	399	xi = 0.12; yi = 0.14; xw = 0.78; yw = 0.80	426	plplot.pltimefmt("%H:%M")
			427	timedelta = (xmax - xmin + 1)/8.
			428	plplot.plbox(xopt, timedelta, 3, yopt, 0.0, 0)
			429	else:
			430	plplot.plbox(xopt, 0.0, 0, yopt, 0.0, 0)
	400		431
	401	if width == 'medium':
	402	xi = 0.07; yi = 0.10; xw = 0.90; yw = 0.60
	403		432
	404	xf = xi + xw	433	if not(nolabels):
	405	yf = yi + yw	434	plplot.pllab(self.xlabel, self.ylabel, self.title)
	406		435
	407	self.linearGraphObj.setScreenPos([xi, xf], [yi, yf])
	408		436
	409	def setup(self, subpage, title="", xlabel="", ylabel="", XAxisAsTime=False):	437	def delLabels(self):
	410	"""	438	self.setColor(15) #Setting Line Color to White
	411	"""	439	plplot.pllab(self.xlabel, self.ylabel, self.title)
			440	self.setColor(1) #Setting Line Color to Black
	412		441
	413	self.linearGraphObj.setOpt("bcnts","bcntsv")
	414	self.linearGraphObj.setup(title,
	415	xlabel,
	416	ylabel
	417	)
	418		442
	419	self.setScreenPos(width='medium')
	420		443
	421	if XAxisAsTime:	444	def plotImage(self,x,y,z,xrange,yrange,zrange):
	422	self.linearGraphObj.setXAxisAsTime()	445	xi = x[0]
			446	xf = x[-1]
			447	yi = y[0]
			448	yf = y[-1]
	423		449
	424	self.__subpage = subpage	450	plplot.plimage(z,
	425	# def setRanges(self, xrange, yrange, zrange):	451	float(xi),
	426	#	452	float(xf),
	427	# self.linearGraphObj.setRanges(xrange, yrange, zrange)	453	float(yi),
			454	float(yf),
			455	float(zrange[0]),
			456	float(zrange[1]),
			457	float(xi),
			458	float(xf),
			459	float(yrange[0]),
			460	yrange[1])
	428		461
	429	def plotData(self, x, y=None, xmin=None, xmax=None, ymin=None, ymax=None, colline=1):	462	class LinearPlot:
	430	"""	463	linearObjDic = {}
	431	Inputs:	464	__xpos = None
			465	__ypos = None
			466	def __init__(self,indexPlot,nsubplot,winTitle):
			467	self.width = 700
			468	self.height = 150
			469	ncol = 1
			470	nrow = nsubplot
			471	initPlplot(indexPlot,ncol,nrow,winTitle,self.width,self.height)
	432		472
	433	x : Numpy array of dimension 1
	434	y : Numpy array of dimension 1
	435		473
	436	"""	474	def setFigure(self,indexPlot):
			475	setStrm(indexPlot)
	437		476
	438	try:	477	def setPosition(self):
	439	nX = numpy.shape(x)
	440	except:
	441	raise ValueError, "x is not a numpy array"
	442		478
	443	if y == None: y = numpy.arange(nX)	479	xi = 0.07; xf = 0.9 #0.8,0.7,0.5
			480	yi = 0.15; yf = 0.8
	444		481
	445	if xmin == None: xmin = x[0]	482	xpos = [xi,xf]
	446	if xmax == None: xmax = x[-1]	483	ypos = [yi,yf]
	447	if ymin == None: ymin = y[0]
	448	if ymax == None: ymax = y[-1]
	449		484
	450	self.__~~iniSubpage~~()	485	self.__xpos = xpos
	451	self.linearGraphObj.plotBox(xmin, xmax, ymin, ymax)	486	self.__ypos = ypos
	452	self.linearGraphObj.basicLineTimePlot(x, y, xmin, xmax, ymin, ymax, colline)
	453		487
	454	def plotComplexData(self, x, y, xmin=None, xmax=None, ymin=None, ymax=None, colline=1, type='power'):	488	return xpos,ypos
	455	"""
	456	Inputs:
	457		489
	458	x : Numpy array of dimension 1	490	def refresh(self):
	459	y : Complex numpy array of dimension 1	491	plFlush()
	460		492
	461	"""	493	def setup(self,subplot,xmin,xmax,ymin,ymax,title,xlabel,ylabel):
			494	szchar = 1.10
			495	name = "linear"
			496	key = name + "%d"%subplot
			497	xrange = [xmin,xmax]
			498	yrange = [ymin,ymax]
	462		499
	463	try:	500	xpos,ypos = self.setPosition()
	464	nX = numpy.shape(x)	501	linearObj = BaseGraph(name,subplot,xpos,ypos,xlabel,ylabel,title,szchar,xrange,yrange)
	465	except:	502	linearObj.plotBox(linearObj.xrange[0], linearObj.xrange[1], linearObj.yrange[0], linearObj.yrange[1], "bcnst", "bcnstv")
	466	raise ValueError, "x is not a numpy array"	503	self.linearObjDic[key] = linearObj
	467		504
	468	try:	505	def plot(self,subplot,x,y,type="power"):
	469	nY = numpy.shape(y)	506	name = "linear"
	470	except:	507	key = name + "%d"%subplot
	471	raise ValueError, "y is not a numpy array"
	472		508
	473	if xmin == None: xmin = x[0]	509	linearObj = self.linearObjDic[key]
	474	if xmax == None: xmax = x[-1]	510	linearObj.plotBox(linearObj.xrange[0], linearObj.xrange[1], linearObj.yrange[0], linearObj.yrange[1], "bcst", "bcst")
	475	if ymin == None: ymin = y[0]
	476	if ymax == None: ymax = y[-1]
	477		511
	478	self.__iniSubpage()	512	if linearObj.setXYData() != None:
	479	self.linearGraphObj.plotBox(xmin, xmax, ymin, ymax)	513	clearData(linearObj)
	480		514
			515	else:
	481	if type.lower() == 'power':	516	if type.lower() == 'power':
	482	self.linearGraphObj.basicLineTimePlot(x, abs(y), xmin, xmax, ymin, ymax, colline)	517	linearObj.setXYData(x,abs(y),"real")
	483
	484	if type.lower() == 'iq':	518	if type.lower() == 'iq':
			519	linearObj.setXYData(x,y,"complex")
	485		520
	486	self.linearGraphObj.basicLineTimePlot(x, y.real, xmin, xmax, ymin, ymax, colline)	521	if type.lower() == 'power':
	487	self.linearGraphObj.basicLineTimePlot(x, y.imag, xmin, xmax, ymin, ymax, colline+1)	522	colline = 9
	488		523	linearObj.basicLineTimePlot(x, abs(y), xmin, xmax, ymin, ymax, colline)
	489	class ColorPlot:	524	linearObj.setXYData(x,abs(y),"real")
	490
	491	colorGraphObj = BaseGraph()
	492
	493	graphObjDict = {}
	494
	495	__subpage = 0
	496
	497	__showColorbar = False
	498
	499	__showPowerProfile = True
	500
	501	__szchar = 0.65
	502
	503	__xrange = None
	504
	505	__yrange = None
	506
	507	__zrange = None
	508	m_BaseGraph= BaseGraph()
	509
	510
	511
	512	def __init__(self):
	513
	514	self.graphObjDict = {}
	515
	516	self.__subpage = 0
	517	self.__showColorbar = False
	518	self.__showPowerProfile = True
	519
	520	self.__szchar = 0.65
	521	self.__xrange = None
	522	self.__yrange = None
	523	self.__zrange = None
	524
	525	key = "colorplot"
	526	self.colorGraphObj = BaseGraph()
	527	self.colorGraphObj.setName(key)
	528
	529	def setup(self, subpage, title="", xlabel="Frequency", ylabel="Range", colormap="br_green", showColorbar=False, showPowerProfile=False, XAxisAsTime=False):
	530	"""
	531	"""
	532
	533	self.colorGraphObj.setOpt("bcnts","bcntsv")
	534	self.colorGraphObj.setup(title,
	535	xlabel,
	536	ylabel
	537	)
	538
	539	self.__subpage = subpage
	540	self.__colormap = colormap
	541	self.__showColorbar = showColorbar
	542	self.__showPowerProfile = showPowerProfile
	543
	544	if showColorbar:
	545	key = "colorbar"
	546
	547	cmapObj = BaseGraph()
	548	cmapObj.setName(key)
	549	cmapObj.setOpt("bc","bcmtv")
	550	cmapObj.setup(title="dBs",
	551	xlabel="",
	552	ylabel="",
	553	colormap=colormap)
	554
	555	self.graphObjDict[key] = cmapObj
	556
	557
	558	if showPowerProfile:
	559	key = "powerprof"
	560
	561	powObj = BaseGraph()
	562	powObj.setName(key)
	563	powObj.setOpt("bcntg","bc")
	564	powObj.setup(title="Power Profile",
	565	xlabel="dB",
	566	ylabel="")
	567
	568	self.graphObjDict[key] = powObj
	569
	570	self.setScreenPos(width='small')
	571
	572	if XAxisAsTime:
	573	self.colorGraphObj.setXAxisAsTime()
	574
	575	def __iniSubpage(self):
	576
	577	if plplot.plgdev() == '':
	578	raise ValueError, "Plot device has not been initialize"
	579
	580	plplot.pladv(self.__subpage)
	581	plplot.plschr(0.0, self.__szchar)
	582
	583	setColormap(self.__colormap)
	584
	585	def setScreenPos(self, width='small'):
	586
	587	if width == 'small':
	588	xi = 0.13; yi = 0.12; xw = 0.86; yw = 0.70; xcmapw = 0.04; xpoww = 0.25; deltaxcmap = 0.02; deltaxpow = 0.06
	589
	590	if width == 'medium':
	591	xi = 0.07; yi = 0.10; xw = 0.90; yw = 0.60; xcmapw = 0.04; xpoww = 0.24; deltaxcmap = 0.02; deltaxpow = 0.06
	592
	593	if self.__showColorbar:
	594	xw -= xcmapw + deltaxcmap
	595
	596	if self.__showPowerProfile:
	597	xw -= xpoww + deltaxpow
	598
	599	xf = xi + xw
	600	yf = yi + yw
	601	xcmapf = xf
	602
	603	self.colorGraphObj.setScreenPos([xi, xf], [yi, yf])
	604
	605	if self.__showColorbar:
	606	xcmapi = xf + deltaxcmap
	607	xcmapf = xcmapi + xcmapw
	608
	609	key = "colorbar"
	610	cmapObj = self.graphObjDict[key]
	611	cmapObj.setScreenPos([xcmapi, xcmapf], [yi, yf])
	612
	613	if self.__showPowerProfile:
	614
	615	xpowi = xcmapf + deltaxpow
	616	xpowf = xpowi + xpoww
	617
	618	key = "powerprof"
	619	powObj = self.graphObjDict[key]
	620	powObj.setScreenPos([xpowi, xpowf], [yi, yf])
	621
	622
	623
	624	def plotData(self, data, x=None, y=None, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, title = ''):
	625	"""
	626	Inputs:
	627
	628	x : Numpy array of dimension 1
	629	y : Numpy array of dimension 1
	630
	631	"""
	632
	633	try:
	634	nX, nY = numpy.shape(data)
	635	except:
	636	raise ValueError, "data is not a numpy array"
	637
	638	if x == None: x = numpy.arange(nX)
	639	if y == None: y = numpy.arange(nY)
	640
	641	if xmin == None: xmin = x[0]
	642	if xmax == None: xmax = x[-1]
	643	if ymin == None: ymin = y[0]
	644	if ymax == None: ymax = y[-1]
	645	if zmin == None: zmin = numpy.nanmin(data)
	646	if zmax == None: zmax = numpy.nanmax(data)
	647
	648	plplot.plschr(0.0, self.__szchar)
	649	self.__iniSubpage()
	650	self.colorGraphObj.title = title
	651	self.colorGraphObj.plotBox(xmin, xmax, ymin, ymax)
	652	self.colorGraphObj.basicPcolorPlot(data, x, y, xmin, xmax, ymin, ymax, zmin, zmax)
	653
	654	if self.__showColorbar:
	655
	656
	657	key = "colorbar"
	658	cmapObj = self.graphObjDict[key]
	659
	660	plplot.plschr(0.0, self.__szchar-0.05)
	661	cmapObj.plotBox(0., 1., zmin, zmax)
	662	cmapObj.colorbarPlot(0., 1., zmin, zmax)
	663		525
	664	if self.__showPowerProfile:	526	if type.lower() == 'iq':
	665	power = numpy.average(data, axis=0)	527	colline = 9
			528	linearObj.basicLineTimePlot(x=x, y=y.real, colline=colline)
			529	colline = 13
			530	linearObj.basicLineTimePlot(x=x, y=y.imag, colline=colline)
			531
			532	linearObj.setXYData(x,y,"complex")
			533
			534	linearObj.plotBox(linearObj.xrange[0], linearObj.xrange[1], linearObj.yrange[0], linearObj.yrange[1], "bcst", "bcst")
			535
			536
			537	# linearObj.plotBox(linearObj.xrange[0], linearObj.xrange[1], linearObj.yrange[0], linearObj.yrange[1], "bc", "bc")
			538	# linearObj.basicXYPlot(data,y)
			539	# linearObj.setXYData(data,y)
			540
			541
			542
			543	class SpectraPlot:
			544	pcolorObjDic = {}
			545	colorbarObjDic = {}
			546	pwprofileObjDic = {}
			547	showColorbar = None
			548	showPowerProfile = None
			549	XAxisAsTime = None
			550	widht = None
			551	height = None
			552	__spcxpos = None
			553	__spcypos = None
			554	__cmapxpos = None
			555	__cmapypos = None
			556	__profxpos = None
			557	__profypos = None
			558	__lastTitle = None
			559
			560	def __init__(self,indexPlot,nsubplot,winTitle,colormap,showColorbar,showPowerProfile,XAxisAsTime):
			561	self.width = 460
			562	self.height = 300
			563	self.showColorbar = showColorbar
			564	self.showPowerProfile = showPowerProfile
			565	self.XAxisAsTime = XAxisAsTime
	666		566
	667	step = (ymax - ymin)/(nY-1)	567	nrow = 2
	668	heis = numpy.arange(ymin, ymax + step, step)	568	if (nsubplot%2)==0:
			569	ncol = nsubplot/nrow
			570	else:
			571	ncol = int(nsubplot)/nrow + 1
	669		572
	670	key = "powerprof"	573	initPlplot(indexPlot,ncol,nrow,winTitle,self.width,self.height)
	671	powObj = self.graphObjDict[key]	574	setColormap(colormap)
			575	self.ncol = ncol
			576	self.nrow = nrow
	672		577
	673	plplot.pllsty(2)	578	def setFigure(self,indexPlot):
	674	plplot.plschr(0.0, self.__szchar-0.05)	579	setStrm(indexPlot)
	675	powObj.plotBox(zmin, zmax, ymin, ymax, nolabels=True)
	676		580
	677	plplot.pllsty(1)	581	def setSpectraPos(self): #modificar valores de acuerdo al colorbar y pwprofile
	678	plplot.plschr(0.0, self.__szchar)	582	if self.showPowerProfile: xi = 0.09; xf = 0.6 #0.075
	679	powObj.plotBox(zmin, zmax, ymin, ymax, xopt='bc', yopt='bc')	583	else: xi = 0.15; xf = 0.8 #0.8,0.7,0.5
			584	yi = 0.15; yf = 0.80
	680		585
	681	plplot.plcol0(9)	586	xpos = [xi,xf]
	682	powObj.basicXYPlot(power, heis)	587	ypos = [yi,yf]
	683	plplot.plcol0(1)
	684		588
			589	self.__spcxpos = xpos
			590	self.__spcypos = ypos
	685		591
	686	class ColorPlotX:	592	return xpos,ypos
	687		593
			594	def setColorbarScreenPos(self):
	688		595
	689	graphObjDict = {}	596	xi = self.__spcxpos[1] + 0.03; xf = xi + 0.03
	690	showColorbar = False	597	yi = self.__spcypos[0]; yf = self.__spcypos[1]
	691	showPowerProfile = True
	692		598
	693	__szchar = 0.7	599	xpos = [xi,xf]
	694	__xrange = None	600	ypos = [yi,yf]
	695	__yrange = None
	696	__zrange = None
	697		601
	698	colorGraphObj = BaseGraph()	602	self.__cmapxpos = xpos
			603	self.__cmapypos = ypos
	699		604
	700	def __init__(self):	605	return xpos,ypos
	701		606
	702	key = "colorplot"	607	def setPowerprofileScreenPos(self):
	703	self.colorGraphObj.setName(key)
	704		608
	705	self.__subpage = 0	609	xi = self.__cmapxpos[1] + 0.07; xf = xi + 0.25
			610	yi = self.__spcypos[0]; yf = self.__spcypos[1]
	706		611
	707	self.graphObjDict[key] = self.colorGraphObj	612	xpos = [xi,xf]
			613	ypos = [yi,yf]
	708		614
	709	def __iniSubpage(self):	615	self.__profxpos = [xi,xf]
			616	self.__profypos = [yi,yf]
	710		617
	711	if plplot.plgdev() == '':	618	return xpos,ypos
	712	raise ValueError, "Plot device has not been initialize"
	713		619
	714	plplot.pladv(self.__subpage)	620	def setup(self,subplot,xmin,xmax,ymin,ymax,zmin,zmax,title,xlabel,ylabel):
	715	plplot.plschr(0.0, self.__szchar)	621	# Config Spectra plot
			622	szchar = 0.7
			623	name = "spc"
			624	key = name + "%d"%subplot
			625	xrange = [xmin,xmax]
			626	yrange = [ymin,ymax]
			627	zrange = [zmin,zmax]
	716		628
	717	setColormap(self.__colormap)	629	xpos,ypos = self.setSpectraPos()
	718		630	pcolorObj = BaseGraph(name,subplot,xpos,ypos,xlabel,ylabel,title,szchar,xrange,yrange,zrange)
	719	def setScreenPos(self, xi = 0.12, yi = 0.14, xw = 0.78, yw = 0.80, xcmapw = 0.05, xpoww = 0.24, deltaxcmap = 0.02, deltaxpow = 0.06):	631	pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], "bcnst", "bcnstv")
			632	self.pcolorObjDic[key] = pcolorObj
	720		633
			634	# Config Colorbar
	721	if self.showColorbar:	635	if self.showColorbar:
	722	xw -= xcmapw + deltaxcmap	636	szchar = 0.65
	723		637	name = "colorbar"
			638	key = name + "%d"%subplot
			639
			640	xpos,ypos = self.setColorbarScreenPos()
			641	xrange = [0.,1.]
			642	yrange = [zmin,zmax]
			643	cmapObj = BaseGraph(name,subplot,xpos,ypos,"","","dB",szchar,xrange,yrange)
			644	cmapObj.plotBox(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1], "bc", "bcm")
			645	cmapObj.colorbarPlot(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1])
			646	cmapObj.plotBox(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1], "bc", "bcmtsv")
			647	self.colorbarObjDic[key] = cmapObj
			648
			649	# Config Power profile
	724	if self.showPowerProfile:	650	if self.showPowerProfile:
	725	xw -= xpoww + deltaxpow	651	szchar = 0.55
	726		652	name = "pwprofile"
	727	xf = xi + xw	653	key = name + "%d"%subplot
	728	yf = yi + yw	654
	729	xcmapf = xf	655	xpos,ypos = self.setPowerprofileScreenPos()
	730		656	xrange = [zmin,zmax]
	731	self.colorGraphObj.setScreenPos([xi, xf], [yi, yf])	657	yrange = [ymin,ymax]
	732		658	powObj = BaseGraph(name,subplot,xpos,ypos,"dB","","Power Profile",szchar,xrange,yrange)
	733	if self.showColorbar:	659	powObj.setLineStyle(2)
	734	xcmapi = xf + deltaxcmap	660	powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bcntg", "bc")
	735	xcmapf = xcmapi + xcmapw	661	powObj.setLineStyle(1)
	736		662	powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bc", "bc")
	737	key = "colorbar"	663	self.pwprofileObjDic[key] = powObj
	738	cmapObj = self.graphObjDict[key]	664
	739	cmapObj.setScreenPos([xcmapi, xcmapf], [yi, yf])	665	def printTitle(self,pltitle):
	740		666	if self.__lastTitle != None:
			667	setPlTitle(self.__lastTitle,"white")
			668
			669	self.__lastTitle = pltitle
			670
			671	setPlTitle(pltitle,"black")
			672
			673	setSubpages(self.ncol,self.nrow)
			674
			675	def plot(self,subplot,x,y,z,subtitle):
			676	# Spectra plot
			677
			678	name = "spc"
			679	key = name + "%d"%subplot
			680
			681	# newx = [x[0],x[-1]]
			682	pcolorObj = self.pcolorObjDic[key]
			683	pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], "bcst", "bcst")
			684	pcolorObj.delLabels()
			685	pcolorObj.setLabels(title=subtitle)
			686
			687	deltax = None; deltay = None
			688
			689	pcolorObj.advPcolorPlot(z,
			690	x,
			691	y,
			692	xmin=pcolorObj.xrange[0],
			693	xmax=pcolorObj.xrange[1],
			694	ymin=pcolorObj.yrange[0],
			695	ymax=pcolorObj.yrange[1],
			696	zmin=pcolorObj.zrange[0],
			697	zmax=pcolorObj.zrange[1],
			698	deltax=deltax,
			699	deltay=deltay,
			700	getGrid=pcolorObj.getGrid)
			701
			702	pcolorObj.getGrid = False
			703
			704	pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], "bcst", "bcst")
			705
			706	# Power Profile
	741	if self.showPowerProfile:	707	if self.showPowerProfile:
	742		708	power = numpy.average(z, axis=0)
	743	xpowi = xcmapf + deltaxpow	709	name = "pwprofile"
	744	xpowf = xpowi + xpoww	710	key = name + "%d"%subplot
	745		711	powObj = self.pwprofileObjDic[key]
	746	key = "powerprof"	712
	747	powObj = self.graphObjDict[key]	713	if powObj.setXYData() != None:
	748	powObj.setScreenPos([xpowi, xpowf], [yi, yf])	714	clearData(powObj)
	749		715	else:
	750	def setRanges(self, xrange, yrange, zrange):	716	powObj.setXYData(power,y)
	751		717
	752	self.colorGraphObj.setRanges(xrange, yrange, zrange)	718	powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bc", "bc")
	753		719	powObj.basicXYPlot(power,y)
	754	keyList = self.graphObjDict.keys()	720	powObj.setXYData(power,y)
	755		721
	756	key = "colorbar"	722	def refresh(self):
	757	if key in keyList:	723	plFlush()
	758	cmapObj = self.graphObjDict[key]	724
	759	cmapObj.setRanges([0., 1.], zrange)	725	class RtiPlot:
	760		726
	761	key = "powerprof"	727	pcolorObjDic = {}
	762	if key in keyList:	728	colorbarObjDic = {}
	763	powObj = self.graphObjDict[key]	729	pwprofileObjDic = {}
	764	powObj.setRanges(zrange, yrange)	730	showColorbar = None
	765		731	showPowerProfile = None
	766	def setup(self, subpage, title="", xlabel="", ylabel="", colormap="jet", showColorbar=False, showPowerProfile=False, XAxisAsTime=False):	732	XAxisAsTime = None
	767	"""	733	widht = None
	768	"""	734	height = None
	769		735	__rtixpos = None
	770	self.colorGraphObj.setSubpage(subpage)	736	__rtiypos = None
	771	self.colorGraphObj.setSzchar(self.__szchar)	737	__cmapxpos = None
	772	self.colorGraphObj.setOpt("bcnts","bcntsv")	738	__cmapypos = None
	773	self.colorGraphObj.setup(title,	739	__profxpos = None
	774	xlabel,	740	__profypos = None
	775	ylabel,	741
	776	colormap)	742	def __init__(self,indexPlot,nsubplot,winTitle,colormap,showColorbar,showPowerProfile,XAxisAsTime):
	777		743	self.width = 700
	778	if showColorbar:	744	self.height = 150
	779	key = "colorbar"
	780
	781	cmapObj = BaseGraph()
	782	cmapObj.setName(key)
	783	cmapObj.setSubpage(subpage)
	784	cmapObj.setSzchar(self.__szchar)
	785	cmapObj.setOpt("bc","bcmt")
	786	cmapObj.setup(title="dBs",
	787	xlabel="",
	788	ylabel="",
	789	colormap=colormap)
	790
	791	self.graphObjDict[key] = cmapObj
	792
	793
	794	if showPowerProfile:
	795	key = "powerprof"
	796
	797	powObj = BaseGraph()
	798	powObj.setName(key)
	799	powObj.setSubpage(subpage)
	800	powObj.setSzchar(self.__szchar)
	801	plplot.pllsty(2)
	802	powObj.setOpt("bcntg","bc")
	803	plplot.pllsty(1)
	804	powObj.setup(title="Power Profile",
	805	xlabel="dBs",
	806	ylabel="")
	807
	808	self.graphObjDict[key] = powObj
	809
	810	self.showColorbar = showColorbar	745	self.showColorbar = showColorbar
	811	self.showPowerProfile = showPowerProfile	746	self.showPowerProfile = showPowerProfile
	812	self.setScreenPos()	747	self.XAxisAsTime = XAxisAsTime
	813		748
	814	if XAxisAsTime:	749	ncol = 1
	815	self.colorGraphObj.setXAxisAsTime()	750	nrow = nsubplot
	816	#self.setScreenPos(xi = 0.05, yi = 0.18, xw = 0.92, yw = 0.74, xcmapw = 0.015, xpoww = 0.14, deltaxcmap = 0.01, deltaxpow = 0.02)	751	initPlplot(indexPlot,ncol,nrow,winTitle,self.width,self.height)
			752	setColormap(colormap)
	817		753
			754	def setFigure(self,indexPlot):
			755	setStrm(indexPlot)
	818		756
	819	def plotData(self, data, x=None, y=None, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None):	757	def setRtiScreenPos(self):
	820	"""
	821	"""
	822		758
	823	try:	759	if self.showPowerProfile: xi = 0.07; xf = 0.65
	824	nX, nY = numpy.shape(data)	760	else: xi = 0.07; xf = 0.9
	825	except:	761	yi = 0.15; yf = 0.80
	826	raise ValueError, "data is not a numpy array"
	827		762
	828	if x == None: x = numpy.arange(nX)	763	xpos = [xi,xf]
	829	if y == None: y = numpy.arange(nY)	764	ypos = [yi,yf]
	830		765
	831	if xmin == None: xmin = x[0]	766	self.__rtixpos = xpos
	832	if xmax == None: xmax = x[-1]	767	self.__rtiypos = ypos
	833	if ymin == None: ymin = y[0]
	834	if ymax == None: ymax = y[-1]
	835	if zmin == None: zmin = numpy.nanmin(data)
	836	if zmax == None: zmax = numpy.nanmax(data)
	837		768
	838	if self.colorGraphObj.hasNotRange:	769	return xpos,ypos
	839	self.setRanges([xmin, xmax], [ymin,ymax], [zmin,zmax])
	840		770
	841	self.colorGraphObj.initSubpage()	771	def setColorbarScreenPos(self):
	842	self.colorGraphObj.basicPcolorPlot(data, x, y, xmin, xmax, ymin, ymax, self.colorGraphObj.zrange[0], self.colorGraphObj.zrange[1])
	843		772
	844	if self.showColorbar:	773	xi = self.__rtixpos[1] + 0.03; xf = xi + 0.03
	845	key = "colorbar"
	846	cmapObj = self.graphObjDict[key]
	847	cmapObj.colorbarPlot()
	848		774
	849	if self.showPowerProfile:	775	yi = self.__rtiypos[0]; yf = self.__rtiypos[1]
	850	power = numpy.average(data, axis=1)
	851		776
	852	step = (ymax - ymin)/(nY-1)	777	xpos = [xi,xf]
	853	heis = numpy.arange(ymin, ymax + step, step)	778	ypos = [yi,yf]
	854		779
	855	key = "powerprof"	780	self.__cmapxpos = xpos
	856	powObj = self.graphObjDict[key]	781	self.__cmapypos = ypos
	857	powObj.basicXYPlot(power, heis)
	858		782
	859	if __name__ == '__main__':	783	return xpos,ypos
	860		784
	861	import numpy	785	def setPowerprofileScreenPos(self):
	862	plplot.plsetopt("geometry", "%dx%d" %(3502, 3002))
	863	plplot.plsdev("xwin")
	864	plplot.plscolbg(255,255,255)
	865	plplot.plscol0(1,0,0,0)
	866	plplot.plspause(False)
	867	plplot.plinit()
	868	plplot.plssub(2, 2)
	869		786
	870	nx = 64	787	xi = self.__cmapxpos[1] + 0.05; xf = xi + 0.20
	871	ny = 100
	872		788
	873	data = numpy.random.uniform(-50,50,(nx,ny))	789	yi = self.__rtiypos[0]; yf = self.__rtiypos[1]
	874		790
	875	baseObj = ColorPlot()	791	xpos = [xi,xf]
	876	specObj = ColorPlot()	792	ypos = [yi,yf]
	877	baseObj1 = ColorPlot()
	878	specObj1 = ColorPlot()
	879		793
	880	baseObj.setup(1, "Spectrum", "Frequency", "Range", "br_green", True, True)	794	self.__profxpos = [xi,xf]
	881	specObj.setup(2, "Spectrum", "Frequency", "Range", "br_green", False, True)	795	self.__profypos = [yi,yf]
	882		796
	883	baseObj1.setup(3, "Spectrum", "Frequency", "Range", "br_green", False, True)	797	return xpos,ypos
	884	specObj1.setup(4, "Spectrum", "Frequency", "Range", "br_green", False, True)
	885		798
	886	data = numpy.random.uniform(-50,50,(nx,ny))	799	def setup(self,subplot,xmin,xmax,ymin,ymax,zmin,zmax,title,xlabel,ylabel,timedata,timezone="lt",npoints=100):
			800	# Config Rti plot
			801	szchar = 1.10
			802	name = "rti"
			803	key = name + "%d"%subplot
	887		804
	888	plplot.plbop()	805	# xmin, xmax --> minHour, max Hour : valores que definen el ejex x=[horaInicio,horaFinal]
	889	baseObj.plotData(data)	806	thisDateTime = datetime.datetime.fromtimestamp(timedata)
			807	startDateTime = datetime.datetime(thisDateTime.year,thisDateTime.month,thisDateTime.day,xmin,0,0)
			808	endDateTime = datetime.datetime(thisDateTime.year,thisDateTime.month,thisDateTime.day,xmax,59,59)
			809	deltaTime = 0
			810	if timezone == "lt":
			811	deltaTime = time.timezone
			812	startTimeInSecs = time.mktime(startDateTime.timetuple()) - deltaTime
			813	endTimeInSecs = time.mktime(endDateTime.timetuple()) - deltaTime
	890		814
	891	specObj.plotData(data)	815	xrange = [startTimeInSecs,endTimeInSecs]
			816	totalTimeInXrange = endTimeInSecs - startTimeInSecs + 1.
			817	deltax = totalTimeInXrange / npoints
	892		818
	893	baseObj1.plotData(data)	819	yrange = [ymin,ymax]
			820	zrange = [zmin,zmax]
	894		821
	895	specObj1.plotData(data)	822	xpos,ypos = self.setRtiScreenPos()
			823	pcolorObj = BaseGraph(name,subplot,xpos,ypos,xlabel,ylabel,title,szchar,xrange,yrange,zrange,deltax)
			824	if self.XAxisAsTime:
			825	pcolorObj.setXAxisAsTime(self.XAxisAsTime)
			826	xopt = "bcnstd"
			827	yopt = "bcnstv"
			828	else:
			829	xopt = "bcnst"
			830	yopt = "bcnstv"
			831
			832	pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], xopt, yopt)
			833	self.pcolorObjDic[key] = pcolorObj
	896		834
	897	plplot.plflush()
	898		835
	899	plplot.plspause(1)	836	# Config Colorbar
	900	plplot.plend()	837	if self.showColorbar:
	901	exit(0)	838	szchar = 0.9
			839	name = "colorbar"
			840	key = name + "%d"%subplot
			841
			842	xpos,ypos = self.setColorbarScreenPos()
			843	xrange = [0.,1.]
			844	yrange = [zmin,zmax]
			845	cmapObj = BaseGraph(name,subplot,xpos,ypos,"","","dB",szchar,xrange,yrange)
			846	cmapObj.plotBox(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1], "bc", "bcm")
			847	cmapObj.colorbarPlot(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1])
			848	cmapObj.plotBox(cmapObj.xrange[0], cmapObj.xrange[1], cmapObj.yrange[0], cmapObj.yrange[1], "bc", "bcmtsv")
			849	self.colorbarObjDic[key] = cmapObj
	902		850
	903		851
			852	# Config Power profile
			853	if self.showPowerProfile:
			854	szchar = 0.8
			855	name = "pwprofile"
			856	key = name + "%d"%subplot
			857
			858	xpos,ypos = self.setPowerprofileScreenPos()
			859	xrange = [zmin,zmax]
			860	yrange = [ymin,ymax]
			861	powObj = BaseGraph(name,subplot,xpos,ypos,"dB","","Power Profile",szchar,xrange,yrange)
			862	powObj.setLineStyle(2)
			863	powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bcntg", "bc")
			864	powObj.setLineStyle(1)
			865	powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bc", "bc")
			866	self.pwprofileObjDic[key] = powObj
			867
			868
			869	def plot(self,subplot,x,y,z):
			870	# RTI plot
			871	name = "rti"
			872	key = name + "%d"%subplot
			873
			874	data = numpy.reshape(z, (1,-1))
			875	data = numpy.abs(data)
			876	data = 10*numpy.log10(data)
			877	newx = [x,x+1]
			878
			879	pcolorObj = self.pcolorObjDic[key]
			880
			881	if pcolorObj.xaxisIsTime:
			882	xopt = "bcstd"
			883	yopt = "bcst"
			884	else:
			885	xopt = "bcst"
			886	yopt = "bcst"
			887
			888	pcolorObj.plotBox(pcolorObj.xrange[0], pcolorObj.xrange[1], pcolorObj.yrange[0], pcolorObj.yrange[1], xopt, yopt)
			889
			890	deltax = pcolorObj.deltax
			891	deltay = None
			892
			893	if pcolorObj.xmin == None and pcolorObj.xmax == None:
			894	pcolorObj.xmin = x
			895	pcolorObj.xmax = x
			896
			897	if x >= pcolorObj.xmax:
			898	xmin = x
			899	xmax = x + deltax
			900	x = [x]
			901	pcolorObj.advPcolorPlot(data,
			902	x,
			903	y,
			904	xmin=xmin,
			905	xmax=xmax,
			906	ymin=pcolorObj.yrange[0],
			907	ymax=pcolorObj.yrange[1],
			908	zmin=pcolorObj.zrange[0],
			909	zmax=pcolorObj.zrange[1],
			910	deltax=deltax,
			911	deltay=deltay,
			912	getGrid=pcolorObj.getGrid)
			913
			914	pcolorObj.xmin = xmin
			915	pcolorObj.xmax = xmax
			916
			917
			918	# Power Profile
			919	if self.showPowerProfile:
			920	data = numpy.reshape(data,(numpy.size(data)))
			921	name = "pwprofile"
			922	key = name + "%d"%subplot
			923	powObj = self.pwprofileObjDic[key]
			924
			925	if powObj.setXYData() != None:
			926	clearData(powObj)
			927	powObj.setLineStyle(2)
			928	powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bcntg", "bc")
			929	powObj.setLineStyle(1)
			930	else:
			931	powObj.setXYData(data,y)
			932
			933	powObj.plotBox(powObj.xrange[0], powObj.xrange[1], powObj.yrange[0], powObj.yrange[1], "bc", "bc")
			934	powObj.basicXYPlot(data,y)
			935	powObj.setXYData(data,y)
			936
			937	def refresh(self):
			938	plFlush() No newline at end of file

schainpy/Graphics/SpectraPlot.py +74 -159

@@ -1,204 +1,119
1	'''	1	'''
2	Created on Feb 7, 2012	2	Created on Feb 7, 2012
3		3
4	@author $Author$	4	@author $Author$
5	@version $Id$	5	@version $Id$
6	'''	6	'''
7		7
8	import os, sys
9	import numpy	8	import numpy
10	import datetime	9	import os
		10	import sys
11	import plplot	11	import plplot
		12	import datetime
12		13
13	path = os.path.split(os.getcwd())[0]	14	path = os.path.split(os.getcwd())[0]
14	sys.path.append(path)	15	sys.path.append(path)
15		16
16	from Graphics.BaseGraph import *	17	from Graphics.BaseGraph import *
17	from Model.Spectra import Spectra	18	from Model.Spectra import Spectra
18		19
19	class Spectrum:	20	class Spectrum:
		21	colorplotObj = None
20		22
21	__isPlotConfig = False	23	def __init__(self,Spectra, index):
22
23	__isPlotIni = False
24
25	__xrange = None
26
27	__yrange = None
28
29	nGraphs = 0
30
31	indexPlot = None
32
33	graphObjList = []
34
35	spectraObj = Spectra
36
37	colorGraphObj = ColorPlot()
38	m_Spectra= Spectra()
39
40
41	m_ColorPlot= ColorPlot()
42
43
44
45
46
47	def __init__(self, Spectra, index=0):
48
49	"""
50
51	Inputs:
52
53	type: "power" ->> Potencia
54	"iq" ->> Real + Imaginario
55	"""
56
57	self.__isPlotConfig = False	24	self.__isPlotConfig = False
58
59	self.__isPlotIni = False	25	self.__isPlotIni = False
60
61	self.__xrange = None	26	self.__xrange = None
62
63	self.__yrange = None	27	self.__yrange = None
64
65	self.nGraphs = 0	28	self.nGraphs = 0
66
67	self.indexPlot = index	29	self.indexPlot = index
68
69	self.graphObjList = []
70
71	self.spectraObj = Spectra	30	self.spectraObj = Spectra
72		31
		32	def setup(self,indexPlot,nsubplot,winTitle='',colormap="br_green",showColorbar=False,showPowerProfile=False,XAxisAsTime=False):
		33	self.colorplotObj = SpectraPlot(indexPlot,nsubplot,winTitle,colormap,showColorbar,showPowerProfile,XAxisAsTime)
		34
		35	def initPlot(self,xmin,xmax,ymin,ymax,zmin,zmax,titleList,xlabelList,ylabelList):
		36	nsubplot = self.spectraObj.nChannels
		37
		38	for index in range(nsubplot):
		39	title = titleList[index]
		40	xlabel = xlabelList[index]
		41	ylabel = ylabelList[index]
		42	subplot = index
		43	self.colorplotObj.setup(subplot+1,xmin,xmax,ymin,ymax,zmin,zmax,title,xlabel,ylabel)
		44
		45
		46	def plotData(self,
		47	xmin=None,
		48	xmax=None,
		49	ymin=None,
		50	ymax=None,
		51	zmin=None,
		52	zmax=None,
		53	titleList=None,
		54	xlabelList=None,
		55	ylabelList=None,
		56	winTitle='',
		57	colormap = "br_green",
		58	showColorbar = True,
		59	showPowerProfile = True,
		60	XAxisAsTime = False):
		61
		62	databuffer = 10.*numpy.log10(self.spectraObj.data_spc)
		63	noise = 10.*numpy.log10(self.spectraObj.noise)
73		64
74	def __addGraph(self, subpage, title="", xlabel="", ylabel="", showColorbar=False, showPowerProfile=True, XAxisAsTime=False):	65	nsubplot = self.spectraObj.nChannels
75		66	nsubplot, nX, nY = numpy.shape(databuffer)
76	graphObj = ColorPlot()
77	graphObj.setup(subpage,
78	title,
79	xlabel,
80	ylabel,
81	showColorbar=showColorbar,
82	showPowerProfile=showPowerProfile,
83	XAxisAsTime=XAxisAsTime)
84
85	self.graphObjList.append(graphObj)
86
87
88	def setup(self, titleList=None, xlabelList=None, ylabelList=None, showColorbar=False, showPowerProfile=True, XAxisAsTime=False):
89
90	nChan = int(self.spectraObj.m_SystemHeader.numChannels)
91	channels = range(nChan)
92
93	myXlabel = "Radial Velocity (m/s)"
94	myYlabel = "Range (km)"
95
96	for i in channels:
97	if titleList != None:
98	myTitle = titleList[i]
99	myXlabel = xlabelList[i]
100	myYlabel = ylabelList[i]
101
102	# if self.spectraObj.m_NoiseObj != None:
103	# noise = '%4.2fdB' %(self.spectraObj.m_NoiseObj[i])
104	# else:
105	noise = '--'
106		67
107	myTitle = "Channel: %d - Noise: %s" %(i, noise)	68	x = numpy.arange(nX)
		69	y = self.spectraObj.heightList
108		70
109	self.__addGraph(i+1,	71	indexPlot = self.indexPlot
110	title=myTitle,
111	xlabel=myXlabel,
112	ylabel=myYlabel,
113	showColorbar=showColorbar,
114	showPowerProfile=showPowerProfile,
115	XAxisAsTime=XAxisAsTime)
116		72
117	self.nGraphs = nChan	73	if not(self.__isPlotConfig):
		74	self.setup(indexPlot,nsubplot,winTitle,colormap,showColorbar,showPowerProfile,XAxisAsTime)
118	self.__isPlotConfig = True	75	self.__isPlotConfig = True
119		76
120	def iniPlot(self, winTitle=""):	77	if not(self.__isPlotIni):
		78	if titleList == None:
		79	titleList = []
		80	for i in range(nsubplot):
		81	titleList.append("Channel: %d - Noise: %.2f" %(i, noise[i]))
121		82
122	nx = int(numpy.sqrt(self.nGraphs)+1)	83	if xlabelList == None:
123	#ny = int(self.nGraphs/nx)	84	xlabelList = []
		85	for i in range(nsubplot):
		86	xlabelList.append("")
124		87
125	plplot.plsstrm(self.indexPlot)	88	if ylabelList == None:
126	plplot.plparseopts([winTitle], plplot.PL_PARSE_FULL)	89	ylabelList = []
127	plplot.plsetopt("geometry", "%dx%d" %(300nx, 240nx))	90	for i in range(nsubplot):
128	plplot.plsdev("xwin")	91	ylabelList.append("Range (Km)")
129	plplot.plscolbg(255,255,255)
130	plplot.plscol0(1,0,0,0)
131	plplot.plinit()
132	plplot.plspause(False)
133	plplot.pladv(0)
134	plplot.plssub(nx, nx)
135		92
136	self.__nx = nx	93	if xmin == None: xmin = x[0]
137	self.__ny = nx	94	if xmax == None: xmax = x[-1]
138	self.__isPlotIni = True	95	if ymin == None: ymin = y[0]
		96	if ymax == None: ymax = y[-1]
		97	if zmin == None: zmin = 0
		98	if zmax == None: zmax = 120
139		99
		100	self.initPlot(xmin,xmax,ymin,ymax,zmin,zmax,titleList,xlabelList,ylabelList)
		101	self.__isPlotIni = True
140		102
141	def plotData(self, xmin=None, xmax=None, ymin=None, ymax=None, zmin=None, zmax=None, titleList=None, xlabelList=None, ylabelList=None, showColorbar=False, showPowerProfile=True, XAxisAsTime=False, winTitle="Spectra"):	103	self.colorplotObj.setFigure(indexPlot)
142		104
143	if not(self.__isPlotConfig):	105	thisDatetime = datetime.datetime.fromtimestamp(self.spectraObj.m_BasicHeader.utc)
144	self.setup(titleList,	106	pltitle = "Self Spectra - Date: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
145	xlabelList,
146	ylabelList,
147	showColorbar,
148	showPowerProfile,
149	XAxisAsTime)
150		107
151	if not(self.__isPlotIni):	108	self.colorplotObj.printTitle(pltitle) #setPlTitle(pltitle)
152	self.iniPlot(winTitle)
153		109
154	plplot.plsstrm(self.indexPlot)	110	for index in range(nsubplot):
		111	data = databuffer[index,:,:]
		112	subtitle = "Channel: %d - Noise: %.2f" %(index, noise[index])
		113	self.colorplotObj.plot(index+1,x,y,data,subtitle)
155		114
156	data = 10.*numpy.log10(self.spectraObj.data_spc)
157	noise = 10.*numpy.log10(self.spectraObj.noise)
158	#data.shape = Channels x Heights x Profiles
159	# data = numpy.transpose( data, (0,2,1) )
160	#data.shape = Channels x Profiles x Heights
161		115
162	nChan, nX, nY = numpy.shape(data)
163		116
164	x = numpy.arange(nX)	117	self.colorplotObj.refresh()
165	y = self.spectraObj.heightList
166		118
167	thisDatetime = datetime.datetime.fromtimestamp(self.spectraObj.m_BasicHeader.utc)
168	txtDate = "Self Spectra - Date: %s" %(thisDatetime.strftime("%d-%b-%Y %H:%M:%S"))
169		119
170	if xmin == None: xmin = x[0]
171	if xmax == None: xmax = x[-1]
172	if ymin == None: ymin = y[0]
173	if ymax == None: ymax = y[-1]
174	if zmin == None: zmin = numpy.nanmin(abs(data))
175	if zmax == None: zmax = numpy.nanmax(abs(data))
176
177	plplot.plbop()
178
179	plplot.plssub(self.__nx, self.__ny)
180	for i in range(self.nGraphs):
181	self.graphObjList[i].plotData(data[i,:,:],
182	x,
183	y,
184	xmin=xmin,
185	xmax=xmax,
186	ymin=ymin,
187	ymax=ymax,
188	zmin=zmin,
189	zmax=zmax,
190	title = "Channel: %d - Noise: %.2f" %(i, noise[i]))
191
192	plplot.plssub(1,0)
193	plplot.pladv(0)
194	plplot.plvpor(0., 1., 0., 1.)
195	plplot.plmtex("t",-1., 0.5, 0.5, txtDate)
196	plplot.plflush()
197	plplot.pleop()
198
199	def end(self):
200	plplot.plend()
201
202
203	if __name__ == '__main__':
204	pass No newline at end of file

schainpy/Graphics/VoltagePlot.py +144 -151

@@ -1,204 +1,197
1	'''	1	'''
2	Created on Feb 7, 2012	2	Created on Feb 7, 2012
3		3
4	@author $Author$	4	@author $Author$
5	@version $Id$	5	@version $Id$
6	'''	6	'''
7	import os, sys
8	import numpy	7	import numpy
9	import ~~plplot~~	8	import os
		9	import sys
10		10
11	path = os.path.split(os.getcwd())[0]	11	path = os.path.split(os.getcwd())[0]
12	sys.path.append(path)	12	sys.path.append(path)
13		13
14	from Graphics.BaseGraph import *	14	from Graphics.BaseGraph import *
15	from Model.Voltage import Voltage	15	from Model.Voltage import Voltage
16		16
17	class Osciloscope:	17	class Osciloscope:
		18	linearplotObj = None
18		19
19	voltageObj = Voltage()	20	def __init__(self, Voltage, index):
20
21	linearGraphObj = LinearPlot()
22
23	__isPlotConfig = False
24
25	__isPlotIni = False
26
27	__xrange = None
28
29	__yrange = None
30
31	voltageObj = Voltage()
32
33	nGraphs = 0
34
35	indexPlot = None
36
37	graphObjList = []
38	m_LinearPlot= LinearPlot()
39
40
41	m_Voltage= Voltage()
42
43
44
45	def __init__(self, Voltage, index=0):
46
47	"""
48
49	Inputs:
50
51	type: "power" ->> Potencia
52	"iq" ->> Real + Imaginario
53	"""
54
55	self.__isPlotConfig = False	21	self.__isPlotConfig = False
56
57	self.__isPlotIni = False	22	self.__isPlotIni = False
58
59	self.__xrange = None	23	self.__xrange = None
60
61	self.__yrange = None	24	self.__yrange = None
62
63	self.voltageObj = None
64
65	self.nGraphs = 0
66
67	self.indexPlot = index	25	self.indexPlot = index
68
69	self.graphObjList = []
70
71	self.voltageObj = Voltage	26	self.voltageObj = Voltage
72		27
		28	def setup(self,indexPlot,nsubplot,winTitle=''):
		29	self.linearplotObj = LinearPlot(indexPlot,nsubplot,winTitle)
73		30
74	def __addGraph(self, subpage, title="", xlabel="", ylabel="", XAxisAsTime=False):	31	def initPlot(self,xmin,xmax,ymin,ymax,titleList,xlabelList,ylabelList):
75		32	nsubplot = self.voltageObj.nChannels
76	graphObj = LinearPlot()
77	graphObj.setup(subpage, title="", xlabel="", ylabel="", XAxisAsTime=False)
78	#graphObj.setScreenPos()
79
80	self.graphObjList.append(graphObj)
81
82	del graphObj
83		33
84	# def setXRange(self, xmin, xmax):	34	for index in range(nsubplot):
85	# self.__xrange = (xmin, xmax)	35	title = titleList[index]
86	#	36	xlabel = xlabelList[index]
87	# def setYRange(self, ymin, ymax):	37	ylabel = ylabelList[index]
88	# self.__yrange = (ymin, ymax)	38	subplot = index
		39	self.linearplotObj.setup(subplot+1,xmin,xmax,ymin,ymax,title,xlabel,ylabel)
89		40
		41	def plotData(self,
		42	xmin=None,
		43	xmax=None,
		44	ymin=None,
		45	ymax=None,
		46	titleList=None,
		47	xlabelList=None,
		48	ylabelList=None,
		49	winTitle='',
		50	type="power"):
90		51
91	def setup(self, titleList=None, xlabelList=None, ylabelList=None, XAxisAsTime=False):	52	databuffer = self.voltageObj.data
92		53
93	nChan = int(self.voltageObj.m_SystemHeader.numChannels)	54	height = self.voltageObj.heightList
		55	nsubplot = self.voltageObj.nChannels
		56	indexPlot = self.indexPlot
94		57
95	myTitle = ""
96	myXlabel = ""
97	myYlabel = ""
98
99	for chan in range(nChan):
100	if titleList != None:
101	myTitle = titleList[chan]
102	myXlabel = xlabelList[chan]
103	myYlabel = ylabelList[chan]
104
105	self.__addGraph(chan+1, title=myTitle, xlabel=myXlabel, ylabel=myYlabel, XAxisAsTime=XAxisAsTime)
106
107	self.nGraphs = nChan
108	self.__isPlotConfig = True
109
110	def iniPlot(self, winTitle=""):
111
112	plplot.plsstrm(self.indexPlot)
113	plplot.plparseopts([winTitle], plplot.PL_PARSE_FULL)
114	plplot.plsetopt("geometry", "%dx%d" %(700, 115*self.nGraphs))
115	plplot.plsdev("xwin")
116	plplot.plscolbg(255,255,255)
117	plplot.plscol0(1,0,0,0)
118	plplot.plinit()
119	plplot.plspause(False)
120	plplot.plssub(1, self.nGraphs)
121
122	self.__isPlotIni = True
123
124	def plotData(self, xmin=None, xmax=None, ymin=None, ymax=None, titleList=None, xlabelList=None, ylabelList=None, XAxisAsTime=False, type='iq', winTitle="Voltage"):
125		58
126	if not(self.__isPlotConfig):	59	if not(self.__isPlotConfig):
127	self.setup(titleList, xlabelList, ylabelList, XAxisAsTime)	60	self.setup(indexPlot,nsubplot,winTitle)
		61	self.__isPlotConfig = True
128		62
129	if not(self.__isPlotIni):	63	if not(self.__isPlotIni):
130	self.iniPlot(winTitle)	64	if titleList == None:
		65	titleList = []
		66	thisDatetime = datetime.datetime.fromtimestamp(self.voltageObj.m_BasicHeader.utc)
		67	txtdate = "Date: %s" %(thisDatetime.strftime("%d-%b-%Y"))
		68	for i in range(nsubplot):
		69	titleList.append("Channel: %d %s" %(i, txtdate))
		70
		71	if xlabelList == None:
		72	xlabelList = []
		73	for i in range(nsubplot):
		74	xlabelList.append("")
		75
		76	if ylabelList == None:
		77	ylabelList = []
		78	for i in range(nsubplot):
		79	ylabelList.append("")
		80
		81	if xmin == None: xmin = height[0]
		82	if xmax == None: xmax = height[-1]
		83	if ymin == None: ymin = numpy.nanmin(abs(databuffer))
		84	if ymax == None: ymax = numpy.nanmax(abs(databuffer))
		85
		86	self.initPlot(xmin,xmax,ymin,ymax,titleList,xlabelList,ylabelList)
		87	self.__isPlotIni = True
131		88
132	plplot.plsstrm(self.indexPlot)	89	self.linearplotObj.setFigure(indexPlot)
133		90
134	data = self.voltageObj.data	91	for index in range(nsubplot):
		92	data = databuffer[index,:]
		93	self.linearplotObj.plot(subplot=index+1,x=height,y=data,type=type)
135		94
136	x = self.voltageObj.heightList	95	self.linearplotObj.refresh()
137		96
138	if xmin == None: xmin = x[0]
139	if xmax == None: xmax = x[-1]
140	if ymin == None: ymin = numpy.nanmin(abs(data))
141	if ymax == None: ymax = numpy.nanmax(abs(data))
142		97
143	plplot.plbop()
144	for chan in range(self.nGraphs):
145	y = data[chan,:]
146		98
147	self.graphObjList[chan].plotComplexData(x, y, xmin, xmax, ymin, ymax, 8, type)
148		99
149	plplot.plflush()
150	plplot.pleop()
151		100
152	def end(self):
153	plplot.plend()
154		101
155	class VoltagePlot(object):
156	'''
157	classdocs
158	'''
159		102
160	__m_Voltage = None
161		103
162	def __init__(self, voltageObj):	104	class RTI:
163	'''	105	colorplotObj = None
164	Constructor
165	'''
166	self.__m_Voltage = voltageObj
167		106
168	def setup(self):	107	def __init__(self, Voltage, index):
169	pass	108	self.__isPlotConfig = False
170		109	self.__isPlotIni = False
171	def addGraph(self, type, xrange=None, yrange=None, zrange=None):	110	self.__xrange = None
172	pass	111	self.__yrange = None
173		112	self.indexPlot = index
174	def plotData(self):	113	self.voltageObj = Voltage
175	pass
176
177	if __name__ == '__main__':
178		114
179	import numpy	115	def setup(self,indexPlot,nsubplot,winTitle='',colormap="br_green",showColorbar=False,showPowerProfile=False,XAxisAsTime=False):
		116	self.colorplotObj = RtiPlot(indexPlot,nsubplot,winTitle,colormap,showColorbar,showPowerProfile,XAxisAsTime)
		117
		118	def initPlot(self,xmin,xmax,ymin,ymax,zmin,zmax,titleList,xlabelList,ylabelList,timezone,npoints):
		119
		120	nsubplot = self.voltageObj.nChannels
		121	timedata = self.voltageObj.m_BasicHeader.utc
		122
		123	for index in range(nsubplot):
		124	title = titleList[index]
		125	xlabel = xlabelList[index]
		126	ylabel = ylabelList[index]
		127	subplot = index
		128	self.colorplotObj.setup(subplot+1,xmin,xmax,ymin,ymax,zmin,zmax,title,xlabel,ylabel,timedata,timezone,npoints)
		129
		130	def plotData(self,
		131	xmin=None,
		132	xmax=None,
		133	ymin=None,
		134	ymax=None,
		135	zmin=None,
		136	zmax=None,
		137	titleList=None,
		138	xlabelList=None,
		139	ylabelList=None,
		140	winTitle='',
		141	timezone='lt',
		142	npoints=1000.0,
		143	colormap="br_green",
		144	showColorbar=True,
		145	showPowerProfile=True,
		146	XAxisAsTime=True):
		147
		148	databuffer = self.voltageObj.data
		149	timedata = self.voltageObj.m_BasicHeader.utc
		150	height = self.voltageObj.heightList
		151	nsubplot = self.voltageObj.nChannels
		152	indexPlot = self.indexPlot
180		153
181	plplot.plsetopt("geometry", "%dx%d" %(4502, 2002))	154	if not(self.__isPlotConfig):
182	plplot.plsdev("xcairo")	155	self.setup(indexPlot,nsubplot,winTitle,colormap,showColorbar,showPowerProfile,XAxisAsTime)
183	plplot.plscolbg(255,255,255)	156	self.__isPlotConfig = True
184	plplot.plscol0(1,0,0,0)
185	plplot.plinit()
186	plplot.plssub(1, 2)
187		157
188	nx = 64	158	if not(self.__isPlotIni):
189	ny = 100	159	if titleList == None:
		160	titleList = []
		161	thisDatetime = datetime.datetime.fromtimestamp(timedata)
		162	txtdate = "Date: %s" %(thisDatetime.strftime("%d-%b-%Y"))
		163	for i in range(nsubplot):
		164	titleList.append("Channel: %d %s" %(i, txtdate))
		165
		166	if xlabelList == None:
		167	xlabelList = []
		168	for i in range(nsubplot):
		169	xlabelList.append("")
		170
		171	if ylabelList == None:
		172	ylabelList = []
		173	for i in range(nsubplot):
		174	ylabelList.append("")
		175
		176	if xmin == None: xmin = 0
		177	if xmax == None: xmax = 23
		178	if ymin == None: ymin = min(self.voltageObj.heightList)
		179	if ymax == None: ymax = max(self.voltageObj.heightList)
		180	if zmin == None: zmin = 0
		181	if zmax == None: zmax = 50
		182
		183
		184	self.initPlot(xmin,xmax,ymin,ymax,zmin,zmax,titleList,xlabelList,ylabelList,timezone,npoints)
		185	self.__isPlotIni = True
190		186
191	data = numpy.random.uniform(-50,50,(nx,ny))
192		187
193	baseObj = RTI()	188	self.colorplotObj.setFigure(indexPlot)
194	baseObj.setup(1, "Spectrum", "Frequency", "Range", "br_green", False, False)
195	baseObj.plotData(data)
196		189
197	data = numpy.random.uniform(-50,50,(nx,ny))	190	if timezone == 'lt':
		191	timedata = timedata - time.timezone
198		192
199	base2Obj = RTI()	193	for index in range(nsubplot):
200	base2Obj.setup(2, "Spectrum", "Frequency", "Range", "br_green", True, True)	194	data = databuffer[index,:]
201	base2Obj.plotData(data)	195	self.colorplotObj.plot(subplot=index+1,x=timedata,y=height,z=data)
202		196
203	plplot.plend()	197	self.colorplotObj.refresh()
204	exit(0) No newline at end of file

schainpy/Processing/SpectraProcessor.py +33 -6

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.Spectra import Spectra
             from IO.SpectraIO import SpectraWriter
             from Graphics.SpectraPlot import Spectrum
             from JRONoise import Noise
             class SpectraProcessor:
                 '''
                 classdocs
                 '''
                 dataInObj = None
                 dataOutObj = None
                 noiseObj = None
                 integratorObjList = []
                 decoderObjList = []
                 writerObjList = []
                 plotterObjList = []
                 integratorObjIndex = None
                 decoderObjIndex = None
                 writerObjIndex = None
                 plotterObjIndex = None
                 buffer = None
                 profIndex = 0
                 nFFTPoints = None
                 nChannels = None
                 nHeights = None
                 nPairs = None
                 pairList = None
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.integratorObjIndex = None
                     self.decoderObjIndex = None
                     self.writerObjIndex = None
                     self.plotterObjIndex = None
                     self.integratorObjList = []
                     self.decoderObjList = []
                     self.writerObjList = []
                     self.plotterObjList = []
                     self.noiseObj = Noise()
                     self.buffer = None
                     self.profIndex = 0
                 def setup(self, dataInObj=None, dataOutObj=None, nFFTPoints=None, pairList=None):
                     if dataInObj == None:
                         raise ValueError, ""
                     if nFFTPoints == None:
                         raise ValueError, ""
                     self.dataInObj = dataInObj
                     if dataOutObj == None:
                         dataOutObj = Spectra()
                     self.dataOutObj = dataOutObj
                     self.noiseObj = Noise()
                     ##########################################
                     self.nFFTPoints = nFFTPoints
                     self.nChannels = self.dataInObj.nChannels
                     self.nHeights = self.dataInObj.nHeights
                     self.pairList = pairList
                     if pairList != None:
                         self.nPairs = len(pairList)
                     else:
                         self.nPairs = 0
                     self.dataOutObj.heightList = self.dataInObj.heightList
                     self.dataOutObj.channelIndexList = self.dataInObj.channelIndexList
                     self.dataOutObj.m_BasicHeader = self.dataInObj.m_BasicHeader.copy()
                     self.dataOutObj.m_ProcessingHeader = self.dataInObj.m_ProcessingHeader.copy()
                     self.dataOutObj.m_RadarControllerHeader = self.dataInObj.m_RadarControllerHeader.copy()
                     self.dataOutObj.m_SystemHeader = self.dataInObj.m_SystemHeader.copy()
                     self.dataOutObj.dataType = self.dataInObj.dataType
                     self.dataOutObj.nPairs = self.nPairs
                     self.dataOutObj.nChannels = self.nChannels
                     self.dataOutObj.nProfiles = self.nFFTPoints
                     self.dataOutObj.nHeights = self.nHeights
                     self.dataOutObj.nFFTPoints = self.nFFTPoints
                     #self.dataOutObj.data = None
                     self.dataOutObj.m_SystemHeader.numChannels = self.nChannels
                     self.dataOutObj.m_SystemHeader.nProfiles = self.nFFTPoints
                     self.dataOutObj.m_ProcessingHeader.totalSpectra = self.nChannels + self.nPairs
                     self.dataOutObj.m_ProcessingHeader.profilesPerBlock = self.nFFTPoints
                     self.dataOutObj.m_ProcessingHeader.numHeights = self.nHeights
                     self.dataOutObj.m_ProcessingHeader.shif_fft = True
                     spectraComb = numpy.zeros( (self.nChannels+self.nPairs)*2,numpy.dtype('u1'))
                     k = 0
                     for i in range( 0,self.nChannels*2,2 ):
                         spectraComb[i]   = k
                         spectraComb[i+1] = k
                         k += 1
                     k *= 2
                     if self.pairList != None:
                         for pair in self.pairList:
                             spectraComb[k]   = pair[0]
                             spectraComb[k+1] = pair[1]
                             k += 2
                     self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
                     return self.dataOutObj
                 def init(self):
                     self.integratorObjIndex = 0
                     self.decoderObjIndex = 0
                     self.writerObjIndex = 0
                     self.plotterObjIndex = 0
                     if self.dataInObj.type == "Voltage":
                         if self.buffer == None:
                             self.buffer = numpy.zeros((self.nChannels,
                                                        self.nFFTPoints,
                                                        self.nHeights),
                                                       dtype='complex')
                         self.buffer[:,self.profIndex,:] = self.dataInObj.data
                         self.profIndex += 1
                         if self.profIndex == self.nFFTPoints:
                             self.__getFft()
                             self.dataOutObj.flagNoData = False
                             self.buffer = None
                             self.profIndex = 0
                             return
                         self.dataOutObj.flagNoData = True
                         return
                     #Other kind of data
                     if self.dataInObj.type == "Spectra":
                         self.dataOutObj.copy(self.dataInObj)
                         self.dataOutObj.flagNoData = False
                         return
                     raise ValueError, "The datatype is not valid"
                 def __getFft(self):
                     """
                     Convierte valores de Voltaje a Spectra
                     Affected:
                         self.dataOutObj.data_spc
                         self.dataOutObj.data_cspc
                         self.dataOutObj.data_dc
                         self.dataOutObj.heightList
                         self.dataOutObj.m_BasicHeader
                         self.dataOutObj.m_ProcessingHeader
                         self.dataOutObj.m_RadarControllerHeader
                         self.dataOutObj.m_SystemHeader
                         self.profIndex
                         self.buffer
                         self.dataOutObj.flagNoData
                         self.dataOutObj.dataType
                         self.dataOutObj.nPairs
                         self.dataOutObj.nChannels
                         self.dataOutObj.nProfiles
                         self.dataOutObj.m_SystemHeader.numChannels
                         self.dataOutObj.m_ProcessingHeader.totalSpectra
                         self.dataOutObj.m_ProcessingHeader.profilesPerBlock
                         self.dataOutObj.m_ProcessingHeader.numHeights
                         self.dataOutObj.m_ProcessingHeader.spectraComb
                         self.dataOutObj.m_ProcessingHeader.shif_fft
                     """
                     if self.dataInObj.flagNoData:
                         return 0
                     fft_volt = numpy.fft.fft(self.buffer,axis=1)
                     dc = fft_volt[:,0,:]
                     #calculo de self-spectra
                     fft_volt = numpy.fft.fftshift(fft_volt,axes=(1,))
                     spc = numpy.abs(fft_volt * numpy.conjugate(fft_volt))
                     blocksize = 0
                     blocksize += dc.size
                     blocksize += spc.size
                     cspc = None
                     pairIndex = 0
                     if self.pairList != None:
                         #calculo de cross-spectra
                         cspc = numpy.zeros((self.nPairs, self.nFFTPoints, self.nHeights), dtype='complex')
                         for pair in self.pairList:
                             cspc[pairIndex,:,:] = numpy.abs(fft_volt[pair[0],:,:] * numpy.conjugate(fft_volt[pair[1],:,:]))
                             pairIndex += 1
                         blocksize += cspc.size
                     self.dataOutObj.data_spc = spc
                     self.dataOutObj.data_cspc = cspc
                     self.dataOutObj.data_dc = dc
                     self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
+                    self.dataOutObj.m_BasicHeader.utc = self.dataInObj.m_BasicHeader.utc
                 def addWriter(self,wrpath):
                     objWriter = SpectraWriter(self.dataOutObj)
                     objWriter.setup(wrpath)
                     self.writerObjList.append(objWriter)
                 def addPlotter(self,index=None):
                     if index==None:
                         index = self.plotterObjIndex
                     plotObj = Spectrum(self.dataOutObj, index)
                     self.plotterObjList.append(plotObj)
                 def addIntegrator(self,N,timeInterval):
                     objIncohInt = IncoherentIntegration(N,timeInterval)
                     self.integratorObjList.append(objIncohInt)
                 def writeData(self, wrpath):
                     if self.dataOutObj.flagNoData:
                             return 0
                     if len(self.writerObjList) <= self.writerObjIndex:
                         self.addWriter(wrpath)
                     self.writerObjList[self.writerObjIndex].putData()
                     self.writerObjIndex += 1
-                def plotData(self,xmin=None, xmax=None, ymin=None, ymax=None, winTitle='', index=None):
+                def plotData(self,
+                             xmin=None,
+                             xmax=None,
+                             ymin=None,
+                             ymax=None,
+                             zmin=None,
+                             zmax=None,
+                             titleList=None,
+                             xlabelList=None,
+                             ylabelList=None,
+                             winTitle='',
+                             colormap="br_green",
+                             showColorbar=False,
+                             showPowerProfile=False,
+                             XAxisAsTime=False,
+                             index=None):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if len(self.plotterObjList) <= self.plotterObjIndex:
                         self.addPlotter(index)
-                    self.plotterObjList[self.plotterObjIndex].plotData(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,winTitle=winTitle)
+                    self.plotterObjList[self.plotterObjIndex].plotData(xmin,
+                                                                       xmax,
+                                                                       ymin,
+                                                                       ymax,
+                                                                       zmin,
+                                                                       zmax,
+                                                                       titleList,
+                                                                       xlabelList,
+                                                                       ylabelList,
+                                                                       winTitle,
+                                                                       colormap,
+                                                                       showColorbar,
+                                                                       showPowerProfile,
+                                                                       XAxisAsTime)
                     self.plotterObjIndex += 1
                 def integrator(self, N=None, timeInterval=None):
                     if self.dataOutObj.flagNoData:
                             return 0
                     if len(self.integratorObjList) <= self.integratorObjIndex:
                         self.addIntegrator(N,timeInterval)
                     myIncohIntObj = self.integratorObjList[self.integratorObjIndex]
                     myIncohIntObj.exe(data=self.dataOutObj.data_spc,timeOfData=self.dataOutObj.m_BasicHeader.utc)
                     if myIncohIntObj.isReady:
                         self.dataOutObj.data_spc = myIncohIntObj.data
                         self.dataOutObj.nAvg = myIncohIntObj.navg
                         self.dataOutObj.m_ProcessingHeader.incoherentInt *= myIncohIntObj.navg
                         #print "myIncohIntObj.navg: ",myIncohIntObj.navg
                         self.dataOutObj.flagNoData = False
                         self.getNoise(type="hildebrand",parm=myIncohIntObj.navg)
             #            self.getNoise(type="sort", parm=16)
                     else:
                         self.dataOutObj.flagNoData = True
                     self.integratorObjIndex += 1
                     """Calcular el ruido"""
             #        self.getNoise(type="hildebrand", parm=1)
                 def removeDC(self, type):
                     if self.dataOutObj.flagNoData:
                         return 0
                 def removeInterference(self):
                     if self.dataOutObj.flagNoData:
                         return 0
                 def removeSatellites(self):
                     if self.dataOutObj.flagNoData:
                         return 0
                 def getNoise(self, type="hildebrand", parm=None):
                     self.noiseObj.setNoise(self.dataOutObj.data_spc)
                     if type == "hildebrand":
                         noise = self.noiseObj.byHildebrand(parm)
                     if type == "window":
                         noise = self.noiseObj.byWindow(parm)
                     if type == "sort":
                         noise = self.noiseObj.bySort(parm)
                     self.dataOutObj.noise = noise
-                    print 10*numpy.log10(noise)
+            #        print 10*numpy.log10(noise)
                 def selectChannels(self, channelList, pairList=[]):
                     channelIndexList = []
                     for channel in channelList:
                         if channel in self.dataOutObj.channelList:
                             index = self.dataOutObj.channelList.index(channel)
                             channelIndexList.append(index)
                     pairIndexList = []
                     for pair in pairList:
                         if pair in self.dataOutObj.pairList:
                             index = self.dataOutObj.pairList.index(pair)
                             pairIndexList.append(index)
                     self.selectChannelsByIndex(channelIndexList, pairIndexList)
                 def selectChannelsByIndex(self, channelIndexList, pairIndexList=[]):
                     """
                     Selecciona un bloque de datos en base a canales y pares segun el
                     channelIndexList y el pairIndexList
                     Input:
                         channelIndexList :    lista de indices de los canales a seleccionar por ej.
                                                  Si tenemos los canales
                                                          self.channelList = (2,3,5,7)
                                                 y deseamos escoger los canales (3,7)
                                                 entonces colocaremos el parametro
                                                         channelndexList = (1,3)
                         pairIndexList   :    tupla de indice depares que se desea selecionar por ej.
                                                 Si tenemos los pares :
                                                         ( (0,1), (0,2), (1,3), (2,5) )
                                                 y deseamos seleccionar los pares ((0,2), (2,5))
                                                 entonces colocaremos el parametro
                                                         pairIndexList = (1,3)
                     Affected:
                         self.dataOutObj.data_spc
                         self.dataOutObj.data_cspc
                         self.dataOutObj.data_dc
                         self.dataOutObj.nChannels
                         self.dataOutObj.nPairs
                         self.dataOutObj.m_ProcessingHeader.spectraComb
                         self.dataOutObj.m_SystemHeader.numChannels
                         self.dataOutObj.noise
                     Return:
                         None
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     if pairIndexList == []:
                         pairIndexList = numpy.arange(len(self.dataOutObj.pairList))
                     nChannels = len(channelIndexList)
                     nPairs = len(pairIndexList)
                     blocksize = 0
                     #self spectra
                     spc = self.dataOutObj.data_spc[channelIndexList,:,:]
                     blocksize += spc.size
                     cspc = None
                     if pairIndexList != []:
                         cspc = self.dataOutObj.data_cspc[pairIndexList,:,:]
                         blocksize += cspc.size
                     #DC channel
                     dc = None
                     if self.dataOutObj.m_ProcessingHeader.flag_dc:
                         dc = self.dataOutObj.data_dc[channelIndexList,:]
                         blocksize += dc.size
                     #Almacenar las combinaciones de canales y cros espectros
                     spectraComb = numpy.zeros( (nChannels+nPairs)*2,numpy.dtype('u1'))
                     i = 0
                     for spcChannel in channelIndexList:
                         spectraComb[i]   = spcChannel
                         spectraComb[i+1] = spcChannel
                         i += 2
                     if pairList != None:
                         for pair in pairList:
                             spectraComb[i]   = pair[0]
                             spectraComb[i+1] = pair[1]
                             i += 2
                     #######
                     self.dataOutObj.data_spc = spc
                     self.dataOutObj.data_cspc = cspc
                     self.dataOutObj.data_dc = dc
                     self.dataOutObj.nChannels = nChannels
                     self.dataOutObj.nPairs = nPairs
                     self.dataOutObj.channelIndexList = channelIndexList
                     self.dataOutObj.m_ProcessingHeader.spectraComb = spectraComb
                     self.dataOutObj.m_ProcessingHeader.totalSpectra = nChannels + nPairs
                     self.dataOutObj.m_SystemHeader.numChannels = nChannels
                     self.dataOutObj.nChannels = nChannels
                     self.dataOutObj.m_ProcessingHeader.blockSize = blocksize
                     if cspc == None:
                         self.dataOutObj.m_ProcessingHeader.flag_dc = False
                     if dc == None:
                         self.dataOutObj.m_ProcessingHeader.flag_cpsc = False
                 def selectHeightsByValue(self, minHei, maxHei):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
                     minHei <= height <= maxHei
                     Input:
                         minHei    :    valor minimo de altura a considerar
                         maxHei    :    valor maximo de altura a considerar
                     Affected:
                         Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
                     Return:
                         None
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     if (minHei < self.dataOutObj.heightList[0]) or (minHei > maxHei):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                     if (maxHei > self.dataOutObj.heightList[-1]):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                     minIndex = 0
                     maxIndex = 0
                     data = self.dataOutObj.heightList
                     for i,val in enumerate(data):
                         if val < minHei:
                             continue
                         else:
                             minIndex = i;
                             break
                     for i,val in enumerate(data):
                         if val <= maxHei:
                             maxIndex = i;
                         else:
                             break
                     self.selectHeightsByIndex(minIndex, maxIndex)
                 def selectHeightsByIndex(self, minIndex, maxIndex):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                     minIndex <= index <= maxIndex
                     Input:
                         minIndex    :    valor minimo de altura a considerar
                         maxIndex    :    valor maximo de altura a considerar
                     Affected:
                         self.dataOutObj.data_spc
                         self.dataOutObj.data_cspc
                         self.dataOutObj.data_dc
                         self.dataOutObj.heightList
                         self.dataOutObj.nHeights
                         self.dataOutObj.m_ProcessingHeader.numHeights
                         self.dataOutObj.m_ProcessingHeader.blockSize
                         self.dataOutObj.m_ProcessingHeader.firstHeight
                         self.dataOutObj.m_RadarControllerHeader.numHeights
                     Return:
                         None
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                     if (maxIndex >= self.dataOutObj.nHeights):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                     nChannels = self.dataOutObj.nChannels
                     nPairs = self.dataOutObj.nPairs
                     nProfiles = self.dataOutObj.nProfiles
                     dataType = self.dataOutObj.dataType
                     nHeights = maxIndex - minIndex + 1
                     blockSize = 0
                     #self spectra
                     spc = self.dataOutObj.data_spc[:,:,minIndex:maxIndex+1]
                     blockSize += spc.size
                     #cross spectra
                     cspc = None
                     if self.dataOutObj.data_cspc != None:
                         cspc = self.dataOutObj.data_cspc[:,:,minIndex:maxIndex+1]
                         blockSize += cspc.size
                     #DC channel
                     dc = self.dataOutObj.data_dc[:,minIndex:maxIndex+1]
                     blockSize += dc.size
                     self.dataOutObj.data_spc = spc
                     if cspc != None:
                         self.dataOutObj.data_cspc = cspc
                     self.dataOutObj.data_dc = dc
                     firstHeight = self.dataOutObj.heightList[minIndex]
                     self.dataOutObj.nHeights = nHeights
                     self.dataOutObj.m_ProcessingHeader.blockSize = blockSize
                     self.dataOutObj.m_ProcessingHeader.numHeights = nHeights
                     self.dataOutObj.m_ProcessingHeader.firstHeight = firstHeight
                     self.dataOutObj.m_RadarControllerHeader.numHeights = nHeights
                     self.dataOutObj.heightList = self.dataOutObj.heightList[minIndex:maxIndex+1]
             class IncoherentIntegration:
                 integ_counter = None
                 data = None
                 navg = None
                 buffer = None
                 nIncohInt = None
                 def __init__(self, N = None, timeInterval = None):
                     """
                     N
                     timeInterval - interval time [min], integer value
                     """
                     self.data = None
                     self.navg = None
                     self.buffer = None
                     self.timeOut = None
                     self.exitCondition = False
                     self.isReady = False
                     self.nIncohInt = N
                     self.integ_counter = 0
                     if timeInterval!=None:
                         self.timeIntervalInSeconds = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
                     if ((timeInterval==None) and (N==None)):
                          print 'N = None ; timeInterval = None'
                          sys.exit(0)
                     elif timeInterval == None:
                         self.timeFlag = False
                     else:
                         self.timeFlag = True
                 def exe(self,data,timeOfData):
                     """
                     data
                     timeOfData [seconds]
                     """
                     if self.timeFlag:
                         if self.timeOut == None:
                             self.timeOut = timeOfData + self.timeIntervalInSeconds
                         if timeOfData < self.timeOut:
                             if self.buffer == None:
                                 self.buffer = data
                             else:
                                 self.buffer = self.buffer + data
                             self.integ_counter += 1
                         else:
                             self.exitCondition = True
                     else:
                         if self.integ_counter < self.nIncohInt:
                             if self.buffer == None:
                                 self.buffer = data
                             else:
                                 self.buffer = self.buffer + data
                             self.integ_counter += 1
                         if self.integ_counter == self.nIncohInt:
                             self.exitCondition = True
                     if self.exitCondition:
                         self.data = self.buffer
                         self.navg = self.integ_counter
                         self.isReady = True
                         self.buffer = None
                         self.timeOut = None
                         self.integ_counter = 0
                         self.exitCondition = False
                         if self.timeFlag:
                             self.buffer = data
                             self.timeOut = timeOfData + self.timeIntervalInSeconds
                     else:
                         self.isReady = False
   No newline at end of file

schainpy/Processing/VoltageProcessor.py +90 -3

             '''
             Created on Feb 7, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import numpy
             path = os.path.split(os.getcwd())[0]
             sys.path.append(path)
             from Model.Voltage import Voltage
             from IO.VoltageIO import VoltageWriter
             from Graphics.VoltagePlot import Osciloscope
+            from Graphics.VoltagePlot import RTI
             class VoltageProcessor:
                 '''
                 classdocs
                 '''
                 dataInObj = None
                 dataOutObj = None
                 integratorObjIndex = None
                 decoderObjIndex = None
                 profSelectorObjIndex = None
                 writerObjIndex = None
                 plotterObjIndex = None
                 flipIndex = None
                 integratorObjList = []
                 decoderObjList = []
                 profileSelectorObjList = []
                 writerObjList = []
                 plotterObjList = []
                 m_Voltage= Voltage()
                 def __init__(self):
                     '''
                     Constructor
                     '''
                     self.integratorObjIndex = None
                     self.decoderObjIndex = None
                     self.profSelectorObjIndex = None
                     self.writerObjIndex = None
                     self.plotterObjIndex = None
                     self.flipIndex = 1
                     self.integratorObjList = []
                     self.decoderObjList = []
                     self.profileSelectorObjList = []
                     self.writerObjList = []
                     self.plotterObjList = []
                 def setup(self, dataInObj=None, dataOutObj=None):
                     self.dataInObj = dataInObj
                     if dataOutObj == None:
                         dataOutObj = Voltage()
                     dataOutObj.copy(dataInObj)
                     self.dataOutObj = dataOutObj
                     return self.dataOutObj
                 def init(self):
                     self.integratorObjIndex = 0
                     self.decoderObjIndex = 0
                     self.profSelectorObjIndex = 0
                     self.writerObjIndex = 0
                     self.plotterObjIndex = 0
                     self.dataOutObj.copy(self.dataInObj)
                     if self.profSelectorObjIndex != None:
                         for profSelObj in self.profileSelectorObjList:
                             profSelObj.incIndex()
                 def addWriter(self, wrpath):
                     objWriter = VoltageWriter(self.dataOutObj)
                     objWriter.setup(wrpath)
                     self.writerObjList.append(objWriter)
+                def addRti(self,index=None):
+                    if index==None:
+                        index = self.plotterObjIndex
+                    plotObj = RTI(self.dataOutObj, index)
+                    self.plotterObjList.append(plotObj)
                 def addPlotter(self, index=None):
                     if index==None:
                         index = self.plotterObjIndex
                     plotObj = Osciloscope(self.dataOutObj, index)
                     self.plotterObjList.append(plotObj)
                 def addIntegrator(self, N,timeInterval):
                     objCohInt = CoherentIntegrator(N,timeInterval)
                     self.integratorObjList.append(objCohInt)
                 def addDecoder(self, code, ncode, nbaud):
                     objDecoder = Decoder(code,ncode,nbaud)
                     self.decoderObjList.append(objDecoder)
                 def addProfileSelector(self, nProfiles):
                     objProfSelector = ProfileSelector(nProfiles)
                     self.profileSelectorObjList.append(objProfSelector)
                 def writeData(self,wrpath):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if len(self.writerObjList) <= self.writerObjIndex:
                         self.addWriter(wrpath)
                     self.writerObjList[self.writerObjIndex].putData()
-            #        myWrObj = self.writerObjList[self.writerObjIndex]
-            #        myWrObj.putData()
                     self.writerObjIndex += 1
+                def addScope(self,index=None):
+                    if index==None:
+                        index = self.plotterObjIndex
+                    plotObj = Osciloscope(self.dataOutObj, index)
+                    self.plotterObjList.append(plotObj)
+                def plotScope(self,
+                            xmin=None,
+                            xmax=None,
+                            ymin=None,
+                            ymax=None,
+                            titleList=None,
+                            xlabelList=None,
+                            ylabelList=None,
+                            winTitle='',
+                            type="power",
+                            index=None):
+                    if self.dataOutObj.flagNoData:
+                        return 0
+                    if len(self.plotterObjList) <= self.plotterObjIndex:
+                        self.addScope(index)
+                    self.plotterObjList[self.plotterObjIndex].plotData(xmin,
+                                                                       xmax,
+                                                                       ymin,
+                                                                       ymax,
+                                                                       titleList,
+                                                                       xlabelList,
+                                                                       ylabelList,
+                                                                       winTitle,
+                                                                       type)
+                    self.plotterObjIndex += 1
+                def plotRti(self,
+                            xmin=None,
+                            xmax=None,
+                            ymin=None,
+                            ymax=None,
+                            zmin=None,
+                            zmax=None,
+                            titleList=None,
+                            xlabelList=None,
+                            ylabelList=None,
+                            winTitle='',
+                            timezone='lt',
+                            npoints=1000.0,
+                            colormap="br_green",
+                            showColorbar=True,
+                            showPowerProfile=False,
+                            XAxisAsTime=True,
+                            index=None):
+                    if self.dataOutObj.flagNoData:
+                        return 0
+                    if len(self.plotterObjList) <= self.plotterObjIndex:
+                        self.addRti(index)
+                    self.plotterObjList[self.plotterObjIndex].plotData(xmin,
+                                                                       xmax,
+                                                                       ymin,
+                                                                       ymax,
+                                                                       zmin,
+                                                                       zmax,
+                                                                       titleList,
+                                                                       xlabelList,
+                                                                       ylabelList,
+                                                                       winTitle,
+                                                                       timezone,
+                                                                       npoints,
+                                                                       colormap,
+                                                                       showColorbar,
+                                                                       showPowerProfile,
+                                                                       XAxisAsTime)
+                    self.plotterObjIndex += 1
                 def plotData(self,xmin=None, xmax=None, ymin=None, ymax=None, type='iq', winTitle='', index=None):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if len(self.plotterObjList) <= self.plotterObjIndex:
                         self.addPlotter(index)
                     self.plotterObjList[self.plotterObjIndex].plotData(xmin=xmin, xmax=xmax, ymin=ymin, ymax=ymax,type=type, winTitle=winTitle)
                     self.plotterObjIndex += 1
                 def integrator(self, N=None, timeInterval=None):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if len(self.integratorObjList) <= self.integratorObjIndex:
                         self.addIntegrator(N,timeInterval)
                     myCohIntObj = self.integratorObjList[self.integratorObjIndex]
                     myCohIntObj.exe(data=self.dataOutObj.data,timeOfData=self.dataOutObj.m_BasicHeader.utc)
                     if myCohIntObj.isReady:
                         self.dataOutObj.data = myCohIntObj.data
                         self.dataOutObj.nAvg = myCohIntObj.navg
                         self.dataOutObj.m_ProcessingHeader.coherentInt *= myCohIntObj.navg
                         #print "myCohIntObj.navg: ",myCohIntObj.navg
                         self.dataOutObj.flagNoData = False
                     else:
                         self.dataOutObj.flagNoData = True
                     self.integratorObjIndex += 1
                 def decoder(self,code=None,type = 0):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if code == None:
                         code = self.dataOutObj.m_RadarControllerHeader.code
                     ncode, nbaud = code.shape
                     if len(self.decoderObjList) <= self.decoderObjIndex:
                         self.addDecoder(code,ncode,nbaud)
                     myDecodObj = self.decoderObjList[self.decoderObjIndex]
                     myDecodObj.exe(data=self.dataOutObj.data,type=type)
                     if myDecodObj.flag:
                         self.dataOutObj.data = myDecodObj.data
                         self.dataOutObj.flagNoData = False
                     else:
                         self.dataOutObj.flagNoData = True
                     self.decoderObjIndex += 1
                 def filterByHei(self, window):
                     if window == None:
                         window = self.dataOutObj.m_RadarControllerHeader.txA / self.dataOutObj.m_ProcessingHeader.deltaHeight[0]
                     newdelta = self.dataOutObj.m_ProcessingHeader.deltaHeight[0] * window
                     dim1 = self.dataOutObj.data.shape[0]
                     dim2 = self.dataOutObj.data.shape[1]
                     r = dim2 % window
                     buffer = self.dataOutObj.data[:,0:dim2-r]
                     buffer = buffer.reshape(dim1,dim2/window,window)
                     buffer = numpy.sum(buffer,2)
                     self.dataOutObj.data = buffer
                     self.dataOutObj.m_ProcessingHeader.deltaHeight = newdelta
                     self.dataOutObj.m_ProcessingHeader.numHeights = buffer.shape[1]
                     self.dataOutObj.nHeights = self.dataOutObj.m_ProcessingHeader.numHeights
                     #self.dataOutObj.heightList es un numpy.array
                     self.dataOutObj.heightList = numpy.arange(self.dataOutObj.m_ProcessingHeader.firstHeight[0],newdelta*self.dataOutObj.nHeights,newdelta)
                 def deFlip(self):
                     self.dataOutObj.data *= self.flipIndex
                     self.flipIndex *= -1.
                 def selectChannels(self, channelList):
                     pass
                 def selectChannelsByIndex(self, channelIndexList):
                     """
                     Selecciona un bloque de datos en base a canales segun el channelIndexList
                     Input:
                         channelIndexList    :    lista sencilla de canales a seleccionar por ej. [2,3,7]
                     Affected:
                         self.dataOutObj.data
                         self.dataOutObj.channelIndexList
                         self.dataOutObj.nChannels
                         self.dataOutObj.m_ProcessingHeader.totalSpectra
                         self.dataOutObj.m_SystemHeader.numChannels
                         self.dataOutObj.m_ProcessingHeader.blockSize
                     Return:
                         None
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     for channel in channelIndexList:
                         if channel not in self.dataOutObj.channelIndexList:
                             raise ValueError, "The value %d in channelIndexList is not valid" %channel
                     nChannels = len(channelIndexList)
                     data = self.dataOutObj.data[channelIndexList,:]
                     self.dataOutObj.data = data
                     self.dataOutObj.channelIndexList = channelIndexList
                     self.dataOutObj.nChannels = nChannels
                     self.dataOutObj.m_ProcessingHeader.totalSpectra = 0
                     self.dataOutObj.m_SystemHeader.numChannels = nChannels
                     self.dataOutObj.m_ProcessingHeader.blockSize = data.size
                     return 1
                 def selectHeightsByValue(self, minHei, maxHei):
                     """
                     Selecciona un bloque de datos en base a un grupo de valores de alturas segun el rango
                     minHei <= height <= maxHei
                     Input:
                         minHei    :    valor minimo de altura a considerar
                         maxHei    :    valor maximo de altura a considerar
                     Affected:
                         Indirectamente son cambiados varios valores a travez del metodo selectHeightsByIndex
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     if (minHei < self.dataOutObj.heightList[0]) or (minHei > maxHei):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                     if (maxHei > self.dataOutObj.heightList[-1]):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minHei, maxHei)
                     minIndex = 0
                     maxIndex = 0
                     data = self.dataOutObj.heightList
                     for i,val in enumerate(data):
                         if val < minHei:
                             continue
                         else:
                             minIndex = i;
                             break
                     for i,val in enumerate(data):
                         if val <= maxHei:
                             maxIndex = i;
                         else:
                             break
                     self.selectHeightsByIndex(minIndex, maxIndex)
                     return 1
                 def selectHeightsByIndex(self, minIndex, maxIndex):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de alturas segun el rango
                     minIndex <= index <= maxIndex
                     Input:
                         minIndex    :    valor de indice minimo de altura a considerar
                         maxIndex    :    valor de indice maximo de altura a considerar
                     Affected:
                         self.dataOutObj.data
                         self.dataOutObj.heightList
                         self.dataOutObj.nHeights
                         self.dataOutObj.m_ProcessingHeader.blockSize
                         self.dataOutObj.m_ProcessingHeader.numHeights
                         self.dataOutObj.m_ProcessingHeader.firstHeight
                         self.dataOutObj.m_RadarControllerHeader
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     if (minIndex < 0) or (minIndex > maxIndex):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                     if (maxIndex >= self.dataOutObj.nHeights):
                         raise ValueError, "some value in (%d,%d) is not valid" % (minIndex, maxIndex)
                     nHeights = maxIndex - minIndex + 1
                     #voltage
                     data = self.dataOutObj.data[:,minIndex:maxIndex+1]
                     firstHeight = self.dataOutObj.heightList[minIndex]
                     self.dataOutObj.data = data
                     self.dataOutObj.heightList = self.dataOutObj.heightList[minIndex:maxIndex+1]
                     self.dataOutObj.nHeights = nHeights
                     self.dataOutObj.m_ProcessingHeader.blockSize = data.size
                     self.dataOutObj.m_ProcessingHeader.numHeights = nHeights
                     self.dataOutObj.m_ProcessingHeader.firstHeight = firstHeight
                     self.dataOutObj.m_RadarControllerHeader.numHeights = nHeights
                     return 1
                 def selectProfilesByValue(self,indexList, nProfiles):
                     if self.dataOutObj.flagNoData:
                         return 0
                     if self.profSelectorObjIndex >= len(self.profileSelectorObjList):
                         self.addProfileSelector(nProfiles)
                     profileSelectorObj = self.profileSelectorObjList[self.profSelectorObjIndex]
                     if not(profileSelectorObj.isProfileInList(indexList)):
                         self.dataOutObj.flagNoData = True
                         self.profSelectorObjIndex += 1
                         return 0
                     self.dataOutObj.flagNoData = False
                     self.profSelectorObjIndex += 1
                     return 1
                 def selectProfilesByIndex(self, minIndex, maxIndex, nProfiles):
                     """
                     Selecciona un bloque de datos en base a un grupo indices de perfiles segun el rango
                     minIndex <= index <= maxIndex
                     Input:
                         minIndex    :    valor de indice minimo de perfil a considerar
                         maxIndex    :    valor de indice maximo de perfil a considerar
                         nProfiles   :    numero de profiles
                     Affected:
                         self.dataOutObj.flagNoData
                         self.profSelectorObjIndex
                     Return:
 si el metodo se ejecuto con exito caso contrario devuelve 0
                     """
                     if self.dataOutObj.flagNoData:
                         return 0
                     if self.profSelectorObjIndex >= len(self.profileSelectorObjList):
                         self.addProfileSelector(nProfiles)
                     profileSelectorObj = self.profileSelectorObjList[self.profSelectorObjIndex]
                     if not(profileSelectorObj.isProfileInRange(minIndex, maxIndex)):
                         self.dataOutObj.flagNoData = True
                         self.profSelectorObjIndex += 1
                         return 0
                     self.dataOutObj.flagNoData = False
                     self.profSelectorObjIndex += 1
                     return 1
                 def selectNtxs(self, ntx):
                     pass
             class Decoder:
                 data = None
                 profCounter = 1
                 nCode = None
                 nBaud = None
                 codeIndex = 0
                 code = None
                 flag = False
                 def __init__(self,code, ncode, nbaud):
                     self.data = None
                     self.profCounter = 1
                     self.nCode = ncode
                     self.nBaud = nbaud
                     self.codeIndex = 0
                     self.code = code #this is a List
                     self.flag = False
                 def exe(self, data, ndata=None, type = 0):
                     if ndata == None: ndata = data.shape[1]
                     if type == 0:
                         self.convolutionInFreq(data,ndata)
                     if type == 1:
                         self.convolutionInTime(data, ndata)
                 def convolutionInFreq(self,data, ndata):
                     newcode = numpy.zeros(ndata)
                     newcode[0:self.nBaud] = self.code[self.codeIndex]
                     self.codeIndex += 1
                     fft_data = numpy.fft.fft(data, axis=1)
                     fft_code = numpy.conj(numpy.fft.fft(newcode))
                     fft_code = fft_code.reshape(1,len(fft_code))
                     conv = fft_data.copy()
                     conv.fill(0)
                     conv = fft_data*fft_code
                     self.data = numpy.fft.ifft(conv,axis=1)
                     self.flag = True
                     if self.profCounter == self.nCode:
                         self.profCounter = 0
                         self.codeIndex = 0
                     self.profCounter += 1
                 def convolutionInTime(self, data, ndata):
                     nchannel = data.shape[1]
                     newcode = self.code[self.codeIndex]
                     self.codeIndex += 1
                     conv = data.copy()
                     for i in range(nchannel):
                         conv[i,:] = numpy.correlate(data[i,:], newcode, 'same')
                     self.data = conv
                     self.flag = True
                     if self.profCounter == self.nCode:
                         self.profCounter = 0
                         self.codeIndex = 0
                     self.profCounter += 1
             class CoherentIntegrator:
                 integ_counter = None
                 data = None
                 navg = None
                 buffer = None
                 nCohInt = None
                 def __init__(self, N=None,timeInterval=None):
                     self.data = None
                     self.navg = None
                     self.buffer = None
                     self.timeOut = None
                     self.exitCondition = False
                     self.isReady = False
                     self.nCohInt = N
                     self.integ_counter = 0
                     if timeInterval!=None:
                         self.timeIntervalInSeconds = timeInterval * 60. #if (type(timeInterval)!=integer) -> change this line
                     if ((timeInterval==None) and (N==None)):
                          print 'N = None ; timeInterval = None'
                          sys.exit(0)
                     elif timeInterval == None:
                         self.timeFlag = False
                     else:
                         self.timeFlag = True
                 def exe(self, data, timeOfData):
                     if self.timeFlag:
                         if self.timeOut == None:
                             self.timeOut = timeOfData + self.timeIntervalInSeconds
                         if timeOfData < self.timeOut:
                             if self.buffer == None:
                                 self.buffer = data
                             else:
                                 self.buffer = self.buffer + data
                             self.integ_counter += 1
                         else:
                             self.exitCondition = True
                     else:
                         if self.integ_counter < self.nCohInt:
                             if self.buffer == None:
                                 self.buffer = data
                             else:
                                 self.buffer = self.buffer + data
                             self.integ_counter += 1
                         if self.integ_counter == self.nCohInt:
                             self.exitCondition = True
                     if self.exitCondition:
                         self.data = self.buffer
                         self.navg = self.integ_counter
                         self.isReady = True
                         self.buffer = None
                         self.timeOut = None
                         self.integ_counter = 0
                         self.exitCondition = False
                         if self.timeFlag:
                             self.buffer = data
                             self.timeOut = timeOfData + self.timeIntervalInSeconds
                     else:
                         self.isReady = False
             class ProfileSelector:
                 profileIndex = None
                 # Tamanho total de los perfiles
                 nProfiles = None
                 def __init__(self, nProfiles):
                     self.profileIndex = 0
                     self.nProfiles = nProfiles
                 def incIndex(self):
                     self.profileIndex += 1
                     if self.profileIndex >= self.nProfiles:
                         self.profileIndex = 0
                 def isProfileInRange(self, minIndex, maxIndex):
                     if self.profileIndex < minIndex:
                         return False
                     if self.profileIndex > maxIndex:
                         return False
                     return True
                 def isProfileInList(self, profileList):
                     if self.profileIndex not in profileList:
                         return False
                     return True
   No newline at end of file

schainpy/TestSVoltageChain.py +16 -32

             '''
-            Created on 27/03/2012
+            Created on Jul 31, 2012
             @author $Author$
             @version $Id$
             '''
             import os, sys
             import time, datetime
             from Model.Voltage import Voltage
             from IO.VoltageIO import *
-            #from Graphics.VoltagePlot import Osciloscope
             from Model.Spectra import Spectra
             from IO.SpectraIO import *
             from Processing.VoltageProcessor import *
             from Processing.SpectraProcessor import *
             class TestSChain():
                 def __init__(self):
                     self.setValues()
                     self.createObjects()
                     self.testSChain()
                 def setValues( self ):
-                    self.path = "/home/dsuarez/Projects"  #1
+                    self.path = "/home/dsuarez/Projects"
                     self.path = "/Users/jro/Documents/RadarData/EW_Drifts"
                     self.path = "/Users/jro/Documents/RadarData/MST_ISR/MST"
-            #        self.startDateTime = datetime.datetime(2007,5,1,15,49,0)
-            #        self.endDateTime = datetime.datetime(2007,5,1,23,0,0)
                     self.startDateTime = datetime.datetime(2009,01,1,0,0,0)
                     self.endDateTime = datetime.datetime(2009,01,31,0,20,0)
-            #        self.startDateTime = datetime.datetime(2011,11,1,0,0,0)
-            #        self.endDateTime = datetime.datetime(2011,12,31,0,20,0)
                     self.N = 4
                     self.npts = 8
                 def createObjects( self ):
                     self.readerObj = VoltageReader()
                     self.voltProcObj = VoltageProcessor()
                     self.specProcObj = SpectraProcessor()
-                    voltObj1 = self.readerObj.setup(
+                    self.voltObj1 = self.readerObj.setup(
                                                path = self.path,
                                                startDateTime = self.startDateTime,
                                                endDateTime = self.endDateTime,
                                                expLabel = '',
                                                online = 0)
-                    if not(voltObj1):
+                    if not(self.voltObj1):
                         sys.exit(0)
-                    voltObj2 = self.voltProcObj.setup(dataInObj = voltObj1)
+                    self.voltObj2 = self.voltProcObj.setup(dataInObj = self.voltObj1)
-                    specObj1 = self.specProcObj.setup(dataInObj = voltObj2,
+                    self.specObj1 = self.specProcObj.setup(dataInObj = self.voltObj2,
                                                       nFFTPoints = 16)
-            #        voltObj2 = self.voltProcObj.setup(dataInObj = voltObj1,
-            #                                          dataOutObj = voltObj2)
-            #        specObj1 = self.specProcObj.setup(dataInObj = voltObj2,
-            #                                          dataOutObj =specObj1,
-            #                                          nFFTPoints=16)
                 def testSChain( self ):
                     ini = time.time()
                     while(True):
                         self.readerObj.getData()
                         self.voltProcObj.init()
-            #            self.voltProcObj.plotData(winTitle='VOLTAGE INPUT', index=1)
+                        self.voltProcObj.plotScope(winTitle="Scope 1",type="iq", index=1)
-            #            self.voltProcObj.integrator(4)
-            #            self.voltProcObj.plotData(winTitle='VOLTAGE AVG', index=2)
-                        self.specProcObj.init()
+                        self.voltProcObj.plotRti(winTitle='VOLTAGE INPUT', showPowerProfile=True, index=2)
-                        self.specProcObj.integrator(N=1)
+                        self.voltProcObj.integrator(4)
-                        self.specProcObj.plotData(winTitle='Spectra 1', index=1)
+                        self.specProcObj.init()
+                        self.specProcObj.integrator(N=4)
+            #            self.specProcObj.plotSpec(winTitle='Spectra Test', showColorbar=True,showPowerProfile=True,index=3)
+                        self.specProcObj.plotData(winTitle='Spectra Test', showColorbar=True,showPowerProfile=True,index=3)
                         if self.readerObj.flagNoMoreFiles:
                             break
                         if self.readerObj.flagIsNewBlock:
                             print 'Block No %04d, Time: %s' %(self.readerObj.nTotalBlocks,
                                                               datetime.datetime.fromtimestamp(self.readerObj.m_BasicHeader.utc),)
-            #        self.plotObj.end()
             if __name__ == '__main__':
                 TestSChain()

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages