def checkForChanges(self):
gm = InstanceObject(**self.attributes)
self.gmEditor.applyChanges(gm)
changed = False
for attr in self.attributes:
if getattr(gm, attr) != self.attributes[attr]:
if str(getattr(gm, attr)) != str(self.attributes[attr]):
changed = True
break
#check if continents or ratios changed
if not changed and hasattr(self.gmEditor, 'continents'):
if self.continents is None:
if self.gmEditor.continents.currentIndex() != 0:
changed = True
elif self.continents != self.gmEditor.continents.currentIndex(
) + 1:
changed = True
if self.ratio is None:
if self.gmEditor.getAspectRatio() != 'autot':
changed = True
elif self.ratio != self.gmEditor.getAspectRatio():
changed = True
return changed
def getFunctionUpdates(self):
functions = []
gm = InstanceObject(**self.attributes)
self.gmEditor.applyChanges(gm)
for attr in self.attributes:
newval = getattr(gm, attr)
if newval != self.attributes[attr]:
functions.append((attr, [str(getattr(gm, attr))]))
self.attributes[attr] = newval
# FIXME why can't these be rolled in with self.attributes?
#continents
if hasattr(self.gmEditor, 'continents'):
gui_continent = self.gmEditor.continents.currentIndex() + 1
if self.continents is None or gui_continent != self.continents:
functions.append(('continents', [str(gui_continent)]))
self.continents = gui_continent
# aspect ratio
gui_ratio = self.gmEditor.getAspectRatio()
if self.ratio is None or gui_ratio != self.ratio:
functions.append(('ratio', [str(gui_ratio)]))
self.ratio = gui_ratio
return functions
def updateVistrail(self):
functions = []
gm = InstanceObject(**self.attributes)
self.gmEditor.applyChanges(gm)
pipeline = self.controller.vistrail.getPipeline(
self.controller.current_version)
# maybe this module was just added by the user in the gui and it was not
# added to the pipeline yet. So we need to add it before updating the
# functions
action1 = None
if self.module.id not in pipeline.modules:
ops = [('add', self.module)]
action1 = core.db.action.create_action(ops)
self.controller.add_new_action(action1)
self.controller.perform_action(action1)
for attr in self.attributes:
newval = getattr(gm, attr)
if newval != self.attributes[attr]:
functions.append((attr, [str(getattr(gm, attr))]))
self.attributes[attr] = newval
#continents
if hasattr(self.gmEditor, 'continents'):
gui_continent = self.gmEditor.continents.currentIndex() + 1
if self.continents is None:
func_obj = self.controller.create_function(
self.module, 'continents', [str(gui_continent)])
action1 = self.controller.add_function_action(
self.module, func_obj)
self.continents = gui_continent
elif gui_continent != self.continents:
functions.append(('continents', [str(gui_continent)]))
self.continents = gui_continent
# aspect ratio
gui_ratio = self.gmEditor.getAspectRatio()
if self.ratio is None:
func_obj = self.controller.create_function(self.module, 'ratio',
[str(gui_ratio)])
action1 = self.controller.add_function_action(
self.module, func_obj)
self.ratio = gui_ratio
elif gui_ratio != self.ratio:
functions.append(('ratio', [str(gui_ratio)]))
self.ratio = gui_ratio
action = self.controller.update_functions(self.module, functions)
if action is None:
action = action1
return (action, True)
def setupEditors(self):
gm = InstanceObject(**self.attributes)
self.gmEditor.initValues(gm)
#set continent
self.continents = self.getValueFromFunction('continents')
if self.continents:
self.gmEditor.continents.setCurrentIndex(self.continents - 1)
#set aspect ratio
self.ratio = self.getValueFromFunction('ratio')
#taylor diagram does not have aspectAuto
if hasattr(self.gmEditor, 'aspectAuto'):
if self.ratio is None or self.ratio == 'autot':
self.gmEditor.aspectAuto.setCheckState(Qt.Checked)
else:
#if the ratio cannot cast to float, check auto in gui
try:
self.gmEditor.aspectRatio.setText(str(float(self.ratio)))
self.gmEditor.aspectAuto.setCheckState(Qt.Unchecked)
except ValueError:
self.gmEditor.aspectAuto.setCheckState(Qt.Checked)
def initialize():
""" initialize() -> None
Package-entry to initialize the package
"""
# Check VTK version
v = vtksnl.vtkVersion()
version = [v.GetVTKMajorVersion(),
v.GetVTKMinorVersion(),
v.GetVTKBuildVersion()]
if version < [5, 0, 0]:
raise Exception("You need to upgrade your VTK install to version \
> >= 5.0.0")
inheritanceGraph = ClassTree(vtksnl)
inheritanceGraph.create()
# Transfer Function constant
tf_widget.initialize()
delayed = InstanceObject(add_input_port=[])
# Add VTK modules
registry = get_module_registry()
registry.add_module(vtkBaseModule)
createAllModules(inheritanceGraph)
setAllPorts(registry.get_descriptor_by_name(identifier,
'vtkObjectBase'),
delayed)
# Register the VTKCell and VTKHandler type if the spreadsheet is up
if registry.has_module('edu.utah.sci.vistrails.spreadsheet',
'SpreadsheetCell'):
import vtkhandler
import vtkcell
import vtkviewcell
vtkhandler.registerSelf()
vtkcell.registerSelf()
vtkviewcell.registerSelf()
# register offscreen rendering module
offscreen.register_self()
# Now add all "delayed" ports - see comment on addSetGetPorts
for args in delayed.add_input_port:
registry.add_input_port(*args)
# register Transfer Function adjustment
# This can't be reordered -- TransferFunction needs to go before
# vtkVolumeProperty, but vtkScaledTransferFunction needs
# to go after vtkAlgorithmOutput
getter = registry.get_descriptor_by_name
registry.add_module(tf_widget.vtkScaledTransferFunction)
registry.add_input_port(tf_widget.vtkScaledTransferFunction,
'Input', getter('edu.utah.sci.vistrails.vtksnl',
'vtkAlgorithmOutput').module)
registry.add_input_port(tf_widget.vtkScaledTransferFunction,
'Dataset', getter ('edu.utah.sci.vistrails.vtksnl',
'vtkDataObject').module)
registry.add_input_port(tf_widget.vtkScaledTransferFunction,
'Range', [Float, Float])
registry.add_input_port(tf_widget.vtkScaledTransferFunction,
'TransferFunction',
tf_widget.TransferFunctionConstant)
registry.add_output_port(tf_widget.vtkScaledTransferFunction,
'TransferFunction',
tf_widget.TransferFunctionConstant)
inspectors.initialize()
def displayCell(self, res30, row, column, sheet="Sheet 1", dropInfo=True):
"""Display result into one cell defined by row/col args"""
import pdb
projectController = self.parent().get_current_project_controller()
if dropInfo:
projectController.get_sheet_widget(sheet).deleteCell(row, column)
projectController.enable_animation = False # I (JfP) don't know why I need this, it didn't
# used to be necessary.
if res30 is None:
return
if not hasattr(
res30, 'presentation'
) or res30.presentation is None or res30.presentation is "text":
return
pvars = res30.vars
labels = res30.labels
title = res30.title
presentation = res30.presentation
Gtype = res30.type
if Gtype == "Taylor":
Gtype = "Taylordiagram"
pm = projectController.plot_manager
VCS_LIST = pm._plot_list["VCS"]
gm = res30.presentation
from packages.uvcdat_cdms.init import get_canvas, get_gm_attributes, original_gm_attributes
from gui.uvcdat.uvcdatCommons import gmInfos
if False: # standard diagnostics prints:
print "pvars:", [p.id for p in pvars]
print "labels:", labels
print "title:", title
print "presentation:", presentation
print "x min,max:", getattr(presentation, 'datawc_x1',
None), getattr(presentation,
'datawc_x2', None)
print "y min,max:", getattr(presentation, 'datawc_y1',
None), getattr(presentation,
'datawc_y2', None)
print "res", res30.type
#define where to drag and drop
import cdms2
from packages.uvcdat_cdms.init import CDMSVariable
from core.utils import InstanceObject
from metrics.frontend.uvcdat import diagnostics_template
tm = diagnostics_template() # template name is 'diagnostic'
if dropInfo:
tmplDropInfo = ('diagnostic', sheet, row, column)
projectController.template_was_dropped(tmplDropInfo)
if Gtype == 'Vector':
pvars = pvars[0]
for varindex, V in enumerate(pvars):
if Gtype != 'Vector':
V.title = title # VCS looks the title of the variable, not the plot.
V.long_name = V.title # VCS overrides title with long_name!
# Until I know better storing vars in tempfile....
f = tempfile.NamedTemporaryFile()
filename = f.name
f.close()
value = 0
cdms2.setNetcdfShuffleFlag(value) ## where value is either 0 or 1
cdms2.setNetcdfDeflateFlag(value) ## where value is either 0 or 1
cdms2.setNetcdfDeflateLevelFlag(
value) ## where value is a integer between 0 and 9 included
fd = cdms2.open(filename, "w")
fd.write(V)
fd.close()
cdmsFile = cdms2.open(filename)
#define name of variable to appear in var widget
if Gtype == 'Vector':
name_in_var_widget = V[0].id
else:
name_in_var_widget = V.id
#get uri if exists
url = None
if hasattr(cdmsFile, 'uri'):
url = cdmsFile.uri
#create vistrails module
cdmsVar = CDMSVariable(filename=cdmsFile.id,
url=url,
name=name_in_var_widget,
varNameInFile=name_in_var_widget) #V.id)
#get variable widget and project controller
definedVariableWidget = self.parent().dockVariable.widget()
#add variable to display widget and controller
definedVariableWidget.addVariable(V)
projectController.add_defined_variable(cdmsVar)
# simulate drop variable
varDropInfo = (name_in_var_widget, sheet, row, column)
projectController.variable_was_dropped(varDropInfo)
# Trying to add method to plot list....
#from gui.application import get_vistrails_application
#_app = get_vistrails_application()
#d = _app.uvcdatWindow.dockPlot
# simulate drop plot
G = VCS_LIST[Gtype]
if not gm.name in G.keys():
G[gm.name] = pm._registry.add_plot(gm.name, "VCS", None, None,
Gtype)
G[gm.name].varnum = int(gmInfos[Gtype]["nSlabs"])
#add initial attributes to global dict
canvas = get_canvas()
method_name = "get" + Gtype.lower()
attributes = get_gm_attributes(Gtype)
attrs = {}
for attr in attributes:
attrs[attr] = getattr(gm, attr)
original_gm_attributes[Gtype][gm.name] = InstanceObject(**attrs)
if Gtype in ["Scatter", "Vector"] and varindex == 0:
#to plot a scatter plot or vector plot, requires both axes passed to plotspec.
#so dont plot the 1st one until the 2nd variable is processed.
pass
else:
# simulate drop plot
plot = projectController.plot_manager.new_plot(
'VCS', Gtype, gm.name)
#plot = projectController.plot_manager.new_plot('VCS', Gtype, "default" )
plotDropInfo = (plot, sheet, row, column)
projectController.plot_was_dropped(plotDropInfo)
def translate_to_python(x):
return InstanceObject(
tuple=tuple([float(a) for a in x.split(',')]))
class Color(Constant):
# We set the value of a color object to be an InstanceObject that
# contains a tuple because a tuple would be interpreted as a
# type(tuple) which messes with the interpreter
def __init__(self):
Constant.__init__(self)
default_value = InstanceObject(tuple=(1,1,1))
@staticmethod
def translate_to_python(x):
return InstanceObject(
tuple=tuple([float(a) for a in x.split(',')]))
@staticmethod
def translate_to_string(v):
return str(v.tuple)[1:-1]
@staticmethod
def validate(x):
return type(x) == InstanceObject and hasattr(x, 'tuple')
@staticmethod
def to_string(r, g, b):
return "%s,%s,%s" % (r,g,b)
@staticmethod
def get_widget_class():
return ("gui.modules.constant_configuration", "ColorWidget")
@staticmethod
def get_query_widget_class():
return ("gui.modules.query_configuration", "ColorQueryWidget")
@staticmethod
def get_param_explore_widget_list():
return [('gui.modules.paramexplore', 'RGBExploreWidget'),
('gui.modules.paramexplore', 'HSVExploreWidget')]
@staticmethod
def query_compute(value_a, value_b, query_method):
# SOURCE: http://www.easyrgb.com/index.php?X=MATH
def rgb_to_xyz(r, g, b):
# r,g,b \in [0,1]
if r > 0.04045:
r = ( ( r + 0.055 ) / 1.055 ) ** 2.4
else:
r = r / 12.92
if g > 0.04045:
g = ( ( g + 0.055 ) / 1.055 ) ** 2.4
else:
g = g / 12.92
if b > 0.04045:
b = ( ( b + 0.055 ) / 1.055 ) ** 2.4
else:
b = b / 12.92
r *= 100
g *= 100
b *= 100
# Observer. = 2 deg, Illuminant = D65
x = r * 0.4124 + g * 0.3576 + b * 0.1805
y = r * 0.2126 + g * 0.7152 + b * 0.0722
z = r * 0.0193 + g * 0.1192 + b * 0.9505
return (x,y,z)
def xyz_to_cielab(x,y,z):
# Observer= 2 deg, Illuminant= D65
ref_x, ref_y, ref_z = (95.047, 100.000, 108.883)
x /= ref_x
y /= ref_y
z /= ref_z
if x > 0.008856:
x = x ** ( 1/3.0 )
else:
x = ( 7.787 * x ) + ( 16 / 116.0 )
if y > 0.008856:
y = y ** ( 1/3.0 )
else:
y = ( 7.787 * y ) + ( 16 / 116.0 )
if z > 0.008856:
z = z ** ( 1/3.0 )
else:
z = ( 7.787 * z ) + ( 16 / 116.0 )
L = ( 116 * y ) - 16
a = 500 * ( x - y )
b = 200 * ( y - z )
return (L, a, b)
def rgb_to_cielab(r,g,b):
return xyz_to_cielab(*rgb_to_xyz(r,g,b))
value_a_rgb = (float(a) for a in value_a.split(','))
value_b_rgb = (float(b) for b in value_b.split(','))
value_a_lab = rgb_to_cielab(*value_a_rgb)
value_b_lab = rgb_to_cielab(*value_b_rgb)
# cie76 difference
diff = sum((v_1 - v_2) ** 2
for v_1, v_2 in izip(value_a_lab, value_b_lab)) ** (0.5)
# print "CIE 76 DIFFERENCE:", diff
if query_method is None:
query_method = '2.3'
return diff < float(query_method)
def __init__(self, *args, **kwargs):
InstanceObject.__init__(self, *args, **kwargs)
self.__subscribers__ = {}
def init(self, optionsDict=None):
""" VistrailsApplicationSingleton(optionDict: dict)
-> VistrailsApplicationSingleton
Create the application with a dict of settings
"""
# gui.theme.initializeCurrentTheme()
# self.connect(self, QtCore.SIGNAL("aboutToQuit()"), self.finishSession)
# This is the persistent configuration
# Setup configuration to default
self.configuration = core.configuration.default()
self.keyChain = keychain.KeyChain()
self.setupOptions()
# self.temp_configuration is the configuration that will be updated
# with the command line and custom options dictionary.
# We have to do this because we don't want to make these settings
# persistent. This is the actual VisTrails current configuration
self.temp_configuration = copy.copy(self.configuration)
core.interpreter.default.connect_to_configuration(
self.temp_configuration)
# now we want to open vistrails and point to a specific version
# we will store the version in temp options as it doesn't
# need to be persistent. We will do the same to database
# information passed in the command line
self.temp_db_options = InstanceObject(host=None,
port=None,
db=None,
user=None,
vt_id=None,
parameters=None)
# Read only new .vistrails folder option if passed in the command line
# or in the optionsDict because this may affect the configuration file
# VistrailsStartup will load. This updates self.temp_configuration
self.read_dotvistrails_option()
if optionsDict and 'dotVistrails' in optionsDict.keys():
self.temp_configuration.dotVistrails = optionsDict['dotVistrails']
# the problem here is that if the user pointed to a new .vistrails
# folder, the persistent configuration will always point to the
# default ~/.vistrails. So we will copy whatever it's on
# temp_configuration to the persistent one. In case the configuration
# that is on disk is different, it will overwrite this one
self.configuration.dotVistrails = self.temp_configuration.dotVistrails
# During this initialization, VistrailsStartup will load the
# configuration from disk and update both configurations
self.vistrailsStartup = \
core.startup.VistrailsStartup(self.configuration,
self.temp_configuration)
# Starting in version 1.2.1 logging is enabled by default.
# Users have to explicitly disable it through the command-line
self.configuration.nologger = False
self.temp_configuration.nologger = False
if optionsDict:
for (k, v) in optionsDict.iteritems():
setattr(self.temp_configuration, k, v)
# Command line options override temp_configuration
self.readOptions()
# Redirect console output
if self.temp_configuration.output != "":
#place in dotVistrails dir if no path detected
if os.path.split(self.temp_configuration.output)[0] == '':
self.temp_configuration.output = os.path.join(
self.configuration.dotVistrails,
self.temp_configuration.output)
try:
sys.stdout = sys.stderr = open(self.temp_configuration.output,
"w")
except (Exception):
print "Failed to redirect output to file: %s" % self.temp_configuration.output
print Exception.message
if self.temp_configuration.check('staticRegistry'):
reg = self.temp_configuration.staticRegistry
else:
reg = None
self.vistrailsStartup.set_registry(reg)
def readOptions(self):
""" readOptions() -> None
Read arguments from the command line
"""
#print self
#print self.__class__
get = command_line.CommandLineParser().get_option
self.uvcdatLoadFileStart = get('uvcdat_filename')
self.uvcdatLoadVariableStart = get('uvcdat_var')
if get('nosplash') != None:
self.temp_configuration.showSplash = bool(get('nosplash'))
if get('debugsignals') != None:
self.temp_configuration.debugSignals = bool(get('debugsignals'))
if get('dotVistrails') != None:
self.temp_configuration.dotVistrails = get('dotVistrails')
#in theory this should never happen because core.configuration.default()
#should have done this already
#if not self.configuration.check('dotVistrails'):
# self.configuration.dotVistrails = system.default_dot_vistrails()
# self.temp_configuration.dotVistrails = system.default_dot_vistrails()
if get('multiheads') != None:
self.temp_configuration.multiHeads = bool(get('multiheads'))
if get('maximized') != None:
self.temp_configuration.maximizeWindows = bool(get('maximized'))
if get('movies') != None:
self.temp_configuration.showMovies = bool(get('movies'))
if get('cache') != None:
self.temp_configuration.useCache = bool(get('cache'))
if get('verbose') != None:
self.temp_configuration.verbosenessLevel = get('verbose')
if get('fixedcells') != None:
self.temp_configuration.fixedSpreadsheetCells = str(
get('fixedcells'))
if get('noninteractive') != None:
self.temp_configuration.interactiveMode = \
not bool(get('noninteractive'))
if get('workflowinfo') != None:
self.temp_configuration.workflowInfo = str(get('workflowinfo'))
if get('dumpcells') != None:
self.temp_configuration.spreadsheetDumpCells = get('dumpcells')
if get('pdf') != None:
self.temp_configuration.spreadsheetDumpPDF = get('pdf')
if get('workflowgraph') != None:
self.temp_configuration.workflowGraph = str(
get('workflowgraph'))
if get('evolutiongraph') != None:
self.temp_configuration.evolutionGraph = str(
get('evolutiongraph'))
if get('executeworkflows') != None:
self.temp_configuration.executeWorkflows = \
bool(get('executeworkflows'))
if get('showspreadsheetonly') != None:
self.temp_configuration.showSpreadsheetOnly = \
bool(get('showspreadsheetonly'))
# asking to show only the spreadsheet will force the workflows to
# be executed
if get('reviewmode') != None:
self.temp_configuration.reviewMode = bool(get('reviewmode'))
if self.temp_configuration.showSpreadsheetOnly and not self.temp_configuration.reviewMode:
self.temp_configuration.executeWorkflows = True
self.temp_db_options = InstanceObject(host=get('host'),
port=get('port'),
db=get('db'),
user=get('user'),
parameters=get('parameters'))
if get('nologger') != None:
self.temp_configuration.nologger = bool(get('nologger'))
if get('quickstart') != None:
self.temp_configuration.staticRegistry = str(get('quickstart'))
if get('detachHistoryView') != None:
self.temp_configuration.detachHistoryView = bool(
get('detachHistoryView'))
if get('noSingleInstance') != None:
self.temp_configuration.singleInstance = not bool(
get('noSingleInstance'))
if get('noDebugPopups') != None:
self.temp_configuration.noDebugPopups = bool(get('noDebugPopups'))
if get('time') != None:
self.temp_configuration.time = get("time")
if get('testUVCDAT') != None:
self.temp_configuration.testUVCDAT = bool(get("testUVCDAT"))
if get('cdatSourceDir') != None:
self.temp_configuration.cdatSourceDir = get("cdatSourceDir")
self.temp_configuration.specificTest = get("specificTest")
if get('output') != None:
self.temp_configuration.output = get("output")
if get('noErrorReporting') != None:
self.temp_configuration.noErrorReporting = bool(
get('noErrorReporting'))
self.input = command_line.CommandLineParser().positional_arguments()
def updateFromPipeline(self, pipeline):
""" updateFromPipeline(pipeline: Pipeline) -> None
Read the list of aliases and parameters from the pipeline
"""
self.clear()
if not pipeline:
return
# Update the aliases
# if len(pipeline.aliases)>0:
# aliasRoot = QParameterTreeWidgetItem(None, self,
# QtCore.QStringList('Aliases'))
# aliasRoot.setFlags(QtCore.Qt.ItemIsEnabled,
# )
# for (alias, info) in pipeline.aliases.iteritems():
# ptype, pId, parentType, parentId, _ = info
# parameter = pipeline.db_get_object(ptype, pId)
# v = parameter.strValue
# aType = parameter.type
# aIdentifier = parameter.identifier
# aNamespace = parameter.namespace
# label = QtCore.QStringList('%s = %s' % (alias, v))
# pInfo = InstanceObject(type=aType,
# identifier=aIdentifier,
# namespace=aNamespace,
# value=v,
# id=pId,
# dbtype=ptype,
# parent_dbtype=parentType,
# parent_id=parentId,
# is_alias=True)
# aliasItem = QParameterTreeWidgetItem((alias, [pInfo]),
# aliasRoot, label)
# aliasRoot.setExpanded(True)
# Now go through all modules and functions
self.aliasNames = pipeline.aliases.keys()
inspector = PipelineInspector()
inspector.inspect_ambiguous_modules(pipeline)
sortedModules = sorted(pipeline.modules.iteritems(),
key=lambda item: item[1].name)
for mId, module in sortedModules:
if len(module.functions) > 0:
mLabel = QtCore.QStringList(module.name)
moduleItem = None
for fId in xrange(len(module.functions)):
function = module.functions[fId]
if len(function.params) == 0: continue
if moduleItem == None:
if inspector.annotated_modules.has_key(mId):
annotatedId = inspector.annotated_modules[mId]
moduleItem = QAliasParameterTreeWidgetItem(
annotatedId, self, mLabel)
else:
moduleItem = QAliasParameterTreeWidgetItem(
None, self, mLabel)
#v = ', '.join([p.strValue for p in function.params])
label = QtCore.QStringList('%s' % function.name)
pList = [
InstanceObject(
type=function.params[pId].type,
identifier=function.params[pId].identifier,
namespace=function.params[pId].namespace,
value=function.params[pId].strValue,
id=function.params[pId].real_id,
dbtype=ModuleParam.vtType,
parent_dbtype=function.vtType,
parent_id=function.real_id,
alias=function.params[pId].alias,
mId=mId) for pId in xrange(len(function.params))
]
mName = module.name
if moduleItem.parameter != None:
mName += '(%d)' % moduleItem.parameter
fName = '%s :: %s' % (mName, function.name)
mItem = QAliasParameterTreeWidgetItem((fName, pList),
moduleItem, label)
if moduleItem:
moduleItem.setExpanded(True)