schain-jc Commit - r691:4042108b4f6b

A new Plotter Class was added for plotting using queues

Miguel Valdez -

r691:4042108b4f6b

parent child

Context file:

r691:4042108b4f6b

Collapse all files

schainpy/model/graphics/jroplotter.py created 644 +68 0

@@ -0,0 +1,68
	1	'''
	2	Created on Jul 9, 2014
	3
	4	@author: roj-idl71
	5	'''
	6	import os
	7	import datetime
	8	import numpy
	9
	10	from figure import Figure
	11
	12	class Plotter(Figure):
	13
	14	isConfig = None
	15	name = None
	16	plotterQueue = None
	17
	18	def __init__(self, plotter_name, plotter_queue=None):
	19
	20	self.isConfig = False
	21	self.name = plotter_name
	22	self.plotterQueue = plotter_queue
	23
	24	def getSubplots(self):
	25
	26	nrow = self.nplots
	27	ncol = 1
	28	return nrow, ncol
	29
	30	def setup(self, **kwargs):
	31
	32	# self.nplots = nplots
	33	#
	34	# self.createFigure(id=id,
	35	# wintitle=wintitle,
	36	# show=show)
	37	#
	38	# nrow,ncol = self.getSubplots()
	39	# colspan = 3
	40	# rowspan = 1
	41	#
	42	# for i in range(nplots):
	43	# self.addAxes(nrow, ncol, i, 0, colspan, rowspan)
	44
	45
	46
	47	print "Initializing ..."
	48
	49
	50	def run(self, dataOut, **kwargs):
	51
	52	"""
	53
	54	Input:
	55	dataOut :
	56	id :
	57	wintitle :
	58	channelList :
	59	show :
	60	"""
	61
	62	if not self.isConfig:
	63	self.setup(**kwargs)
	64	self.isConfig=True
	65
	66	print "Putting data on %s queue:" %self.name
	67	print kwargs
	68

schainpy/__init__.py +1 -1

             @author $Author$
             @version $Id$
             '''
-            __version__ = "2.1.4.1"
  No newline at end of file
+            __version__ = "2.1.4.2"
  No newline at end of file

schainpy/controller.py +29 -11

                     for parmConfObj in self.parmConfObjList:
                         parmConfObj.printattr()
-                def createObject(self):
+                def createObject(self, plotter_queue=None):
                     if self.type == 'self':
                         raise ValueError, "This operation type cannot be created"
+                    if self.type == 'plotter':
+                        #Plotter(plotter_name)
+                        opObj = Plotter(self.name, plotter_queue)
                     if self.type == 'external' or self.type == 'other':
                         className = eval(self.name)
                         opObj = className()
                     for opConfObj in self.opConfObjList:
                         opConfObj.printattr()
-                def createObjects(self):
+                def createObjects(self, plotter_queue=None):
                     className = eval(self.name)
                     procUnitObj = className()
                         if opConfObj.type == 'self':
                             continue
-                        opObj = opConfObj.createObject()
+                        opObj = opConfObj.createObject(plotter_queue)
                         self.opObjDict[opConfObj.id] = opObj
                         procUnitObj.addOperation(opObj, opConfObj.id)
                 ELEMENTNAME = 'Project'
-                def __init__(self):
+                __plotterQueue = None
+                def __init__(self, filename="./schain.xml", plotter_queue=None):
                     self.id = None
                     self.name = None
                     self.description = None
+                    self.filename = filename
+                    self.__plotterQueue = plotter_queue
                     self.procUnitConfObjDict = {}
                 def __getNewId(self):
                 def createObjects(self):
                     for procUnitConfObj in self.procUnitConfObjDict.values():
-                        procUnitConfObj.createObjects()
+                        procUnitConfObj.createObjects(self.__plotterQueue)
                 def __connect(self, objIN, thisObj):
                         return 0
                     return 1
+                def setFilename(self, filename):
+                    self.filename = filename
+                def setPlotterQueue(self, plotter_queue):
+                    self.__plotterQueue = plotter_queue
+                def getPlotterQueue(self):
+                    return self.__plotterQueue
                 def run(self):
                     print
                         procUnitConfObj.close()
                     print "Process finished"
-                def start(self, filename):
-                    if not self.writeXml(filename):
+                def start(self):
-                        return
-                    if not self.readXml(filename):
+                    if not self.writeXml(self.filename):
                         return
                     self.createObjects()
                     self.connectObjects()
                     self.run()

schainpy/controller_api.py +2 -4

             class ControllerThread(threading.Thread, Project):
-                def __init__(self, filename):
+                def __init__(self, filename=None, plotter_queue=None):
                     threading.Thread.__init__(self)
-                    Project.__init__(self)
+                    Project.__init__(self, filename, plotter_queue)
                     self.setDaemon(True)
-                    self.filename = filename
                     self.lock = threading.Lock()
                     self.control = {'stop':False, 'pause':False}

schainpy/model/graphics/__init__.py +2 -1

             from jroplot_spectra import *
             from jroplot_heispectra import *
             from jroplot_correlation import *
-            from jroplot_parameters import *
  No newline at end of file
+            from jroplot_parameters import *
+            from jroplotter import *
  No newline at end of file

schainpy/model/proc/jroproc_base.py +18 -10

                         opType    :    Puede ser "self" o "external"
-                            La operacion puede ser de dos tipos (callMethod or callObject):
+                            Depende del tipo de operacion para llamar a:callMethod or callObject:
-. Un metodo propio de esta clase:
+. If opType = "self": Llama a un metodo propio de esta clase:
+                                    name_method = getattr(self, name)
+                                    name_method(**kwargs)
-                                opType = "self"
-. El metodo "run" de un objeto del tipo Operation o de un derivado de ella:
+. If opType = "other" o"external": Llama al metodo "run()" de una instancia de la
+                               clase "Operation" o de un derivado de ella:
-                                opType = "other" or "external".
+                                    instanceName = self.operationList[opId]
+                                    instanceName.run(**kwargs)
                         opName    : Si la operacion es interna (opType = 'self'), entonces el "opName" sera
                                     usada para llamar a un metodo interno de la clase Processing
-                        opId    :    Si la operacion es externa (opType = 'other'), entonces el "opId" sera
+                        opId    :    Si la operacion es externa (opType = 'other' o 'external), entonces el
-                                    usada para llamar al metodo "run" de la clase Operation registrada con ese Id
+                                    "opId" sera usada para llamar al metodo "run" de la clase Operation
+                                    registrada anteriormente con ese Id
                     Exception:
                            Este objeto de tipo Operation debe de haber sido agregado antes con el metodo:
                            "addOperation" e identificado con el valor "opId"  = el id de la operacion.
-                           De lo contrario retornara un error del tipo IOError
+                           De lo contrario retornara un error del tipo ValueError
                     """
                         sts = self.callMethod(opName, **kwargs)
-                    if opType == 'other' or opType == 'external':
+                    elif opType == 'other' or opType == 'external' or opType == 'plotter':
                         if not opId:
                             raise ValueError, "opId parameter should be defined"
                         if opId not in self.operations2RunDict.keys():
-                            raise ValueError, "Id operation has not been registered"
+                            raise ValueError, "Any operation with id=%s has been added" %str(opId)
                         sts = self.callObject(opId, **kwargs)
+                    else:
+                        raise ValueError, "opType should be 'self', 'external' or 'plotter'; and not '%s'" %opType
                     return sts
                 def setInput(self, dataIn):

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