X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FPV_SWIG%2Fpvsimple.py;h=6b474725ab32d70408884e93db851e98e0901d28;hb=1d6fe1344be14cbab6bff5cfca040709ac56d51b;hp=48ad9621c00b996ea458d117efe06ff67534360b;hpb=f97aa0a72a48a5411faa8d0defd3cf4b54f4c305;p=modules%2Fparavis.git diff --git a/src/PV_SWIG/pvsimple.py b/src/PV_SWIG/pvsimple.py index 48ad9621..6b474725 100644 --- a/src/PV_SWIG/pvsimple.py +++ b/src/PV_SWIG/pvsimple.py @@ -17,25 +17,1157 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -r""" This module is a direct forward to the initial -'simple' module of ParaView. +r"""simple is a module for using paraview server manager in Python. It +provides a simple convenience layer to functionality provided by the +C++ classes wrapped to Python as well as the servermanager module. + +A simple example: + from paraview.simple import * + + # Create a new sphere proxy on the active connection and register it + # in the sources group. + sphere = Sphere(ThetaResolution=16, PhiResolution=32) + + # Apply a shrink filter + shrink = Shrink(sphere) + + # Turn the visiblity of the shrink object on. + Show(shrink) + + # Render the scene + Render() """ -from paraview import simple - -for name in dir(simple): - if name != "__file__": - globals()[name] = getattr(simple, name) -del simple - -print "Connecting to PVServer ..." -try: - # TODO: this should be improved (retrieval from the engine) - Connect('localhost') -except Exception as e: - print "*******************************************" - print "*******************************************" - print "Could not connect to PVServer on localhost!" - print "*******************************************" - print "*******************************************" - raise e +import paravisSM + +servermanager = paravisSM + +def enableMultiServer(): + servermanager.enableMultiServer() + +def switchActiveConnection(newActiveConnection=None, ns=None): + if not ns: + ns = globals() + _remove_functions(ns) + servermanager.switchActiveConnection(newActiveConnection) + _add_functions(ns) + +def Disconnect(ns=None, force=True): + if servermanager.ActiveConnection and (force or servermanager.MultiServerConnections == None): + if ns: + _remove_functions(ns) + _remove_functions(globals()) + if not servermanager.fromGUI: + servermanager.ProxyManager().DisableStateUpdateNotification() + servermanager.ProxyManager().UnRegisterProxies() + active_objects.view = None + active_objects.source = None + servermanager.Disconnect() + if not servermanager.fromGUI: + import gc + gc.collect() + +def Connect(ds_host=None, ds_port=11111, rs_host=None, rs_port=11111): + """Creates a connection to a server. Example usage: + > Connect("amber") # Connect to a single server at default port + > Connect("amber", 12345) # Connect to a single server at port 12345 + > Connect("amber", 11111, "vis_cluster", 11111) # connect to data server, render server pair""" + Disconnect(globals(), False) + connection = servermanager.Connect(ds_host, ds_port, rs_host, rs_port) + _add_functions(globals()) + + servermanager.ProxyManager().DisableStateUpdateNotification() + servermanager.ProxyManager().UpdateFromRemote() + tk = servermanager.ProxyManager().GetProxy("timekeeper", "TimeKeeper") + if not tk: + try: + tk = servermanager.misc.TimeKeeper() + servermanager.ProxyManager().RegisterProxy("timekeeper", "TimeKeeper", tk) + except AttributeError: + print "Error: Could not create TimeKeeper" + + scene = servermanager.ProxyManager().GetProxy("animation", "AnimationScene") + if not scene: + try: + scene = AnimationScene() + scene.TimeKeeper = tk + except NameError: + print "Error: Could not create AnimationScene" + + servermanager.ProxyManager().EnableStateUpdateNotification() + servermanager.ProxyManager().TriggerStateUpdate() + + return connection + +def ReverseConnect(port=11111): + """Create a reverse connection to a server. Listens on port and waits for + an incoming connection from the server.""" + Disconnect(globals(), False) + connection = servermanager.ReverseConnect(port) + _add_functions(globals()) + + servermanager.ProxyManager().DisableStateUpdateNotification() + servermanager.ProxyManager().UpdateFromRemote() + tk = servermanager.ProxyManager().GetProxy("timekeeper", "TimeKeeper") + if not tk: + tk = servermanager.misc.TimeKeeper() + servermanager.ProxyManager().RegisterProxy("timekeeper", "TimeKeeper", tk) + + scene = servermanager.ProxyManager().GetProxy("animation", "AnimationScene") + if not scene: + scene = AnimationScene() + scene.TimeKeeper = tk + + servermanager.ProxyManager().EnableStateUpdateNotification() + servermanager.ProxyManager().TriggerStateUpdate() + + return connection + +def _create_view(view_xml_name): + "Creates and returns a 3D render view." + view = servermanager._create_view(view_xml_name) + servermanager.ProxyManager().RegisterProxy("views", \ + "my_view%d" % _funcs_internals.view_counter, view) + active_objects.view = view + _funcs_internals.view_counter += 1 + + tk = servermanager.ProxyManager().GetProxiesInGroup("timekeeper").values()[0] + views = tk.Views + if not view in views: + views.append(view) + try: + scene = GetAnimationScene() + if not view in scene.ViewModules: + scene.ViewModules.append(view) + except servermanager.MissingProxy: + pass + return view + +def CreateRenderView(): + return _create_view("RenderView") + +def CreateXYPlotView(): + return _create_view("XYChartView") + +def CreateBarChartView(): + return _create_view("XYBarChartView") + +def CreateComparativeRenderView(): + return _create_view("ComparativeRenderView") + +def CreateComparativeXYPlotView(): + return _create_view("ComparativeXYPlotView") + +def CreateComparativeBarChartView(): + return _create_view("ComparativeBarChartView") + +def CreateParallelCoordinatesChartView(): + return _create_view("ParallelCoordinatesChartView") + +def Create2DRenderView(): + return _create_view("2DRenderView") + +def OpenDataFile(filename, **extraArgs): + """Creates a reader to read the give file, if possible. + This uses extension matching to determine the best reader possible. + If a reader cannot be identified, then this returns None.""" + session = servermanager.ActiveConnection.Session + reader_factor = servermanager.vtkSMProxyManager.GetProxyManager().GetReaderFactory() + if reader_factor.GetNumberOfRegisteredPrototypes() == 0: + reader_factor.RegisterPrototypes(session, "sources") + first_file = filename + if type(filename) == list: + first_file = filename[0] + if not reader_factor.TestFileReadability(first_file, session): + msg = "File not readable: %s " % first_file + raise RuntimeError, msg + if not reader_factor.CanReadFile(first_file, session): + msg = "File not readable. No reader found for '%s' " % first_file + raise RuntimeError, msg + prototype = servermanager.ProxyManager().GetPrototypeProxy( + reader_factor.GetReaderGroup(), reader_factor.GetReaderName()) + # [ABN]: bug fix for Christian VW (temporary - pvsimple should disappear soon) + from paraview import make_name_valid # make_name_valid is not in paravisSM + xml_name = make_name_valid(prototype.GetXMLLabel()) + reader_func = _create_func(xml_name, servermanager.sources) + if prototype.GetProperty("FileNames"): + reader = reader_func(FileNames=filename, **extraArgs) + else : + reader = reader_func(FileName=filename, **extraArgs) + return reader + +def CreateWriter(filename, proxy=None, **extraArgs): + """Creates a writer that can write the data produced by the source proxy in + the given file format (identified by the extension). If no source is + provided, then the active source is used. This doesn't actually write the + data, it simply creates the writer and returns it.""" + if not filename: + raise RuntimeError, "filename must be specified" + session = servermanager.ActiveConnection.Session + writer_factory = servermanager.vtkSMProxyManager.GetProxyManager().GetWriterFactory() + if writer_factory.GetNumberOfRegisteredPrototypes() == 0: + writer_factory.RegisterPrototypes(session, "writers") + if not proxy: + proxy = GetActiveSource() + if not proxy: + raise RuntimeError, "Could not locate source to write" + writer_proxy = writer_factory.CreateWriter(filename, proxy.SMProxy, proxy.Port) + return servermanager._getPyProxy(writer_proxy) + +def GetRenderView(): + """Returns the active view if there is one. Else creates and returns a new view.""" + view = active_objects.view + if not view: + # it's possible that there's no active view, but a render view exists. + # If so, locate that and return it (before trying to create a new one). + view = servermanager.GetRenderView() + if not view: + view = CreateRenderView() + return view + +def GetRenderViews(): + """Returns all render views as a list.""" + return servermanager.GetRenderViews() + +def GetRepresentation(proxy=None, view=None): + """Given a pipeline object and view, returns the corresponding representation object. + If pipeline object and view are not specified, active objects are used.""" + if not view: + view = active_objects.view + if not proxy: + proxy = active_objects.source + rep = servermanager.GetRepresentation(proxy, view) + if not rep: + rep = servermanager.CreateRepresentation(proxy, view) + servermanager.ProxyManager().RegisterProxy("representations", \ + "my_representation%d" % _funcs_internals.rep_counter, rep) + _funcs_internals.rep_counter += 1 + return rep + +def GetDisplayProperties(proxy=None, view=None): + """Given a pipeline object and view, returns the corresponding representation object. + If pipeline object and/or view are not specified, active objects are used.""" + return GetRepresentation(proxy, view) + +def Show(proxy=None, view=None, **params): + """Turns the visibility of a given pipeline object on in the given view. + If pipeline object and/or view are not specified, active objects are used.""" + if proxy == None: + proxy = GetActiveSource() + if proxy == None: + raise RuntimeError, "Show() needs a proxy argument or that an active source is set." + if not view and not active_objects.view: + CreateRenderView() + rep = GetDisplayProperties(proxy, view) + if rep == None: + raise RuntimeError, "Could not create a representation object for proxy %s" % proxy.GetXMLLabel() + for param in params.keys(): + setattr(rep, param, params[param]) + rep.Visibility = 1 + return rep + +def Hide(proxy=None, view=None): + """Turns the visibility of a given pipeline object off in the given view. + If pipeline object and/or view are not specified, active objects are used.""" + rep = GetDisplayProperties(proxy, view) + rep.Visibility = 0 + +def Render(view=None): + """Renders the given view (default value is active view)""" + if not view: + view = active_objects.view + view.StillRender() + if _funcs_internals.first_render: + # Not all views have a ResetCamera method + try: + view.ResetCamera() + view.StillRender() + except AttributeError: pass + _funcs_internals.first_render = False + return view + +def ResetCamera(view=None): + """Resets the settings of the camera to preserver orientation but include + the whole scene. If an argument is not provided, the active view is + used.""" + if not view: + view = active_objects.view + if hasattr(view, "ResetCamera"): + view.ResetCamera() + if hasattr(view, "ResetDisplay"): + view.ResetDisplay() + Render(view) + +def _DisableFirstRenderCameraReset(): + """Disable the first render camera reset. Normally a ResetCamera is called + automatically when Render is called for the first time after importing + this module.""" + _funcs_internals.first_render = False + +def SetProperties(proxy=None, **params): + """Sets one or more properties of the given pipeline object. If an argument + is not provided, the active source is used. Pass a list of property_name=value + pairs to this function to set property values. For example: + SetProperties(Center=[1, 2, 3], Radius=3.5) + """ + if not proxy: + proxy = active_objects.source + for param in params.keys(): + if not hasattr(proxy, param): + raise AttributeError("object has no property %s" % param) + setattr(proxy, param, params[param]) + +def GetProperty(*arguments, **keywords): + """Get one property of the given pipeline object. If keywords are used, + you can set the proxy and the name of the property that you want to get + like in the following example : + GetProperty({proxy=sphere, name="Radius"}) + If it's arguments that are used, then you have two case: + - if only one argument is used that argument will be + the property name. + - if two arguments are used then the first one will be + the proxy and the second one the property name. + Several example are given below: + GetProperty({name="Radius"}) + GetProperty({proxy=sphereProxy, name="Radius"}) + GetProperty( sphereProxy, "Radius" ) + GetProperty( "Radius" ) + """ + name = None + proxy = None + for key in keywords: + if key == "name": + name = keywords[key] + if key == "proxy": + proxy = keywords[key] + if len(arguments) == 1 : + name = arguments[0] + if len(arguments) == 2 : + proxy = arguments[0] + name = arguments[1] + if not name: + raise RuntimeError, "Expecting at least a property name as input. Otherwise keyword could be used to set 'proxy' and property 'name'" + if not proxy: + proxy = active_objects.source + return proxy.GetProperty(name) + +def SetDisplayProperties(proxy=None, view=None, **params): + """Sets one or more display properties of the given pipeline object. If an argument + is not provided, the active source is used. Pass a list of property_name=value + pairs to this function to set property values. For example: + SetProperties(Color=[1, 0, 0], LineWidth=2) + """ + rep = GetDisplayProperties(proxy, view) + SetProperties(rep, **params) + +def SetViewProperties(view=None, **params): + """Sets one or more properties of the given view. If an argument + is not provided, the active view is used. Pass a list of property_name=value + pairs to this function to set property values. For example: + SetProperties(Background=[1, 0, 0], UseImmediateMode=0) + """ + if not view: + view = active_objects.view + SetProperties(view, **params) + +def RenameSource(newName, proxy=None): + """Renames the given source. If the given proxy is not registered + in the sources group this method will have no effect. If no source is + provided, the active source is used.""" + if not proxy: + proxy = active_objects.source + pxm = servermanager.ProxyManager() + oldName = pxm.GetProxyName("sources", proxy) + if oldName: + pxm.RegisterProxy("sources", newName, proxy) + pxm.UnRegisterProxy("sources", oldName, proxy) + +def FindSource(name): + return servermanager.ProxyManager().GetProxy("sources", name) + +def GetSources(): + """Given the name of a source, return its Python object.""" + return servermanager.ProxyManager().GetProxiesInGroup("sources") + +def GetRepresentations(): + """Returns all representations (display properties).""" + return servermanager.ProxyManager().GetProxiesInGroup("representations") + +def UpdatePipeline(time=None, proxy=None): + """Updates (executes) the given pipeline object for the given time as + necessary (i.e. if it did not already execute). If no source is provided, + the active source is used instead.""" + if not proxy: + proxy = active_objects.source + if time: + proxy.UpdatePipeline(time) + else: + proxy.UpdatePipeline() + +def Delete(proxy=None): + """Deletes the given pipeline object or the active source if no argument + is specified.""" + if not proxy: + proxy = active_objects.source + # Unregister any helper proxies stored by a vtkSMProxyListDomain + for prop in proxy: + listdomain = prop.GetDomain('proxy_list') + if listdomain: + if listdomain.GetClassName() != 'vtkSMProxyListDomain': + continue + group = "pq_helper_proxies." + proxy.GetGlobalIDAsString() + for i in xrange(listdomain.GetNumberOfProxies()): + pm = servermanager.ProxyManager() + iproxy = listdomain.GetProxy(i) + name = pm.GetProxyName(group, iproxy) + if iproxy and name: + pm.UnRegisterProxy(group, name, iproxy) + + # Remove source/view from time keeper + tk = servermanager.ProxyManager().GetProxiesInGroup("timekeeper").values()[0] + if isinstance(proxy, servermanager.SourceProxy): + try: + idx = tk.TimeSources.index(proxy) + del tk.TimeSources[idx] + except ValueError: + pass + else: + try: + idx = tk.Views.index(proxy) + del tk.Views[idx] + except ValueError: + pass + servermanager.UnRegister(proxy) + + # If this is a representation, remove it from all views. + if proxy.SMProxy.IsA("vtkSMRepresentationProxy") or \ + proxy.SMProxy.IsA("vtkSMNewWidgetRepresentationProxy"): + for view in GetRenderViews(): + view.Representations.remove(proxy) + # If this is a source, remove the representation iff it has no consumers + # Also change the active source if necessary + elif proxy.SMProxy.IsA("vtkSMSourceProxy"): + sources = servermanager.ProxyManager().GetProxiesInGroup("sources") + for i in range(proxy.GetNumberOfConsumers()): + if proxy.GetConsumerProxy(i) in sources: + raise RuntimeError("Source has consumers. It cannot be deleted " + + "until all consumers are deleted.") + #VSV:== + if proxy.IsSame(GetActiveSource()): + if hasattr(proxy, "Input") and proxy.Input: + if isinstance(proxy.Input, servermanager.Proxy): + SetActiveSource(proxy.Input) + else: + SetActiveSource(proxy.Input[0]) + else: SetActiveSource(None) + for rep in GetRepresentations().values(): + #VSV:== + if rep.Input.IsSame(proxy): + Delete(rep) + # Change the active view if necessary + elif proxy.SMProxy.IsA("vtkSMRenderViewProxy"): + ##VSV:== + if proxy.IsSame(GetActiveView()): + if len(GetRenderViews()) > 0: + SetActiveView(GetRenderViews()[0]) + else: + SetActiveView(None) + +def CreateLookupTable(**params): + """Create and return a lookup table. Optionally, parameters can be given + to assign to the lookup table. + """ + lt = servermanager.rendering.PVLookupTable() + servermanager.Register(lt) + SetProperties(lt, **params) + return lt + +def CreatePiecewiseFunction(**params): + """Create and return a piecewise function. Optionally, parameters can be + given to assign to the piecewise function. + """ + pfunc = servermanager.piecewise_functions.PiecewiseFunction() + servermanager.Register(pfunc) + SetProperties(pfunc, **params) + return pfunc + +def GetLookupTableForArray(arrayname, num_components, **params): + """Used to get an existing lookuptable for a array or to create one if none + exists. Keyword arguments can be passed in to initialize the LUT if a new + one is created.""" + proxyName = "%d.%s.PVLookupTable" % (int(num_components), arrayname) + lut = servermanager.ProxyManager().GetProxy("lookup_tables", proxyName) + if lut: + return lut + # No LUT exists for this array, create a new one. + # TODO: Change this to go a LookupTableManager that is shared with the GUI, + # so that the GUI and python end up create same type of LUTs. For now, + # python will create a Blue-Red LUT, unless overridden by params. + lut = servermanager.rendering.PVLookupTable( + ColorSpace="HSV", RGBPoints=[0, 0, 0, 1, 1, 1, 0, 0]) + SetProperties(lut, **params) + servermanager.Register(lut, registrationName=proxyName) + return lut + +def CreateScalarBar(**params): + """Create and return a scalar bar widget. The returned widget may + be added to a render view by appending it to the view's representations + The widget must have a valid lookup table before it is added to a view. + It is possible to pass the lookup table (and other properties) as arguments + to this method: + + lt = MakeBlueToRedLt(3.5, 7.5) + bar = CreateScalarBar(LookupTable=lt, Title="Velocity") + GetRenderView().Representations.append(bar) + + By default the returned widget is selectable and resizable. + """ + sb = servermanager.rendering.ScalarBarWidgetRepresentation() + servermanager.Register(sb) + sb.Selectable = 1 + sb.Resizable = 1 + sb.Enabled = 1 + sb.Title = "Scalars" + SetProperties(sb, **params) + return sb + +# TODO: Change this to take the array name and number of components. Register +# the lt under the name ncomp.array_name +def MakeBlueToRedLT(min, max): + # Define RGB points. These are tuples of 4 values. First one is + # the scalar values, the other 3 the RGB values. + rgbPoints = [min, 0, 0, 1, max, 1, 0, 0] + return CreateLookupTable(RGBPoints=rgbPoints, ColorSpace="HSV") + +def _find_writer(filename): + """Internal function.""" + extension = None + parts = filename.split('.') + if len(parts) > 1: + extension = parts[-1] + else: + raise RuntimeError, "Filename has no extension, please specify a write" + + if extension == 'png': + return 'vtkPNGWriter' + elif extension == 'bmp': + return 'vtkBMPWriter' + elif extension == 'ppm': + return 'vtkPNMWriter' + elif extension == 'tif' or extension == 'tiff': + return 'vtkTIFFWriter' + elif extension == 'jpg' or extension == 'jpeg': + return 'vtkJPEGWriter' + else: + raise RuntimeError, "Cannot infer filetype from extension:", extension + +def AddCameraLink(viewProxy, viewProxyOther, linkName): + """Create a camera link between two view proxies. A name must be given + so that the link can be referred to by name. If a link with the given + name already exists it will be removed first.""" + if not viewProxyOther: viewProxyOther = GetActiveView() + link = servermanager.vtkSMCameraLink() + link.AddLinkedProxy(viewProxy.SMProxy, 1) + link.AddLinkedProxy(viewProxyOther.SMProxy, 2) + link.AddLinkedProxy(viewProxyOther.SMProxy, 1) + link.AddLinkedProxy(viewProxy.SMProxy, 2) + RemoveCameraLink(linkName) + servermanager.ProxyManager().RegisterLink(linkName, link) + +def RemoveCameraLink(linkName): + """Remove a camera link with the given name.""" + servermanager.ProxyManager().UnRegisterLink(linkName) + +def WriteImage(filename, view=None, **params): + """Saves the given view (or the active one if none is given) as an + image. Optionally, you can specify the writer and the magnification + using the Writer and Magnification named arguments. For example: + WriteImage("foo.mypng", aview, Writer=vtkPNGWriter, Magnification=2) + If no writer is provided, the type is determined from the file extension. + Currently supported extensions are png, bmp, ppm, tif, tiff, jpg and jpeg. + The writer is a VTK class that is capable of writing images. + Magnification is used to determine the size of the written image. The size + is obtained by multiplying the size of the view with the magnification. + Rendering may be done using tiling to obtain the correct size without + resizing the view.""" + if not view: + view = active_objects.view + writer = None + if params.has_key('Writer'): + writer = params['Writer'] + mag = 1 + if params.has_key('Magnification'): + mag = int(params['Magnification']) + if not writer: + writer = _find_writer(filename) + view.WriteImage(filename, writer, mag) + +def AnimateReader(reader=None, view=None, filename=None): + """This is a utility function that, given a reader and a view + animates over all time steps of the reader. If the optional + filename is provided, a movie is created (type depends on the + extension of the filename.""" + if not reader: + reader = active_objects.source + if not view: + view = active_objects.view + + return servermanager.AnimateReader(reader, view, filename) + + +def _create_func(key, module): + """Internal function.""" + + def CreateObject(*input, **params): + """This function creates a new proxy. For pipeline objects that accept inputs, + all non-keyword arguments are assumed to be inputs. All keyword arguments are + assumed to be property,value pairs and are passed to the new proxy.""" + + # Instantiate the actual object from the given module. + px = module.__dict__[key]() + + # Make sure non-keyword arguments are valid + for inp in input: + if inp != None and not isinstance(inp, servermanager.Proxy): + if px.GetProperty("Input") != None: + raise RuntimeError, "Expecting a proxy as input." + else: + raise RuntimeError, "This function does not accept non-keyword arguments." + + # Assign inputs + if px.GetProperty("Input") != None: + if len(input) > 0: + px.Input = input + else: + # If no input is specified, try the active pipeline object + if px.GetProperty("Input").GetRepeatable() and active_objects.get_selected_sources(): + px.Input = active_objects.get_selected_sources() + elif active_objects.source: + px.Input = active_objects.source + else: + if len(input) > 0: + raise RuntimeError, "This function does not expect an input." + + registrationName = None + for nameParam in ['registrationName', 'guiName']: + if nameParam in params: + registrationName = params[nameParam] + del params[nameParam] + + # Pass all the named arguments as property,value pairs + for param in params.keys(): + setattr(px, param, params[param]) + + try: + # Register the proxy with the proxy manager. + if registrationName: + group, name = servermanager.Register(px, registrationName=registrationName) + else: + group, name = servermanager.Register(px) + + + # Register pipeline objects with the time keeper. This is used to extract time values + # from sources. NOTE: This should really be in the servermanager controller layer. + if group == "sources": + has_tk = True + try: + tk = servermanager.ProxyManager().GetProxiesInGroup("timekeeper").values()[0] + except IndexError: + has_tk = False + if has_tk: + sources = tk.TimeSources + if not px in sources: + sources.append(px) + + active_objects.source = px + except servermanager.MissingRegistrationInformation: + pass + + return px + + return CreateObject + +def _create_doc(new, old): + """Internal function.""" + import string + res = "" + for doc in (new, old): + ts = [] + strpd = doc.split('\n') + for s in strpd: + ts.append(s.lstrip()) + res += string.join(ts) + res += '\n' + return res + +def _func_name_valid(name): + """Internal function.""" + valid = True + for c in name: + if c == '(' or c ==')': + valid = False + break + return valid + +def _add_functions(g): + activeModule = servermanager.ActiveConnection.Modules + for m in [activeModule.filters, activeModule.sources, + activeModule.writers, activeModule.animation]: + dt = m.__dict__ + for key in dt.keys(): + cl = dt[key] + if not isinstance(cl, str): + if not key in g and _func_name_valid(key): + g[key] = _create_func(key, m) + exec "g[key].__doc__ = _create_doc(m.%s.__doc__, g[key].__doc__)" % key + +def _remove_functions(g): + list = [] + if servermanager.ActiveConnection: + list = [m for m in dir(servermanager.ActiveConnection.Modules) if m[0] != '_'] + + for m in list: + dt = servermanager.ActiveConnection.Modules.__dict__[m].__dict__ + for key in dt.keys(): + cl = dt[key] + if not isinstance(cl, str) and g.has_key(key): + g.pop(key) + #print "remove %s function" % key + +def GetActiveView(): + """Returns the active view.""" + return active_objects.view + +def SetActiveView(view): + """Sets the active view.""" + active_objects.view = view + +def GetActiveSource(): + """Returns the active source.""" + return active_objects.source + +def SetActiveSource(source): + """Sets the active source.""" + active_objects.source = source + +def GetActiveCamera(): + """Returns the active camera for the active view. The returned object + is an instance of vtkCamera.""" + return GetActiveView().GetActiveCamera() + +def GetAnimationScene(): + """Returns the application-wide animation scene. ParaView has only one + global animation scene. This method provides access to that. Users are + free to create additional animation scenes directly, but those scenes + won't be shown in the ParaView GUI.""" + animation_proxies = servermanager.ProxyManager().GetProxiesInGroup("animation") + scene = None + for aProxy in animation_proxies.values(): + if aProxy.GetXMLName() == "AnimationScene": + scene = aProxy + break + if not scene: + raise servermanager.MissingProxy, "Could not locate global AnimationScene." + return scene + +def WriteAnimation(filename, **params): + """Writes the current animation as a file. Optionally one can specify + arguments that qualify the saved animation files as keyword arguments. + Accepted options are as follows: + * Magnification (integer) : set the maginification factor for the saved + animation. + * Quality (0 [worst] or 1 or 2 [best]) : set the quality of the generated + movie (if applicable). + * Subsampling (integer) : setting whether the movie encoder should use + subsampling of the chrome planes or not, if applicable. Since the human + eye is more sensitive to brightness than color variations, subsampling + can be useful to reduce the bitrate. Default value is 0. + * BackgroundColor (3-tuple of doubles) : set the RGB background color to + use to fill empty spaces in the image. + * FrameRate (double): set the frame rate (if applicable).""" + scene = GetAnimationScene() + # ensures that the TimeKeeper track is created. + GetTimeTrack() + iw = servermanager.vtkSMAnimationSceneImageWriter() + iw.SetAnimationScene(scene.SMProxy) + iw.SetFileName(filename) + if params.has_key("Magnification"): + iw.SetMagnification(int(params["Magnification"])) + if params.has_key("Quality"): + iw.SetQuality(int(params["Quality"])) + if params.has_key("Subsampling"): + iw.SetSubsampling(int(params["Subsampling"])) + if params.has_key("BackgroundColor"): + iw.SetBackgroundColor(params["BackgroundColor"]) + if params.has_key("FrameRate"): + iw.SetFrameRate(float(params["FrameRate"])) + iw.Save() + +def _GetRepresentationAnimationHelper(sourceproxy): + """Internal method that returns the representation animation helper for a + source proxy. It creates a new one if none exists.""" + # ascertain that proxy is a source proxy + if not sourceproxy in GetSources().values(): + return None + for proxy in servermanager.ProxyManager(): + if proxy.GetXMLName() == "RepresentationAnimationHelper" and\ + proxy.GetProperty("Source").IsProxyAdded(sourceproxy.SMProxy): + return proxy + # create a new helper + proxy = servermanager.misc.RepresentationAnimationHelper( + Source=sourceproxy) + servermanager.ProxyManager().RegisterProxy( + "pq_helper_proxies.%s" % sourceproxy.GetGlobalIDAsString(), + "RepresentationAnimationHelper", proxy) + return proxy + +def GetAnimationTrack(propertyname_or_property, index=None, proxy=None): + """Returns an animation cue for the property. If one doesn't exist then a + new one will be created. + Typical usage: + track = GetAnimationTrack("Center", 0, sphere) or + track = GetAnimationTrack(sphere.GetProperty("Radius")) or + + # this returns the track to animate visibility of the active source in + # all views. + track = GetAnimationTrack("Visibility") + + For animating properties on implicit planes etc., use the following + signatures: + track = GetAnimationTrack(slice.SliceType.GetProperty("Origin"), 0) or + track = GetAnimationTrack("Origin", 0, slice.SliceType) + + """ + if not proxy: + proxy = GetActiveSource() + if not isinstance(proxy, servermanager.Proxy): + raise TypeError, "proxy must be a servermanager.Proxy instance" + if isinstance(propertyname_or_property, str): + propertyname = propertyname_or_property + elif isinstance(propertyname_or_property, servermanager.Property): + prop = propertyname_or_property + propertyname = prop.Name + proxy = prop.Proxy + else: + raise TypeError, "propertyname_or_property must be a string or servermanager.Property" + + # To handle the case where the property is actually a "display" property, in + # which case we are actually animating the "RepresentationAnimationHelper" + # associated with the source. + if propertyname in ["Visibility", "Opacity"]: + proxy = _GetRepresentationAnimationHelper(proxy) + if not proxy or not proxy.GetProperty(propertyname): + raise AttributeError, "Failed to locate property %s" % propertyname + + scene = GetAnimationScene() + for cue in scene.Cues: + try: + if cue.AnimatedProxy.IsSame(proxy) and\ + cue.AnimatedPropertyName == propertyname: + if index == None or index.IsSame(cue.AnimatedElement): ##index == cue.AnimatedElement: + return cue + except AttributeError: + pass + + # matching animation track wasn't found, create a new one. + cue = KeyFrameAnimationCue() + cue.AnimatedProxy = proxy + cue.AnimatedPropertyName = propertyname + if index != None: + cue.AnimatedElement = index + scene.Cues.append(cue) + return cue + +def GetCameraTrack(view=None): + """Returns the camera animation track for the given view. If no view is + specified, active view will be used. If no exisiting camera animation track + is found, a new one will be created.""" + if not view: + view = GetActiveView() + if not view: + raise ValueError, "No view specified" + scene = GetAnimationScene() + for cue in scene.Cues: + if cue.AnimatedProxy.IsSame(view) and\ + cue.GetXMLName() == "CameraAnimationCue": + return cue + # no cue was found, create a new one. + cue = CameraAnimationCue() + cue.AnimatedProxy = view + scene.Cues.append(cue) + return cue + +def GetTimeTrack(): + """Returns the animation track used to control the time requested from all + readers/filters during playback. + This is the "TimeKeeper - Time" track shown in ParaView's 'Animation View'. + If none exists, a new one will be created.""" + scene = GetAnimationScene() + tk = scene.TimeKeeper + for cue in scene.Cues: + if cue.GetXMLName() == "TimeAnimationCue" and cue.AnimatedProxy.IsSame(tk)\ + and cue.AnimatedPropertyName == "Time": + return cue + # no cue was found, create a new one. + cue = TimeAnimationCue() + cue.AnimatedProxy = tk + cue.AnimatedPropertyName = "Time" + scene.Cues.append(cue) + return cue + +def LoadXML(xmlstring, ns=None): + """Given a server manager XML as a string, parse and process it. + If you loaded the simple module with from paraview.simple import *, + make sure to pass globals() as the second arguments: + LoadXML(xmlstring, globals()) + Otherwise, the new functions will not appear in the global namespace.""" + if not ns: + ns = globals() + servermanager.LoadXML(xmlstring) + _add_functions(ns) + +def LoadPlugin(filename, remote=True, ns=None): + """Loads a ParaView plugin and updates this module with new constructors + if any. The remote argument (default to True) is to specify whether + the plugin will be loaded on client (remote=False) or on server (remote=True). + If you loaded the simple module with from paraview.simple import *, + make sure to pass globals() as an argument: + LoadPlugin("myplugin", False, globals()), to load on client; + LoadPlugin("myplugin", True, globals()), to load on server; + LoadPlugin("myplugin", ns=globals()), to load on server. + Otherwise, the new functions will not appear in the global namespace.""" + + if not ns: + ns = globals() + servermanager.LoadPlugin(filename, remote) + _add_functions(ns) + +def LoadDistributedPlugin(pluginname, remote=True, ns=None): + """Loads a plugin that's distributed with the executable. This uses the + information known about plugins distributed with ParaView to locate the + shared library for the plugin to load. Raises a RuntimeError if the plugin + was not found.""" + if not servermanager.ActiveConnection: + raise RuntimeError, "Cannot load a plugin without a session." + plm = servermanager.vtkSMProxyManager.GetProxyManager().GetPluginManager() + if remote: + session = servermanager.ActiveConnection.Session + info = plm.GetRemoteInformation(session) + else: + info = plm.GetLocalInformation() + for cc in range(0, info.GetNumberOfPlugins()): + if info.GetPluginName(cc) == pluginname: + return LoadPlugin(info.GetPluginFileName(cc), remote, ns) + raise RuntimeError, "Plugin '%s' not found" % pluginname + +def GetLayouts(): + """Returns the layout proxies on the active session. + Layout proxies are used to place views in a grid.""" + return servermanager.ProxyManager().GetProxiesInGroup("layouts") + +def GetLayout(view=None): + """Return the layout containing the give view, if any. + If no view is specified, active view is used. + """ + if not view: + view = GetActiveView() + if not view: + raise RuntimeError, "No active view was found." + layouts = GetLayouts() + for layout in layouts.values(): + if layout.GetViewLocation(view) != -1: + return layout + return None + + +def SelectCells(query=None, proxy=None): + """Select cells satisfying the query. If query is None, then all cells are + selected. If proxy is None, then the active source is used.""" + if not proxy: + proxy = GetActiveSource() + if not proxy: + raise RuntimeError, "No active source was found." + + if not query: + # This ends up being true for all cells. + query = "id >= 0" + + # Note, selSource is not registered with the proxy manager. + selSource = servermanager.sources.SelectionQuerySource() + selSource.FieldType = "CELL" + selSource.QueryString = str(query) + proxy.SMProxy.SetSelectionInput(proxy.Port, selSource.SMProxy, 0) + return selSource + +def ClearSelection(proxy=None): + """Clears the selection on the active source.""" + if not proxy: + proxy = GetActiveSource() + if not proxy: + raise RuntimeError, "No active source was found." + proxy.SMProxy.SetSelectionInput(proxy.Port, None, 0) + +class ActiveObjects(object): + """This class manages the active objects (source and view). The active + objects are shared between Python and the user interface. This class + is for internal use. Use the Set/Get methods for setting and getting + active objects.""" + def __get_selection_model(self, name, session=None): + "Internal method." + if session and not servermanager.ActiveConnection.Session.IsSame(session): + raise RuntimeError, "Try to set an active object with invalid active connection." + pxm = servermanager.ProxyManager(session) + model = pxm.GetSelectionModel(name) + if not model: + model = servermanager.vtkSMProxySelectionModel() + pxm.RegisterSelectionModel(name, model) + return model + + def set_view(self, view): + "Sets the active view." + active_view_model = self.__get_selection_model("ActiveView") + if view: + active_view_model = self.__get_selection_model("ActiveView", view.GetSession()) + active_view_model.SetCurrentProxy(view.SMProxy, 0) + else: + active_view_model = self.__get_selection_model("ActiveView") + active_view_model.SetCurrentProxy(None, 0) + + def get_view(self): + "Returns the active view." + return servermanager._getPyProxy( + self.__get_selection_model("ActiveView").GetCurrentProxy()) + + def set_source(self, source): + "Sets the active source." + active_sources_model = self.__get_selection_model("ActiveSources") + if source: + # 3 == CLEAR_AND_SELECT + active_sources_model = self.__get_selection_model("ActiveSources", source.GetSession()) + active_sources_model.SetCurrentProxy(source.SMProxy, 3) + else: + active_sources_model = self.__get_selection_model("ActiveSources") + active_sources_model.SetCurrentProxy(None, 3) + + def __convert_proxy(self, px): + "Internal method." + if not px: + return None + if px.IsA("vtkSMSourceProxy"): + return servermanager._getPyProxy(px) + else: + return servermanager.OutputPort( + servermanager._getPyProxy(px.GetSourceProxy()), + px.GetPortIndex()) + + def get_source(self): + "Returns the active source." + return self.__convert_proxy( + self.__get_selection_model("ActiveSources").GetCurrentProxy()) + + def get_selected_sources(self): + "Returns the set of sources selected in the pipeline browser." + model = self.__get_selection_model("ActiveSources") + proxies = [] + for i in xrange(model.GetNumberOfSelectedProxies()): + proxies.append(self.__convert_proxy(model.GetSelectedProxy(i))) + return proxies + + view = property(get_view, set_view) + source = property(get_source, set_source) + +class _funcs_internals: + """Internal class.""" + first_render = True + view_counter = 0 + rep_counter = 0 + +def demo1(): + """Simple demo that create the following pipeline + sphere - shrink - \ + - append + cone - / + """ + # Create a sphere of radius = 2, theta res. = 32 + # This object becomes the active source. + ss = Sphere(Radius=2, ThetaResolution=32) + # Apply the shrink filter. The Input property is optional. If Input + # is not specified, the filter is applied to the active source. + shr = Shrink(Input=ss) + # Create a cone source. + cs = Cone() + # Append cone and shrink + app = AppendDatasets() + app.Input = [shr, cs] + # Show the output of the append filter. The argument is optional + # as the app filter is now the active object. + Show(app) + # Render the default view. + Render() + +def demo2(fname="/Users/berk/Work/ParaView/ParaViewData/Data/disk_out_ref.ex2"): + """This demo shows the use of readers, data information and display + properties.""" + + # Create the exodus reader and specify a file name + reader = ExodusIIReader(FileName=fname) + # Get the list of point arrays. + avail = reader.PointVariables.Available + print avail + # Select all arrays + reader.PointVariables = avail + + # Turn on the visibility of the reader + Show(reader) + # Set representation to wireframe + SetDisplayProperties(Representation = "Wireframe") + # Black background is not pretty + SetViewProperties(Background = [0.4, 0.4, 0.6]) + Render() + # Change the elevation of the camera. See VTK documentation of vtkCamera + # for camera parameters. + # NOTE: THIS WILL BE SIMPLER + GetActiveCamera().Elevation(45) + Render() + # Now that the reader executed, let's get some information about it's + # output. + pdi = reader[0].PointData + # This prints a list of all read point data arrays as well as their + # value ranges. + print 'Number of point arrays:', len(pdi) + for i in range(len(pdi)): + ai = pdi[i] + print "----------------" + print "Array:", i, " ", ai.Name, ":" + numComps = ai.GetNumberOfComponents() + print "Number of components:", numComps + for j in range(numComps): + print "Range:", ai.GetRange(j) + # White is boring. Let's color the geometry using a variable. + # First create a lookup table. This object controls how scalar + # values are mapped to colors. See VTK documentation for + # details. + # Map min (0.00678) to blue, max (0.0288) to red + SetDisplayProperties(LookupTable = MakeBlueToRedLT(0.00678, 0.0288)) + # Color by point array called Pres + SetDisplayProperties(ColorAttributeType = "POINT_DATA") + SetDisplayProperties(ColorArrayName = "Pres") + Render() + +def PrintTrace(): + print paravisSM.myParavis.GetTrace() + +def SaveTrace(fileName): + paravisSM.myParavis.SaveTrace(fileName) + + +if not servermanager.ActiveConnection: + Connect() +else: + _add_functions(globals()) + +def ImportFile(theFileName): + paravisSM.ImportFile(theFileName) + +active_objects = ActiveObjects() +active_objects.view = GetRenderView()