class Mysocket(QtCore.QThread):
'''
classdocs
'''
def __init__(self, parent = None):
QtCore.QThread.__init__(self)
self.qtobj=QObject()
self.mysql=ConMysql()
self.mysql.setting('localhost', 'root', '443622796', 3306, 'utf8')
self.mysql.open()
self.mysql.start()
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#self.s.bind(('192.168.1.107', 8899))
self.s.bind(('192.168.0.199', 8899))
#self.s.bind((socket.gethostbyname(socket.gethostname()), 8899))
self.s.listen(5)
def run(self):
sprint.sprint('程序开始运行，等待连接...')
while True:
#print "current has %d threads" % (threading.activeCount())
#for item in threading.enumerate():
# print item
self.sock, self.addr =self.s.accept()
self.t =tcplink(self.sock,self.addr,self.mysql)
self.t.start()
self.qtobj.emit(SIGNAL("NewData"), self.t)
class Mysocket(QtCore.QThread):
'''
classdocs
'''
def __init__(self, parent=None):
QtCore.QThread.__init__(self)
self.qtobj = QObject()
self.mysql = ConMysql()
self.mysql.setting('localhost', 'root', '443622796', 3306, 'utf8')
self.mysql.open()
self.mysql.start()
self.s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
#self.s.bind(('192.168.1.107', 8899))
self.s.bind(('192.168.0.199', 8899))
#self.s.bind((socket.gethostbyname(socket.gethostname()), 8899))
self.s.listen(5)
def run(self):
sprint.sprint('程序开始运行，等待连接...')
while True:
#print "current has %d threads" % (threading.activeCount())
#for item in threading.enumerate():
# print item
self.sock, self.addr = self.s.accept()
self.t = tcplink(self.sock, self.addr, self.mysql)
self.t.start()
self.qtobj.emit(SIGNAL("NewData"), self.t)
def itemCollapsedOrExpanded(self, item):
if item.isExpanded():
item.expanded()
else: # collapsed
item.collapsed()
self.setVisibleRowCount()
QObject.emit(self, SIGNAL("contentChanged(void)"))
def _connect(self):
try:
if not self._connected:
if not self._attempts < self.kMaxAttempts:
if not self._resetTimer.isActive():
Log.progress(Settings.getMeta("name") + ": Max connection attempts reached - waiting " + str(self.kResetTimer) + " seconds before retrying" )
self._resetTimer.start(self.kResetTimer*1000) # 1 minute parameterise
return
if self._attempts > 0 and (time.time() - pow(2,self._attempts +1)) < self._attemped:
return
Log.debug("Trying to connect")
self._attemped = time.time()
result = self.mqttc.connect(str(self._host), int(self._port),int( self._keepAlive), 1)
self._connected = result == mqtt.MQTT_ERR_SUCCESS # paho
# self._connected = result == mqtt.MOSQ_ERR_SUCCESS # mosquitto
if not self._connected:
self._attempts += 1
Log.progress(mqtt.connack_string(connResult))
QObject.emit(self, SIGNAL('mqttConnectionError'), self, mqtt.connack_string(connResult))
except Exception as e:
msg = 'MQTT: ' + str(e)
QObject.emit(self, SIGNAL('mqttConnectionError'), self, msg)
#Log.progress(msg)
Log.debug(msg)
#exc_type, exc_value, exc_traceback = sys.exc_info()
#Log.debug(repr(traceback.format_exception(exc_type, exc_value,
# exc_traceback)))
self._attempts += 1
self._connected = False
def runBtnSwitch(self):
self.treeWidget.blockSignals(
True
) #prevents time and other values from updating. Stops time re-add during successive runs.
if self.runBtn.text() == "Run":
self.resetTestStats()
self.runBtn.setText("Stop")
self.getTestsToRun()
self.treeWidget.blockSignals(
False
) #prevents time and other values from updating. Stops time re-add during successive runs.
if not self.TestRunner.isRunning():
self.TestRunner.start()
QObject.emit(self.qt_object, SIGNAL("start"))
elif self.runBtn.text() == "Stop":
self.TestRunner.stop_test_run()
self.stopTests = True
self.testingStarted = False
self.runBtn.setText("Kill")
elif self.runBtn.text() == "Kill":
self.TestRunner.terminate()
self.TestRunner.wait()
self.endTestRun()
def resultPointValueListMethod(resultValueList, dataBaseProcedureData_0,
point3d_0, procEntityListType_0, parent):
if len(resultValueList) > 0:
lat = None
lon = None
if define._units == QGis.Meters:
point3d = QgisHelper.CrsTransformPoint(
float(resultValueList[1]), float(resultValueList[2]),
define._xyCrs, define._latLonCrs)
lat = Degrees(point3d.get_Y(), None, None,
DegreesType.Latitude)
lon = Degrees(point3d.get_X(), None, None,
DegreesType.Longitude)
else:
lat = Degrees(float(resultValueList[2]), None, None,
DegreesType.Latitude)
lon = Degrees(float(resultValueList[1]), None, None,
DegreesType.Longitude)
str0 = lon.method_1("dddmmss.ssssH")
textString = lat.method_1("ddmmss.ssssH")
procEntityBases = DlgAixmSelectPosition.smethod_1(
dataBaseProcedureData_0, procEntityListType_0, point3d_0,
textString, str0)
dlgAixmSelectPosition = DlgAixmSelectPosition()
naN = None
degree = None
result, naN, degree = Geo.smethod_2(point3d_0.get_X(),
point3d_0.get_Y())
if (result):
dataBaseProcedureData_0.method_60(procEntityBases,
procEntityListType_0,
naN.ToString(),
degree.ToString())
dlgAixmSelectPosition.lstItems.Sorted = True
for procEntityBase in procEntityBases:
dlgAixmSelectPosition.lstItems.Add(procEntityBase)
if (procEntityListType_0 != ProcEntityListType.CentersEx
and procEntityListType_0 != ProcEntityListType.FixesEx):
dlgAixmSelectPosition.btnNewPCP.setEnabled(False)
dlgAixmSelectPosition.btnNewPCP.setVisible(False)
resultDlg = dlgAixmSelectPosition.exec_()
procEntityBase_0 = None
if (resultDlg != 1):
if dlgAixmSelectPosition.newTypeSelected == NewDbEntryType.DPN:
flag, procEntityBase_0 = DlgAixmNewDPN.smethod_0(
dataBaseProcedureData_0, naN, degree)
elif dlgAixmSelectPosition.newTypeSelected == NewDbEntryType.PCP:
flag, procEntityBase_0 = DlgAixmNewPCP.smethod_0(
dataBaseProcedureData_0, naN, degree)
else:
flag = False
else:
procEntityBase_0 = dlgAixmSelectPosition.lstItems.SelectedItem
flag = True
QObject.emit(parent,
SIGNAL("DlgAixmSelectPosition_Smethod_0_Event"), flag,
procEntityBase_0)
return
def doAction(self, text="", methodObj=None):
# print "doAction pre"
if not methodObj:
return
try:
methodObj()
except Exception, e:
QObject.emit(self, SIGNAL("exception(QString, PyQt_PyObject)"), text, e)
def _connectError(self, client, msg):
Log.debug(msg)
QObject.emit(self, SIGNAL('mqttOnCompletion'), self, False, msg)
if not self._callbackonerr is None:
self._callbackonerr(self, False, msg)
elif not self._callback is None:
self._callback(self, False, msg)
self.kill()
def _connectError(self,client, msg):
Log.debug(msg)
QObject.emit(self, SIGNAL('mqttOnCompletion'), self, False, msg)
if not self._callbackonerr is None:
self._callbackonerr(self,False,msg)
elif not self._callback is None:
self._callback(self,False,msg)
self.kill()
def setNoise(self, aNoise):
'''
Must be between 0 and 1 included
'''
if 0 <= aNoise <= 1:
self._noise = aNoise
else:
raise ConnectionError("Noise must be between 0 and 1")
QObject.emit(emitter(self), SIGNAL('noiseChanged'), self._noise)
def append_data(self, mlist):
""" Append data from a tuple in the model """
try:
if len(mlist[0])==3:
self.items = self.items + mlist
QObject.emit(self, \
SIGNAL("dataChanged(const QModelIndex&, const QModelIndex &)"), self.createIndex(0,0), self.createIndex(0,len(self.items))) # pylint: disable=C0301
except StandardError:
pass
def append_data(self, mlist):
""" Append data from a tuple in the model """
try:
if len(mlist[0]) == 3:
self.items = self.items + mlist
QObject.emit(self, \
SIGNAL("dataChanged(const QModelIndex&, const QModelIndex &)"), self.createIndex(0,0), self.createIndex(0,len(self.items))) # pylint: disable=C0301
except StandardError:
pass
def onMessage(self, client, obj, msg):
self._messages += 1
if self._messages > 1:
return # ignore subsequent
self._timer.stop()
client.disconnect()
QObject.emit(self, SIGNAL('mqttOnCompletion'), self, True, msg.payload)
if not self._callback is None:
self._callback(self,True,msg)
def __init__(self):
"Initialize the HomeoUniselector instance"
'''sets the defaults for the uniselector weights.
Can be (and usually is) overridden by subclasses'''
self._lowerBound = 0
self._upperBound = 1
self._beeps = False
QObject.emit(emitter(self), SIGNAL('uniselSoundChanged'), self._beeps)
def onMessage(self, client, obj, msg):
self._messages += 1
if self._messages > 1:
return # ignore subsequent
self._timer.stop()
client.disconnect()
QObject.emit(self, SIGNAL('mqttOnCompletion'), self, True, msg.payload)
if not self._callback is None:
self._callback(self, True, msg)
self.kill()
def dispatch_next_fuzz_item(self):
if self.keep_fuzzing:
fuzz_item = self.get_next_fuzz_item()
if fuzz_item:
QObject.emit(self.fuzz_callback, SIGNAL('fuzzItemAvailable(int, QByteArray, QUrl)'), fuzz_item[0], fuzz_item[1], fuzz_item[2])
else:
self.processed_urls = {}
QObject.emit(self.fuzz_callback, SIGNAL('fuzzRunFinished()'))
else:
self.processed_urls = {}
def dispatch_next_render_item(self):
###-> print('****7')
if self.keep_spidering:
###-> print('****8')
render_item = self.get_next_render_item()
if render_item:
self.renderer_available = False
QObject.emit(self.spider_callback, SIGNAL('spiderItemAvailable(int, QString, QUrl, int)'), render_item[0], render_item[1], render_item[2], render_item[3])
else:
self.renderer_available = True
def setAbsoluteWeight(self, aPositiveValue):
'Utility function that changes the weight of a connection without changing its sign (i.e. the switch)'
if aPositiveValue == 0:
self._switch = 1
self._weight = 0
else:
if 0 < aPositiveValue <= 1:
self._weight= aPositiveValue
# QObject.emit(emitter(self), SIGNAL('weightChanged'), self._weight)
"signal back to unit's potentiometer in case of self-connections"
if self.incomingUnit == self.outgoingUnit:
QObject.emit(emitter(self.incomingUnit), SIGNAL('potentiometerChangedLineEdit'), str(round(self._weight, 4)))
def dispatch_next_fuzz_item(self):
if self.keep_fuzzing:
fuzz_item = self.get_next_fuzz_item()
if fuzz_item:
QObject.emit(
self.fuzz_callback,
SIGNAL('fuzzItemAvailable(int, QByteArray, QUrl)'),
fuzz_item[0], fuzz_item[1], fuzz_item[2])
else:
self.processed_urls = {}
QObject.emit(self.fuzz_callback, SIGNAL('fuzzRunFinished()'))
else:
self.processed_urls = {}
class GUILogWriter(object):
"""Provides writeable file-like interface to send text to GUI."""
def __init__(self):
self.emitter = QObject()
self.softspace = 0
def write(self, message):
self.emitter.emit(SIGNAL("AppendToLog"), message)
def flush(self):
pass
def close(self):
pass
def dispatch_next_render_item(self):
###-> print('****7')
if self.keep_spidering:
###-> print('****8')
render_item = self.get_next_render_item()
if render_item:
self.renderer_available = False
QObject.emit(
self.spider_callback,
SIGNAL('spiderItemAvailable(int, QString, QUrl, int)'),
render_item[0], render_item[1], render_item[2],
render_item[3])
else:
self.renderer_available = True
class GUILogWriter(object):
"""Provides writeable file-like interface to send text to GUI."""
def __init__(self):
self.emitter = QObject()
self.softspace = 0
def write(self, message):
self.emitter.emit(SIGNAL("AppendToLog"), message)
def flush(self):
pass
def close(self):
pass
def runFor(self,ticks):
'''Start the simulation by setting the units 'in motion' and run it
for a certain number of ticks.
This involves cycling through the units and asking them to update themselves,
then collecting data for each unit.
First check that there are enough data to start'''
sleepTime = self.slowingFactor
if self.isReadyToGo():
if self.time is None:
self.time = 0
"FOR TESTING"
outputString = ("INITIAL DATA AT TIME: %u and tick: %u \n" % (self.time, ticks))
for unit in self.homeoUnits:
outputString += ('Unit %s with output %.3f and critical deviation %.3f \n' %
(unit.name,
unit.currentOutput,
unit.criticalDeviation))
"END TESTING"
while self.time < ticks:
for unit in self.homeoUnits:
if self.collectsData:
self.dataCollector.atTimeIndexAddDataUnitForAUnit(self.time, unit)
unit.time = self.time
# sys.stderr.write("the status of %s in the function is %s and in the ivar is %s \n" % (unit.name, unit.isActive(), unit._status))
# print "unit: %s of type %s about to update with value: %.3f" % (unit.name, type(unit), unit.criticalDeviation)
if unit.isActive():
unit.selfUpdate()
self.time += 1
QObject.emit(emitter(self), SIGNAL('homeostatTimeChanged'), self.time)
time.sleep(sleepTime / 1000) # sleep accepts seconds, slowingFactor is in milliseconds
else:
sys.stderr.write('Warning: Homeostat is not ready to start')
"FOR TESTING"
outputString = 'FINAL DATA AT TIME: %u and tick %u \n' % (self.time, ticks)
for unit in self.homeoUnits:
outputString += ('Unit %s with output %.3f and deviation %.3f \n' %
(unit.name,
unit.currentOutput,
unit.criticalDeviation))
"END TESTING"
class Uploader(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.qobj = QObject()
self.avrdude = const.avrdude
self.avrdude_conf = const.avrconf
self.mcu = 'atmega328p'
self.speed = "115200"
self.protocol = "arduino"
self.comport = "COM3"
self.flash_bin = ''
self.__buildUploadCmd()
def __buildUploadCmd(self):
self.upload_cmd = "%s -C%s -v -p%s -c%s -P%s -b%s -D -Uflash:w:%s:i 2>%s" % (
self.avrdude,
self.avrdude_conf,
self.mcu,
self.protocol,
self.comport,
self.speed,
self.flash_bin,
const.arduloader_log)
def resetUploadArgs(self, argsdict):
assert type(argsdict) is dict
self.mcu = argsdict["mcu"]
self.speed = argsdict["speed"]
self.protocol = argsdict["protocol"]
self.comport = argsdict["comport"]
self.flash_bin = argsdict["flash_bin"]
self.__buildUploadCmd()
def run(self):
self.upload()
def upload(self):
ret, text = getstatusoutput(self.upload_cmd)
self.qobj.emit(SIGNAL(const.finish_sig), ret, text)
class Thumbnailmaker(QRunnable):
"""
Worker thread for creating thumbnails
"""
def __init__(self, filename, width, height, parent=None):
QRunnable.__init__(self)
self.dontrun = False
self.filename = filename
self._w = width
self._h = height
# Need a QObject to emit signals from a QRunnable
self.obj = QObject()
def dontRun(self):
self.dontrun = True
def run(self):
"""
Method run by the worker thread, responsible for downscaling
one image to thumbnail size
"""
if self.dontrun: # dont run the image resize if the image is not needed
return
# Use two way scaling of the image.
# The result will be calculated faster than a one-way
# SmoothTransformation but will be as nice.
thumb = QtGui.QImage(self.filename)\
.scaled(self._w * 4, self._h * 4,
Qt.KeepAspectRatio,
Qt.FastTransformation)\
.scaled(self._w, self._h,
Qt.KeepAspectRatio,
Qt.SmoothTransformation)
logging.info("creating thumbnail image for %s is done", self.filename)
self.obj.emit(SIGNAL("imageDone"), thumb)
def loop(self, timeout=0.1):
if not self.isConnected():
if not self._killing:
self._connect()
return
try:
connResult = self.mqttc.loop(timeout)
if connResult == mqtt.MQTT_ERR_SUCCESS: # paho
# if connResult == mqtt.MOSQ_ERR_SUCCESS: # mosquitto
return
self._connected = False
self._attempts += 1
Log.warn("MQTT: An error occurred while looping")
QObject.emit(self, SIGNAL('mqttConnectionError'), self, mqtt.error_string(connResult))
except ValueError as e:
if e == 'Invalid timeout.':
QObject.emit(self, SIGNAL('mqttOnTimeout'), self, "Connection Timeout")
else:
Log.debug("Paho Client ValueError" + str(e))
except Exception as e:
QObject.emit(self, SIGNAL('mqttConnectionError'), self, str(e))
Log.debug("MQTT Connect: Unknown exception raised " + str(e))
class FileDialogSignal(QWidget):
''' NO DOCUMENTATION '''
def __init__(self, parent=None, typeName=None, param=None):
''' NO DOCUMENTATION '''
QWidget.__init__(self, parent)
self.o = QObject()
self.param = param
self.type = typeName
def updateParam(self, param):
''' NO DOCUMENTATION '''
self.param = param
def updateType(self, typeName):
''' NO DOCUMENTATION '''
self.type = typeName
def relayButtonSignal(self):
''' NO DOCUMENTATION '''
#print "relayButtonSignal"
self.o.emit(SIGNAL("buttonPressed(PyQt_PyObject,PyQt_PyObject)"),
self.type, self.param)
class FileDialogSignal(QWidget):
''' NO DOCUMENTATION '''
def __init__(self, parent=None, typeName=None, param=None):
''' NO DOCUMENTATION '''
QWidget.__init__(self, parent)
self.o = QObject()
self.param = param
self.type = typeName
def updateParam(self,param):
''' NO DOCUMENTATION '''
self.param = param
def updateType(self,typeName):
''' NO DOCUMENTATION '''
self.type = typeName
def relayButtonSignal(self):
''' NO DOCUMENTATION '''
#print "relayButtonSignal"
self.o.emit(SIGNAL("buttonPressed(PyQt_PyObject,PyQt_PyObject)"),self.type,self.param)
class Uploader(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.qobj = QObject()
self.avrdude = const.avrdude
self.avrdude_conf = const.avrconf
self.mcu = 'atmega328p'
self.speed = "115200"
self.protocol = "arduino"
self.comport = "COM3"
self.flash_bin = ''
self.__buildUploadCmd()
def __buildUploadCmd(self):
self.upload_cmd = "%s -C%s -v -p%s -c%s -P%s -b%s -D -Uflash:w:%s:i 2>%s" % (
self.avrdude, self.avrdude_conf, self.mcu, self.protocol,
self.comport, self.speed, self.flash_bin, const.arduloader_log)
def resetUploadArgs(self, argsdict):
assert type(argsdict) is dict
self.mcu = argsdict["mcu"]
self.speed = argsdict["speed"]
self.protocol = argsdict["protocol"]
self.comport = argsdict["comport"]
self.flash_bin = argsdict["flash_bin"]
self.__buildUploadCmd()
def run(self):
self.upload()
def upload(self):
ret, text = getstatusoutput(self.upload_cmd)
self.qobj.emit(SIGNAL(const.finish_sig), ret, text)
def newWeight(self, aWeight):
"updates weight and switch on the basis -1 <= aWeight <= 1"
if aWeight == 0:
self._switch = 1
self._weight = 0
else:
if -1 <= aWeight <= 1:
self._weight= abs(aWeight)
self._switch = np.sign(aWeight)
else:
raise(ConnectionError, "A HomeoConnection weight must be between -1 and 1")
QObject.emit(emitter(self), SIGNAL('weightChanged'), self._weight)
QObject.emit(emitter(self), SIGNAL('switchChanged'), self._switch)
"Signaling back to the incoming unit's potentiometer and switch in case of a self-connection"
try:
if self.incomingUnit == self.outgoingUnit:
QObject.emit(emitter(self.incomingUnit), SIGNAL('potentiometerChangedLineEdit'), str(round(self._weight, 4)))
QObject.emit(emitter(self.incomingUnit), SIGNAL('switchChangedLineEdit'), str(int(self._switch)))
except AttributeError:
pass
class TransFuze():
"""
Convert input image to a fuze-suitable image
"""
#Do something useful
def __init__(self, GUI = None):
self.size = [int(QSettings().value("imagew",QVariant(defaultsize[0])).toInt()[0]), int(QSettings().value("imageh",QVariant(defaultsize[1])).toInt()[0])]
self.size = defaultsize
self.GUI = GUI
self.tab = GUI.Image
if self.GUI != None:
self.qobject = QObject()
self.qobject.connect(self.qobject, SIGNAL("stop"),GUI.WAIT)
self.qobject.connect(self.qobject, SIGNAL("working"),GUI.Status)
self.qobject.connect(self.qobject, SIGNAL("Exception"),GUI.ErrorDiag)
self.qobject.connect(self.qobject, SIGNAL("itemDone"),GUI.DelItem)
self.qobject.connect(self.qobject, SIGNAL("finished"),GUI.getReady)
def convert(self,args, FINALPREFIX = None):
"""
This method converts the passed files to jpg viewable in the fuze.
"""
self.qobject.emit(SIGNAL("stop"),self.tab)
for argument in args:
try:
self.qobject.emit(SIGNAL("working"),"Converting " + argument + "...")
image = Image.open(argument)
image.thumbnail(self.size, Image.ANTIALIAS)
if FINALPREFIX == None:
image.save(os.path.splitext(argument)[0] + "_fuze.jpg")
else:
image.save(os.path.join(FINALPREFIX,os.path.splitext(os.path.basename(argument))[0] + "_fuze.jpg"))
self.qobject.emit(SIGNAL("itemDone"), argument, True)
except Exception, e:
print e
self.qobject.emit(SIGNAL("Exception"),e)
self.qobject.emit(SIGNAL("finished"),self.tab)
def toggleSwitch(self, aNumber):
"Change the polarity of the connection to aNumber"
# self.newWeight(self.weight * -1)
# QObject.emit(emitter(self), SIGNAL('switchChanged'), self._switch)
acceptedValues = (-1,1)
oldWeight = self.weight
oldSwitch = self.switch
try:
if int(aNumber) in acceptedValues:
newWeight = abs(oldWeight) * int(aNumber)
self.newWeight(newWeight)
self._switch = int(aNumber)
# sys.stderr.write("Unit %s's new weight is %f: with switch equal to %f. The value passed from the GUI was %f . \nThe old weight was %f and the old switch was %f, and the old unit's switch was %f\n"
# % (self.name, self.inputConnections[0].weight, self.switch, int(aNumber), oldWeight, oldSwitch, oldUnitSwitch))
else:
raise ConnectionError
except ValueError:
sys.stderr.write("Tried to assign a non-numeric value to the switch of the connection from %s to %s The value was: %s\n" % (self.outgoingUnit.name, self.incomingUnit.name, aNumber))
finally:
QObject.emit(emitter(self), SIGNAL('switchChanged'), self._switch)
QObject.emit(emitter(self), SIGNAL('switchChangedLineEdit'), str(int(self._switch)))
QObject.emit(emitter(self.incomingUnit), SIGNAL('switchChangedLineEdit'),str(int(self._switch)))
self.exec_()
class ActionHandler(QObject):
"""Executes an action on a certain device (methodObj)."""
def doAction(self, text="", methodObj=None):
# print "doAction pre"
if not methodObj:
return
try:
methodObj()
except Exception, e:
QObject.emit(self, SIGNAL("exception(QString, PyQt_PyObject)"), text, e)
finally:
QObject.emit(self, SIGNAL("actionDone(void)"))
def emitPwdSignal(self):
resList = [""]
QObject.emit(self, SIGNAL("passwordDialog(PyQt_PyObject)"), resList)
return str(resList[0])
class MyTreeWidgetItem(QTreeWidgetItem):
"""An item (row) in the GUI device tree. Has an associated device and
keeps track of the existing and visible children of a node."""
_dev = None # one element list (&reference ?)
_overallChildCount = None
_visibleChildCount = None
def show(self, f):
QObject.emit(emitter(self), SIGNAL('test'), f)
class PlotConfig(object):
"""
Plot config represents settings information relating to plot lines.
All values are available as properties.
"""
def __init__(self, name, linestyle="-", marker="", color=(0.0, 0.0, 0.0), alpha=0.75, zorder=1, picker=None, visible=True):
self._name = name
self._linestyle = linestyle
self._marker = marker
self._color = color
self._alpha = alpha
self._is_visible = visible
self._z_order = zorder
self._picker = picker
self.signal_handler = QObject()
def notify(self):
"""Tell all listeners that something has changed. Automatically called by setters."""
self.signal_handler.emit(SIGNAL('plotConfigChanged(PlotConfig)'), self)
def get_name(self):
return self._name
name = property(get_name, doc="The name of this plot.")
def hasStyle(self):
return not self.style == ""
def get_style(self):
return (str(self._marker) + str(self._linestyle)).strip()
style = property(get_style, doc="Returns the combined style of line style and marker style.")
def setLinestyle(self, linestyle):
self._linestyle = linestyle
self.notify()
def getLinestyle(self):
return self._linestyle
linestyle = property(getLinestyle, setLinestyle, doc="Line style")
def setMarker(self, marker):
self._marker = marker
self.notify()
def getMarker(self):
return self._marker
marker = property(getMarker, setMarker, doc="Marker style")
def setAlpha(self, alpha):
self._alpha = alpha
self.notify()
def getAlpha(self):
return self._alpha
alpha = property(getAlpha, setAlpha, doc="Transparency of the line. 1 = Opaque ... 0 transparent.")
def setColor(self, color):
self._color = color
self.notify()
def getColor(self):
return self._color
color = property(getColor, setColor, doc="Color of the line.")
def set_is_visible(self, is_visible):
self._is_visible = is_visible
self.notify()
def is_visible(self):
return self._is_visible
is_visible = property(is_visible, set_is_visible, doc="Hide or show the plotline.")
def set_z_order(self, z_order):
self._z_order = z_order
self.notify()
def get_z_order(self):
return self._z_order
z_order = property(get_z_order, set_z_order, doc="Z drawing order. 10 = top ... 1 = bottom.")
def setPicker(self, picker):
self._picker = picker
self.notify()
def getPicker(self):
return self._picker
picker = property(getPicker, setPicker, doc="Picker radius")
class Fuze():
"""
This class implements a convert() method used to convert video files for the fuze.
"""
def __init__(self, GUI = None):
self.pool = multiprocessing.Pool()
self.GUI = GUI
self.CWD = os.getcwd()
self.qobject = QObject()
if self.GUI:
self.qobject.connect(self.qobject, SIGNAL("stop"),GUI.WAIT)
self.qobject.connect(self.qobject, SIGNAL("working"),GUI.Status)
self.qobject.connect(self.qobject, SIGNAL("Exception"),GUI.ErrorDiag)
self.qobject.connect(self.qobject, SIGNAL("itemDone"),GUI.DelItem)
self.qobject.connect(self.qobject, SIGNAL("finished"),GUI.getReady)
self.LoadSettings()
self.xterm = None
if os.name != 'posix' or not self.GUI:
global xterm
xterm = None
def LoadSettings(self):
"""
Loads video4fuze's settings for this instance
"""
global mencoderpass1
global mencoderpass2
global mencodersinglepass
global pass2
self.Settings = QSettings(QSettings.IniFormat, QSettings.UserScope, info.ORGNAME, info.NAME)
mencoderpass1 = unicode(self.Settings.value("mencoderpass1", QVariant(mencoderpass1)).toString())
mencoderpass2 = unicode(self.Settings.value("mencoderpass2", QVariant(mencoderpass2)).toString())
mencodersinglepass = unicode(self.Settings.value("mencodersinglepass",QVariant(mencodersinglepass)).toString())
pass2 = self.Settings.value("2pass",QVariant(pass2)).toBool()
print "Current settings:"
print
if pass2:
print "Two-pass conversion;"
print "Pass 1: ", mencoderpass1
print "Pass 2: ", mencoderpass2
else:
print "Single-pass conversion;"
print "Options used: ", mencodersinglepass
def convert(self,args, dest = None):
"""
This method converts any video file passed as argument to a file suitable for the sansa fuze.
"""
vdict['FINALPREFIX'] = dest
if self.GUI:
self.qobject.emit(SIGNAL("stop"),self.GUI.Video)
self.qobject.emit(SIGNAL("working"),"Converting files...")
os.chdir(vdict['fuzemuxPrefix'])
argslist = []
for arg in args:
if os.path.isfile(arg):
argslist.append((arg, vdict))
elif os.path.isdir(arg):
if not os.path.isdir(arg + '/VIDEO_TS') and not os.path.isdir(arg + '/BDMV/STREAM'):
glob_file = arg + '/*.??*'
for file in glob.glob(glob_file):
argslist.append((file, vdict))
else:
argslist.append((arg, vdict))
else:
print arg,': file not found'
#print [a[0] for a in argslist]
for file, error in self.pool.map(_convert_process, argslist):
if error:
self.qobject.emit(SIGNAL("Exception"),unicode(error))
print file, 'could not be converted succesfully'
if self.GUI:
self.qobject.emit(SIGNAL("itemDone"),file)
os.chdir(self.CWD)
if self.GUI:
self.qobject.emit(SIGNAL("finished"),self.GUI.Video)
print "Finished!"
def __emitStatus(self, status):
QObject.emit(self, SIGNAL('qidianStatus'), status)
class QRunner(QRunnable):
"""
Only QRunnable objects can be used with the QThreadPool
therefore we need to do the whole song and dance with
creating QRunnables, connecting signals and other such nonsense.
"""
def __init__(self, ifname, ofname, cls):
"""
This class does the work of moving the files to the executable to
process the pdf pages.
This class should not be called directly as it is a QRunnable object
therefore we need a QThreadPool object to start/stop and monitor
progress.
The worker is QWorker and will create these instances for us.
"""
# Init parent object
QRunnable.__init__(self)
# create an instance of a QObject so we can emit signals
self.q_object = QObject()
# take the inputs
self.ofname = ofname
self.ifname = ifname
self.res = cls.resolution
self.mode = cls.mode
# gs exe
self.gscriptpath = '"' + os.getcwd() + r'\gs\gs9.02\bin'
def run(self):
"""
Tasks to put in separate thread.
"""
self.process_file()
self.q_object.emit(SIGNAL("finished()"))
def process_file(self):
"""
Converts PDF pages to tif files,
Uses ghostscript from the command line
"""
process = QProcess()
process.start(' '.join([
self.gscriptpath + '\gswin32c.exe"', #gs exe
'-q',
'-dNOPAUSE',
'-dBATCH',
# resolution/dpi
'-r{0}x{0}'.format(self.res),
# container type, see gs docs
'-sDEVICE={0}'.format(self.mode),
'-sPAPERSIZE=a4', # page size
'-sOutputFile=%s %s' % (str(self.ofname),
str(self.ifname))]))
# don't spawn cmd window
process.waitForFinished(-1)
def toggleBeeping(self):
self._beeps = not self._beeps
QObject.emit(emitter(self), SIGNAL('unitUniselSoundChanged'), self._beeps)
def acceptDlg(self):
self.legs.refresh()
QObject.emit(self, SIGNAL("DlgAixmProcLegs_Smethod_0_Event"),
self.legs, self.data)
self.accept()
def triggerAction(self, checked=False):
if self.methodObj:
QObject.emit(self, SIGNAL("triggered(QString, PyQt_PyObject)"), self.text(), self.methodObj)
def __emitVoteOk(self, userName, bookName, recVoteNum, advVoteNum):
QObject.emit(self, SIGNAL('qidianVoteOk'), userName, bookName, recVoteNum, advVoteNum)
def emitPwdSignal(self):
resList = [""]
QObject.emit(self, SIGNAL("passwordDialog(PyQt_PyObject)"), resList)
return str(resList[0])
class nexusDoor(taurus.core.tango.sardana.macroserver.BaseDoor):
## constructor
# \param name door name
# \param kw dictionary with other arguments
def __init__(self, name, **kw):
print "nexusDoor.__init__()", name
self.call__init__(taurus.core.tango.sardana.macroserver.BaseDoor, name,
**kw)
## Nexus scan directory
self.scandir = ""
## Nexus file name
self.filename = ""
## serial number
self.serialno = 0
## start position
self.start = 0
## stop position
self.stop = 100
## number of points
self.np = 100
## device aliases
self.deviceAliases = {}
## cut device aliases
self.cutDeviceAliases = {}
## dictionary with names to replace
self.toReplace = {}
## configuration server
self.cnfServer = None
## Nexus writer
self.nexusWriter = None
## writing status
self.writing = False
## signal emitter
if PYQT:
self.emitter = QObject()
else:
self.emitter = None
## component selection mode
self.__ccmode = 'SARDANA_MODE'
env = self.getEnvironment()
if not env.has_key('NexusWriterDevice'):
## Nexus writer device name
self.device = 'haso228k.desy.de:10000/p09/tdw/r228'
self.setEnvironment('NexusWriterDevice', self.device)
else:
## Nexus writer device name
self.device = self.getEnvironment('NexusWriterDevice')
if not env.has_key('ScanFinished'):
self.setEnvironment('ScanFinished', 'True')
env = self.getEnvironment()
if not env.has_key('ConfigurationServerDevice'):
## configuration server device name
self.cnfdevice = 'haso228k.desy.de:10000/p09/mcs/r228'
self.setEnvironment('ConfigurationServerDevice', self.cnfdevice)
else:
## configuration server device name
self.cnfdevice = self.getEnvironment('ConfigurationServerDevice')
## provides a device alias
# \param name device name
# \return device alias
def get_alias(self, name):
# if name does not contain a "/" it's probably an alias
if name.find("/") == -1:
return name
# haso107klx:10000/expchan/hasysis3820ctrl/1
if name.find(':') >= 0:
lst = name.split("/")
name = "/".join(lst[1:])
return db.get_alias(name)
## creates a file name from dataRecord variables
# \param dataRecord Sardana data record
def prepareFileName(self, dataRecord):
if type(dataRecord[1]['data']['scanfile']).__name__ == 'list':
scanfile = dataRecord[1]['data']['scanfile'][0]
else:
scanfile = dataRecord[1]['data']['scanfile']
self.scandir = dataRecord[1]['data']['scandir']
self.serialno = dataRecord[1]['data']['serialno']
self.filename = "%s_%05d.%s" % (scanfile.rpartition('.')[0],
self.serialno, "h5")
# startTime = dataRecord[1]['data']['starttime']
# title = dataRecord[1]['data']['title']
## finds scan limits
# \param dataRecord Sardana data record
def findScanLimits(self, dataRecord):
# get the scan limits from the title
cmd = dataRecord[1]['data']['title'].split()
self.start, self.stop, self.np = 0, 100, 100
# ascan exp_dmy01 0 1 10 0.2
if cmd[0] == 'ascan':
self.start = float(cmd[2])
self.stop = float(cmd[3])
self.np = int(cmd[4])
# a2scan exp_dmy01 0 1 exp_dmy02 2 3 10 0.2
elif cmd[0] == 'a2scan':
self.start = float(cmd[2])
self.stop = float(cmd[3])
self.np = int(cmd[7])
# a3scan exp_dmy01 0 1 exp_dmy02 2 3 exp_dmy03 3 4 10 0.2
elif cmd[0] == 'a3scan':
self.start = float(cmd[2])
self.stop = float(cmd[3])
self.np = int(cmd[10])
else:
raise Exception(
"nexusDoor.findScanLimits",
"cmd not recognized %s" % (dataRecord[1]['data']['title']))
return
## creates Nexus configuration
# \param dataRecord Sardana data record
# \returns Nexus configuration string
def createNexusConfiguration(self, dataRecord):
self.deviceAliases = {}
self.toReplace = {}
env = self.getEnvironment()
if env.has_key('SelectionMode'):
self.__ccmode = self.getEnvironment('SelectionMode')
for elm in dataRecord[1]['data']['counters']:
alias = self.get_alias(str(elm))
self.deviceAliases[alias] = elm
for elm in dataRecord[1]['data']['column_desc']:
if "name" in elm.keys():
alias = self.get_alias(str(elm["name"]))
self.deviceAliases[alias] = elm["name"]
self.cutDeviceAliases = {}
for alias in self.deviceAliases.keys():
if alias.startswith("sca_exp_mca"):
self.cutDeviceAliases[alias] = "_".join(alias.split("_")[:3])
self.toReplace[alias] = "_".join(alias.split("_")[:3])
else:
self.cutDeviceAliases[alias] = alias
dsFound = {}
cpReq = {}
self.cnfServer = PyTango.DeviceProxy(self.cnfdevice)
if not self.cnfServer or not hasattr(self.cnfServer, "State"):
raise Exception, "Configuration server not accessible"
if PYQT:
self.emitter.emit(SIGNAL("updateCServer(QString)"),
QString(self.cnfdevice))
# self.cnfServer.State() == PyTango.DevState.RUNNING:
# self.cnfServer.Init()
self.cnfServer.Open()
if self.__ccmode == 'SARDANA_MODE':
cmps = self.cnfServer.AvailableComponents()
for cp in cmps:
dss = self.cnfServer.ComponentDataSources(cp)
for ds in dss:
if ds in self.cutDeviceAliases.values():
print ds, "found in ", cp
if ds not in dsFound.keys():
dsFound[ds] = []
dsFound[ds].append(cp)
if cp not in cpReq.keys():
cpReq[cp] = []
cpReq[cp].append(ds)
for ds in self.cutDeviceAliases.values():
if ds not in dsFound.keys():
print "Warning:", ds, "not found!"
mandatory = self.cnfServer.MandatoryComponents()
print "Default Components", mandatory
print "Sardana Components", cpReq.keys()
if not mandatory and not cpReq.keys():
raise Exception, "None of the components selected"
self.cnfServer.CreateConfiguration(cpReq.keys())
cnfxml = self.cnfServer.XMLString
return cnfxml
## inits Nexus Writer
# \param xml Nexus configuration string
def initNexusWriter(self, xml):
self.nexusWriter = PyTango.DeviceProxy(self.device)
if not self.nexusWriter or not hasattr(self.nexusWriter, 'State'):
raise Exception, "Tango Data Server not accessible"
if PYQT:
self.emitter.emit(SIGNAL("updateNWriter(QString)"),
QString(self.device))
self.nexusWriter.Init()
print " Connected to: ", self.device
fname = "%s/%s" % (self.scandir, self.filename)
print "FILE:", fname
self.nexusWriter.FileName = fname.encode()
if PYQT:
self.emitter.emit(SIGNAL("updateFile(QString)"), QString(fname))
print "opening the H5 file"
self.nexusWriter.OpenFile()
amsterdam = timezone('Europe/Amsterdam')
fmt = '%Y-%m-%dT%H:%M:%S.%f%z'
starttime = amsterdam.localize(datetime.now())
theString = '{"data": {'\
+' "sample_name":"test sample 1",'\
+' "start_time":"'+ str(starttime.strftime(fmt)) + '"' \
+'} }'
# +' "start_time":"2012-11-14T14:05:23.2344-0200"' \
self.nexusWriter.XMLSettings = xml
self.nexusWriter.JSONRecord = theString
print "opening the entry"
self.nexusWriter.OpenEntry()
## prepares a new scan and performs the INIT mode writing
# \param dataRecord Sardana data record
def prepareNewScan(self, dataRecord):
self.indexScan = 0
self.prepareFileName(dataRecord)
self.findScanLimits(dataRecord)
if PYQT:
self.emitter.emit(SIGNAL("updateNP(int,int)"), self.indexScan,
self.np + 1)
try:
xml = self.createNexusConfiguration(dataRecord)
except:
self.writing = False
print sys.exc_info()[0]
raise
try:
self.initNexusWriter(xml)
except:
self.writing = False
print sys.exc_info()[0]
# raise Exception,"Configuration cannot be performed. Abort writing"
raise
## performs the FINAL mode writing and closes the Nexus file
# \param dataRecord Sardana data record
def closeScan(self, dataRecord):
# close the H5 file
# optional JSON attribute
amsterdam = timezone('Europe/Amsterdam')
fmt = '%Y-%m-%dT%H:%M:%S.%f%z'
endtime = amsterdam.localize(datetime.now())
theString = '{"data": {'\
+' "end_time":"'+ str(endtime.strftime(fmt)) + '"' \
+'} }'
self.nexusWriter.JSONRecord = theString
print "closing the entry"
self.nexusWriter.CloseEntry()
print "closing the H5 file"
self.nexusWriter.CloseFile()
## replaces alias but cut aliases according to self.toReplaces
# \param text with aliases
# \returns text with cut aliases
def replaceAliases(self, text):
res = text
if self.toReplace:
for el in self.toReplace.keys():
res = res.replace(el, self.toReplace[el])
return res
## records Data
# \param s door s parameter
# \param t door t parameter
# \param v door v parameter
# \returns dataRecord on STEP mode
def recordDataReceived(self, s, t, v):
try:
dataRecord = taurus.core.tango.sardana.macroserver.BaseDoor.recordDataReceived(
self, s, t, v)
except:
self.writing = False
raise Exception, "Problems in fetching dataRecord"
if dataRecord == None:
return
print ">>> recordDataReceived "
pp.pprint(dataRecord)
# new scan
if "type" in dataRecord[1] and dataRecord[1]['type'] == "data_desc":
finished = False if self.getEnvironment(
'ScanFinished').upper() == "FALSE" else True
if not finished:
self.closeScan(dataRecord)
self.setEnvironment('ScanFinished', 'False')
self.writing = True
print "Writing NeXus: INIT"
self.prepareNewScan(dataRecord)
return dataRecord
# end of the scan2
if "type" in dataRecord[1] and dataRecord[1]['type'] == "record_end":
if self.writing:
print "Writing NeXus: FINAL"
self.closeScan(dataRecord)
env = self.getEnvironment()
self.setEnvironment('ScanFinished', 'True')
return dataRecord
# record step
if "type" in dataRecord[1] and dataRecord[1]['type'] == "record_data":
if self.writing:
jsonString = self.replaceAliases(json.dumps(dataRecord[1]))
print "Writing NeXus: STEP"
self.nexusWriter.record(jsonString)
self.indexScan += 1
if PYQT:
self.emitter.emit(SIGNAL("updateNP(int,int)"),
self.indexScan, self.np + 1)
return dataRecord
return dataRecord
def emit( self, record ):
QObject.emit( self, SIGNAL("log(QString,int)"), "%s: %s" % (record.name, record.getMessage()), 5000 )
