def tick(self): """ function called at each timestep """ view = smp.GetActiveView() # lidar orientation and position R_l = self.orientations[self.i] T_l = self.pts[self.i, :] # move camera for c in self.cameras: if c.timestep_inside_range(self.i): print c.type view.CameraPosition = c.interpolate_position(self.i, R_l, T_l, np.asarray(list(view.CameraPosition))) view.CameraFocalPoint = c.interpolate_focal_point(self.i, R_l, T_l) view.CameraViewUp = c.interpolate_up_vector(self.i, R_l) break # move 3d model (vtk Transform rotation are angle axis in degrees) if self.model is not None: self.model.Transform.Translate = self.pts[self.i, :3] o = R_l.as_rotvec() angle_rad = np.linalg.norm(o) angle_deg = np.rad2deg(angle_rad) self.model.Transform.Rotate = o * angle_deg / angle_rad smp.Render() # save frame if len(frames_output_dir) > 0: imageName = os.path.join(frames_output_dir, "image_%04d.png" % (self.image_index)) smp.WriteImage(imageName) self.image_index += 1 self.i += 1
def getRenameMap(): renameMap = {} names = getAllNames() view = simple.GetActiveView() renderer = view.GetClientSideObject().GetRenderer() viewProps = renderer.GetViewProps() volumes = renderer.GetVolumes() idx = 1 for viewProp in viewProps: if not viewProp.IsA('vtkActor'): continue if not viewProp.GetVisibility(): continue bounds = viewProp.GetBounds() if bounds[0] > bounds[1]: continue # The mapping will fail for multiblock that are composed of several blocks # Merge block should be used to solve the renaming issue for now # as the id is based on the a valid block vs representation. strIdx = '%s' % idx renameMap[strIdx] = findName(names, viewProp, strIdx) idx += 1 for volume in volumes: if not volume.IsA('vtkVolume'): continue if not volume.GetVisibility(): continue bounds = volume.GetBounds() if bounds[0] > bounds[1]: continue strIdx = '%s' % idx renameMap[strIdx] = findName(names, volume, strIdx) idx += 1 return renameMap
def init_view(self): pasi.SetActiveView(pasi.GetRenderView()) if paraview_loaded: camera = pasi.GetActiveCamera() self.camera = camera # cm = CameraMover(camera) print("Camera loaded") if self.view_size is not None: pasi.GetActiveView().ViewSize = self.view_size
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 getView(self, vid): """ Returns the view for a given view ID, if vid is None then return the current active view. :param vid: The view ID :type vid: str """ view = self.mapIdToProxy(vid) if not view: # Use active view is none provided. view = simple.GetActiveView() if not view: raise Exception("no view provided: " + vid) return view
def animate(fn): casefoam = pv.OpenFOAMReader(FileName=fn) pv.Show(casefoam) dp = pv.GetDisplayProperties(casefoam) dp.SetPropertyWithName('ColorArrayName', ['POINTS', 'U']) view = pv.GetActiveView() reader = pv.GetActiveSource() tsteps = reader.TimestepValues annTime = pv.AnnotateTimeFilter(reader) pv.Show(annTime) pv.Render() while True: try: for t in tsteps: view.ViewTime = t pv.Render() except KeyboardInterrupt: sys.exit(0)
def getRenameMap(): renameMap = {} names = getAllNames() view = simple.GetActiveView() renderer = view.GetClientSideObject().GetRenderer() viewProps = renderer.GetViewProps() volumes = renderer.GetVolumes() idx = 1 for viewProp in viewProps: if not viewProp.IsA("vtkActor"): continue if not viewProp.GetVisibility(): continue # The mapping will fail for multiblock that are composed of several blocks # Merge block should be used to solve the renaming issue for now # as the id is based on the a valid block vs representation. strIdx = "%s" % idx # Prop is valid if we can find it in the current sources for name, actor in names.items(): if viewProp == actor: renameMap[strIdx] = name idx += 1 break for volume in volumes: if not volume.IsA("vtkVolume"): continue if not volume.GetVisibility(): continue strIdx = "%s" % idx for name, actor in names.items(): if viewProp == actor: renameMap[strIdx] = name idx += 1 break return renameMap
def RequestData(): # R.0.2018.080 import sys sys.path.insert(0, "EMC_SRC_PATH") import paraview.simple as simple import numpy as np import csv import os from vtk.util import numpy_support as nps import IrisEMC_Paraview_Lib as lib import urlparse Label = '' pts = vtk.vtkPoints() # make sure we have input files query = lib.volcanoLocationsQuery if len(Alternate_FileName) <= 0: volcanoFile = lib.query2fileName(query) query = '?'.join([lib.volcanoLocationsKeys[Data_Source], query]) fileFound, address, source = lib.findFile(volcanoFile, loc='EMC_VOLCANOES_PATH', query=query) Label = ' '.join([ lib.volcanoLocationsValues[Data_Source].strip(), 'from', urlparse.urlparse( lib.volcanoLocationsKeys[Data_Source]).netloc.strip() ]) else: fileFound, address, source = lib.findFile(Alternate_FileName, loc='EMC_VOLCANOES_PATH') if not fileFound: raise Exception( 'volcano file "' + address + '" not found! Please provide the full path or UR for the file. Aborting.' ) (params, lines) = lib.readGcsv(address) Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End = lib.getArea( Area, Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End) Label2 = " - %s (lat:%0.1f,%0.1f, lon:%0.1f,%0.1f)" % ( lib.areaValues[Area], Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End) pdo = self.GetOutput() # vtkPoints count = 0 latIndex = 0 lonIndex = 1 column_keys = lib.columnKeys for key in lib.columnKeys.keys(): if key in params.keys(): column_keys[key] = params[key] delimiter = params['delimiter'].strip() origin = None if 'source' in params: origin = params['source'] if len(Label.strip()) <= 0: Label = origin header = lines[0].strip() fields = header.split(delimiter) for i in range(len(fields)): if fields[i].strip().lower() == column_keys['longitude_column'].lower( ): lonIndex = i elif fields[i].strip().lower() == column_keys['latitude_column'].lower( ): latIndex = i elif fields[i].strip().lower( ) == column_keys['elevation_column'].lower(): elevIndex = i for i in range(1, len(lines)): line = lines[i].strip() values = line.strip().split(params['delimiter'].strip()) try: lat = float(values[latIndex]) lon = float(values[lonIndex]) except: continue if len(values[elevIndex].strip()) <= 0: depth = 0.0 else: try: depth = -1 * float(values[elevIndex]) / 1000.0 except: continue if lat >= Latitude_Begin and lat <= Latitude_End and lon >= Longitude_Begin and lon <= Longitude_End: x, y, z = lib.llz2xyz(lat, lon, depth) pts.InsertNextPoint(x, y, z) pdo.SetPoints(pts) done = False simple.RenameSource(' '.join( ['Volcano locations:', Label.strip(), Label2.strip()])) view = simple.GetActiveView() # store metadata fieldData = pdo.GetFieldData() fieldData.AllocateArrays(3) # number of fields data = vtk.vtkFloatArray() data.SetName('Latitude\nRange (deg)') data.InsertNextValue(Latitude_Begin) data.InsertNextValue(Latitude_End) fieldData.AddArray(data) data = vtk.vtkFloatArray() data.SetName('Longitude\nRange (deg)') data.InsertNextValue(Longitude_Begin) data.InsertNextValue(Longitude_End) fieldData.AddArray(data) data = vtk.vtkStringArray() data.SetName('Source') if origin is not None: data.InsertNextValue(origin) data.InsertNextValue(source) fieldData.AddArray(data) pdo.SetFieldData(fieldData)
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()
else: sceneName = args[1] # arg 2 shoud be compression prefernece doCompressArrays = args[2] # Generate timestamp and use it to make subdirectory within the top level output dir timeStamp = time.strftime("%a-%d-%b-%Y-%H-%M-%S") outputDir = os.path.join(ROOT_OUTPUT_DIRECTORY, timeStamp) mkdir_p(outputDir) # Get the active view and render window, use it to iterate over renderers activeView = simple.GetActiveView() renderWindow = activeView.GetRenderWindow() renderers = renderWindow.GetRenderers() scDirs = [] sceneComponents = [] textureToSave = {} for rIdx in range(renderers.GetNumberOfItems()): renderer = renderers.GetItemAsObject(rIdx) renProps = renderer.GetViewProps() for rpIdx in range(renProps.GetNumberOfItems()): renProp = renProps.GetItemAsObject(rpIdx) if not renProp.GetVisibility(): continue if hasattr(renProp, 'GetMapper'):
def export_scene(baseDirName, viewSelection, trackSelection): '''This explores a set of user-defined views and tracks. export_scene is called from vtkCinemaExport. The expected order of parameters is as follows: - viewSelection (following the format defined in Wrapping/Python/paraview/cpstate.py): Directory of the form {'ViewName' : [parameters], ...}, with parameters defined in the order: Image filename, freq, fittoscreen, magnification, width, height, cinema). - trackSelection: Directory of the form {'TrackName' : [v1, v2, v3], ...} Note: baseDirName is used as the parent directory of the database generated for each view in viewSelection. 'Image filename' is used as the database directory name. ''' import paraview.simple as pvs # save initial state initialView = pvs.GetActiveView() pvstate = record_visibility() atLeastOneViewExported = False for viewName, viewParams in viewSelection.iteritems(): # check if this view was selected to export as spec b cinemaParams = viewParams[6] if len(cinemaParams) == 0: print "Skipping view: Not selected to export as cinema spherical." continue # get the view and save the initial status view = pvs.FindView(viewName) pvs.SetActiveView(view) view.ViewSize = [viewParams[4], viewParams[5]] pvs.Render() # fully renders the scene (if not, some faces might be culled) view.LockBounds = 1 #writeFreq = viewParams[1] # TODO where to get the timestamp in this case? #if (writeFreq and timestamp % writeFreq == 0): #magnification = viewParams[3] # Not used in cinema (TODO hide in UI) fitToScreen = viewParams[2] if fitToScreen != 0: if view.IsA("vtkSMRenderViewProxy") == True: view.ResetCamera() elif view.IsA("vtkSMContextViewProxy") == True: view.ResetDisplay() else: print ' do not know what to do with a ', view.GetClassName() userDefValues = {} if "theta" in cinemaParams: userDefValues["theta"] = cinemaParams["theta"] if "phi" in cinemaParams: userDefValues["phi"] = cinemaParams["phi"] userDefValues.update(trackSelection) # generate file path import os.path viewFileName = viewParams[0] viewDirName = viewFileName[0:viewFileName.rfind("_")] #strip _num.ext filePath = os.path.join(baseDirName, viewDirName, "info.json") p = inspect() cs = make_cinema_store(p, filePath, forcetime = False, _userDefinedValues = userDefValues) explore(cs, p) view.LockBounds = 0 cs.save() atLeastOneViewExported = True if not atLeastOneViewExported: print "No view was selected to export as cinema spherical." return # restore initial state pvs.SetActiveView(initialView) restore_visibility(pvstate)
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(): # V.2019.014 import sys sys.path.insert(0, r'EMC_SRC_PATH') import paraview.simple as simple import numpy as np import csv import os from vtk.util import numpy_support as nps import IrisEMC_Paraview_Lib as lib import urllib.parse Label = '' pts = vtk.vtkPoints() # make sure we have input files if len(File_name.strip()) <= 0: fileFound = False address = '' else: fileFound, address, source = lib.find_file(File_name.strip(), loc=r'EMC_VOLCANOES_PATH') if not fileFound: raise Exception( 'volcano file "' + address + '" not found! Please provide the full path or UR for the file. Aborting.' ) (params, lines) = lib.read_geocsv(address) Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End = lib.get_area( Area, Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End) Label2 = " - %s (lat:%0.1f,%0.1f, lon:%0.1f,%0.1f)" % ( lib.areaValues[Area], Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End) pdo = self.GetOutput() # vtkPoints lat_index = 0 lon_index = 1 column_keys = lib.columnKeys for key in list(lib.columnKeys.keys()): if key in list(params.keys()): column_keys[key] = params[key] delimiter = params['delimiter'].strip() origin = None if 'source' in params: origin = params['source'] if len(Label.strip()) <= 0: Label = origin fields = params['header'] for i in range(len(fields)): if fields[i].strip().lower() == column_keys['longitude_column'].lower( ): lon_index = i elif fields[i].strip().lower() == column_keys['latitude_column'].lower( ): lat_index = i elif fields[i].strip().lower( ) == column_keys['elevation_column'].lower(): elev_index = i for i, line in enumerate(lines): line = line.strip() values = line.split(delimiter) try: lat = float(values[lat_index]) lon = float(values[lon_index]) except: continue if len(values[elev_index].strip()) <= 0: depth = 0.0 else: try: depth = -1 * float(values[elev_index]) / 1000.0 except: continue if Latitude_Begin <= lat <= Latitude_End and Longitude_Begin <= lon <= Longitude_End: x, y, z = lib.llz2xyz(lat, lon, depth) pts.InsertNextPoint(x, y, z) pdo.SetPoints(pts) simple.RenameSource(' '.join( ['Volcano locations:', Label.strip(), Label2.strip()])) view = simple.GetActiveView() # store metadata fieldData = pdo.GetFieldData() fieldData.AllocateArrays(3) # number of fields data = vtk.vtkFloatArray() data.SetName('Latitude\nRange (deg)') data.InsertNextValue(Latitude_Begin) data.InsertNextValue(Latitude_End) fieldData.AddArray(data) data = vtk.vtkFloatArray() data.SetName('Longitude\nRange (deg)') data.InsertNextValue(Longitude_Begin) data.InsertNextValue(Longitude_End) fieldData.AddArray(data) data = vtk.vtkStringArray() data.SetName('Source') if origin is not None: data.InsertNextValue(origin) data.InsertNextValue(source) 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)
def Save_PV_data_to_picture_file(inputFileName, field_name, node_or_cell,outputFileName ): pvs._DisableFirstRenderCameraReset() #pvs.HideAll(view=None)#Not available in paraview 5.1.2 view = pvs.GetActiveView() sources = pvs.GetSources().values() for aSource in sources: pvs.Hide(aSource, view) # create a new 'XML Unstructured Grid Reader' reader = pvs.XMLUnstructuredGridReader(FileName=[inputFileName]) if node_or_cell== 'CELLS': reader.CellArrayStatus = [field_name] elif node_or_cell== 'NODES': reader.PointArrayStatus = [field_name] else: raise ValueError("unknown type : should be CELLS or NODES") # get active view renderView1 = pvs.GetActiveViewOrCreate('RenderView') # uncomment following to set a specific view size # renderView1.ViewSize = [1057, 499] # show data in view display = pvs.Show(reader, renderView1); # trace defaults for the display properties. display.ColorArrayName = [None, ''] display.GlyphType = 'Arrow' display.ScalarOpacityUnitDistance = 0.02234159571242408 # reset view to fit data renderView1.ResetCamera() # set scalar coloring if node_or_cell== 'CELLS': pvs.ColorBy(display, ('CELLS', field_name)) elif node_or_cell== 'NODES': pvs.ColorBy(display, ('POINTS', field_name)) else: raise ValueError("unknown type : should be CELLS or NODES") # rescale color and/or opacity maps used to include current data range display.RescaleTransferFunctionToDataRange(True) # show color bar/color legend display.SetScalarBarVisibility(renderView1, True) pvs.SaveScreenshot(outputFileName+".png", magnification=1, quality=100, view=renderView1) display.SetScalarBarVisibility(renderView1, False) if field_name=='Velocity' : #pvs.HideAll(view=None)#Not available in paraview 5.1.2 view = pvs.GetActiveView() sources = pvs.GetSources().values() for aSource in sources: pvs.Hide(aSource, view) # create a new 'Stream Tracer' streamTracer1 = pvs.StreamTracer(Input=reader, SeedType='Point Source') streamTracer1.Vectors = ['CELLS', 'Velocity'] # init the 'Point Source' selected for 'SeedType' streamTracer1.SeedType.Center = [0.5, 0.5, 0.0] streamTracer1.SeedType.Radius = 0.0 # Properties modified on streamTracer1 streamTracer1.SeedType = 'High Resolution Line Source' # Properties modified on streamTracer1.SeedType streamTracer1.SeedType.Point1 = [0.0, 0.0, 0.0] streamTracer1.SeedType.Point2 = [1.0, 1.0, 0.0] streamTracer1.SeedType.Resolution = 20# Pb : claims attribute Resolution does not exist # show data in view streamTracer1Display = pvs.Show(streamTracer1, renderView1) # create a new 'Stream Tracer' streamTracer2 = pvs.StreamTracer(Input=reader, SeedType='Point Source') streamTracer2.Vectors = ['CELLS', 'Velocity'] # init the 'Point Source' selected for 'SeedType' streamTracer2.SeedType.Center = [0.5, 0.5, 0.0] streamTracer2.SeedType.Radius = 0.0 # Properties modified on streamTracer2 streamTracer2.SeedType = 'High Resolution Line Source' # Properties modified on streamTracer2.SeedType streamTracer2.SeedType.Point1 = [0.0, 1.0, 0.0] streamTracer2.SeedType.Point2 = [1.0, 0.0, 0.0] streamTracer2.SeedType.Resolution = 25# Pb : claims attribute Resolution does not exist # show data in view streamTracer2Display = pvs.Show(streamTracer2, renderView1) pvs.SaveScreenshot(outputFileName+"_streamlines.png", magnification=1, quality=100, view=renderView1) pvs.Delete()
def start_cue(self): """ function called at the beginning of the animation """ self.image_index = 0 # image index # setup view parameters view = smp.GetActiveView() view.CameraParallelProjection = CameraParallelProjection view.Background = Background view.Background2 = Background2 view.UseGradientBackground = UseGradientBackground view.CameraViewAngle = CameraViewAngle # setup initial opacity frames = smp.FindSource(pointclouds_name) self.frames_repr = smp.Show(frames) self.frames_repr.Opacity = opacity # get trajectory positions and orientations trajectory = smp.FindSource(trajectory_name) traj = trajectory.GetClientSideObject().GetOutput() self.pts = numpy_support.vtk_to_numpy(traj.GetPoints().GetData()).copy() # convert veloview axis angle to scipy Rotation orientations_data = traj.GetPointData().GetArray("Orientation(AxisAngle)") orientations = numpy_support.vtk_to_numpy(orientations_data).copy() axis = orientations[:, :3] angles = orientations[:, 3].reshape((-1, 1)) axis_angles = axis * angles self.orientations = [Rotation.from_rotvec(a) for a in axis_angles] # get the 3D model self.model = None if len(cad_model_name) > 0: self.model = smp.FindSource(cad_model_name) # get all available timesteps and find the index corresponding to the start time time = view.ViewTime source_frames = smp.FindSource(temporal_source_name) timesteps = list(source_frames.TimestepValues) self.i = np.argmin(np.abs(np.asarray(timesteps) - time)) print "Start timestep: ", self.i # -----------------------------TO MODIFY-------------------------------------- # Camera path definition (need to be specified) # This is an example, you can define your custom camera path c1 = FirstPersonView(self.i, self.i+40, focal_point=[0, 0, 1]) c2 = FixedPositionView(self.i+40, self.i+100) c2.set_transition(c1, 5, "s-shape") # transition from c1 c3 = AbsoluteOrbit(self.i+100, self.i+200, center=[99.65169060331509, 35.559305816556, 37.233268868598536], up_vector=[0, 0, 1.0], initial_pos = [85.65169060331509, 35.559305816556, 37.233268868598536], focal_point=[99.65169060331509, 35.559305816556, 7.233268868598536]) c3.set_transition(c2, 20, "s-shape") c4 = ThirdPersonView(self.i+200, self.i+280) c4.set_transition(c3, 20, "s-shape") c5 = RelativeOrbit(self.i+280, self.i+350, up_vector=[0, 0, 1.0], initial_pos = [0.0, -10, 10]) c5.set_transition(c4, 20, "square") self.cameras = [c1, c2, c3, c4, c5]
def RequestData(): # R.0.2018.120 import sys sys.path.insert(0, "EMC_SRC_PATH") import paraview.simple as simple import numpy as np import csv import os from vtk.util import numpy_support as nps import IrisEMC_Paraview_Lib as lib import urlparse Label = '' pts = vtk.vtkPoints() Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End = lib.getArea( Area, Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End) Label2 = " - %s (lat:%0.1f,%0.1f, lon:%0.1f,%0.1f, depth:%0.1f-%0.1f)" % ( lib.areaValues[Area], Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End, Depth_Begin, Depth_End) # make sure we have input files query = lib.earthquakeQuery % (Start_Time, Magnitude_Begin, Magnitude_End, Depth_Begin, Depth_End, Latitude_Begin, Latitude_End, Longitude_Begin, Longitude_End, Max_Count) if len(Alternate_FileName) <= 0: eqFile = lib.query2fileName(query, url=lib.earthquakeKeys[Data_Source]) query = '?'.join([lib.earthquakeKeys[Data_Source], query]) fileFound, address, source = lib.findFile(eqFile, loc='EMC_EARTHQUAKES_PATH', query=query) else: fileFound, address, source = lib.findFile(Alternate_FileName, loc='EMC_EARTHQUAKES_PATH') if not fileFound: raise Exception( 'earthquake catalog file "' + address + '" not found! Please provide the full path or UR for the file. Aborting.' ) (params, lines) = lib.readGcsv(address) pdo = self.GetOutput() # vtkPoints column_keys = lib.columnKeys for key in lib.columnKeys.keys(): if key in params.keys(): column_keys[key] = params[key] delimiter = params['delimiter'].strip() origin = None if 'source' in params: origin = params['source'] Label = urlparse.urlparse(origin).netloc else: try: Label = urlparse.urlparse(Alternate_FileName).netloc except: Label = Alternate_FileName header = lines[0].strip() fields = header.split(delimiter) for i in range(len(fields)): if fields[i].strip().lower() == column_keys['longitude_column'].lower( ): lonIndex = i elif fields[i].strip().lower() == column_keys['latitude_column'].lower( ): latIndex = i elif fields[i].strip().lower() == column_keys['depth_column'].lower(): depthIndex = i elif fields[i].strip().lower( ) == column_keys['magnitude_column'].lower(): magIndex = i scalars = vtk.vtkFloatArray() scalars.SetNumberOfComponents(1) scalars.SetName("magnitude") lat = [] lon = [] depth = [] mag = [] for i in range(1, len(lines)): line = lines[i].strip() values = line.strip().split(params['delimiter'].strip()) lat.append(float(values[latIndex])) lon.append(float(values[lonIndex])) depth.append(float(values[depthIndex])) mag.append(float(values[magIndex])) if lat[-1] >= Latitude_Begin and lat[-1] <= Latitude_End and lon[ -1] >= Longitude_Begin and lon[-1] <= Longitude_End: x, y, z = lib.llz2xyz(lat[-1], lon[-1], depth[-1]) pts.InsertNextPoint(x, y, z) scalars.InsertNextValue(mag[-1]) pdo.SetPoints(pts) pdo.GetPointData().AddArray(scalars) if len(Label.strip()) > 0: simple.RenameSource(' '.join( ['Earthquake locations:', 'from', Label.strip(), Label2.strip()])) view = simple.GetActiveView() # store metadata fieldData = pdo.GetFieldData() fieldData.AllocateArrays(3) # number of fields data = vtk.vtkFloatArray() data.SetName('Latitude\nRange (deg)') data.InsertNextValue(min(lat)) data.InsertNextValue(max(lat)) fieldData.AddArray(data) data = vtk.vtkFloatArray() data.SetName('Longitude\nRange (deg)') data.InsertNextValue(min(lon)) data.InsertNextValue(max(lon)) fieldData.AddArray(data) data = vtk.vtkFloatArray() data.SetName('Depth\nRange (km)') data.InsertNextValue(min(depth)) data.InsertNextValue(max(depth)) fieldData.AddArray(data) data = vtk.vtkFloatArray() data.SetName('Magnitude\nRange') data.InsertNextValue(min(mag)) data.InsertNextValue(max(mag)) fieldData.AddArray(data) data = vtk.vtkIntArray() data.SetName('Max. Event\nCount') data.InsertNextValue(len(mag)) fieldData.AddArray(data) data = vtk.vtkStringArray() data.SetName('Start Date') data.InsertNextValue(Start_Time) fieldData.AddArray(data) data = vtk.vtkStringArray() data.SetName('Source') if origin is not None: data.InsertNextValue(origin) data.InsertNextValue(source) fieldData.AddArray(data) pdo.SetFieldData(fieldData)
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 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_active_view(): view = simple.GetActiveView() if not view: raise Error(404, "No view provided to WebGL resource") return view
files = glob.glob(args.source_dir + "/*.vtk") files = natural_sort(files) jump = args.step count = 0 files = files[::jump] #some_list[start:stop:step] reader = simple.OpenDataFile(files) simple.Show(reader) dp = simple.GetDisplayProperties(reader) dp.Representation = 'Surface' simple.GetActiveView().GetRenderWindow().SetSize(800, 800) dp.LookupTable = simple.MakeBlueToRedLT(-86.2, 40.0) dp.ColorArrayName = 'Scalars_' camera = simple.GetActiveCamera() camera.Elevation(args.elevation) camera.Azimuth(args.azimuth) simple.Render() #simple.AnimateReader(reader, filename=video_file) simple.SaveAnimation(video_file) if args.images: os.system('ffmpeg -i ' + video_file + ' ./images/output_%04d.png') if not args.video: