def processCommand(self, terms):
print " -- processCommand: %s " % str( terms )
if terms[0] == "reltimestep":
relTimeValue = float( terms[1] )
relTimeIndex = float( terms[2] )
useTimeIndex = bool(terms[3])
displayText = terms[4]
if self.current_pipeline:
for module in self.current_pipeline.module_list:
persistentCellModule = ModuleStore.getModule( module.id )
if persistentCellModule: persistentCellModule.updateAnimation( [ relTimeValue, relTimeIndex, useTimeIndex ], displayText )
elif terms[0] == "pipelineHelper":
if self.current_config_function:
if self.current_config_function.type == 'leveling':
range = list( self.current_config_function.range )
cmd_args = terms[1].split('-')
iRangeArg = int( cmd_args[1] )
range[ iRangeArg ] = float( terms[2] )
# print " --- PipelineHelper: set range = ", str( range )
self.current_config_function.broadcastLevelingData( range )
else:
pass
# print " --- PipelineHelper, config type: ", self.current_config_function.type
else:
if self.current_pipeline:
for module in self.current_pipeline.module_list:
persistentCellModule = ModuleStore.getModule( module.id )
if persistentCellModule: persistentCellModule.updateConfigurationObserver( terms[0], terms[1:] )
def addVariable(self, var, type_='CDMS'):
""" Add variable into dict / list & emit signal to create
a tab for the variable
"""
if var is None:
return
from packages.vtDV3D import ModuleStore
cdmsVar = None
replaced = False
if type_ == 'CDMS':
if type(var) == tuple:
cdmsVar = var[1]
var = var[0]
self.root.stick_defvar_into_main_dict(var)
for i in range(self.varList.count()-1,-1,-1):
if self.varList.item(i).getVarName() == var.id:
replaced = True
item = self.varList.item(i)
item.setVariable(var)
ModuleStore.addActiveVariable( item.varName, item.variable )
break
if not replaced:
item = QDefinedVariableItem(var,self.root,cdmsVar)
self.varList.addItem(item)
ModuleStore.addActiveVariable( item.varName, item.variable )
def processCommand(self, terms):
print " -- processCommand: %s " % str(terms)
if terms[0] == "reltimestep":
relTimeValue = float(terms[1])
relTimeIndex = float(terms[2])
useTimeIndex = bool(terms[3])
displayText = terms[4]
if self.current_pipeline:
for module in self.current_pipeline.module_list:
persistentCellModule = ModuleStore.getModule(module.id)
if persistentCellModule:
persistentCellModule.updateAnimation(
[relTimeValue, relTimeIndex, useTimeIndex],
displayText)
elif terms[0] == "pipelineHelper":
if self.current_config_function:
if self.current_config_function.type == 'leveling':
range = list(self.current_config_function.range)
cmd_args = terms[1].split('-')
iRangeArg = int(cmd_args[1])
range[iRangeArg] = float(terms[2])
# print " --- PipelineHelper: set range = ", str( range )
self.current_config_function.broadcastLevelingData(range)
else:
pass
# print " --- PipelineHelper, config type: ", self.current_config_function.type
else:
if self.current_pipeline:
for module in self.current_pipeline.module_list:
persistentCellModule = ModuleStore.getModule(module.id)
if persistentCellModule:
persistentCellModule.updateConfigurationObserver(
terms[0], terms[1:])
def myPressed(self, item):
from packages.vtDV3D import ModuleStore
if item.isSelected():
self.selectVariableFromListEvent(item)
self.waitingForClick = False
ModuleStore.setActiveVariable( item.varName )
else:
self.waitingForClick = True
item.setSelected(True) # wait for click to deselect
def getPersistentModule( self, **args ):
mid = self.moduleInfo['moduleId']
force = args.get('force',False)
module = ModuleStore.getModule( mid )
if force and ( module == None ):
module = ModuleStore.forceGetModule( mid, self.__class__.PersistentModuleClass( mid, **args ) )
if module:
invalidate = args.get('invalidate',False)
if invalidate: module.invalidateWorkflowModule( self )
else: module.setWorkflowModule( self )
return module
def getPersistentModule(self, **args):
mid = self.moduleInfo['moduleId']
force = args.get('force', False)
module = ModuleStore.getModule(mid)
if force and (module == None):
module = ModuleStore.forceGetModule(
mid, self.__class__.PersistentModuleClass(mid, **args))
if module:
invalidate = args.get('invalidate', False)
if invalidate: module.invalidateWorkflowModule(self)
else: module.setWorkflowModule(self)
return module
def finalizePlot( self, plot_name ):
from packages.vtDV3D import ModuleStore
from packages.vtDV3D.CDMS_VariableReaders import CDMSTransientVariable
from core.db.action import create_action
proj_controller = self.app.uvcdatWindow.get_current_project_controller()
controller = self.app.get_controller()
plot = proj_controller.plot_registry.add_plot( plot_name, 'DV3D', None, None )
action = create_action( self.port_ops )
controller.add_new_action(action)
controller.perform_action(action)
controller.select_latest_version()
current_version = controller.current_version
proj_controller.plot_was_dropped( (plot, self.sheetName, self.row, self.col) )
proj_controller.execute_plot( current_version )
controller.change_selected_version( current_version )
proj_controller.update_plot_configure( self.sheetName, self.row, self.col )
cell = proj_controller.sheet_map[ self.sheetName ][ ( self.row, self.col ) ]
cell.current_parent_version = current_version
cell_address = "%s%s" % ( chr(ord('A') + self.col ), self.row + 1 )
sheetName = proj_controller.current_sheetName
cell_location = [ proj_controller.name, sheetName, cell_address ]
pipeline = controller.current_pipeline
for mid in pipeline.modules.keys():
pmod = ModuleStore.getModule( mid )
if pmod: pmod.setCellLocation( cell_location )
for ( name, var ) in self.variables:
dvar = CDMSTransientVariable.from_module( var )
proj_controller.defined_variables[ name ] = dvar
proj_controller.emit( QtCore.SIGNAL("update_cell"), self.sheetName, self.row, self.col, None, None, 'DV3D', current_version )
def deleteVariable(self, varid):
""" Remove variable from dict and project
"""
from packages.vtDV3D import ModuleStore
from packages.vtDV3D.vtUtilities import memoryLogger
memoryLogger.log("start QDefinedVariableWidget.deleteVariable")
for i in range(self.varList.count()-1,-1,-1):
if self.varList.item(i).getVarName() == varid:
success = True
#this will delete from all projects
for project in self.varList.item(i).projects:
controller = self.root.get_project_controller_by_name(project)
if controller:
if controller.remove_defined_variable(varid):
self.varList.takeItem(i)
else:
success = False
ModuleStore.removeActiveVariable( varid )
if success and varid in __main__.__dict__:
del __main__.__dict__[varid]
memoryLogger.log("finished QDefinedVariableWidget.deleteVariable")
def finalizePlot(self, plot_name):
from packages.vtDV3D import ModuleStore
from packages.vtDV3D.CDMS_VariableReaders import CDMSTransientVariable
from core.db.action import create_action
proj_controller = self.app.uvcdatWindow.get_current_project_controller(
)
controller = self.app.get_controller()
plot = proj_controller.plot_registry.add_plot(plot_name, 'DV3D', None,
None)
action = create_action(self.port_ops)
controller.add_new_action(action)
controller.perform_action(action)
controller.select_latest_version()
current_version = controller.current_version
proj_controller.plot_was_dropped(
(plot, self.sheetName, self.row, self.col))
proj_controller.execute_plot(current_version)
controller.change_selected_version(current_version)
proj_controller.update_plot_configure(self.sheetName, self.row,
self.col)
cell = proj_controller.sheet_map[self.sheetName][(self.row, self.col)]
cell.current_parent_version = current_version
cell_address = "%s%s" % (chr(ord('A') + self.col), self.row + 1)
sheetName = proj_controller.current_sheetName
cell_location = [proj_controller.name, sheetName, cell_address]
pipeline = controller.current_pipeline
for mid in pipeline.modules.keys():
pmod = ModuleStore.getModule(mid)
if pmod: pmod.setCellLocation(cell_location)
for (name, var) in self.variables:
dvar = CDMSTransientVariable.from_module(var)
proj_controller.defined_variables[name] = dvar
proj_controller.emit(QtCore.SIGNAL("update_cell"), self.sheetName,
self.row, self.col, None, None, 'DV3D',
current_version)
def processEvent(self, terms):
"""processEvent(message: String) -> None
decodifies the event received by the server and posts it to QT's event handler. In order
to do this, we must send three events: the first one disables this client's method that
would send events to the server. The second is the actual event we want processed and the third
reenables event sending to the server. This must be done to avoid a deadlock"""
def decodeMouseEvent( event, screenDims ):
"""decodeMouseEvent(event: String) -> QtGui.QMouseEvent
this method receives a string and returns the corresponding mouse event"""
pos = ( int( float( event[2] ) * screenDims[0] ), int( float( event[3] ) * screenDims[1] ) )
if event[1] == "left":
button = QtCore.Qt.LeftButton
elif event[1] == "right":
button = QtCore.Qt.RightButton
if event[0] == "singleClick":
t = QtCore.QEvent.MouseButtonPress
elif event[0] == "mouseMove":
t = QtCore.QEvent.MouseMove
button = QtCore.Qt.NoButton
elif event[0] == "mouseRelease":
t = QtCore.QEvent.MouseButtonRelease
button = QtCore.Qt.MouseButton(button)
m = QtCore.Qt.NoModifier
if event[4] == "shift":
m = QtCore.Qt.ShiftModifier
elif event[4] == "ctrl":
m = QtCore.Qt.ControlModifier
elif event[4] == "alt":
m = QtCore.Qt.AltModifier
# print " Client process %s %s event: pos = %s, screenDims=%s " % ( button, event[0], str( pos ), str( screenDims ) )
return QtGui.QMouseEvent(t, QtCore.QPoint(pos[0], pos[1]), button, button, m)
def decodeKeyEvent(event):
"""decodeKeyEvent(event: String) -> QtGui.QKeyEvent
this method receives a string and returns the corresponding Key event"""
type = None
if event[0] == "keyPress":
type = QtCore.QEvent.KeyPress
elif event[0] == "keyRelease":
type = QtCore.QEvent.KeyRelease
key = int( event[1] )
m = QtCore.Qt.NoModifier
if event[2] == "shift":
m = QtCore.Qt.ShiftModifier
elif event[2] == "ctrl":
m = QtCore.Qt.ControlModifier
elif event[2] == "alt":
m = QtCore.Qt.AltModifier
# print " Client process key event: %s " % str( event )
return QtGui.QKeyEvent( type, key, QtCore.Qt.KeyboardModifiers(m) )
app = QtCore.QCoreApplication.instance()
newTab = self.updateCurrentTab()
widget = self.currentTab.getCellWidget( 0, 0 ) if self.currentTab else None
# print " ------------- QiVisClient.processEvent: %s ---------------------" % ( str(terms) )
sys.stdout.flush()
if terms[2] == "interactionState":
if self.current_pipeline:
state = terms[3] if ( len(terms) > 3 ) else None
altMode = terms[4] if ( len(terms) > 4 ) else None
print " ~~~~~ Setting Client Interaction State: ", str(state), str(altMode)
sys.stdout.flush()
for module in self.current_pipeline.module_list:
persistentModule = ModuleStore.getModule( module.id )
if persistentModule:
cf = persistentModule.updateInteractionState( state, altMode )
if cf: self.current_config_function = cf
else: print "Can't find client persistentModule: ", module.id
else:
newEvent = None
if terms[2] == "singleClick":
cellModules = self.getCellModules()
cpos = [ float(terms[i]) for i in range(7,10) ]
cfol = [ float(terms[i]) for i in range(10,13) ]
cup = [ float(terms[i]) for i in range(13,16) ]
# print " >>> QiVisClient.cellModules: %s, modules: %s" % ( str( [ cellMod.id for cellMod in cellModules ] ), str( ModuleStore.getModuleIDs() ) )
for cellMod in cellModules:
persistentCellModule = ModuleStore.getModule( cellMod.id )
if persistentCellModule: persistentCellModule.syncCamera( cpos, cfol, cup )
if terms[2] in ["singleClick", "mouseMove", "mouseRelease"]:
if self.currentTab:
screenRect = self.currentTab.getCellRect( 0, 0 )
screenDims = ( screenRect.width(), screenRect.height() )
newEvent = decodeMouseEvent( terms[2:], screenDims )
elif terms[2] in ["keyPress", "keyRelease" ]:
newEvent = decodeKeyEvent(terms[2:])
if widget and newEvent:
cellWidget = widget.widget()
app.postEvent( cellWidget, newEvent)
cellWidget.setFocus()
cellWidget.update()
def processEvent(self, terms):
"""processEvent(message: String) -> None
decodifies the event received by the server and posts it to QT's event handler. In order
to do this, we must send three events: the first one disables this client's method that
would send events to the server. The second is the actual event we want processed and the third
reenables event sending to the server. This must be done to avoid a deadlock"""
def decodeMouseEvent(event, screenDims):
"""decodeMouseEvent(event: String) -> QtGui.QMouseEvent
this method receives a string and returns the corresponding mouse event"""
pos = (int(float(event[2]) * screenDims[0]),
int(float(event[3]) * screenDims[1]))
if event[1] == "left":
button = QtCore.Qt.LeftButton
elif event[1] == "right":
button = QtCore.Qt.RightButton
if event[0] == "singleClick":
t = QtCore.QEvent.MouseButtonPress
elif event[0] == "mouseMove":
t = QtCore.QEvent.MouseMove
button = QtCore.Qt.NoButton
elif event[0] == "mouseRelease":
t = QtCore.QEvent.MouseButtonRelease
button = QtCore.Qt.MouseButton(button)
m = QtCore.Qt.NoModifier
if event[4] == "shift":
m = QtCore.Qt.ShiftModifier
elif event[4] == "ctrl":
m = QtCore.Qt.ControlModifier
elif event[4] == "alt":
m = QtCore.Qt.AltModifier
# print " Client process %s %s event: pos = %s, screenDims=%s " % ( button, event[0], str( pos ), str( screenDims ) )
return QtGui.QMouseEvent(t, QtCore.QPoint(pos[0], pos[1]), button,
button, m)
def decodeKeyEvent(event):
"""decodeKeyEvent(event: String) -> QtGui.QKeyEvent
this method receives a string and returns the corresponding Key event"""
type = None
if event[0] == "keyPress":
type = QtCore.QEvent.KeyPress
elif event[0] == "keyRelease":
type = QtCore.QEvent.KeyRelease
key = int(event[1])
m = QtCore.Qt.NoModifier
if event[2] == "shift":
m = QtCore.Qt.ShiftModifier
elif event[2] == "ctrl":
m = QtCore.Qt.ControlModifier
elif event[2] == "alt":
m = QtCore.Qt.AltModifier
# print " Client process key event: %s " % str( event )
return QtGui.QKeyEvent(type, key, QtCore.Qt.KeyboardModifiers(m))
app = QtCore.QCoreApplication.instance()
newTab = self.updateCurrentTab()
widget = self.currentTab.getCellWidget(0,
0) if self.currentTab else None
# print " ------------- QiVisClient.processEvent: %s ---------------------" % ( str(terms) )
sys.stdout.flush()
if terms[2] == "interactionState":
if self.current_pipeline:
state = terms[3] if (len(terms) > 3) else None
altMode = terms[4] if (len(terms) > 4) else None
print " ~~~~~ Setting Client Interaction State: ", str(
state), str(altMode)
sys.stdout.flush()
for module in self.current_pipeline.module_list:
persistentModule = ModuleStore.getModule(module.id)
if persistentModule:
cf = persistentModule.updateInteractionState(
state, altMode)
if cf: self.current_config_function = cf
else:
print "Can't find client persistentModule: ", module.id
else:
newEvent = None
if terms[2] == "singleClick":
cellModules = self.getCellModules()
cpos = [float(terms[i]) for i in range(7, 10)]
cfol = [float(terms[i]) for i in range(10, 13)]
cup = [float(terms[i]) for i in range(13, 16)]
# print " >>> QiVisClient.cellModules: %s, modules: %s" % ( str( [ cellMod.id for cellMod in cellModules ] ), str( ModuleStore.getModuleIDs() ) )
for cellMod in cellModules:
persistentCellModule = ModuleStore.getModule(cellMod.id)
if persistentCellModule:
persistentCellModule.syncCamera(cpos, cfol, cup)
if terms[2] in ["singleClick", "mouseMove", "mouseRelease"]:
if self.currentTab:
screenRect = self.currentTab.getCellRect(0, 0)
screenDims = (screenRect.width(), screenRect.height())
newEvent = decodeMouseEvent(terms[2:], screenDims)
elif terms[2] in ["keyPress", "keyRelease"]:
newEvent = decodeKeyEvent(terms[2:])
if widget and newEvent:
cellWidget = widget.widget()
app.postEvent(cellWidget, newEvent)
cellWidget.setFocus()
cellWidget.update()
def execute(self, **args ):
import api
from packages.vtDV3D.CDMS_DatasetReaders import CDMSDataset
cdms_vars = self.getInputValues( "variable" )
if cdms_vars and len(cdms_vars):
iVar = 1
cdms_var = cdms_vars.pop(0)
self.cdmsDataset = CDMSDataset()
var, dsetId = self.addCDMSVariable( cdms_var, iVar )
self.newDataset = ( self.datasetId <> dsetId )
if self.newDataset: ModuleStore.archiveCdmsDataset( dsetId, self.cdmsDataset )
self.newLayerConfiguration = self.newDataset
self.datasetId = dsetId
self.designateAxes(var)
self.nTimesteps = 1
self.timeRange = [ 0, self.nTimesteps, 0.0, 0.0 ]
self.timeAxis = var.getTime()
if self.timeAxis:
self.nTimesteps = len( self.timeAxis ) if self.timeAxis else 1
try:
comp_time_values = self.timeAxis.asComponentTime()
t0 = comp_time_values[0].torel(self.referenceTimeUnits).value
if (t0 < 0):
self.referenceTimeUnits = self.timeAxis.units
t0 = comp_time_values[0].torel(self.referenceTimeUnits).value
dt = 0.0
if self.nTimesteps > 1:
t1 = comp_time_values[-1].torel(self.referenceTimeUnits).value
dt = (t1-t0)/(self.nTimesteps-1)
self.timeRange = [ 0, self.nTimesteps, t0, dt ]
except:
values = self.timeAxis.getValue()
t0 = values[0] if len(values) > 0 else 0
t1 = values[-1] if len(values) > 1 else t0
dt = ( values[1] - values[0] )/( len(values) - 1 ) if len(values) > 1 else 0
self.timeRange = [ 0, self.nTimesteps, t0, dt ]
self.setParameter( "timeRange" , self.timeRange )
self.cdmsDataset.timeRange = self.timeRange
self.cdmsDataset.referenceTimeUnits = self.referenceTimeUnits
self.timeLabels = self.cdmsDataset.getTimeValues()
timeData = args.get( 'timeData', [ self.cdmsDataset.timeRange[2], 0, False ] )
self.timeValue = cdtime.reltime( float(timeData[0]), self.referenceTimeUnits )
self.timeIndex = timeData[1]
self.useTimeIndex = timeData[2]
# print "Set Time [mid = %d]: %s, NTS: %d, Range: %s, Index: %d (use: %s)" % ( self.moduleID, str(self.timeValue), self.nTimesteps, str(self.timeRange), self.timeIndex, str(self.useTimeIndex) )
# print "Time Step Labels: %s" % str( self.timeLabels )
intersectedRoi = self.cdmsDataset.gridBounds
intersectedRoi = self.getIntersectedRoi( cdms_var, intersectedRoi )
while( len(cdms_vars) ):
cdms_var2 = cdms_vars.pop(0)
if cdms_var2:
iVar = iVar+1
self.addCDMSVariable( cdms_var2, iVar )
intersectedRoi = self.getIntersectedRoi( cdms_var2, intersectedRoi )
for iVarInputIndex in range( 2,5 ):
cdms_var2 = self.getInputValue( "variable%d" % iVarInputIndex )
if cdms_var2:
iVar = iVar+1
self.addCDMSVariable( cdms_var2, iVar )
intersectedRoi = self.getIntersectedRoi( cdms_var2, intersectedRoi )
self.generateOutput(roi=intersectedRoi)
# if self.newDataset: self.addAnnotation( "datasetId", self.datasetId )
else:
dset = self.getInputValue( "dataset" )
if dset:
self.cdmsDataset = dset
# dsetid = self.getAnnotation( "datasetId" )
# if dsetid: self.datasetId = dsetid
dsetId = self.cdmsDataset.getDsetId()
# self.newDataset = ( self.datasetId <> dsetId )
self.newLayerConfiguration = True # self.newDataset
self.datasetId = dsetId
ModuleStore.archiveCdmsDataset( self.datasetId, self.cdmsDataset )
self.timeRange = self.cdmsDataset.timeRange
timeData = args.get( 'timeData', [ self.cdmsDataset.timeRange[2], 0, False ] )
self.timeValue = cdtime.reltime( float(timeData[0]), self.referenceTimeUnits )
self.timeIndex = timeData[1]
self.useTimeIndex = timeData[2]
self.timeLabels = self.cdmsDataset.getTimeValues()
self.nTimesteps = self.timeRange[1]
# print "Set Time: %s, NTS: %d, Range: %s, Index: %d (use: %s)" % ( str(self.timeValue), self.nTimesteps, str(self.timeRange), self.timeIndex, str(self.useTimeIndex) )
# print "Time Step Labels: %s" % str( self.timeLabels )
self.generateOutput()