def RequestData():
# R.0.2018.080
import sys
import numpy as np
import os
import paraview.simple as simple
sys.path.insert(0, r'EMC_SRC_PATH')
import IrisEMC_Paraview_Lib as lib
views = simple.GetViews(viewtype="SpreadSheetView")
if len(views) > 0:
simple.Delete(views[0])
else:
view = simple.GetActiveView()
layout = simple.GetLayout(view)
pdo = self.GetOutput() # vtkTable
if Coordinate_Type == 0:
lon = X_or_Longitude
lat = Y_or_Latitude
depth = Z_or_Depth
x, y, z = lib.llz2xyz(lat, lon, depth)
else:
x = X_or_Longitude
y = Y_or_Latitude
z = Z_or_Depth
lat, lon, depth = lib.xyz2llz(x, y, z)
# store metadata
fieldData = pdo.GetFieldData()
fieldData.AllocateArrays(3) # number of fields
fieldData = pdo.GetFieldData()
data = vtk.vtkFloatArray()
data.SetName('Longitude, Latitude, Depth')
data.InsertNextValue(lon)
data.InsertNextValue(lat)
data.InsertNextValue(depth)
fieldData.AddArray(data)
data = vtk.vtkFloatArray()
data.SetName('X, Y, Z')
data.InsertNextValue(x)
data.InsertNextValue(y)
data.InsertNextValue(z)
fieldData.AddArray(data)
pdo.SetFieldData(fieldData)
def get_state(options=None, source_set=[], filter=None, raw=False):
"""Returns the state string"""
if options:
options = sm._getPyProxy(options)
propertiesToTraceOnCreate = options.PropertiesToTraceOnCreate
skipHiddenRepresentations = options.SkipHiddenDisplayProperties
skipRenderingComponents = options.SkipRenderingComponents
else:
propertiesToTraceOnCreate = RECORD_MODIFIED_PROPERTIES
skipHiddenRepresentations = True
skipRenderingComponents = False
# essential to ensure any obsolete accessors don't linger - can cause havoc
# when saving state following a Python trace session
# (paraview/paraview#18994)
import gc
gc.collect()
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(preamble="")
# this ensures that lookup tables/scalar bars etc. are fully traced.
trace_config.SetFullyTraceSupplementalProxies(True)
trace_config.SetSkipRenderingComponents(skipRenderingComponents)
trace = smtrace.TraceOutput()
trace.append("# state file generated using %s" % simple.GetParaViewSourceVersion())
trace.append_separated(smtrace.get_current_trace_output_and_reset(raw=True))
#--------------------------------------------------------------------------
# We trace the views and layouts, if any.
if skipRenderingComponents:
views = []
else:
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(["SetActiveView(None)"])
# from views, build the list of layouts of interest.
layouts = set()
for aview in views:
l = simple.GetLayout(aview)
if l:
layouts.add(simple.GetLayout(aview))
# trace create of layouts
if layouts:
layouts = sorted(layouts, key=lambda x:\
smtrace.Trace.get_registered_name(x, "layouts"))
trace.append_separated([\
"# ----------------------------------------------------------------",
"# setup view layouts",
"# ----------------------------------------------------------------"])
for layout in layouts:
traceitem = smtrace.RegisterLayoutProxy(layout)
traceitem.finalize(filter=lambda x: x in views)
del traceitem
trace.append_separated(smtrace.get_current_trace_output_and_reset(raw=True))
if views:
# restore the active view after the layouts have been created.
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 afterwards, opting for afterwards 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 not skipRenderingComponents and (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 not skipRenderingComponents and 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))
# Trace extract generators.
exgens = set([x for x in proxies_of_interest \
if smtrace.Trace.get_registered_name(x, "extract_generators")])
if exgens:
trace.append_separated([\
"# ----------------------------------------------------------------",
"# setup extract generators",
"# ----------------------------------------------------------------"])
for exgen in exgens:
# FIXME: this currently doesn't handle multiple output ports
# correctly.
traceitem = smtrace.CreateExtractGenerator(\
xmlname=exgen.Writer.GetXMLName(),
producer=exgen.Producer,
generator=exgen,
registrationName=smtrace.Trace.get_registered_name(exgen, "extract_generators"))
traceitem.finalize()
del traceitem
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([\
"# ----------------------------------------------------------------",
"# restore active source",
"SetActiveSource(%s)" % smtrace.Trace.get_accessor(simple.GetActiveSource()),
"# ----------------------------------------------------------------"])
if options:
# add coda about extracts generation.
trace.append_separated(["",
"if __name__ == '__main__':",
" # generate extracts",
" SaveExtracts(ExtractsOutputDirectory='%s')" % options.ExtractsOutputDirectory])
del trace_config
smtrace.stop_trace()
#print (trace)
return str(trace) if not raw else 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.GetParaViewSourceVersion())
#--------------------------------------------------------------------------
# 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()
def gen_screenshot(state, dest=OUTPUT_DIR):
for i, view in enumerate(simple.GetViews()):
simple.SaveScreenshot(f"{dest}/{state.stem}_{i}.png", view)
print(f"{state}: view #{i} saved")
simple.ResetSession()
def run(self):
doPic=True
doGeom=False
doSources=False
if self.opts.geomType:
if PVVersion()<(3,9):
self.error("This paraview version does not support geometry writing")
doGeom=True
doPic=self.opts.pictureWithGeometry
if len(self.opts.sources)==0:
self.opts.sources=[""] # add empty string as token
if self.opts.sourcesList:
doPic=False
doGeom=False
doSources=True
try:
filterColors=eval(self.opts.filterColors)
except TypeError:
filterColors=self.opts.filterColors
for f in filterColors:
c=filterColors[f]
if type(c)==tuple:
if not c[1]:
filterColors[f]=(c[0],self.opts.defaultField)
else:
if not c:
filterColors[f]=self.opts.defaultField
try:
colorRanges=eval(self.opts.colorRanges)
except TypeError:
colorRanges=self.opts.colorRanges
try:
percentileRanges=eval(self.opts.percentileRanges)
except TypeError:
percentileRanges=self.opts.percentileRanges
self.say("Paraview version",PVVersion(),"FoamVersion",foamVersion())
# if PVVersion()>=(3,6):
# self.warning("This is experimental because the API in Paraview>=3.6 has changed. But we'll try")
case=path.abspath(self.parser.getArgs()[0])
short=path.basename(case)
stateString=""
if self.opts.state==None:
self.opts.state=path.join(case,"default.pvsm")
else:
stateString="_"+path.splitext(path.basename(self.opts.state))[0]
if not path.exists(self.opts.state):
self.error("The state file",self.opts.state,"does not exist")
timeString=""
if self.opts.casename:
timeString+="_"+short
timeString+="_%(nr)05d"
if self.opts.timename:
timeString+="_t=%(t)s"
sol=SolutionDirectory(case,
paraviewLink=False,
archive=None)
self.say("Opening state file",self.opts.state)
sf=StateFile(self.opts.state)
decoResult=None
newParallelMode=None
if self.opts.decomposeMode=="keep":
pass
elif self.opts.decomposeMode=="decomposed":
decoResult=sf.setDecomposed(True)
newParallelMode=True
elif self.opts.decomposeMode=="reconstructed":
decoResult=sf.setDecomposed(False)
newParallelMode=False
elif self.opts.decomposeMode=="auto":
nrTimes=len(sol.getTimes())
nrParTimes=len(sol.getParallelTimes())
if nrTimes>nrParTimes:
newParallelMode=False
decoResult=sf.setDecomposed(False)
else:
newParallelMode=True
decoResult=sf.setDecomposed(True)
else:
self.error("Setting decompose mode",self.opts.decomposeMode,"is not implemented")
if decoResult:
self.warning("Setting decomposed type to",self.opts.decomposeMode,":",decoResult)
if newParallelMode:
if self.opts.parallelTimes!=newParallelMode:
self.warning("Resetting parallel mode",newParallelMode)
self.opts.parallelTimes=newParallelMode
times=self.processTimestepOptions(sol)
if len(times)<1:
self.warning("Can't continue without time-steps")
return
dataFile=path.join(case,short+".OpenFOAM")
createdDataFile=False
if not path.exists(dataFile):
self.say("Creating",dataFile)
createdDataFile=True
f=open(dataFile,"w")
f.close()
self.say("Setting data to",dataFile)
sf.setCase(dataFile)
values={}
if self.opts.addPrepareCaseParameters:
fName=path.join(case,PrepareCase.parameterOutFile)
if path.exists(fName):
self.say("Adding vaules from",fName)
pf=ParsedParameterFile(fName,noHeader=True)
values.update(pf.content)
else:
self.say("No file",fName)
values.update(eval(self.opts.replacements))
values[self.opts.casenameKey]=short
if self.opts.listReplacements:
rKeys=sorted(values.keys())
kLen=max([len(k) for k in rKeys])
vLen=max([len(str(values[k])) for k in rKeys])
kFormat=" %"+str(kLen)+"s | %"+str(vLen)+"s"
print
print kFormat % ("Key","Value")
print "-"*(kLen+2)+"|"+"-"*(vLen+2)
for k in rKeys:
print kFormat % (k,str(values[k]))
print
sf.rewriteTexts(values)
newState=sf.writeTemp()
self.say("Setting session manager with reader type",sf.readerType())
sm=SM(requiredReader=sf.readerType())
exporterType=None
if doGeom:
self.say("Getting geometry exporter",self.geomTypeTable[self.opts.geomType])
exporters=sm.createModule("exporters")
exporterType=getattr(exporters,self.geomTypeTable[self.opts.geomType])
# make sure that the first snapshot is rendered correctly
import paraview.simple as pvs
pvs._DisableFirstRenderCameraReset()
if not self.opts.progress:
self.say("Toggling progress")
sm.ToggleProgressPrinting()
self.say("Loading state")
sm.LoadState(newState)
self.say("Getting Views")
rViews=sm.GetRenderViews()
views=pvs.GetViews()
if (len(views)>1 and PVVersion()<(4,2)) or not self.opts.doLayouts:
self.warning("More than 1 view in state-file. Generating multiple series")
timeString="_View%(view)02d"+timeString
timeString=self.opts.prefix+timeString+stateString
self.say("Setting Offscreen rendering")
offWarn=True
for iView,view in enumerate(views):
self.say("Processing view",iView,"of",len(views))
if self.opts.offscreenRender:
view.UseOffscreenRenderingForScreenshots=True
if offWarn:
self.warning("Trying offscreen rendering. If writing the file fails with a segmentation fault try --no-offscreen-rendering")
elif offWarn:
self.warning("No offscreen rendering. Camera perspective will probably be wrong")
offWarn=False
allSources=None
alwaysSources=None
self.say("Starting times",times)
for i,t in enumerate(times):
self.say("Nr",i,"time",t)
print "Snapshot ",i," for t=",t,
sys.stdout.flush()
self.say()
layouts=[]
colorPrefix=""
# from paraview.simple import UpdatePipeline
# UpdatePipeline(time=float(t))
if len(colorRanges)>0:
for c in colorRanges:
rng=colorRanges[c]
self.say("Setting color",c,"to range",rng)
self.setColorTransferFunction(c,rng)
if PVVersion()>=(4,2) and len(filterColors)>0:
self.say("Switch colors")
from paraview.simple import GetSources,GetDisplayProperties,GetColorTransferFunction,GetScalarBar,HideUnusedScalarBars,UpdatePipeline,ColorBy,SetActiveView,GetRepresentations
sources=GetSources()
changedSources=set()
for j,view in enumerate(views):
for n in sources:
if n[0] in filterColors:
if view in rViews:
self.say("Found",n[0],"to be switched")
# This does not work as expected.
# dp=GetDisplayProperties(sources[n],view)
display=sm.GetRepresentation(sources[n],view)
if display==None:
self.say("No representation for",n[0],"in this view")
continue
if display.Visibility==0:
self.say("Not switching",n[0],"because it is not visible in this view")
# Invisible Sources don't need a color-change
# Currently Visibily does not work as I expect it (is always 1)
continue
if type(filterColors[n[0]])==tuple:
assoc,col=filterColors[n[0]]
else:
assoc,col=display.ColorArrayName[0],filterColors[n[0]]
if display.ColorArrayName==[assoc,col]:
self.say("Color already set to",assoc,col,".Skipping")
continue
ColorBy(display,[assoc,col])
# display.ColorArrayName=[assoc,col]
changedSources.add(n[0])
color=GetColorTransferFunction(col)
# display.ColorArrayName=filterColors[n[0]]
# display.LookupTable=color
# UpdatePipeline(proxy=sources[n])
if n[0] not in self.opts.noColorbar and (len(self.opts.colorbarView)==0 or j in self.opts.colorbarView):
self.say("Adding a colorbar")
scalar=GetScalarBar(color,view)
scalar.Visibility=1
elif sources[n].__class__.__name__=="Histogram" \
and view.__class__.__name__=="BarChartView":
self.say(n,"is a Histogram")
# dp=GetDisplayProperties(sources[n],view)
assoc,oldCol=sources[n].SelectInputArray
col=filterColors[n[0]]
self.say("Setting color from",oldCol,"to",col)
sources[n].SelectInputArray=[assoc,col]
else:
# self.say(n,"is unsuppored Source:",sources[n],
# "View:",view)
pass
HideUnusedScalarBars(view)
if self.opts.colorPrefix:
for s in changedSources:
if type(filterColors[s])==tuple:
colorPrefix+=s+"="+filterColors[s][1]+"_"
else:
colorPrefix+=s+"="+filterColors[s]+"_"
for c in self.opts.rescaleToSource:
found=False
from paraview.simple import GetSources
sources=GetSources()
for n in sources:
if n[0]==c:
src=sources[n]
found=True
for view in views:
display=sm.GetRepresentation(sources[n],view)
if display==None:
continue
if display.Visibility==0:
continue
col=display.ColorArrayName[1]
src.UpdatePipeline(time=float(t))
if col in percentileRanges:
low,hig=percentileRanges[col]
if low is None:
low=0
if hig is None:
hig=100
else:
hig=100-hig
rng=self.getDataRangePercentile(src,col,low=low,high=hig)
else:
rng=self.getDataRange(src,col)
if not rng is None:
self.say("Resetting color function",col,"to range",rng,"because of data set",c)
if col in colorRanges:
low,hig=colorRanges[col]
if low is not None:
rng=low,rng[1]
if hig is not None:
rng=rng[0],hig
self.say("Extremes overruled to",rng,"for resetting")
self.setColorTransferFunction(col,rng)
else:
self.warning("No field",col,"found on",c)
break
if not found:
self.warning("Source",c,"not found")
for j,view in enumerate(views):
self.say("Preparing views")
view.ViewTime=float(t)
for j,view in enumerate(views):
if len(views)>0:
print "View %d" % j,
sys.stdout.flush()
self.say()
if doPic:
print self.opts.picType,
sys.stdout.flush()
fn = (timeString % {'nr':i,'t':t,'view':j})+"."+self.opts.picType
if PVVersion()<(3,6):
self.say("Very old Paraview writing")
view.WriteImage(fn,
self.picTypeTable[self.opts.picType],
self.opts.magnification)
elif PVVersion()<(4,2):
self.say("Old Paraview writing")
from paraview.simple import SetActiveView,Render,WriteImage
self.say("Setting view")
SetActiveView(view)
self.say("Rendering")
Render()
self.say("Writing image",fn,"type",self.picTypeTable[self.opts.picType])
# This may produce a segmentation fault with offscreen rendering
WriteImage(fn,
view,
# Writer=self.picTypeTable[self.opts.picType],
Magnification=self.opts.magnification)
self.say("Finished writing")
else:
doRender=True
usedView=view
self.say("New Paraview writing")
from paraview.simple import SetActiveView,SaveScreenshot,GetLayout,GetSources
layout=GetLayout(view)
if self.opts.doLayouts:
usedView=None
if layout in layouts:
doRender=False
else:
layouts.append(layout)
else:
layout=None
if doRender:
self.say("Writing image",colorPrefix+fn,"type",self.picTypeTable[self.opts.picType])
# This may produce a segmentation fault with offscreen rendering
SaveScreenshot(colorPrefix+fn,
view=usedView,
layout=layout,
magnification=self.opts.magnification)
else:
self.say("Skipping image",colorPrefix+fn)
self.say("Finished writing")
if doGeom:
from paraview.simple import Show,Hide,GetSources
print self.opts.geomType,
sys.stdout.flush()
for select in self.opts.sources:
fn = (timeString % {'nr':i,'t':t,'view':j})
if select!="":
print "*"+select+"*",
sys.stdout.flush()
fn+="_"+select
sources=GetSources()
for n,s in sources.iteritems():
if n[0].find(select)>=0:
Show(s,view)
else:
Hide(s,view)
fn += "."+self.opts.geomType
self.say("Creating exporter for file",fn)
ex=exporterType(FileName=fn)
ex.SetView(view)
ex.Write()
if doSources:
from paraview.simple import GetSources
srcNames=[]
sources=GetSources()
for n in sources:
srcNames.append(n[0])
if allSources==None:
allSources=set(srcNames)
alwaysSources=set(srcNames)
else:
allSources|=set(srcNames)
alwaysSources&=set(srcNames)
print
if doSources:
print
print "List of found sources (* means that it is present in all timesteps)"
for n in allSources:
if n in alwaysSources:
flag="*"
else:
flag=" "
print " %s %s" % (flag,n)
if createdDataFile:
self.warning("Removing pseudo-data-file",dataFile)
unlink(dataFile)
del sm
def run(self):
doPic = True
doGeom = False
doSources = False
if self.opts.geomType:
if PVVersion() < (3, 9):
self.error(
"This paraview version does not support geometry writing")
doGeom = True
doPic = self.opts.pictureWithGeometry
if len(self.opts.sources) == 0:
self.opts.sources = [""] # add empty string as token
if self.opts.sourcesList or self.opts.viewList:
doPic = False
doGeom = False
doSources = True
try:
filterColors = eval(self.opts.filterColors)
except TypeError:
filterColors = self.opts.filterColors
for f in filterColors:
c = filterColors[f]
if isinstance(c, (tuple, )):
if not c[1]:
filterColors[f] = (c[0], self.opts.defaultField)
elif isinstance(c, (dict, )):
for k in c:
v = c[k]
if isinstance(v, (tuple, )):
if not v[1]:
c[k] = (v[0], self.opts.defaultField)
else:
if not v:
c[k] = self.opts.defaultField
else:
if not c:
filterColors[f] = self.opts.defaultField
try:
colorRanges = eval(self.opts.colorRanges)
except TypeError:
colorRanges = self.opts.colorRanges
try:
percentileRanges = eval(self.opts.percentileRanges)
except TypeError:
percentileRanges = self.opts.percentileRanges
self.say("Paraview version", PVVersion(), "FoamVersion", foamVersion())
# if PVVersion()>=(3,6):
# self.warning("This is experimental because the API in Paraview>=3.6 has changed. But we'll try")
case = path.abspath(self.parser.getArgs()[0])
short = path.basename(case)
stateString = ""
if self.opts.state == None:
self.opts.state = path.join(case, "default.pvsm")
else:
stateString = "_" + path.splitext(path.basename(
self.opts.state))[0]
if not path.exists(self.opts.state):
self.error("The state file", self.opts.state, "does not exist")
timeString = ""
if self.opts.casename:
timeString += "_" + short
timeString += "_%(nr)05d"
if self.opts.timename:
timeString += "_t=%(t)s"
sol = SolutionDirectory(case, paraviewLink=False, archive=None)
self.say("Opening state file", self.opts.state)
sf = StateFile(self.opts.state)
if self.opts.analyzeState:
print_(
"\n\nReaders:\n ", "\n ".join([
p.type_() + " \t: " + p.getProperty("FileName")
for p in sf.getProxy(".+Reader", regexp=True)
]))
print_("Source Proxies:")
for i, name in sf.sourceIds():
print_(" ", name, " \t: ", sf[i].type_())
return
if self.opts.listProperties:
print_("\n\nProperties for", self.opts.listProperties, ":")
srcs = []
for i, name in sf.sourceIds():
srcs.append(name)
if name == self.opts.listProperties:
for namee, el in sf[i].listProperties():
print_(" ", namee, " \t: ", end=" ")
if len(el) == 1:
print_("Single element:", el[0][1], end=" ")
elif len(el) > 1:
print_(len(el), "Elements:", end=" ")
for j, v in el:
print_("%d:%s" % (j, v), end=" ")
else:
print_("No value", end=" ")
print_()
return
self.error("Not found. Available:", " ".join(srcs))
decoResult = None
newParallelMode = None
if self.opts.decomposeMode == "keep":
pass
elif self.opts.decomposeMode == "decomposed":
decoResult = sf.setDecomposed(True)
newParallelMode = True
elif self.opts.decomposeMode == "reconstructed":
decoResult = sf.setDecomposed(False)
newParallelMode = False
elif self.opts.decomposeMode == "auto":
nrTimes = len(sol.getTimes())
nrParTimes = len(sol.getParallelTimes())
if nrTimes > nrParTimes:
newParallelMode = False
decoResult = sf.setDecomposed(False)
else:
newParallelMode = True
decoResult = sf.setDecomposed(True)
else:
self.error("Setting decompose mode", self.opts.decomposeMode,
"is not implemented")
if decoResult:
self.warning("Setting decomposed type to", self.opts.decomposeMode,
":", decoResult)
if newParallelMode:
if self.opts.parallelTimes != newParallelMode:
self.warning("Resetting parallel mode", newParallelMode)
self.opts.parallelTimes = newParallelMode
if self.opts.consecutiveIndex:
times = self.processTimestepOptions(sol)
times = zip(times, range(0, len(times)))
else:
times = self.processTimestepOptionsIndex(sol)
if len(times) < 1:
self.warning("Can't continue without time-steps")
return
dataFile = path.join(case, short + ".OpenFOAM")
createdDataFile = False
if not path.exists(dataFile):
self.say("Creating", dataFile)
createdDataFile = True
f = open(dataFile, "w")
f.close()
self.say("Setting data to", dataFile)
sf.setCase(dataFile)
values = {}
if self.opts.addPrepareCaseParameters:
fName = path.join(case, PrepareCase.parameterOutFile)
if path.exists(fName):
self.say("Adding vaules from", fName)
pf = ParsedParameterFile(fName, noHeader=True)
values.update(pf.content)
else:
self.say("No file", fName)
replString = self.opts.replacements.strip()
if replString[0] == '{' and replString[-1] == '}':
values.update(eval(self.opts.replacements))
else:
values.update(FoamStringParser(replString).data)
values[self.opts.casenameKey] = short
if self.opts.listReplacements:
rKeys = sorted(values.keys())
kLen = max([len(k) for k in rKeys])
maxLen = 100
vLen = min(max([len(str(values[k])) for k in rKeys]), maxLen)
kFormat = " %" + str(kLen) + "s | %" + str(vLen) + "s"
print_()
print_(kFormat % ("Key", "Value"))
print_("-" * (kLen + 2) + "|" + "-" * (vLen + 2))
for k in rKeys:
valStr = str(values[k])
if len(valStr) > maxLen:
valStr = valStr[:maxLen] + " .. cut"
print_(kFormat % (k, valStr))
print_()
sf.rewriteTexts(values)
for setProp in self.opts.setProperties:
parts = setProp.split("=", 1)
if len(parts) != 2:
self.error("'=' missing in", setProp)
value = parts[1]
left = parts[0].split(":")
if len(left) == 2:
src, prop = left
index = None
elif len(left) == 3:
src, prop, index = left
else:
self.error(setProp, "not a proper left side")
print_("Setting on", src, "the property", prop, "index", index,
"to", value)
srcs = []
for i, name in sf.sourceIds():
srcs.append(name)
if name == src:
srcs = None
props = []
for namee, el in sf[i].listProperties():
props.append(namee)
if namee == prop:
props = None
sf[i].setProperty(name=prop,
index=index,
value=value)
break
if props is not None:
self.error("No propery", prop, "in", src, "Available:",
" ".join(props))
break
if srcs is not None:
self.error(src, "not found. Available:", " ".join(srcs))
newState = sf.writeTemp()
if self.opts.rewriteOnly:
print_("Written new statefile to", newState)
return
self.say("Setting session manager with reader type", sf.readerType())
sm = SM(requiredReader=sf.readerType())
exporterType = None
if doGeom:
self.say("Getting geometry exporter",
self.geomTypeTable[self.opts.geomType])
exporters = sm.createModule("exporters")
exporterType = getattr(exporters,
self.geomTypeTable[self.opts.geomType])
# make sure that the first snapshot is rendered correctly
import paraview.simple as pvs
pvs._DisableFirstRenderCameraReset()
if not self.opts.progress:
self.say("Toggling progress")
sm.ToggleProgressPrinting()
self.say("Loading state")
sm.LoadState(newState)
self.say("Getting Views")
rViews = sm.GetRenderViews()
views = pvs.GetViews()
if (len(views) > 1 and PVVersion() <
(4, 2)) or not self.opts.doLayouts:
self.warning(
"More than 1 view in state-file. Generating multiple series")
timeString = "_View%(view)02d" + timeString
timeString = self.opts.prefix + timeString + stateString
self.say("Setting Offscreen rendering")
offWarn = True
viewOrder = []
for iView, view in enumerate(views):
self.say("Processing view", iView, "of", len(views))
viewOrder.append((iView, view.GetProperty("ViewPosition")))
if self.opts.offscreenRender and PVVersion() < (5, 6):
view.UseOffscreenRenderingForScreenshots = True
if offWarn:
self.warning(
"Trying offscreen rendering. If writing the file fails with a segmentation fault try --no-offscreen-rendering"
)
elif offWarn:
self.warning(
"No offscreen rendering. Camera perspective will probably be wrong"
)
offWarn = False
viewOrder.sort(key=lambda x: (x[1][1], x[1][0]))
viewReorder = {viewOrder[k][0]: k for k in range(len(viewOrder))}
allSources = None
alwaysSources = None
self.say("Starting times", times[0][0], "(Index", times[0][1], ")")
for t, i in times:
self.say("Nr", i, "time", t)
print_("Snapshot ", i, " for t=", t, end=" ")
sys.stdout.flush()
self.say()
layouts = []
colorPrefix = ""
# from paraview.simple import UpdatePipeline
# UpdatePipeline(time=float(t))
if len(colorRanges) > 0:
for c in colorRanges:
rng = colorRanges[c]
self.say("Setting color", c, "to range", rng)
self.setColorTransferFunction(c, rng)
if PVVersion() >= (4, 2) and len(filterColors) > 0:
self.say("Switch colors")
from paraview.simple import GetSources, GetDisplayProperties, GetColorTransferFunction, GetScalarBar, HideUnusedScalarBars, UpdatePipeline, ColorBy, SetActiveView, GetRepresentations
sources = GetSources()
changedSources = set()
for j, view in enumerate(views):
viewNr = viewReorder[j]
for n in sources:
if n[0] in filterColors:
if view in rViews:
# print(dir(view),view.ListProperties())
# print(view.GetProperty("ViewSize"),view.GetProperty("ViewPosition"))
self.say("Found", n[0], "in view", viewNr,
"to be switched")
# This does not work as expected.
# dp=GetDisplayProperties(sources[n],view)
display = sm.GetRepresentation(
sources[n], view)
if display == None:
self.say("No representation for", n[0],
"in this view")
continue
if display.Visibility == 0:
self.say(
"Not switching", n[0],
"because it is not visible in this view"
)
# Invisible Sources don't need a color-change
# Currently Visibily does not work as I expect it (is always 1)
continue
if isinstance(filterColors[n[0]], (dict, )):
try:
if type(filterColors[n[0]]
[viewNr]) == tuple:
assoc, col = filterColors[
n[0]][viewNr]
else:
assoc, col = display.ColorArrayName[
0], filterColors[n[0]][viewNr]
except KeyError:
self.say("No color specified for",
n[0], "in view", viewNr)
continue
elif type(filterColors[n[0]]) == tuple:
assoc, col = filterColors[n[0]]
else:
assoc, col = display.ColorArrayName[
0], filterColors[n[0]]
if display.ColorArrayName == [assoc, col]:
self.say("Color already set to", assoc,
col, ".Skipping")
continue
ColorBy(display, [assoc, col])
self.say("Color", n, "in view", viewNr, "with",
(assoc, col))
# display.ColorArrayName=[assoc,col]
changedSources.add(n[0])
color = GetColorTransferFunction(col)
# display.ColorArrayName=filterColors[n[0]]
# display.LookupTable=color
# UpdatePipeline(proxy=sources[n])
if n[0] not in self.opts.noColorbar and (
len(self.opts.colorbarView) == 0
or viewNr in self.opts.colorbarView):
self.say("Adding a colorbar")
scalar = GetScalarBar(color, view)
scalar.Visibility = 1
if scalar.Title == "Name":
scalar.Title = col
if scalar.ComponentTitle == "Component":
scalar.ComponentTitle = ""
elif sources[n].__class__.__name__=="Histogram" \
and view.__class__.__name__=="BarChartView":
self.say(n, "is a Histogram")
# dp=GetDisplayProperties(sources[n],view)
assoc, oldCol = sources[n].SelectInputArray
col = filterColors[n[0]]
self.say("Setting color from", oldCol, "to",
col)
sources[n].SelectInputArray = [assoc, col]
else:
# self.say(n,"is unsuppored Source:",sources[n],
# "View:",view)
pass
HideUnusedScalarBars(view)
if self.opts.colorPrefix:
for s in changedSources:
if isinstance(filterColors[s], (tuple, )):
colorPrefix += s + "=" + filterColors[s][1] + "_"
if isinstance(filterColors[s], (dict, )):
spc = filterColors[s]
colorPrefix += s + "=" + ":".join(
["%d:%s" % (v, spc[v]) for v in spc]) + "_"
else:
colorPrefix += s + "=" + filterColors[s] + "_"
for c in self.opts.rescaleToSource:
found = False
from paraview.simple import GetSources
sources = GetSources()
for n in sources:
if n[0] == c:
src = sources[n]
found = True
for view in views:
display = sm.GetRepresentation(sources[n], view)
if display == None:
continue
if display.Visibility == 0:
continue
col = display.ColorArrayName[1]
src.UpdatePipeline(time=float(t))
if col in percentileRanges:
low, hig = percentileRanges[col]
if low is None:
low = 0
if hig is None:
hig = 100
else:
hig = 100 - hig
rng = self.getDataRangePercentile(src,
col,
low=low,
high=hig)
else:
rng = self.getDataRange(src, col)
if not rng is None:
self.say("Resetting color function", col,
"to range", rng,
"because of data set", c)
if col in colorRanges:
low, hig = colorRanges[col]
if low is not None:
rng = low, rng[1]
if hig is not None:
rng = rng[0], hig
self.say("Extremes overruled to", rng,
"for resetting")
self.setColorTransferFunction(col, rng)
else:
self.warning("No field", col, "found on", c)
break
if not found:
self.warning("Source", c, "not found")
for j, view in enumerate(views):
self.say("Preparing views")
view.ViewTime = float(t)
for j, view in enumerate(views):
if len(views) > 0:
print_("View %d" % j, end=" ")
sys.stdout.flush()
self.say()
if doPic:
print_(self.opts.picType, end=" ")
sys.stdout.flush()
fn = (timeString % {
'nr': i,
't': t,
'view': j
}) + "." + self.opts.picType
if PVVersion() < (3, 6):
self.say("Very old Paraview writing")
view.WriteImage(fn,
self.picTypeTable[self.opts.picType],
self.opts.magnification)
elif PVVersion() < (4, 2):
self.say("Old Paraview writing")
from paraview.simple import SetActiveView, Render, WriteImage
self.say("Setting view")
SetActiveView(view)
self.say("Rendering")
Render()
self.say("Writing image", fn, "type",
self.picTypeTable[self.opts.picType])
# This may produce a segmentation fault with offscreen rendering
WriteImage(
fn,
view,
# Writer=self.picTypeTable[self.opts.picType],
Magnification=self.opts.magnification)
self.say("Finished writing")
elif PVVersion() < (5, 4):
doRender = True
usedView = view
self.say("New Paraview writing")
from paraview.simple import SetActiveView, SaveScreenshot, GetLayout, GetSources
layout = GetLayout(view)
if self.opts.doLayouts:
usedView = None
if layout in layouts:
doRender = False
else:
layouts.append(layout)
else:
layout = None
if doRender:
self.say("Writing image", colorPrefix + fn, "type",
self.picTypeTable[self.opts.picType])
# This may produce a segmentation fault with offscreen rendering
SaveScreenshot(
colorPrefix + fn,
view=usedView,
layout=layout,
quality=100 - self.opts.quality,
magnification=self.opts.magnification)
else:
self.say("Skipping image", colorPrefix + fn)
self.say("Finished writing")
else:
doRender = True
usedView = view
self.say("Paraview >5.4 writing")
from paraview.simple import SetActiveView, SaveScreenshot, GetLayout, GetSources
layout = GetLayout(view)
if self.opts.doLayouts:
usedView = None
if layout in layouts:
doRender = False
else:
layouts.append(layout)
exts = [0] * 4
layout.GetLayoutExtent(exts)
size = [
exts[1] - exts[0] + 1, exts[3] - exts[2] + 1
]
else:
layout = None
size = usedView.ViewSize
if doRender:
self.say("Writing image", colorPrefix + fn, "type",
self.picTypeTable[self.opts.picType])
# This may produce a segmentation fault with offscreen rendering
if self.opts.xRes:
if self.opts.yRes:
size = self.opts.xRes, self.opts.yRes
else:
size = self.opts.xRes, int(self.opts.xRes *
size[1] /
float(size[0]))
elif self.opts.yRes:
size = int(self.opts.yRes * size[0] /
float(size[1])), self.opts.yRes
else:
size = size[0] * self.opts.magnification, size[
1] * self.opts.magnification
SaveScreenshot(
colorPrefix + fn,
viewOrLayout=usedView or layout,
SeparatorWidth=self.opts.separatorWidth,
ImageResolution=size,
TransparentBackground=self.opts.
transparentBackground,
ImageQuality=100 - self.opts.quality)
else:
self.say("Skipping image", colorPrefix + fn)
self.say("Finished writing")
if doGeom:
from paraview.simple import Show, Hide, GetSources
print_(self.opts.geomType, end=" ")
sys.stdout.flush()
for select in self.opts.sources:
fn = (timeString % {'nr': i, 't': t, 'view': j})
if select != "":
print_("*" + select + "*", end=" ")
sys.stdout.flush()
fn += "_" + select
sources = GetSources()
for n, s in sources.iteritems():
if n[0].find(select) >= 0:
Show(s, view)
else:
Hide(s, view)
fn += "." + self.opts.geomType
self.say("Creating exporter for file", fn)
ex = exporterType(FileName=fn)
ex.SetView(view)
ex.Write()
if doSources:
if self.opts.viewList:
print_(
"View Nr %s: Position %s Size: %s" %
(viewReorder[j], view.GetProperty("ViewPosition"),
view.GetProperty("ViewSize")))
if self.opts.sourcesList:
from paraview.simple import GetSources
srcNames = []
sources = GetSources()
for n in sources:
srcNames.append(n[0])
if allSources == None:
allSources = set(srcNames)
alwaysSources = set(srcNames)
else:
allSources |= set(srcNames)
alwaysSources &= set(srcNames)
print_()
if doSources:
print_()
print_(
"List of found sources (* means that it is present in all timesteps)"
)
for n in allSources:
if n in alwaysSources:
flag = "*"
else:
flag = " "
print_(" %s %s" % (flag, n))
if createdDataFile:
self.warning("Removing pseudo-data-file", dataFile)
unlink(dataFile)
del sm
def RequestData():
# R.0.2018.080
import sys
sys.path.insert(0, "EMC_SRC_PATH")
from datetime import datetime
import numpy as np
from vtk.numpy_interface import dataset_adapter as dsa
from vtk.util import numpy_support
import IrisEMC_Paraview_Lib as lib
import paraview.simple as simple
views = simple.GetViews(viewtype="SpreadSheetView")
if len(views) > 0:
simple.Delete(views[0])
else:
view = simple.GetActiveView()
layout = simple.GetLayout(view)
locationId = layout.SplitViewVertical(view=view ,fraction=0.7)
myId = simple.GetActiveSource().Input.GetGlobalIDAsString()
proxies = simple.GetSources()
proxyList = []
for key in proxies:
listElt = {}
listElt['name'] = key[0]
listElt['id'] = key[1]
proxy = proxies[key]
parentId = '0'
if hasattr(proxy, 'Input'):
parentId = proxy.Input.GetGlobalIDAsString()
listElt['parent'] = parentId
proxyList.append(listElt)
pdi = self.GetInput() # VTK PolyData Type
np = pdi.GetNumberOfPoints()
depthMin = 9999999999999.0
depthMax = -9999999999999.0
latitude = {}
longitude = {}
pdo = self.GetOutput() # VTK Table Type
polyData = vtk.vtkPolyData()
dataPoints = vtk.vtkPoints()
if len(Label.strip()) <= 0:
pid = simple.GetActiveSource().Input.GetGlobalIDAsString()
proxies = simple.GetSources()
for key in proxies:
if key[1] == pid:
Label = " ".join(["Coordinates View:",key[0]])
break
for i in range(np):
point = pdi.GetPoints().GetPoint(i)
(lat,lon,depth) = lib.xyz2llz(point[0],point[1],point[2])
dataPoints.InsertNextPoint((lat,lon,depth))
key = "%0.1f"%(depth)
if depthMin >= float(key):
depthMin = float(key)
depthMinKey = key
if depthMax <= float(key):
depthMax = float(key)
depthMaxKey = key
if key not in latitude.keys():
latitude[key] =[]
longitude[key] = []
latitude[key].append(float("%0.1f"%(lat)))
longitude[key].append(float("%0.1f"%(lon)))
# store boundary metadata
fieldData = polyData.GetFieldData()
fieldData.AllocateArrays(3) # number of fields
depthData = vtk.vtkStringArray()
depthData.SetName('Depth\n(km)')
data = vtk.vtkStringArray()
data.SetName('Corners (lat,lon)\n(degrees)')
depthKeys = [depthMinKey,depthMaxKey]
if depthMinKey == depthMaxKey:
depthKeys = [depthMinKey]
for i in range(len(depthKeys)):
depthKey = depthKeys[i]
borderLat = []
borderLon = []
oldMin = 999999999.0
oldMax = -99999999.0
lonList = list(set(sorted(longitude[depthKey])))
for j in range(len(lonList)):
lon = lonList[j]
minVal = 999999999.0
maxVal = -99999999.0
for i in range(len(longitude[depthKey])):
if longitude[depthKey][i] == lon:
if latitude[depthKey][i] > maxVal:
maxVal = latitude[depthKey][i]
if latitude[depthKey][i] < minVal:
minVal = latitude[depthKey][i]
if oldMin != minVal or j==len(lonList)-1:
if abs(oldMin) < 9999.0:
borderLat.append(oldMin)
borderLon.append(lon)
borderLat.append(minVal)
borderLon.append(lon)
oldMin = minVal
if oldMax != maxVal or j==len(lonList)-1:
if abs(oldMax) < 9999.0:
borderLat.append(oldMax)
borderLon.append(lon)
borderLat.append(maxVal)
borderLon.append(lon)
oldMax = maxVal
borderList = zip(borderLat, borderLon)
borderList.sort()
borderList = list(set(borderList))
min1 = borderList[0][0]
max1 = borderList[0][0]
for i in range(len(borderList)):
if borderList[i][0] < min1:
min1 = borderList[i][0]
if borderList[i][0] > max1:
max1 = borderList[i][0]
minList = []
maxList = []
for i in range(len(borderList)):
if borderList[i][0] == min1:
minList.append(borderList[i][1])
if borderList[i][0] == max1:
maxList.append(borderList[i][1])
depthData.InsertNextValue(depthKey)
data.InsertNextValue("%0.1f, %0.1f"%(min1,min(minList)))
if min(minList) != max(minList):
depthData.InsertNextValue(" ")
data.InsertNextValue("%0.1f, %0.1f"%(min1,max(minList)))
depthData.InsertNextValue(" ")
data.InsertNextValue("%0.1f, %0.1f"%(max1,max(maxList)))
if min(maxList) != max(maxList):
depthData.InsertNextValue(" ")
data.InsertNextValue("%0.1f, %0.1f"%(max1,min(maxList)))
fieldData.AddArray(data)
fieldData.AddArray(depthData)
if len(Label.strip()) > 0:
simple.RenameSource(Label)
pdo.SetFieldData(fieldData)
def RequestData():
# R.0.2018.080
import sys
import numpy as np
import os
import paraview.simple as simple
sys.path.insert(0, "EMC_SRC_PATH")
import IrisEMC_Paraview_Lib as lib
views = simple.GetViews(viewtype="SpreadSheetView")
if len(views) > 0:
simple.Delete(views[0])
else:
view = simple.GetActiveView()
layout = simple.GetLayout(view)
locationId = layout.SplitViewVertical(view=view, fraction=0.7)
pdo = self.GetOutput() # vtkTable
if Coordinate_Type == 0:
lon = X_or_Longitude
lat = Y_or_Latitude
depth = Z_or_Depth
x, y, z = lib.llz2xyz(lat, lon, depth)
else:
x = X_or_Longitude
y = Y_or_Latitude
z = Z_or_Depth
lat, lon, depth = lib.xyz2llz(x, y, z)
# VTK arrays for columns
#name = vtk.vtkStringArray()
#name.SetNumberOfComponents(1)
#name.SetNumberOfTuples(6)
#name.SetName("Component Name")
#name.InsertNextValue("X")
#name.InsertNextValue("Y")
#name.InsertNextValue("Z")
#name.InsertNextValue("Latitude")
#name.InsertNextValue("Longitude")
#name.InsertNextValue("Depth")
#pdo.Array(name)
# store metadata
fieldData = pdo.GetFieldData()
fieldData.AllocateArrays(3) # number of fields
fieldData = pdo.GetFieldData()
data = vtk.vtkFloatArray()
data.SetName('Longitude, Latitude, Depth')
data.InsertNextValue(lon)
data.InsertNextValue(lat)
data.InsertNextValue(depth)
fieldData.AddArray(data)
data = vtk.vtkFloatArray()
data.SetName('X, Y, Z')
data.InsertNextValue(x)
data.InsertNextValue(y)
data.InsertNextValue(z)
fieldData.AddArray(data)
pdo.SetFieldData(fieldData)
def RequestData():
# R.1.2018.354
import sys
sys.path.insert(0, "EMC_SRC_PATH")
from operator import itemgetter
from datetime import datetime
import numpy as np
from vtk.numpy_interface import dataset_adapter as dsa
from vtk.util import numpy_support
import IrisEMC_Paraview_Lib as lib
import paraview.simple as simple
views = simple.GetViews(viewtype="SpreadSheetView")
if len(views) > 0:
# set active view
view = simple.SetActiveView(views[0])
else:
view = simple.GetActiveView()
layout = simple.GetLayout(view)
location_id = layout.SplitViewVertical(view=view, fraction=0.7)
myId = simple.GetActiveSource().Input.GetGlobalIDAsString()
proxies = simple.GetSources()
proxyList = []
for key in proxies:
list_elt = dict()
list_elt['name'] = key[0]
list_elt['id'] = key[1]
proxy = proxies[key]
parent_id = '0'
if hasattr(proxy, 'Input'):
parent_id = proxy.Input.GetGlobalIDAsString()
list_elt['parent'] = parent_id
proxyList.append(list_elt)
pdi = self.GetInput() # VTK PolyData Type
try:
np = pdi.GetNumberOfPoints()
except Exception:
raise Exception('Invalid input!')
na = pdi.GetPointData().GetNumberOfArrays()
val_arrays = []
for i in range(na):
val_arrays.append(pdi.GetPointData().GetArray(i))
latitude = {}
longitude = {}
value = {}
depth = {}
pdo = self.GetOutput() # VTK Table Type
poly_data = vtk.vtkPolyData()
data_points = vtk.vtkPoints()
if len(Label.strip()) <= 0:
pid = simple.GetActiveSource().Input.GetGlobalIDAsString()
proxies = simple.GetSources()
for key in proxies:
if key[1] == pid:
Label = " ".join(["Coordinates:", key[0]])
break
for i in range(np):
point = pdi.GetPoints().GetPoint(i)
(lat, lon, this_depth) = lib.xyz2llz(point[0], point[1], point[2])
data_points.InsertNextPoint((lat, lon, this_depth))
key = "%0.2f" % this_depth
if key not in list(latitude.keys()):
latitude[key] = []
longitude[key] = []
value[key] = []
# need to control precision to have a reasonable sort order
# note that these coordinates are recomputed
if key not in list(depth.keys()):
depth[key] = float('%0.4f' % this_depth)
latitude[key].append(float('%0.4f' % lat))
longitude[key].append(float('%0.4f' % lon))
value_array = []
for j in range(na):
value_array.append(float(val_arrays[j].GetTuple1(i)))
value[key].append(value_array)
# store boundary metadata
field_data = poly_data.GetFieldData()
field_data.AllocateArrays(5) # number of fields
depth_data = vtk.vtkFloatArray()
depth_data.SetName('depth')
lat_data = vtk.vtkFloatArray()
lat_data.SetName('latitude')
lon_data = vtk.vtkFloatArray()
lon_data.SetName('longitude')
val_data = []
for j in range(na):
val_data.append(vtk.vtkFloatArray())
val_data[j].SetName('value(%s)' %
pdi.GetPointData().GetArray(j).GetName())
depth_keys = list(latitude.keys())
for i in range(len(depth_keys)):
depth_key = depth_keys[i]
lon_list = longitude[depth_key]
lat_list = latitude[depth_key]
val_list = value[depth_key]
point_list = list(zip(lat_list, lon_list, val_list))
point_list.sort(key=itemgetter(0, 1))
for index, data in enumerate(point_list):
depth_data.InsertNextValue(float(depth[depth_key]))
lat_data.InsertNextValue(float(data[0]))
lon_data.InsertNextValue(float(data[1]))
for k in range(na):
point_data = data[2]
val_data[k].InsertNextValue(point_data[k])
field_data.AddArray(lat_data)
field_data.AddArray(lon_data)
field_data.AddArray(depth_data)
for j in range(na):
field_data.AddArray(val_data[j])
if len(Label.strip()) > 0:
simple.RenameSource(Label)
pdo.SetFieldData(field_data)