def trace_ctor(self, ctor, filter, ctor_args=None, skip_assignment=False):
xmlElement = self.get_object().GetHints().FindNestedElementByName(
"WriterProxy")
xmlgroup = xmlElement.GetAttribute("group")
xmlname = xmlElement.GetAttribute("name")
write_frequency = self.get_object().GetProperty(
"WriteFrequency").GetElement(0)
filename = self.get_object().GetProperty("FileName").GetElement(0)
padding_amount = self.get_object().GetProperty(
"PaddingAmount").GetElement(0)
ctor = self.get_proxy_label(xmlgroup, xmlname)
original_trace = smtrace.RealProxyAccessor.trace_ctor(\
self, ctor, WriterFilter(), ctor_args, skip_assignment)
trace = smtrace.TraceOutput(original_trace)
trace.append_separated([
"# register the writer with coprocessor",
"# and provide it with information such as the filename to use,",
"# how frequently to write the data, etc."
])
trace.append("coprocessor.RegisterWriter(%s, filename='%s', freq=%s, paddingamount=%s)" % \
(self, filename, write_frequency, padding_amount))
trace.append_separator()
return trace.raw_data()
def trace_ctor(self, ctor, filter, ctor_args=None, skip_assignment=False):
# FIXME: ensures thate FileName doesn't get traced.
# change to call STP.CreateReader instead.
ctor_args = "%s, fileInfo='%s'" % (ctor, self.FileNameGlob)
ctor = "STP.CreateReader"
original_trace = smtrace.RealProxyAccessor.trace_ctor(\
self, ctor, ReaderFilter(), ctor_args, skip_assignment)
trace = smtrace.TraceOutput()
trace.append(original_trace)
trace.append(\
"timeSteps = %s.TimestepValues if len(%s.TimestepValues) != 0 else [0]" % (self, self))
return trace.raw_data()
def trace_ctor(self, ctor, filter, ctor_args=None, skip_assignment=False):
original_trace = smtrace.RealProxyAccessor.trace_ctor( \
self, ctor, filter, ctor_args, skip_assignment)
trace = smtrace.TraceOutput(original_trace)
if self.varname in cpstate_globals.cinema_arrays:
arrays = cpstate_globals.cinema_arrays[self.varname]
trace.append_separated(["# define target arrays of filters."])
trace.append([
"coprocessor.AddArraysToCinemaTrack(%s, 'arraySelection', %s)"
% (self, arrays)
])
trace.append_separator()
return trace.raw_data()
def trace_ctor(self, ctor, filter, ctor_args=None, skip_assignment=False):
original_trace = smtrace.RealProxyAccessor.trace_ctor(\
self, ctor, filter, ctor_args, skip_assignment)
trace = smtrace.TraceOutput(original_trace)
trace.append_separated(["# register the view with coprocessor",
"# and provide it with information such as the filename to use,",
"# how frequently to write the images, etc."])
params = self.ScreenshotInfo
assert len(params) == 4
trace.append([
"STP.RegisterView(%s," % self,
" filename='%s', magnification=%s, width=%s, height=%s, tp_views=tp_views)" %\
(params[0], params[1], params[2], params[3])])
trace.append_separator()
return trace.raw_data()
def trace_ctor(self, ctor, filter, ctor_args=None, skip_assignment=False):
trace = smtrace.TraceOutput()
trace.append("# create a producer from a simulation input")
trace.append("%s = coprocessor.CreateProducer(datadescription, '%s')" % \
(self, self.SimulationInputName))
if self.varname in cpstate_globals.cinema_arrays:
arrays = cpstate_globals.cinema_arrays[self.varname]
trace.append_separated(["# define target arrays of filters."])
trace.append([
"coprocessor.AddArraysToCinemaTrack(%s, 'arraySelection', %s)"
% (self, arrays)
])
trace.append_separator()
return trace.raw_data()
def trace_ctor(self, ctor, filter, ctor_args=None, skip_assignment=False):
xmlElement = self.get_object().GetHints().FindNestedElementByName("WriterProxy")
xmlgroup = xmlElement.GetAttribute("group")
xmlname = xmlElement.GetAttribute("name")
filename = self.get_object().FileName
ctor = self.get_proxy_label(xmlgroup, xmlname)
original_trace = smtrace.RealProxyAccessor.trace_ctor(\
self, ctor, filter, ctor_args, skip_assignment)
trace = smtrace.TraceOutput(original_trace)
trace.append_separated(["# register the writer with STP",
"# and provide it with information such as the filename to use"])
trace.append("STP.RegisterWriter(%s, '%s', tp_writers)" % \
(self, filename))
trace.append_separator()
return trace.raw_data()
def trace_ctor(self, ctor, filter, ctor_args=None, skip_assignment=False):
original_trace = smtrace.RealProxyAccessor.trace_ctor(\
self, ctor, filter, ctor_args, skip_assignment)
trace = smtrace.TraceOutput(original_trace)
if self.ProxyName in cpstate_globals.screenshot_info:
trace.append_separated([
"# register the view with coprocessor",
"# and provide it with information such as the filename to use,",
"# how frequently to write the images, etc."
])
params = cpstate_globals.screenshot_info[self.ProxyName]
assert len(params) == 7
trace.append([
"coprocessor.RegisterView(%s," % self,
" filename='%s', freq=%s, fittoscreen=%s, magnification=%s, width=%s, height=%s, cinema=%s)" %\
(params[0], params[1], params[2], params[3], params[4], params[5], params[6]),
"%s.ViewTime = datadescription.GetTime()" % self])
trace.append_separator()
return trace.raw_data()
def trace_ctor(self, ctor, filter, ctor_args=None, skip_assignment=False):
original_trace = smtrace.RealProxyAccessor.trace_ctor( \
self, ctor, filter, ctor_args, skip_assignment)
trace = smtrace.TraceOutput(original_trace)
if cpstate_globals.cinema_tracks and self.varname in cpstate_globals.cinema_tracks:
valrange = cpstate_globals.cinema_tracks[self.varname]
trace.append_separated([
"# register the filter with the coprocessor's cinema generator"
])
trace.append([
"coprocessor.RegisterCinemaTrack('clip', %s, 'OffsetValues', %s)"
% (self, valrange)
])
if self.varname in cpstate_globals.cinema_arrays:
arrays = cpstate_globals.cinema_arrays[self.varname]
trace.append_separated(["# define target arrays of filters."])
trace.append([
"coprocessor.AddArraysToCinemaTrack(%s, 'arraySelection', %s)"
% (self, arrays)
])
trace.append_separator()
return trace.raw_data()
def get_state(propertiesToTraceOnCreate=1, # sm.vtkSMTrace.RECORD_MODIFIED_PROPERTIES,
skipHiddenRepresentations=True, source_set=[], filter=None, raw=False):
"""Returns the state string"""
if sm.vtkSMTrace.GetActiveTracer():
raise RuntimeError ("Cannot generate Python state when tracing is active.")
if filter is None:
filter = visible_representations() if skipHiddenRepresentations else supported_proxies()
# build a set of proxies of interest
if source_set:
start_set = source_set
else:
# if nothing is specified, we save all views and sources.
start_set = [x for x in simple.GetSources().values()] + simple.GetViews()
start_set = [x for x in start_set if filter(x)]
# now, locate dependencies for the start_set, pruning irrelevant branches
consumers = set(start_set)
for proxy in start_set:
get_consumers(proxy, filter, consumers)
producers = set()
for proxy in consumers:
get_producers(proxy, filter, producers)
# proxies_of_interest is set of all proxies that we should trace.
proxies_of_interest = producers.union(consumers)
#print ("proxies_of_interest", proxies_of_interest)
trace_config = smtrace.start_trace()
# this ensures that lookup tables/scalar bars etc. are fully traced.
trace_config.SetFullyTraceSupplementalProxies(True)
trace = smtrace.TraceOutput()
trace.append("# state file generated using %s" % simple.GetVisocyteSourceVersion())
#--------------------------------------------------------------------------
# First, we trace the views and layouts, if any.
# TODO: add support for layouts.
views = [x for x in proxies_of_interest if smtrace.Trace.get_registered_name(x, "views")]
if views:
# sort views by their names, so the state has some structure to it.
views = sorted(views, key=lambda x:\
smtrace.Trace.get_registered_name(x, "views"))
trace.append_separated([\
"# ----------------------------------------------------------------",
"# setup views used in the visualization",
"# ----------------------------------------------------------------"])
for view in views:
# FIXME: save view camera positions and size.
traceitem = smtrace.RegisterViewProxy(view)
traceitem.finalize()
del traceitem
trace.append_separated(smtrace.get_current_trace_output_and_reset(raw=True))
trace.append_separated([\
"# ----------------------------------------------------------------",
"# restore active view",
"SetActiveView(%s)" % smtrace.Trace.get_accessor(simple.GetActiveView()),
"# ----------------------------------------------------------------"])
#--------------------------------------------------------------------------
# Next, trace data processing pipelines.
sorted_proxies_of_interest = __toposort(proxies_of_interest)
sorted_sources = [x for x in sorted_proxies_of_interest \
if smtrace.Trace.get_registered_name(x, "sources")]
if sorted_sources:
trace.append_separated([\
"# ----------------------------------------------------------------",
"# setup the data processing pipelines",
"# ----------------------------------------------------------------"])
for source in sorted_sources:
traceitem = smtrace.RegisterPipelineProxy(source)
traceitem.finalize()
del traceitem
trace.append_separated(smtrace.get_current_trace_output_and_reset(raw=True))
#--------------------------------------------------------------------------
# Can't decide if the representations should be saved with the pipeline
# objects or afterwords, opting for afterwords for now since the topological
# sort doesn't guarantee that the representations will follow their sources
# anyways.
sorted_representations = [x for x in sorted_proxies_of_interest \
if smtrace.Trace.get_registered_name(x, "representations")]
scalarbar_representations = [x for x in sorted_proxies_of_interest\
if smtrace.Trace.get_registered_name(x, "scalar_bars")]
# print ("sorted_representations", sorted_representations)
# print ("scalarbar_representations", scalarbar_representations)
if sorted_representations or scalarbar_representations:
for view in views:
view_representations = [x for x in view.Representations if x in sorted_representations]
view_scalarbars = [x for x in view.Representations if x in scalarbar_representations]
if view_representations or view_scalarbars:
trace.append_separated([\
"# ----------------------------------------------------------------",
"# setup the visualization in view '%s'" % smtrace.Trace.get_accessor(view),
"# ----------------------------------------------------------------"])
for rep in view_representations:
try:
producer = rep.Input
port = rep.Input.Port
traceitem = smtrace.Show(producer, port, view, rep,
comment="show data from %s" % smtrace.Trace.get_accessor(producer))
traceitem.finalize()
del traceitem
trace.append_separated(smtrace.get_current_trace_output_and_reset(raw=True))
if rep.UseSeparateColorMap:
trace.append_separated([\
"# set separate color map",
"%s.UseSeparateColorMap = True" % (\
smtrace.Trace.get_accessor(rep))])
except AttributeError: pass
# save the scalar bar properties themselves.
if view_scalarbars:
trace.append_separated("# setup the color legend parameters for each legend in this view")
for rep in view_scalarbars:
smtrace.Trace.get_accessor(rep)
trace.append_separated(smtrace.get_current_trace_output_and_reset(raw=True))
trace.append_separated([\
"# set color bar visibility", "%s.Visibility = %s" % (\
smtrace.Trace.get_accessor(rep), rep.Visibility)])
for rep in view_representations:
try:
producer = rep.Input
port = rep.Input.Port
if rep.IsScalarBarVisible(view):
# FIXME: this will save this multiple times, right now,
# if two representations use the same LUT.
trace.append_separated([\
"# show color legend",
"%s.SetScalarBarVisibility(%s, True)" % (\
smtrace.Trace.get_accessor(rep),
smtrace.Trace.get_accessor(view))])
if not rep.Visibility:
traceitem = smtrace.Hide(producer, port, view)
traceitem.finalize()
del traceitem
trace.append_separated(smtrace.get_current_trace_output_and_reset(raw=True))
except AttributeError: pass
#--------------------------------------------------------------------------
# Now, trace the transfer functions (color maps and opacity maps) used.
ctfs = set([x for x in proxies_of_interest \
if smtrace.Trace.get_registered_name(x, "lookup_tables")])
if ctfs:
trace.append_separated([\
"# ----------------------------------------------------------------",
"# setup color maps and opacity mapes used in the visualization",
"# note: the Get..() functions create a new object, if needed",
"# ----------------------------------------------------------------"])
for ctf in ctfs:
smtrace.Trace.get_accessor(ctf)
if ctf.ScalarOpacityFunction in proxies_of_interest:
smtrace.Trace.get_accessor(ctf.ScalarOpacityFunction)
trace.append_separated(smtrace.get_current_trace_output_and_reset(raw=True))
# restore the active source since the order in which the pipeline is created
# in the state file can end up changing the active source to be different
# than what it was when the state is being saved.
trace.append_separated([\
"# ----------------------------------------------------------------",
"# finally, restore active source",
"SetActiveSource(%s)" % smtrace.Trace.get_accessor(simple.GetActiveSource()),
"# ----------------------------------------------------------------"])
del trace_config
smtrace.stop_trace()
#print (trace)
return str(trace) if not raw else trace.raw_data()