From: bruneton Date: Mon, 21 Oct 2013 13:16:37 +0000 (+0000) Subject: Minimal CORBA mode: adapted PARAVIS' Python API to work in this mode. X-Git-Tag: V7_3_0a1~24 X-Git-Url: http://git.salome-platform.org/gitweb/?a=commitdiff_plain;h=e2c075bb656e4e5b0d8e6fcb7e06b5c25f903dee;p=modules%2Fparavis.git Minimal CORBA mode: adapted PARAVIS' Python API to work in this mode. --- diff --git a/src/PV_SWIG/CMakeLists.txt b/src/PV_SWIG/CMakeLists.txt index 3ab6b0f9..18e33dc4 100644 --- a/src/PV_SWIG/CMakeLists.txt +++ b/src/PV_SWIG/CMakeLists.txt @@ -18,15 +18,20 @@ # IF(SALOME_PARAVIS_MINIMAL_CORBA) - # Use another set of Python files - SET(_PYFILES_TO_INSTALL) - MESSAGE(WARNING "New Python scripts not impl !!!") -ELSE() + # Use another set of Python files redirecting the API directly + # to the original ParaView modules. SET(_PYFILES_TO_INSTALL paravis.py - paravisSM.py pvsimple.py presentations.py + paravisSM.py + ) +ELSE() + SET(_PYFILES_TO_INSTALL + VTKWrapping/paravis.py + VTKWrapping/paravisSM.py + VTKWrapping/pvsimple.py + VTKWrapping/presentations.py ) ENDIF() diff --git a/src/PV_SWIG/VTKWrapping/paravis.py b/src/PV_SWIG/VTKWrapping/paravis.py new file mode 100644 index 00000000..d5c228ed --- /dev/null +++ b/src/PV_SWIG/VTKWrapping/paravis.py @@ -0,0 +1,97 @@ +# Copyright (C) 2010-2013 CEA/DEN, EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# +# File : paravis.py +# Module : PARAVIS +# + +import os, new + +import PARAVIS +import SALOME +import SALOME_Session_idl +import SALOMEDS +import SALOME_ModuleCatalog +from omniORB import CORBA +from time import sleep +from salome import * + +myORB = None +myNamingService = None +myLifeCycleCORBA = None +myNamingService = None +myLocalStudyManager = None +myLocalStudy = None +myLocalParavis = None +myDelay = None +mySession = None + +## Initialization of paravis server +def Initialize(theORB, theNamingService, theLifeCycleCORBA, theStudyManager, theStudy, theDelay) : + global myORB, myNamingService, myLifeCycleCORBA, myLocalStudyManager, myLocalStudy + global mySession, myDelay + myDelay = theDelay + myORB = theORB + myNamingService = theNamingService + myLifeCycleCORBA = theLifeCycleCORBA + myLocalStudyManager = theStudyManager + while mySession == None: + mySession = myNamingService.Resolve("/Kernel/Session") + mySession = mySession._narrow(SALOME.Session) + mySession.GetInterface() + myDelay = theDelay + sleep(myDelay) + myLocalParavis = myLifeCycleCORBA.FindOrLoadComponent("FactoryServer", "PARAVIS") + myLocalStudy = theStudy + myLocalParavis.SetCurrentStudy(myLocalStudy) + myLocalParavis.ActivateModule() + return myLocalParavis + + +def ImportFile(theFileName): + "Import a file of any format supported by ParaView" + myParavis.ImportFile(theFileName) + + +def createFunction(theName): + "Create function - constructor of Paravis object" + def MyFunction(): + return myParavis.CreateClass(theName) + return MyFunction + + +def createConstructors(): + "Create constructor functions according to list of extracted classes" + g = globals() + aClassNames = myParavis.GetClassesList(); + for aName in aClassNames: + g[aName] = createFunction(aName) + +## Initialize of a PARAVIS interface +myParavis = Initialize(orb, naming_service,lcc,myStudyManager,myStudy, 2) + +## Initialize constructor functions +createConstructors() + +## Initialize Paravis static objects +vtkSMObject = vtkSMObject() +vtkProcessModule = vtkProcessModule() +vtkPVPythonModule = vtkPVPythonModule() +vtkSMProxyManager = vtkSMProxyManager() + + diff --git a/src/PV_SWIG/VTKWrapping/paravisSM.py b/src/PV_SWIG/VTKWrapping/paravisSM.py new file mode 100644 index 00000000..8237dfc1 --- /dev/null +++ b/src/PV_SWIG/VTKWrapping/paravisSM.py @@ -0,0 +1,3014 @@ +# Copyright (C) 2010-2013 CEA/DEN, EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +r"""servermanager is a module for using paraview server manager in Python. +One can always use the server manager API directly. However, this module +provides an interface easier to use from Python by wrapping several VTK +classes around Python classes. + +Note that, upon load, this module will create several sub-modules: sources, +filters and rendering. These modules can be used to instantiate specific +proxy types. For a list, try "dir(servermanager.sources)" + +A simple example: + from paraview.servermanager import * + + # Creates a new built-in session and makes it the active session. + Connect() + + # Creates a new render view on the active session. + renModule = CreateRenderView() + + # Create a new sphere proxy on the active session and register it + # in the sources group. + sphere = sources.SphereSource(registrationGroup="sources", ThetaResolution=16, PhiResolution=32) + + # Create a representation for the sphere proxy and adds it to the render + # module. + display = CreateRepresentation(sphere, renModule) + + renModule.StillRender() +""" + + + +import re, os, new, sys +from paravis import * + +# VTN: Avoid paraview.* instructions in this file. +# It leads to problems during execution. + +def _wrap_property(proxy, smproperty): + """ Internal function. + Given a server manager property and its domains, returns the + appropriate python object. + """ + property = None + if smproperty.IsA("vtkSMStringVectorProperty"): + al = smproperty.GetDomain("array_list") + if al and al.IsA("vtkSMArraySelectionDomain") and \ + smproperty.GetRepeatable(): + property = ArrayListProperty(proxy, smproperty) + elif al and al.IsA("vtkSMArrayListDomain") and smproperty.GetNumberOfElements() == 5: + property = ArraySelectionProperty(proxy, smproperty) + else: + iter = smproperty.NewDomainIterator() + isFileName = False + while not iter.IsAtEnd(): + # Refer to BUG #9710 to see why optional domains need to be + # ignored. + if iter.GetDomain().IsA("vtkSMFileListDomain") and \ + iter.GetDomain().GetIsOptional() == 0 : + isFileName = True + break + iter.Next() + iter.UnRegister(None) + if isFileName: + property = FileNameProperty(proxy, smproperty) + elif _make_name_valid(smproperty.GetXMLLabel()) == 'ColorArrayName': + property = ColorArrayProperty(proxy, smproperty) + else: + property = VectorProperty(proxy, smproperty) + elif smproperty.IsA("vtkSMVectorProperty"): + if smproperty.IsA("vtkSMIntVectorProperty") and \ + smproperty.GetDomain("enum"): + property = EnumerationProperty(proxy, smproperty) + else: + property = VectorProperty(proxy, smproperty) + elif smproperty.IsA("vtkSMInputProperty"): + property = InputProperty(proxy, smproperty) + elif smproperty.IsA("vtkSMProxyProperty"): + property = ProxyProperty(proxy, smproperty) + else: + property = Property(proxy, smproperty) + return property + +class Proxy(object): + """Proxy for a server side object. A proxy manages the lifetime of + one or more server manager objects. It also provides an interface + to set and get the properties of the server side objects. These + properties are presented as Python properties. For example, + you can set a property Foo using the following: + proxy.Foo = (1,2) + or + proxy.Foo.SetData((1,2)) + or + proxy.Foo[0:2] = (1,2) + For more information, see the documentation of the property which + you can obtain with + help(proxy.Foo). + + This class also provides an iterator which can be used to iterate + over all properties. + eg: + proxy = Proxy(proxy=smproxy) + for property in proxy: + print property + + For advanced users: + This is a python class that wraps a vtkSMProxy.. Makes it easier to + set/get properties. + Instead of: + proxy.GetProperty("Foo").SetElement(0, 1) + proxy.GetProperty("Foo").SetElement(0, 2) + you can do: + proxy.Foo = (1,2) + or + proxy.Foo.SetData((1,2)) + or + proxy.Foo[0:2] = (1,2) + Instead of: + proxy.GetProperty("Foo").GetElement(0) + you can do: + proxy.Foo.GetData()[0] + or + proxy.Foo[0] + For proxy properties, you can use append: + proxy.GetProperty("Bar").AddProxy(foo) + you can do: + proxy.Bar.append(foo) + Properties support most of the list API. See VectorProperty and + ProxyProperty documentation for details. + + Please note that some of the methods accessible through the Proxy + class are not listed by help() because the Proxy objects forward + unresolved attributes to the underlying object. To get the full list, + see also dir(proxy.SMProxy). See also the doxygen based documentation + of the vtkSMProxy C++ class. + """ + + def __init__(self, **args): + """ Default constructor. It can be used to initialize properties + by passing keyword arguments where the key is the name of the + property. In addition registrationGroup and registrationName (optional) + can be specified (as keyword arguments) to automatically register + the proxy with the proxy manager. """ + self.add_attribute('Observed', None) + self.add_attribute('ObserverTag', -1) + self.add_attribute('_Proxy__Properties', {}) + self.add_attribute('_Proxy__LastAttrName', None) + self.add_attribute('SMProxy', None) + self.add_attribute('Port', 0) + + if 'port' in args: + self.Port = args['port'] + del args['port'] + + update = True + if 'no_update' in args: + if args['no_update']: + update = False + del args['no_update'] + + if 'proxy' in args: + self.InitializeFromProxy(args['proxy']) + del args['proxy'] + else: + self.Initialize(None, update) + if 'registrationGroup' in args: + registrationGroup = args['registrationGroup'] + del args['registrationGroup'] + registrationName = self.SMProxy.GetGlobalIDAsString() + if 'registrationName' in args: + registrationName = args['registrationName'] + del args['registrationName'] + pxm = ProxyManager() + pxm.RegisterProxy(registrationGroup, registrationName, self.SMProxy) + if update: + self.UpdateVTKObjects() + for key in args.keys(): + setattr(self, key, args[key]) + # Visit all properties so that they are created + for prop in self: + pass + + def __setattr__(self, name, value): + try: + setter = getattr(self.__class__, name) + setter = setter.__set__ + except AttributeError: + if not hasattr(self, name): + raise AttributeError("Attribute %s does not exist. " % name + + " This class does not allow addition of new attributes to avoid " + + "mistakes due to typos. Use add_attribute() if you really want " + + "to add this attribute.") + self.__dict__[name] = value + else: + setter(self, value) + + def add_attribute(self, name, value): + self.__dict__[name] = value + + def __del__(self): + """Destructor. Cleans up all observers as well as remove + the proxy from the _pyproxies dictionary""" + # Make sure that we remove observers we added + if self.Observed: + observed = self.Observed + tag = self.ObserverTag + self.Observed = None + self.ObserverTag = -1 + observed.RemoveObserver(tag) + if _pyproxies and self.SMProxy and (self.SMProxy, self.Port) in _pyproxies: + del _pyproxies[(self.SMProxy, self.Port)] + + def InitializeFromProxy(self, aProxy, update=True): + """Constructor. Assigns proxy to self.SMProxy, updates the server + object as well as register the proxy in _pyproxies dictionary.""" + import weakref + self.SMProxy = aProxy + if update: + self.SMProxy.UpdateVTKObjects() + _pyproxies[(self.SMProxy, self.Port)] = weakref.ref(self) + + def Initialize(self): + "Overridden by the subclass created automatically" + pass + + def __eq__(self, other): + "Returns true if the underlying SMProxies are the same." + if isinstance(other, Proxy): + try: + if self.Port != other.Port: + return False + except: + pass + ## VSV using IsSame instead == + return self.SMProxy.IsSame(other.SMProxy) + return self.SMProxy.IsSame(other) + + def __ne__(self, other): + "Returns false if the underlying SMProxies are the same." + return not self.__eq__(other) + + def __iter__(self): + "Creates an iterator for the properties." + return PropertyIterator(self) + + def SetPropertyWithName(self, pname, arg): + """Generic method for setting the value of a property.""" + prop = self.GetProperty(pname) + if prop is None: + raise RuntimeError, "Property %s does not exist. Please check the property name for typos." % pname + prop.SetData(arg) + + def GetPropertyValue(self, name): + """Returns a scalar for properties with 1 elements, the property + itself for vectors.""" + p = self.GetProperty(name) + if isinstance(p, VectorProperty): + if p.GetNumberOfElements() == 1 and not p.GetRepeatable(): + if p.SMProperty.IsA("vtkSMStringVectorProperty") or not p.GetArgumentIsArray(): + return p[0] + elif isinstance(p, InputProperty): + if not p.GetMultipleInput(): + if len(p) > 0: + return p[0] + else: + return None + elif isinstance(p, ProxyProperty): + if not p.GetRepeatable(): + if len(p) > 0: + return p[0] + else: + return None + return p + + def GetProperty(self, name): + """Given a property name, returns the property object.""" + if name in self.__Properties and self.__Properties[name](): + return self.__Properties[name]() + smproperty = self.SMProxy.GetProperty(name) + # Maybe they are looking by the label. Try to match that. + if not smproperty: + iter = PropertyIterator(self) + for prop in iter: + if name == _make_name_valid(iter.PropertyLabel): + smproperty = prop.SMProperty + break + if smproperty: + property = _wrap_property(self, smproperty) + if property is not None: + import weakref + self.__Properties[name] = weakref.ref(property) + return property + return None + + def ListProperties(self): + """Returns a list of all property names on this proxy.""" + property_list = [] + iter = self.__iter__() + for property in iter: + name = _make_name_valid(iter.PropertyLabel) + if name: + property_list.append(name) + return property_list + + def __ConvertArgumentsAndCall(self, *args): + """ Internal function. + Used to call a function on SMProxy. Converts input and + output values as appropriate. + """ + newArgs = [] + for arg in args: + if issubclass(type(arg), Proxy) or isinstance(arg, Proxy): + newArgs.append(arg.SMProxy) + else: + newArgs.append(arg) + func = getattr(self.SMProxy, self.__LastAttrName) + retVal = func(*newArgs) + if type(retVal) is type(self.SMProxy) and retVal.IsA("vtkSMProxy"): + return _getPyProxy(retVal) + elif type(retVal) is type(self.SMProxy) and retVal.IsA("vtkSMProperty"): + return _wrap_property(self, retVal) + else: + return retVal + + def __GetActiveCamera(self): + """ This method handles GetActiveCamera specially. It adds + an observer to the camera such that everytime it is modified + the render view updated""" + import weakref + c = self.SMProxy.GetActiveCamera() + # VSV: Observers are not supported +## if not c.HasObserver("ModifiedEvent"): +## self.ObserverTag =c.AddObserver("ModifiedEvent", _makeUpdateCameraMethod(weakref.ref(self))) +## self.Observed = c + return c + + def __getattr__(self, name): + """With the exception of a few overloaded methods, + returns the SMProxy method""" + if not self.SMProxy: + raise AttributeError("class %s has no attribute %s" % ("None", name)) + return None + # Handle GetActiveCamera specially. + if name == "GetActiveCamera" and \ + hasattr(self.SMProxy, "GetActiveCamera"): + return self.__GetActiveCamera + if name == "SaveDefinition" and hasattr(self.SMProxy, "SaveDefinition"): + return self.__SaveDefinition + # If not a property, see if SMProxy has the method + try: + proxyAttr = getattr(self.SMProxy, name) + self.__LastAttrName = name + return self.__ConvertArgumentsAndCall + except: + pass + return getattr(self.SMProxy, name) + +class SourceProxy(Proxy): + """Proxy for a source object. This class adds a few methods to Proxy + that are specific to sources. It also provides access to the output + ports. Output ports can be accessed by name or index: + > op = source[0] + or + > op = source['some name']. + """ + def UpdatePipeline(self, time=None): + """This method updates the server-side VTK pipeline and the associated + data information. Make sure to update a source to validate the output + meta-data.""" + if time != None: + self.SMProxy.UpdatePipeline(time) + else: + self.SMProxy.UpdatePipeline() + # This is here to cause a receive + # on the client side so that progress works properly. + if ActiveConnection and ActiveConnection.IsRemote(): + self.SMProxy.GetDataInformation() + + def FileNameChanged(self): + "Called when the filename of a source proxy is changed." + self.UpdatePipelineInformation() + + def UpdatePipelineInformation(self): + """This method updates the meta-data of the server-side VTK pipeline and + the associated information properties""" + self.SMProxy.UpdatePipelineInformation() + + def GetDataInformation(self, idx=None): + """This method returns a DataInformation wrapper around a + vtkPVDataInformation""" + if idx == None: + idx = self.Port + if self.SMProxy: + return DataInformation( \ + self.SMProxy.GetDataInformation(idx), \ + self.SMProxy, idx) + + def __getitem__(self, idx): + """Given a slice, int or string, returns the corresponding + output port""" + if isinstance(idx, slice): + indices = idx.indices(self.SMProxy.GetNumberOfOutputPorts()) + retVal = [] + for i in range(*indices): + retVal.append(OutputPort(self, i)) + return retVal + elif isinstance(idx, int): + if idx >= self.SMProxy.GetNumberOfOutputPorts() or idx < 0: + raise IndexError + return OutputPort(self, idx) + else: + return OutputPort(self, self.SMProxy.GetOutputPortIndex(idx)) + + def GetPointDataInformation(self): + """Returns the associated point data information.""" + self.UpdatePipeline() + return FieldDataInformation(self.SMProxy, self.Port, "PointData") + + def GetCellDataInformation(self): + """Returns the associated cell data information.""" + self.UpdatePipeline() + return FieldDataInformation(self.SMProxy, self.Port, "CellData") + + def GetFieldDataInformation(self): + """Returns the associated cell data information.""" + self.UpdatePipeline() + return FieldDataInformation(self.SMProxy, self.Port, "FieldData") + + PointData = property(GetPointDataInformation, None, None, "Returns point data information") + CellData = property(GetCellDataInformation, None, None, "Returns cell data information") + FieldData = property(GetFieldDataInformation, None, None, "Returns field data information") + + +class ExodusIIReaderProxy(SourceProxy): + """Special class to define convenience functions for array + selection.""" + + def FileNameChanged(self): + "Called when the filename changes. Selects all variables." + SourceProxy.FileNameChanged(self) + self.SelectAllVariables() + + def SelectAllVariables(self): + "Select all available variables for reading." + for prop in ('PointVariables', 'EdgeVariables', 'FaceVariables', + 'ElementVariables', 'GlobalVariables'): + f = getattr(self, prop) + f.SelectAll() + + def DeselectAllVariables(self): + "Deselects all variables." + for prop in ('PointVariables', 'EdgeVariables', 'FaceVariables', + 'ElementVariables', 'GlobalVariables'): + f = getattr(self, prop) + f.DeselectAll() + +class ViewLayoutProxy(Proxy): + """Special class to define convenience methods for View Layout""" + + def SplitViewHorizontal(self, view, fraction=0.5): + """Split the cell containing the specified view horizontally. + If no fraction is specified, the frame is split into equal parts. + On success returns a positve number that identifying the new cell + location that can be used to assign view to, or split further. + Return -1 on failure.""" + location = self.GetViewLocation(view) + if location == -1: + raise RuntimeError, "View is not present in this layout." + if fraction < 0.0 or fraction > 1.0: + raise RuntimeError, "'fraction' must be in the range [0.0, 1.0]" + return self.SMProxy.SplitHorizontal(location, fraction) + + def SplitViewVertical(self, view=None, fraction=0.5): + """Split the cell containing the specified view horizontally. + If no view is specified, active view is used. + If no fraction is specified, the frame is split into equal parts. + On success returns a positve number that identifying the new cell + location that can be used to assign view to, or split further. + Return -1 on failure.""" + location = self.GetViewLocation(view) + if location == -1: + raise RuntimeError, "View is not present in this layout." + if fraction < 0.0 or fraction > 1.0: + raise RuntimeError, "'fraction' must be in the range [0.0, 1.0]" + return self.SMProxy.SplitVertical(location, fraction) + + def AssignView(self, location, view): + """Assign a view at a particular location. Note that the view's position may + be changed by subsequent Split() calls. Returns true on success.""" + viewproxy = None + if isinstance(view, Proxy): + view = view.SMProxy + return self.SMProxy.AssignView(location, view) + + def GetViewLocation(self, view): + if isinstance(view, Proxy): + view = view.SMProxy + return self.SMProxy.GetViewLocation(view) + +class Property(object): + """Generic property object that provides access to one of the properties of + a server object. This class does not allow setting/getting any values but + provides an interface to update a property using __call__. This can be used + for command properties that correspond to function calls without arguments. + For example, + > proxy.Foo() + would push a Foo property which may cause the proxy to call a Foo method + on the actual VTK object. + + For advanced users: + Python wrapper around a vtkSMProperty with a simple interface. + In addition to all method provided by vtkSMProperty (obtained by + forwarding unknown attributes requests to the underlying SMProxy), + Property and sub-class provide a list API. + + Please note that some of the methods accessible through the Property + class are not listed by help() because the Property objects forward + unresolved attributes to the underlying object. To get the full list, + see also dir(proxy.SMProperty). See also the doxygen based documentation + of the vtkSMProperty C++ class. + """ + def __init__(self, proxy, smproperty): + """Default constructor. Stores a reference to the proxy.""" + import weakref + self.SMProperty = smproperty + self.Proxy = proxy + + def __repr__(self): + """Returns a string representation containing property name + and value""" + if not type(self) is Property: + if self.GetData() is not None: + repr = self.GetData().__repr__() + else: + repr = "None" + else: + repr = "Property name= " + name = self.Proxy.GetPropertyName(self.SMProperty) + if name: + repr += name + else: + repr += "Unknown" + + return repr + + def __call__(self): + """Forces a property update using InvokeCommand.""" + if type(self) is Property: + self.Proxy.SMProxy.InvokeCommand(self._FindPropertyName()) + else: + raise RuntimeError, "Cannot invoke this property" + + def _FindPropertyName(self): + "Returns the name of this property." + return self.Proxy.GetPropertyName(self.SMProperty) + + def _UpdateProperty(self): + "Pushes the value of this property to the server." + # For now, we are updating all properties. This is due to an + # issue with the representations. Their VTK objects are not + # created until Input is set therefore, updating a property + # has no effect. Updating all properties everytime one is + # updated has the effect of pushing values set before Input + # when Input is updated. + # self.Proxy.SMProxy.UpdateProperty(self._FindPropertyName()) + self.Proxy.SMProxy.UpdateVTKObjects() + + def __getattr__(self, name): + "Unknown attribute requests get forwarded to SMProperty." + return getattr(self.SMProperty, name) + + Name = property(_FindPropertyName, None, None, + "Returns the name for the property") + +class GenericIterator(object): + """Iterator for container type objects""" + + def __init__(self, obj): + self.Object = obj + self.index = 0 + + def __iter__(self): + return self + + def next(self): + if self.index >= len(self.Object): + raise StopIteration + + idx = self.index + self.index += 1 + return self.Object[idx] + +class VectorProperty(Property): + """A VectorProperty provides access to one or more values. You can use + a slice to get one or more property values: + > val = property[2] + or + > vals = property[0:5:2] + You can use a slice to set one or more property values: + > property[2] = val + or + > property[1:3] = (1,2) + """ + def ConvertValue(self, value): + return value + + def __len__(self): + """Returns the number of elements.""" + return self.SMProperty.GetNumberOfElements() + + def __iter__(self): + """Implementation of the sequence API""" + return GenericIterator(self) + + def __setitem__(self, idx, value): + """Given a list or tuple of values, sets a slice of values [min, max)""" + if isinstance(idx, slice): + indices = idx.indices(len(self)) + for i, j in zip(range(*indices), value): + self.SMProperty.SetElement(i, self.ConvertValue(j)) + self._UpdateProperty() + elif idx >= len(self) or idx < 0: + raise IndexError + else: + self.SMProperty.SetElement(idx, self.ConvertValue(value)) + self._UpdateProperty() + + def GetElement(self, index): + return self.SMProperty.GetElement(index) + + def __getitem__(self, idx): + """Returns the range [min, max) of elements. Raises an IndexError + exception if an argument is out of bounds.""" + ls = len(self) + if isinstance(idx, slice): + indices = idx.indices(ls) + retVal = [] + for i in range(*indices): + retVal.append(self.GetElement(i)) + return retVal + elif idx >= ls: + raise IndexError + elif idx < 0: + idx = ls + idx + if idx < 0: + raise IndexError + + return self.GetElement(idx) + + def GetData(self): + "Returns all elements as either a list or a single value." + property = self.SMProperty + if property.GetRepeatable() or \ + property.GetNumberOfElements() > 1: + return self[0:len(self)] + elif property.GetNumberOfElements() == 1: + return self.GetElement(0) + + def SetData(self, values): + """Allows setting of all values at once. Requires a single value or + a iterable object.""" + if not hasattr(values, "__iter__"): + values = (values,) + if not self.GetRepeatable() and len(values) != self.GetNumberOfElements(): + raise RuntimeError("This property requires %d values." % self.GetNumberOfElements()) + if self.GetRepeatable(): + # Clean up first + self.SMProperty.SetNumberOfElements(0) + idx = 0 + for val in values: + self.SMProperty.SetElement(idx, self.ConvertValue(val)) + idx += 1 + self._UpdateProperty() + + def Clear(self): + "Removes all elements." + self.SMProperty().SetNumberOfElements(0) + self._UpdateProperty() + +class ColorArrayProperty(VectorProperty): + """This subclass of VectorProperty handles setting of the array to + color by. It handles attribute type as well as well array name.""" + + def GetAvailable(self): + """Returns the list of available arrays as (attribute type, array name + tuples.""" + arrays = [] + for a in self.Proxy.Input.PointData: + arrays.append(('POINT_DATA', a.GetName())) + for a in self.Proxy.Input.CellData: + arrays.append(('CELL_DATA', a.GetName())) + return arrays + + def SetData(self, value): + """Overwritten to enable setting attribute type (the ColorAttributeType + property and the array name. The argument should be the array name + (in which case the first appropriate attribute type is picked) or + a tuple of attribute type and array name.""" + if isinstance(value, tuple) and len(value) == 2: + att = value[0] + arr = value[1] + elif isinstance(value, str): + att = None + arr = value + else: + raise ValueError("Expected a tuple of 2 values or a string.") + + if not arr: + self.SMProperty.SetElement(0, '') + self._UpdateProperty() + return + + found = False + for a in self.Available: + if a[1] == arr and (not att or att == a[0]): + att = a[0] + found = True + break + + if not found: + pvoptions = vtkProcessModule.GetProcessModule().GetOptions() + # if this process is from a parallel batch run in symmetric mpi mode + # then we may not have any points or cells on some processes in which + # case we'll probably be missing the point and cell data too. the + # check below makes sure that we avoid this situation. + if pvoptions.GetProcessType() != 0x40 or pvoptions.GetSymmetricMPIMode() == False \ + or len(self.Available) != 0: + raise ValueError("Could not locate array %s in the input." % arr) + + catt = self.Proxy.GetProperty("ColorAttributeType") + if att != None: + catt.SetData(att) + self.SMProperty.SetElement(0, arr) + self._UpdateProperty() + + Available = property(GetAvailable, None, None, \ + "This read-only property returns the list of arrays that can be colored by.") + + +class EnumerationProperty(VectorProperty): + """Subclass of VectorProperty that is applicable for enumeration type + properties.""" + + def GetElement(self, index): + """Returns the text for the given element if available. Returns + the numerical values otherwise.""" + val = self.SMProperty.GetElement(index) + domain = self.SMProperty.GetDomain("enum") + for i in range(domain.GetNumberOfEntries()): + if domain.GetEntryValue(i) == val: + return domain.GetEntryText(i) + return val + + def ConvertValue(self, value): + """Converts value to type suitable for vtSMProperty::SetElement()""" + if type(value) == str: + domain = self.SMProperty.GetDomain("enum") + if domain.HasEntryText(value): + return domain.GetEntryValueForText(value) + else: + raise ValueError("%s is not a valid value." % value) + return VectorProperty.ConvertValue(self, value) + + def GetAvailable(self): + "Returns the list of available values for the property." + retVal = [] + domain = self.SMProperty.GetDomain("enum") + for i in range(domain.GetNumberOfEntries()): + retVal.append(domain.GetEntryText(i)) + return retVal + + Available = property(GetAvailable, None, None, \ + "This read-only property contains the list of values that can be applied to this property.") + + +class FileNameProperty(VectorProperty): + """Property to set/get one or more file names. + This property updates the pipeline information everytime its value changes. + This is used to keep the array lists up to date.""" + + def _UpdateProperty(self): + "Pushes the value of this property to the server." + VectorProperty._UpdateProperty(self) + self.Proxy.FileNameChanged() + +class ArraySelectionProperty(VectorProperty): + "Property to select an array to be processed by a filter." + + def GetAssociation(self): + val = self.GetElement(3) + if val == "": + return None + for key, value in ASSOCIATIONS.iteritems(): + if value == int(val): + return key + + return None + + def GetArrayName(self): + return self.GetElement(4) + + def __len__(self): + """Returns the number of elements.""" + return 2 + + def __setitem__(self, idx, value): + raise RuntimeError, "This property cannot be accessed using __setitem__" + + def __getitem__(self, idx): + """Returns attribute type for index 0, array name for index 1""" + if isinstance(idx, slice): + indices = idx.indices(len(self)) + retVal = [] + for i in range(*indices): + if i >= 2 or i < 0: + raise IndexError + if i == 0: + retVal.append(self.GetAssociation()) + else: + retVal.append(self.GetArrayName()) + return retVal + elif idx >= 2 or idx < 0: + raise IndexError + + if i == 0: + return self.GetAssociation() + else: + return self.GetArrayName() + + def SetData(self, values): + """Allows setting of all values at once. Requires a single value, + a tuple or list.""" + if not isinstance(values, tuple) and \ + not isinstance(values, list): + values = (values,) + if len(values) == 1: + self.SMProperty.SetElement(4, values[0]) + elif len(values) == 2: + if isinstance(values[0], str): + val = str(ASSOCIATIONS[values[0]]) + else: + # In case user didn't specify valid association, + # just pick POINTS. + val = str(ASSOCIATIONS['POINTS']) + self.SMProperty.SetElement(3, str(val)) + self.SMProperty.SetElement(4, values[1]) + else: + raise RuntimeError, "Expected 1 or 2 values." + self._UpdateProperty() + + def UpdateDefault(self): + "Helper method to set default values." + if self.SMProperty.GetNumberOfElements() != 5: + return + if self.GetElement(4) != '' or \ + self.GetElement(3) != '': + return + + for i in range(0,3): + if self.GetElement(i) == '': + self.SMProperty.SetElement(i, '0') + al = self.SMProperty.GetDomain("array_list") + al.Update(self.SMProperty) + al.SetDefaultValues(self.SMProperty) + +class ArrayListProperty(VectorProperty): + """This property provides a simpler interface for selecting arrays. + Simply assign a list of arrays that should be loaded by the reader. + Use the Available property to get a list of available arrays.""" + + def __init__(self, proxy, smproperty): + VectorProperty.__init__(self, proxy, smproperty) + self.__arrays = [] + + def GetAvailable(self): + "Returns the list of available arrays" + dm = self.GetDomain("array_list") + retVal = [] + for i in range(dm.GetNumberOfStrings()): + retVal.append(dm.GetString(i)) + return retVal + + Available = property(GetAvailable, None, None, \ + "This read-only property contains the list of items that can be read by a reader.") + + def SelectAll(self): + "Selects all arrays." + self.SetData(self.Available) + + def DeselectAll(self): + "Deselects all arrays." + self.SetData([]) + + def __iter__(self): + """Implementation of the sequence API""" + return GenericIterator(self) + + def __len__(self): + """Returns the number of elements.""" + return len(self.GetData()) + + def __setitem__(self, idx, value): + """Given a list or tuple of values, sets a slice of values [min, max)""" + self.GetData() + if isinstance(idx, slice): + indices = idx.indices(len(self)) + for i, j in zip(range(*indices), value): + self.__arrays[i] = j + self.SetData(self.__arrays) + elif idx >= len(self) or idx < 0: + raise IndexError + else: + self.__arrays[idx] = self.ConvertValue(value) + self.SetData(self.__arrays) + + def __getitem__(self, idx): + """Returns the range [min, max) of elements. Raises an IndexError + exception if an argument is out of bounds.""" + self.GetData() + if isinstance(idx, slice): + indices = idx.indices(len(self)) + retVal = [] + for i in range(*indices): + retVal.append(self.__arrays[i]) + return retVal + elif idx >= len(self) or idx < 0: + raise IndexError + return self.__arrays[idx] + + def SetData(self, values): + """Allows setting of all values at once. Requires a single value, + a tuple or list.""" + # Clean up first + iup = self.SMProperty.GetImmediateUpdate() + self.SMProperty.SetImmediateUpdate(False) + # Clean up first + self.SMProperty.SetNumberOfElements(0) + if not isinstance(values, tuple) and \ + not isinstance(values, list): + values = (values,) + fullvalues = [] + + # WARNING: + # The order of the two loops below are delibrately set in this way + # so that values passed in will take precedence. + # This is needed for backward compatibility of the + # property ElementBlocks for vtkExodusIIReader. + # If you attemp to change this, please verify that + # python state files for opening old .ex2 file (<=3.14) still works. + for array in self.Available: + if not values.__contains__(array): + fullvalues.append(array) + fullvalues.append('0') + + for i in range(len(values)): + val = self.ConvertValue(values[i]) + fullvalues.append(val) + fullvalues.append('1') + + + i = 0 + for value in fullvalues: + self.SMProperty.SetElement(i, value) + i += 1 + + self._UpdateProperty() + self.SMProperty.SetImmediateUpdate(iup) + + def GetData(self): + "Returns all elements as a list." + property = self.SMProperty + nElems = property.GetNumberOfElements() + if nElems%2 != 0: + raise ValueError, "The SMProperty with XML label '%s' has a size that is not a multiple of 2." % property.GetXMLLabel() + self.__arrays = [] + for i in range(0, nElems, 2): + if self.GetElement(i+1) != '0': + self.__arrays.append(self.GetElement(i)) + return list(self.__arrays) + +class ProxyProperty(Property): + """A ProxyProperty provides access to one or more proxies. You can use + a slice to get one or more property values: + > proxy = property[2] + or + > proxies = property[0:5:2] + You can use a slice to set one or more property values: + > property[2] = proxy + or + > property[1:3] = (proxy1, proxy2) + You can also append and delete: + > property.append(proxy) + and + > del property[1:2] + + You can also remove all elements with Clear(). + + Note that some properties expect only 1 proxy and will complain if + you set the number of values to be something else. + """ + def __init__(self, proxy, smproperty): + """Default constructor. Stores a reference to the proxy. Also looks + at domains to find valid values.""" + Property.__init__(self, proxy, smproperty) + # Check to see if there is a proxy list domain and, if so, + # initialize ourself. (Should this go in ProxyProperty?) + listdomain = self.GetDomain('proxy_list') + if listdomain: + if listdomain.GetClassName() != 'vtkSMProxyListDomain': + raise ValueError, "Found a 'proxy_list' domain on an InputProperty that is not a ProxyListDomain." + pm = ProxyManager() + group = "pq_helper_proxies." + proxy.GetGlobalIDAsString() + if listdomain.GetNumberOfProxies() == 0: + for i in xrange(listdomain.GetNumberOfProxyTypes()): + igroup = listdomain.GetProxyGroup(i) + name = listdomain.GetProxyName(i) + iproxy = CreateProxy(igroup, name) + listdomain.AddProxy(iproxy) + pm.RegisterProxy(group, proxy.GetPropertyName(smproperty), iproxy) + listdomain.SetDefaultValues(self.SMProperty) + + def GetAvailable(self): + """If this proxy has a list domain, then this function returns the + strings you can use to select from the domain. If there is no such + list domain, the returned list is empty.""" + listdomain = self.GetDomain('proxy_list') + retval = [] + if listdomain: + for i in xrange(listdomain.GetNumberOfProxies()): + proxy = listdomain.GetProxy(i) + retval.append(proxy.GetXMLLabel()) + return retval + + Available = property(GetAvailable, None, None, + """This read only property is a list of strings you can + use to select from the list domain. If there is no + such list domain, the array is empty.""") + + def __iter__(self): + """Implementation of the sequence API""" + return GenericIterator(self) + + def __len__(self): + """Returns the number of elements.""" + return self.SMProperty.GetNumberOfProxies() + + def remove(self, proxy): + """Removes the first occurence of the proxy from the property.""" + self.SMProperty.RemoveProxy(proxy.SMProxy) + self._UpdateProperty() + + def __setitem__(self, idx, value): + """Given a list or tuple of values, sets a slice of values [min, max)""" + if isinstance(idx, slice): + indices = idx.indices(len(self)) + for i, j in zip(range(*indices), value): + self.SMProperty.SetProxy(i, j.SMProxy) + self._UpdateProperty() + elif idx >= len(self) or idx < 0: + raise IndexError + else: + self.SMProperty.SetProxy(idx, value.SMProxy) + self._UpdateProperty() + + def __delitem__(self,idx): + """Removes the element idx""" + if isinstance(idx, slice): + indices = idx.indices(len(self)) + # Collect the elements to delete to a new list first. + # Otherwise indices are screwed up during the actual + # remove loop. + toremove = [] + for i in range(*indices): + toremove.append(self[i]) + for i in toremove: + self.SMProperty.RemoveProxy(i.SMProxy) + self._UpdateProperty() + elif idx >= len(self) or idx < 0: + raise IndexError + else: + self.SMProperty.RemoveProxy(self[idx].SMProxy) + self._UpdateProperty() + + def __getitem__(self, idx): + """Returns the range [min, max) of elements. Raises an IndexError + exception if an argument is out of bounds.""" + if isinstance(idx, slice): + indices = idx.indices(len(self)) + retVal = [] + for i in range(*indices): + retVal.append(_getPyProxy(self.SMProperty.GetProxy(i))) + return retVal + elif idx >= len(self) or idx < 0: + raise IndexError + return _getPyProxy(self.SMProperty.GetProxy(idx)) + + def __getattr__(self, name): + "Unknown attribute requests get forwarded to SMProperty." + return getattr(self.SMProperty, name) + + def index(self, proxy): + idx = 0 + for px in self: + ## VSV: == + if proxy.IsSame(px): + return idx + idx += 1 + raise ValueError("proxy is not in the list.") + + def append(self, proxy): + "Appends the given proxy to the property values." + self.SMProperty.AddProxy(proxy.SMProxy) + self._UpdateProperty() + + def GetData(self): + "Returns all elements as either a list or a single value." + property = self.SMProperty + if property.GetRepeatable() or property.GetNumberOfProxies() > 1: + return self[0:len(self)] + else: + if property.GetNumberOfProxies() > 0: + return _getPyProxy(property.GetProxy(0)) + return None + + def SetData(self, values): + """Allows setting of all values at once. Requires a single value, + a tuple or list.""" + if isinstance(values, str): + position = -1 + try: + position = self.Available.index(values) + except: + raise ValueError, values + " is not a valid object in the domain." + values = self.GetDomain('proxy_list').GetProxy(position) + if not isinstance(values, tuple) and \ + not isinstance(values, list): + values = (values,) + self.SMProperty.RemoveAllProxies() + for value in values: + if isinstance(value, Proxy): + value_proxy = value.SMProxy + else: + value_proxy = value + self.SMProperty.AddProxy(value_proxy) + self._UpdateProperty() + + def Clear(self): + "Removes all elements." + self.SMProperty.RemoveAllProxies() + self._UpdateProperty() + +class InputProperty(ProxyProperty): + """An InputProperty allows making pipeline connections. You can set either + a source proxy or an OutputProperty to an input property: + + > property[0] = proxy + or + > property[0] = OuputPort(proxy, 1) + + > property.append(proxy) + or + > property.append(OutputPort(proxy, 0)) + """ + def __setitem__(self, idx, value): + """Given a list or tuple of values, sets a slice of values [min, max)""" + if isinstance(idx, slice): + indices = idx.indices(len(self)) + for i, j in zip(range(*indices), value): + op = value[i-min] + self.SMProperty.SetInputConnection(i, op.SMProxy, op.Port) + self._UpdateProperty() + elif idx >= len(self) or idx < 0: + raise IndexError + else: + self.SMProperty.SetInputConnection(idx, value.SMProxy, value.Port) + self._UpdateProperty() + + def __getitem__(self, idx): + """Returns the range [min, max) of elements. Raises an IndexError + exception if an argument is out of bounds.""" + if isinstance(idx, slice): + indices = idx.indices(len(self)) + retVal = [] + for i in range(*indices): + port = None + if self.SMProperty.GetProxy(i): + port = OutputPort(_getPyProxy(self.SMProperty.GetProxy(i)),\ + self.SMProperty.GetOutputPortForConnection(i)) + retVal.append(port) + return retVal + elif idx >= len(self) or idx < 0: + raise IndexError + return OutputPort(_getPyProxy(self.SMProperty.GetProxy(idx)),\ + self.SMProperty.GetOutputPortForConnection(idx)) + + def append(self, value): + """Appends the given proxy to the property values. + Accepts Proxy or OutputPort objects.""" + self.SMProperty.AddInputConnection(value.SMProxy, value.Port) + self._UpdateProperty() + + def GetData(self): + """Returns all elements as either a list of OutputPort objects or + a single OutputPort object.""" + property = self.SMProperty + if property.GetRepeatable() or property.GetNumberOfProxies() > 1: + return self[0:len(self)] + else: + if property.GetNumberOfProxies() > 0: + return OutputPort(_getPyProxy(property.GetProxy(0)),\ + self.SMProperty.GetOutputPortForConnection(0)) + return None + + def SetData(self, values): + """Allows setting of all values at once. Requires a single value, + a tuple or list. Accepts Proxy or OutputPort objects.""" + if isinstance(values, str): + ProxyProperty.SetData(self, values) + return + if not isinstance(values, tuple) and \ + not isinstance(values, list): + values = (values,) + self.SMProperty.RemoveAllProxies() + for value in values: + if value: + self.SMProperty.AddInputConnection(value.SMProxy, value.Port) + self._UpdateProperty() + + def _UpdateProperty(self): + "Pushes the value of this property to the server." + ProxyProperty._UpdateProperty(self) + iter = PropertyIterator(self.Proxy) + for prop in iter: + if isinstance(prop, ArraySelectionProperty): + prop.UpdateDefault() + + +class DataInformation(object): + """DataInformation is a contained for meta-data associated with an + output data. + + DataInformation is a python wrapper around a vtkPVDataInformation. + In addition to proving all methods of a vtkPVDataInformation, it provides + a few convenience methods. + + Please note that some of the methods accessible through the DataInformation + class are not listed by help() because the DataInformation objects forward + unresolved attributes to the underlying object. To get the full list, + see also dir(proxy.DataInformation). + See also the doxygen based documentation of the vtkPVDataInformation C++ + class. + """ + def __init__(self, dataInformation, proxy, idx): + """Default constructor. Requires a vtkPVDataInformation, a source proxy + and an output port id.""" + self.DataInformation = dataInformation + self.Proxy = proxy + self.Idx = idx + + def Update(self): + """****Deprecated**** There is no reason anymore to use this method + explicitly, it is called automatically when one gets any value from the + data information object. + Update the data information if necessary. Note that this + does not cause execution of the underlying object. In certain + cases, you may have to call UpdatePipeline() on the proxy.""" + if self.Proxy: + self.Proxy.GetDataInformation(self.Idx) + + def GetDataSetType(self): + """Returns the dataset type as defined in vtkDataObjectTypes.""" + self.Update() + if not self.DataInformation: + raise RuntimeError, "No data information is available" + if self.DataInformation.GetCompositeDataSetType() > -1: + return self.DataInformation.GetCompositeDataSetType() + return self.DataInformation.GetDataSetType() + + def GetDataSetTypeAsString(self): + """Returns the dataset type as a user-friendly string. This is + not the same as the enumaration used by VTK""" + return vtk.vtkDataObjectTypes.GetClassNameFromTypeId(self.GetDataSetType()) + + def __getattr__(self, name): + """Forwards unknown attribute requests to the underlying + vtkPVInformation.""" + if not self.DataInformation: + raise AttributeError("class has no attribute %s" % name) + return None + self.Update() + return getattr(self.DataInformation, name) + +class ArrayInformation(object): + """Meta-information associated with an array. Use the Name + attribute to get the array name. + + Please note that some of the methods accessible through the ArrayInformation + class are not listed by help() because the ArrayInformation objects forward + unresolved attributes to the underlying object. + See the doxygen based documentation of the vtkPVArrayInformation C++ + class for a full list. + """ + def __init__(self, proxy, field, name): + self.Proxy = proxy + self.FieldData = field + self.Name = name + + def __getattr__(self, name): + """Forward unknown methods to vtkPVArrayInformation""" + array = self.FieldData.GetFieldData().GetArrayInformation(self.Name) + if not array: return None + return getattr(array, name) + + def __repr__(self): + """Returns a user-friendly representation string.""" + return "Array: " + self.Name + + def GetRange(self, component=0): + """Given a component, returns its value range as a tuple of 2 values.""" + array = self.FieldData.GetFieldData().GetArrayInformation(self.Name) + range = array.GetComponentRange(component) + return (range[0], range[1]) + +class FieldDataInformationIterator(object): + """Iterator for FieldDataInformation""" + + def __init__(self, info, items=False): + self.FieldDataInformation = info + self.index = 0 + self.items = items + + def __iter__(self): + return self + + def next(self): + if self.index >= self.FieldDataInformation.GetNumberOfArrays(): + raise StopIteration + + self.index += 1 + ai = self.FieldDataInformation[self.index-1] + if self.items: + return (ai.GetName(), ai) + else: + return ai + + +class FieldDataInformation(object): + """Meta-data for a field of an output object (point data, cell data etc...). + Provides easy access to the arrays using the slice interface: + > narrays = len(field_info) + > for i in range(narrays): + > array_info = field_info[i] + + Full slice interface is supported: + > arrays = field_info[0:5:3] + where arrays is a list. + + Array access by name is also possible: + > array_info = field_info['Temperature'] + + The number of arrays can also be accessed using the NumberOfArrays + property. + """ + def __init__(self, proxy, idx, field): + self.Proxy = proxy + self.OutputPort = idx + self.FieldData = field + + def GetFieldData(self): + """Convenience method to get the underlying + vtkPVDataSetAttributesInformation""" + return getattr(self.Proxy.GetDataInformation(self.OutputPort), "Get%sInformation" % self.FieldData)() + + def GetNumberOfArrays(self): + """Returns the number of arrays.""" + self.Proxy.UpdatePipeline() + return self.GetFieldData().GetNumberOfArrays() + + def GetArray(self, idx): + """Given an index or a string, returns an array information. + Raises IndexError if the index is out of bounds.""" + self.Proxy.UpdatePipeline() + if not self.GetFieldData().GetArrayInformation(idx): + return None + if isinstance(idx, str): + return ArrayInformation(self.Proxy, self, idx) + elif idx >= len(self) or idx < 0: + raise IndexError + return ArrayInformation(self.Proxy, self, self.GetFieldData().GetArrayInformation(idx).GetName()) + + def __len__(self): + """Returns the number of arrays.""" + return self.GetNumberOfArrays() + + def __getitem__(self, idx): + """Implements the [] operator. Accepts an array name.""" + if isinstance(idx, slice): + indices = idx.indices(self.GetNumberOfArrays()) + retVal = [] + for i in range(*indices): + retVal.append(self.GetArray(i)) + return retVal + return self.GetArray(idx) + + def keys(self): + """Implementation of the dictionary API""" + kys = [] + narrays = self.GetNumberOfArrays() + for i in range(narrays): + kys.append(self.GetArray(i).GetName()) + return kys + + def values(self): + """Implementation of the dictionary API""" + vals = [] + narrays = self.GetNumberOfArrays() + for i in range(narrays): + vals.append(self.GetArray(i)) + return vals + + def iteritems(self): + """Implementation of the dictionary API""" + return FieldDataInformationIterator(self, True) + + def items(self): + """Implementation of the dictionary API""" + itms = [] + narrays = self.GetNumberOfArrays() + for i in range(narrays): + ai = self.GetArray(i) + itms.append((ai.GetName(), ai)) + return itms + + def has_key(self, key): + """Implementation of the dictionary API""" + if self.GetArray(key): + return True + return False + + def __iter__(self): + """Implementation of the dictionary API""" + return FieldDataInformationIterator(self) + + def __getattr__(self, name): + """Forwards unknown attributes to the underlying + vtkPVDataSetAttributesInformation""" + array = self.GetArray(name) + if array: return array + raise AttributeError("class has no attribute %s" % name) + return None + + NumberOfArrays = property(GetNumberOfArrays, None, None, "Returns the number of arrays.") + +def OutputPort(proxy, outputPort=0): + if not Proxy: + return None + if isinstance(outputPort, str): + outputPort = proxy.GetOutputPortIndex(outputPort) + if outputPort >= proxy.GetNumberOfOutputPorts(): + return None + if proxy.Port == outputPort: + return proxy + newinstance = _getPyProxy(proxy.SMProxy, outputPort) + newinstance.Port = outputPort + newinstance._Proxy__Properties = proxy._Proxy__Properties + return newinstance + +class ProxyManager(object): + """When running scripts from the python shell in the ParaView application, + registering proxies with the proxy manager is the only mechanism to + notify the graphical user interface (GUI) that a proxy + exists. Therefore, unless a proxy is registered, it will not show up in + the user interface. Also, the proxy manager is the only way to get + access to proxies created using the GUI. Proxies created using the GUI + are automatically registered under an appropriate group (sources, + filters, representations and views). To get access to these objects, + you can use proxyManager.GetProxy(group, name). The name is the same + as the name shown in the pipeline browser. + + This class is a python wrapper for vtkSMProxyManager. Note that the + underlying vtkSMProxyManager is a singleton. All instances of this + class will refer to the same object. In addition to all methods provided by + vtkSMProxyManager (all unknown attribute requests are forwarded + to the vtkSMProxyManager), this class provides several convenience + methods. + + Please note that some of the methods accessible through the ProxyManager + class are not listed by help() because the ProxyManager objects forwards + unresolved attributes to the underlying object. To get the full list, + see also dir(proxy.SMProxyManager). See also the doxygen based documentation + of the vtkSMProxyManager C++ class. + """ + + def __init__(self, session=None): + """Constructor. Assigned self.SMProxyManager to + vtkSMProxyManager.GetProxyManager().""" + global ActiveConnection + if not session: + session = ActiveConnection.Session + self.SMProxyManager = session.GetSessionProxyManager() + + def RegisterProxy(self, group, name, aProxy): + """Registers a proxy (either SMProxy or proxy) with the + server manager""" + if isinstance(aProxy, Proxy): + self.SMProxyManager.RegisterProxy(group, name, aProxy.SMProxy) + else: + self.SMProxyManager.RegisterProxy(group, name, aProxy) + + def NewProxy(self, group, name): + """Creates a new proxy of given group and name and returns an SMProxy. + Note that this is a server manager object. You should normally create + proxies using the class objects. For example: + obj = servermanager.sources.SphereSource()""" + if not self.SMProxyManager: + return None + aProxy = self.SMProxyManager.NewProxy(group, name, "NULL") + if not aProxy: + return None + aProxy.UnRegister(None) + return aProxy + + def GetProxy(self, group, name): + """Returns a Proxy registered under a group and name""" + if not self.SMProxyManager: + return None + aProxy = self.SMProxyManager.GetProxy(group, name) + if not aProxy: + return None + return _getPyProxy(aProxy) + + def GetPrototypeProxy(self, group, name): + """Returns a prototype proxy given a group and name. This is an + SMProxy. This is a low-level method. You should not normally + have to call it.""" + if not self.SMProxyManager: + return None + aProxy = self.SMProxyManager.GetPrototypeProxy(group, name) + if not aProxy: + return None + return aProxy + + def GetProxiesInGroup(self, groupname): + """Returns a map of proxies in a particular group.""" + proxies = {} + iter = self.NewGroupIterator(groupname) + for aProxy in iter: + proxies[(iter.GetKey(), aProxy.GetGlobalIDAsString())] = aProxy + return proxies + + def UnRegisterProxy(self, groupname, proxyname, aProxy): + """Unregisters a proxy.""" + if not self.SMProxyManager: + return + if aProxy != None and isinstance(aProxy,Proxy): + aProxy = aProxy.SMProxy + if aProxy: + self.SMProxyManager.UnRegisterProxy(groupname, proxyname, aProxy) + + def GetProxies(self, groupname, proxyname): + """Returns all proxies registered under the given group with the + given name. Note that it is possible to register more than one + proxy with the same name in the same group. Because the proxies + are different, there is no conflict. Use this method instead of + GetProxy() if you know that there are more than one proxy registered + with this name.""" + if not self.SMProxyManager: + return [] + collection = vtk.vtkCollection() + result = [] + self.SMProxyManager.GetProxies(groupname, proxyname, collection) + for i in range(0, collection.GetNumberOfItems()): + aProxy = _getPyProxy(collection.GetItemAsObject(i)) + if aProxy: + result.append(aProxy) + + return result + + def __iter__(self): + """Returns a new ProxyIterator.""" + iter = ProxyIterator() + iter.Begin() + return iter + + def NewGroupIterator(self, group_name): + """Returns a ProxyIterator for a group. The resulting object + can be used to traverse the proxies that are in the given + group.""" + iter = self.__iter__() + iter.SetModeToOneGroup() + iter.Begin(group_name) + return iter + + def NewDefinitionIterator(self, groupname=None): + """Returns an iterator that can be used to iterate over + all groups and types of proxies that the proxy manager + can create.""" + iter = None + if groupname != None: + iter = ProxyDefinitionIterator(self.GetProxyDefinitionManager().NewSingleGroupIterator(groupname,0)) + else: + iter = ProxyDefinitionIterator(self.GetProxyDefinitionManager().NewIterator(0)) + + return iter + + def __ConvertArgumentsAndCall(self, *args): + newArgs = [] + for arg in args: + if issubclass(type(arg), Proxy) or isinstance(arg, Proxy): + newArgs.append(arg.SMProxy) + else: + newArgs.append(arg) + func = getattr(self.SMProxyManager, self.__LastAttrName) + retVal = func(*newArgs) + if type(retVal) is type(self.SMProxyManager) and retVal.IsA("vtkSMProxy"): + return _getPyProxy(retVal) + else: + return retVal + + def __getattr__(self, name): + """Returns attribute from the ProxyManager""" + try: + pmAttr = getattr(self.SMProxyManager, name) + self.__LastAttrName = name + return self.__ConvertArgumentsAndCall + except: + pass + return getattr(self.SMProxyManager, name) + + def LoadState(self, filename, loader = None): + self.SMProxyManager.LoadXMLState(filename, loader) + + def SaveState(self, filename): + self.SMProxyManager.SaveXMLState(filename) + +class PropertyIterator(object): + """Wrapper for a vtkSMPropertyIterator class to satisfy + the python iterator protocol. Note that the list of + properties can also be obtained from the class object's + dictionary. + See the doxygen documentation for vtkSMPropertyIterator C++ + class for details. + """ + + def __init__(self, aProxy): + self.SMIterator = aProxy.NewPropertyIterator() + if self.SMIterator: + self.SMIterator.UnRegister(None) + self.SMIterator.Begin() + self.Key = None + self.PropertyLabel = None + self.Proxy = aProxy + + def __iter__(self): + return self + + def next(self): + if not self.SMIterator: + raise StopIteration + + if self.SMIterator.IsAtEnd(): + self.Key = None + raise StopIteration + self.Key = self.SMIterator.GetKey() + self.PropertyLabel = self.SMIterator.GetPropertyLabel() + self.SMIterator.Next() + return self.Proxy.GetProperty(self.Key) + + def GetProxy(self): + """Returns the proxy for the property last returned by the call to + 'next()'""" + return self.Proxy + + def GetKey(self): + """Returns the key for the property last returned by the call to + 'next()' """ + return self.Key + + def GetProperty(self): + """Returns the property last returned by the call to 'next()' """ + return self.Proxy.GetProperty(self.Key) + + def __getattr__(self, name): + """returns attributes from the vtkSMPropertyIterator.""" + return getattr(self.SMIterator, name) + +class ProxyDefinitionIterator(object): + """Wrapper for a vtkPVProxyDefinitionIterator class to satisfy + the python iterator protocol. + See the doxygen documentation of the vtkPVProxyDefinitionIterator + C++ class for more information.""" + def __init__(self, iter): + self.SMIterator = iter + if self.SMIterator: + self.SMIterator.UnRegister(None) + self.SMIterator.InitTraversal() + self.Group = None + self.Key = None + + def __iter__(self): + return self + + def next(self): + if self.SMIterator.IsDoneWithTraversal(): + self.Group = None + self.Key = None + raise StopIteration + self.Group = self.SMIterator.GetGroupName() + self.Key = self.SMIterator.GetProxyName() + self.SMIterator.GoToNextItem() + return {"group": self.Group, "key":self.Key } + + def GetProxyName(self): + """Returns the key for the proxy definition last returned by the call + to 'next()' """ + return self.Key + + def GetGroup(self): + """Returns the group for the proxy definition last returned by the + call to 'next()' """ + return self.Group + + def __getattr__(self, name): + """returns attributes from the vtkPVProxyDefinitionIterator.""" + return getattr(self.SMIterator, name) + + +class ProxyIterator(object): + """Wrapper for a vtkSMProxyIterator class to satisfy the + python iterator protocol. + See the doxygen documentation of vtkSMProxyIterator C++ class for + more information. + """ + def __init__(self): + self.SMIterator = vtkSMProxyIterator() + self.SMIterator.SetSession(ActiveConnection.Session) + self.SMIterator.Begin() + self.AProxy = None + self.Group = None + self.Key = None + + def __iter__(self): + return self + + def next(self): + if self.SMIterator.IsAtEnd(): + self.AProxy = None + self.Group = None + self.Key = None + raise StopIteration + return None + self.AProxy = _getPyProxy(self.SMIterator.GetProxy()) + self.Group = self.SMIterator.GetGroup() + self.Key = self.SMIterator.GetKey() + self.SMIterator.Next() + return self.AProxy + + def GetProxy(self): + """Returns the proxy last returned by the call to 'next()'""" + return self.AProxy + + def GetKey(self): + """Returns the key for the proxy last returned by the call to + 'next()' """ + return self.Key + + def GetGroup(self): + """Returns the group for the proxy last returned by the call to + 'next()' """ + return self.Group + + def __getattr__(self, name): + """returns attributes from the vtkSMProxyIterator.""" + return getattr(self.SMIterator, name) + +# Caution: Observers must be global methods otherwise we run into memory +# leak when the interpreter get reset from the C++ layer. +def _update_definitions(caller, event): + updateModules(ActiveConnection.Modules) + +class Connection(object): + """ + This is a python representation for a session/connection. + """ + def __init__(self, connectionId, session): + """Default constructor. Creates a Connection with the given + ID, all other data members initialized to None.""" + global MultiServerConnections + global ActiveConnection + self.ID = connectionId + self.Session = session + self.Modules = PVModule() + self.Alive = True + self.DefinitionObserverTag = 0 + self.CustomDefinitionObserverTag = 0 + if MultiServerConnections == None and ActiveConnection: + raise RuntimeError, "Concurrent connections not supported!" + if MultiServerConnections != None and not self in MultiServerConnections: + MultiServerConnections.append(self) + ActiveConnection = self + __InitAfterConnect__(self) + __exposeActiveModules__() + + def __eq__(self, other): + "Returns true if the connection ids are the same." + return (self.ID == other.ID) + + def __repr__(self): + """User friendly string representation""" + return "Connection (%s) [%d]" % (self.Session.GetURI(), self.ID) + + def GetURI(self): + """Get URI of the connection""" + return self.Session.GetURI() + + def IsRemote(self): + """Returns True if the connection to a remote server, False if + it is local (built-in)""" + if self.Session.IsA("vtkSMSessionClient"): + return True + return False + + def GetNumberOfDataPartitions(self): + """Returns the number of partitions on the data server for this + connection""" + return self.Session.GetServerInformation().GetNumberOfProcesses() + + def AttachDefinitionUpdater(self): + """Attach observer to automatically update modules when needed.""" + # VTN: Observers are not supported + # ProxyDefinitionsUpdated = 2000 +## self.DefinitionObserverTag = self.Session.GetProxyDefinitionManager().AddObserver(2000, _update_definitions) + # CompoundProxyDefinitionsUpdated = 2001 +## self.CustomDefinitionObserverTag = self.Session.GetProxyDefinitionManager().AddObserver(2001, _update_definitions) + pass + + def close(self): + if self.DefinitionObserverTag: + self.Session.GetProxyDefinitionManager().RemoveObserver(self.DefinitionObserverTag) + self.Session.GetProxyDefinitionManager().RemoveObserver(self.CustomDefinitionObserverTag) + self.Session = None + self.Modules = None + self.Alive = False + + def __del__(self): + if self.Alive: + self.close() + +def SaveState(filename): + """Given a state filename, saves the state of objects registered + with the proxy manager.""" + pm = ProxyManager() + pm.SaveState(filename) + +def LoadState(filename, connection=None): + """Given a state filename and an optional connection, loads the server + manager state.""" + if not connection: + connection = ActiveConnection + if not connection: + raise RuntimeError, "Cannot load state without a connection" + pm = ProxyManager() + pm.LoadState(filename, None) + views = GetRenderViews() + for view in views: + # Make sure that the client window size matches the + # ViewSize property. In paraview, the GUI takes care + # of this. + if view.GetClassName() == "vtkSMIceTDesktopRenderViewProxy": + view.GetRenderWindow().SetSize(view.ViewSize[0], \ + view.ViewSize[1]) + +def InitFromGUI(): + """ + Method used to initialize the Python Shell from the ParaView GUI. + """ + global fromGUI, ActiveConnection + if not fromGUI: + print "from paraview.simple import *" + fromGUI = True + # ToggleProgressPrinting() ### FIXME COLLABORATION + enableMultiServer(vtkProcessModule.GetProcessModule().GetMultipleSessionsSupport()) + iter = vtkProcessModule.GetProcessModule().NewSessionIterator(); + iter.InitTraversal() + ActiveConnection = None + activeSession = vtkSMProxyManager.GetProxyManager().GetActiveSession() + tmpActiveConnection = None + while not iter.IsDoneWithTraversal(): + c = Connection(iter.GetCurrentSessionId(), iter.GetCurrentSession()) + if c.Session == activeSession: + tmpActiveConnection = c + iter.GoToNextItem() + iter.UnRegister(None) + if tmpActiveConnection: + ActiveConnection = tmpActiveConnection + +def Connect(ds_host=None, ds_port=11111, rs_host=None, rs_port=22221): + """ + Use this function call to create a new session. On success, + it returns a vtkSMSession object that abstracts the connection. + Otherwise, it returns None. + There are several ways in which this function can be called: + * When called with no arguments, it creates a new session + to the built-in server on the client itself. + * When called with ds_host and ds_port arguments, it + attempts to connect to a server(data and render server on the same server) + on the indicated host:port. + * When called with ds_host, ds_port, rs_host, rs_port, it + creates a new connection to the data server on ds_host:ds_port and to the + render server on rs_host: rs_port. + """ + if ds_host == None: + session = vtkSMSession() + elif rs_host == None: + session = vtkSMSessionClient() + session.Connect("cs://%s:%d" % (ds_host, ds_port)) + else: + session = vtkSMSessionClient() + session.Connect("cdsrs://%s:%d/%s:%d" % (ds_host, ds_port, rs_host, rs_port)) + id = vtkProcessModule.GetProcessModule().RegisterSession(session) + connection = Connection(id, session) + return connection + +def ReverseConnect(port=11111): + """ + Use this function call to create a new session. On success, + it returns a Session object that abstracts the connection. + Otherwise, it returns None. + In reverse connection mode, the client waits for a connection + from the server (client has to be started first). The server + then connects to the client (run pvserver with -rc and -ch + option). + The optional port specified the port to listen to. + """ + session = vtkSMSessionClient() + session.Connect("csrc://hostname:" + port) + id = vtkProcessModule.GetProcessModule().RegisterSession(session) + connection = Connection(id, session) + return connection + +def Disconnect(session=None): + """Disconnects the connection. Make sure to clear the proxy manager + first.""" + global ActiveConnection + global MultiServerConnections + global fromGUI + if fromGUI: + # Let the UI know that we want to disconnect + ActiveConnection.Session.InvokeEvent('ExitEvent') + return + if ActiveConnection and (not session or session == ActiveConnection.Session): + session = ActiveConnection.Session + if MultiServerConnections: + MultiServerConnections.remove(ActiveConnection) + ActiveConnection.close() + ActiveConnection = None + switchActiveConnection() + else: + ActiveConnection.close() + ActiveConnection = None + elif MultiServerConnections: + for connection in MultiServerConnections: + if connection.Session == session: + connection.close() + MultiServerConnections.remove(connection) + if session: + vtkProcessModule.GetProcessModule().UnRegisterSession(session) + return + +def CreateProxy(xml_group, xml_name, session=None): + """Creates a proxy. If session is set, the proxy's session is + set accordingly. If session is None, the current Session is used, if + present. You should not have to use method normally. Instantiate the + appropriate class from the appropriate module, for example: + sph = servermanager.sources.SphereSource()""" + global ActiveConnection + if not session: + session = ActiveConnection.Session + if not session: + raise RuntimeError, "Cannot create objects without a session." + pxm = ProxyManager(session) + return pxm.NewProxy(xml_group, xml_name) + +def GetRenderView(connection=None): + """Return the render view in use. If more than one render view is in + use, return the first one.""" + + render_module = None + for aProxy in ProxyManager(): + if aProxy.IsA("vtkSMRenderViewProxy"): + render_module = aProxy + break + return render_module + +def GetRenderViews(connection=None): + """Returns the set of all render views.""" + render_modules = [] + for aProxy in ProxyManager(): + if aProxy.IsA("vtkSMRenderViewProxy"): + render_modules.append(aProxy) + return render_modules + +def GetContextViews(connection=None): + """Returns the set of all context views.""" + context_modules = [] + for aProxy in ProxyManager(): + if aProxy.IsA("vtkSMContextViewProxy"): + context_modules.append(aProxy) + return context_modules + +def CreateRenderView(session=None, **extraArgs): + """Creates a render window on the particular session. If session + is not specified, then the active session is used, if available. + + This method can also be used to initialize properties by passing + keyword arguments where the key is the name of the property. In addition + registrationGroup and registrationName (optional) can be specified (as + keyword arguments) to automatically register the proxy with the proxy + manager.""" + return _create_view("RenderView", session, **extraArgs) + +def _create_view(view_xml_name, session=None, **extraArgs): + """Creates a view on the particular session. If session + is not specified, then the active session is used, if available. + This method can also be used to initialize properties by passing + keyword arguments where the key is the name of the property.""" + if not session: + session = ActiveConnection.Session + if not session: + raise RuntimeError, "Cannot create view without session." + pxm = ProxyManager() + view_module = None + if view_xml_name: + view_module = CreateProxy("views", view_xml_name, session) + if not view_module: + return None + extraArgs['proxy'] = view_module + python_proxy_name = _make_name_valid(view_module.GetXMLName()) + proxy = rendering.__dict__[python_proxy_name](**extraArgs) + return proxy + +def GetRepresentation(aProxy, view): + for rep in view.Representations: + #VSV: == + try: isRep = rep.Input.IsSame(aProxy) + except: isRep = False + if isRep: return rep + return None + +def CreateRepresentation(aProxy, view, **extraArgs): + """Creates a representation for the proxy and adds it to the render + module. + + This method can also be used to initialize properties by passing + keyword arguments where the key is the name of the property.In addition + registrationGroup and registrationName (optional) can be specified (as + keyword arguments) to automatically register the proxy with the proxy + manager. + + This method tries to create the best possible representation for the given + proxy in the given view. Additionally, the user can specify proxyName + (optional) to create a representation of a particular type.""" + + global rendering + if not aProxy: + raise RuntimeError, "proxy argument cannot be None." + if not view: + raise RuntimeError, "view argument cannot be None." + if "proxyName" in extraArgs: + display = CreateProxy("representations", extraArgs['proxyName'], None) + del extraArgs['proxyName'] + else: + display = view.SMProxy.CreateDefaultRepresentation(aProxy.SMProxy, 0) + if display: + display.UnRegister(None) + if not display: + return None + extraArgs['proxy'] = display + proxy = rendering.__dict__[display.GetXMLName()](**extraArgs) + proxy.Input = aProxy + proxy.UpdateVTKObjects() + view.Representations.append(proxy) + return proxy + +class _ModuleLoader(object): + def find_module(self, fullname, path=None): + if vtkPVPythonModule.HasModule(fullname): + return self + else: + return None + def load_module(self, fullname): + import imp + moduleInfo = vtkPVPythonModule.GetModule(fullname) + if not moduleInfo: + raise ImportError + module = sys.modules.setdefault(fullname, imp.new_module(fullname)) + module.__file__ = "<%s>" % moduleInfo.GetFullName() + module.__loader__ = self + if moduleInfo.GetIsPackage: + module.__path__ = moduleInfo.GetFullName() + code = compile(moduleInfo.GetSource(), module.__file__, 'exec') + exec code in module.__dict__ + return module + +def LoadXML(xmlstring): + """DEPRECATED. Given a server manager XML as a string, parse and process it.""" + raise RuntimeError, "Deprecated. Use LoadPlugin(...) instead." + + +def LoadPlugin(filename, remote=True, connection=None): + """ Given a filename and a session (optional, otherwise uses + ActiveConnection), loads a plugin. It then updates the sources, + filters and rendering modules.""" + + if not connection: + connection = ActiveConnection + if not connection: + raise RuntimeError, "Cannot load a plugin without a connection." + plm = vtkSMProxyManager.GetProxyManager().GetPluginManager() + + if remote: + status = plm.LoadRemotePlugin(filename, connection.Session) + else: + status = plm.LoadLocalPlugin(filename) + + # shouldn't the extension check happend before attempting to load the plugin? + if not status: + raise RuntimeError, "Problem loading plugin %s" % (filename) + else: + # we should never have to call this. The modules should update automatically. + updateModules(connection.Modules) + + +def Fetch(input, arg1=None, arg2=None, idx=0): + """ + A convenience method that moves data from the server to the client, + optionally performing some operation on the data as it moves. + The input argument is the name of the (proxy for a) source or filter + whose output is needed on the client. + + You can use Fetch to do three things: + + If arg1 is None (the default) then all of the data is brought to the client. + In parallel runs an appropriate append Filter merges the + data on each processor into one data object. The filter chosen will be + vtkAppendPolyData for vtkPolyData, vtkAppendRectilinearGrid for + vtkRectilinearGrid, vtkMultiBlockDataGroupFilter for vtkCompositeData, + and vtkAppendFilter for anything else. + + If arg1 is an integer then one particular processor's output is brought to + the client. In serial runs the arg is ignored. If you have a filter that + computes results in parallel and brings them to the root node, then set + arg to be 0. + + If arg1 and arg2 are a algorithms, for example vtkMinMax, the algorithm + will be applied to the data to obtain some result. Here arg1 will be + applied pre-gather and arg2 will be applied post-gather. In parallel + runs the algorithm will be run on each processor to make intermediate + results and then again on the root processor over all of the + intermediate results to create a global result. + + Optional argument idx is used to specify the output port number to fetch the + data from. Default is port 0. + """ + + import types + + reducer = filters.ReductionFilter(Input=OutputPort(input,idx)) + + #create the pipeline that reduces and transmits the data + if arg1 == None: + cdinfo = input.GetDataInformation(idx).GetCompositeDataInformation() + if cdinfo.GetDataIsComposite(): + print "use composite data append" + reducer.PostGatherHelperName = "vtkMultiBlockDataGroupFilter" + + elif input.GetDataInformation(idx).GetDataClassName() == "vtkPolyData": + print "use append poly data filter" + reducer.PostGatherHelperName = "vtkAppendPolyData" + + elif input.GetDataInformation(idx).GetDataClassName() == "vtkRectilinearGrid": + print "use append rectilinear grid filter" + reducer.PostGatherHelperName = "vtkAppendRectilinearGrid" + + elif input.GetDataInformation(idx).IsA("vtkDataSet"): + print "use unstructured append filter" + reducer.PostGatherHelperName = "vtkAppendFilter" + + elif type(arg1) is types.IntType: + reducer.PassThrough = arg1 + + else: + reducer.PreGatherHelper = arg1 + reducer.PostGatherHelper = arg2 + + # reduce + reducer.UpdatePipeline() + dataInfo = reducer.GetDataInformation(0) + dataType = dataInfo.GetDataSetType() + if dataInfo.GetCompositeDataSetType() > 0: + dataType = dataInfo.GetCompositeDataSetType() + + fetcher = filters.ClientServerMoveData(Input=reducer) + fetcher.OutputDataType = dataType + fetcher.WholeExtent = dataInfo.GetExtent()[:] + #fetch + fetcher.UpdatePipeline() + + op = fetcher.GetClientSideObject().GetOutputDataObject(0) + opc = op.NewInstance() + opc.ShallowCopy(op) + opc.UnRegister(None) + return opc + +def AnimateReader(reader, view, 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: + raise RuntimeError, "No reader was specified, cannot animate." + if not view: + raise RuntimeError, "No view was specified, cannot animate." + # Create an animation scene + scene = animation.AnimationScene() + + # We need to have the reader and the view registered with + # the time keeper. This is how the scene gets its time values. + try: + tk = ProxyManager().GetProxiesInGroup("timekeeper").values()[0] + scene.TimeKeeper = tk + except IndexError: + tk = misc.TimeKeeper() + scene.TimeKeeper = tk + + if not reader in tk.TimeSources: + tk.TimeSources.append(reader) + if not view in tk.Views: + tk.Views.append(view) + + + # with 1 view + scene.ViewModules = [view] + # Update the reader to get the time information + reader.UpdatePipelineInformation() + # Animate from 1st time step to last + scene.StartTime = reader.TimestepValues.GetData()[0] + scene.EndTime = reader.TimestepValues.GetData()[-1] + + # Each frame will correspond to a time step + scene.PlayMode = 2 #Snap To Timesteps + + # Create a special animation cue for time. + cue = animation.TimeAnimationCue() + cue.AnimatedProxy = view + cue.AnimatedPropertyName = "ViewTime" + scene.Cues = [cue] + + if filename: + writer = vtkSMAnimationSceneImageWriter() + writer.SetFileName(filename) + writer.SetFrameRate(1) + writer.SetAnimationScene(scene.SMProxy) + + # Now save the animation. + if not writer.Save(): + raise RuntimeError, "Saving of animation failed!" + else: + scene.Play() + return scene + +def GetProgressPrintingIsEnabled(): + return progressObserverTag is not None + +def SetProgressPrintingEnabled(value): + """Is not supported because of not supported observers""" + pass + +def ToggleProgressPrinting(): + """Turn on/off printing of progress. See SetProgressPrintingEnabled.""" + SetProgressPrintingEnabled(not GetProgressPrintingIsEnabled()) + +def Finalize(): + """Although not required, this can be called at exit to cleanup.""" + global progressObserverTag + # Make sure to remove the observer + if progressObserverTag: + ToggleProgressPrinting() + vtkInitializationHelper.Finalize() + +# Internal methods + +def _getPyProxy(smproxy, outputPort=0): + """Returns a python wrapper for a server manager proxy. This method + first checks if there is already such an object by looking in the + _pyproxies group and returns it if found. Otherwise, it creates a + new one. Proxies register themselves in _pyproxies upon creation.""" + if not smproxy: + return None + if (smproxy, outputPort) in _pyproxies: + return _pyproxies[(smproxy, outputPort)]() + + xmlName = smproxy.GetXMLName() + if smproxy.GetXMLLabel(): + xmlName = smproxy.GetXMLLabel() + classForProxy = _findClassForProxy(_make_name_valid(xmlName), smproxy.GetXMLGroup()) + if classForProxy: + retVal = classForProxy(proxy=smproxy, port=outputPort) + else: + retVal = Proxy(proxy=smproxy, port=outputPort) + return retVal + +def _makeUpdateCameraMethod(rv): + """ This internal method is used to create observer methods """ + if not hasattr(rv(), "BlockUpdateCamera"): + rv().add_attribute("BlockUpdateCamera", False) + def UpdateCamera(obj, string): + if not rv().BlockUpdateCamera: + # used to avoid some nasty recursion that occurs when interacting in + # the GUI. + rv().BlockUpdateCamera = True + rv().SynchronizeCameraProperties() + rv().BlockUpdateCamera = False + return UpdateCamera + +def _createInitialize(group, name): + """Internal method to create an Initialize() method for the sub-classes + of Proxy""" + pgroup = group + pname = name + def aInitialize(self, connection=None, update=True): + if not connection: + connection = ActiveConnection + if not connection: + raise RuntimeError,\ + 'Cannot create a proxy without a session.' + if not connection.Session.GetProxyDefinitionManager().HasDefinition(pgroup, pname): + error_msg = "The connection does not provide any definition for %s." % pname + raise RuntimeError, error_msg + self.InitializeFromProxy(\ + CreateProxy(pgroup, pname, connection.Session), update) + return aInitialize + +def _createGetProperty(pName): + """Internal method to create a GetXXX() method where XXX == pName.""" + propName = pName + def getProperty(self): + return self.GetPropertyValue(propName) + return getProperty + +def _createSetProperty(pName): + """Internal method to create a SetXXX() method where XXX == pName.""" + propName = pName + def setProperty(self, value): + return self.SetPropertyWithName(propName, value) + return setProperty + +def _findClassForProxy(xmlName, xmlGroup): + """Given the xmlName for a proxy, returns a Proxy class. Note + that if there are duplicates, the first one is returned.""" + global sources, filters, writers, rendering, animation, implicit_functions,\ + piecewise_functions, extended_sources, misc + if not xmlName: + return None + if xmlGroup == "sources": + return sources.__dict__[xmlName] + elif xmlGroup == "filters": + return filters.__dict__[xmlName] + elif xmlGroup == "implicit_functions": + return implicit_functions.__dict__[xmlName] + elif xmlGroup == "piecewise_functions": + return piecewise_functions.__dict__[xmlName] + elif xmlGroup == "writers": + return writers.__dict__[xmlName] + elif xmlGroup == "extended_sources": + return extended_sources.__dict__[xmlName] + elif xmlName in rendering.__dict__: + return rendering.__dict__[xmlName] + elif xmlName in animation.__dict__: + return animation.__dict__[xmlName] + elif xmlName in misc.__dict__: + return misc.__dict__[xmlName] + else: + return None + +def _printProgress(caller, event): + """The default event handler for progress. Prints algorithm + name and 1 '.' per 10% progress.""" + global currentAlgorithm, currentProgress + + pm = vtkProcessModule.GetProcessModule() + progress = pm.GetLastProgress() / 10 + # If we got a 100% as the first thing, ignore + # This is to get around the fact that some vtk + # algorithms report 100% more than once (which is + # a bug) + if not currentAlgorithm and progress == 10: + return + alg = pm.GetLastProgressName() + if alg != currentAlgorithm and alg: + if currentAlgorithm: + while currentProgress <= 10: + import sys + sys.stdout.write(".") + currentProgress += 1 + print "]" + currentProgress = 0 + print alg, ": [ ", + currentAlgorithm = alg + while currentProgress <= progress: + import sys + sys.stdout.write(".") + #sys.stdout.write("%d " % pm.GetLastProgress()) + currentProgress += 1 + if progress == 10: + print "]" + currentAlgorithm = None + currentProgress = 0 + +def updateModules(m): + """Called when a plugin is loaded, this method updates + the proxy class object in all known modules.""" + + createModule("sources", m.sources) + createModule("filters", m.filters) + createModule("writers", m.writers) + createModule("representations", m.rendering) + createModule("views", m.rendering) + createModule("lookup_tables", m.rendering) + createModule("textures", m.rendering) + createModule('cameramanipulators', m.rendering) + createModule("animation", m.animation) + createModule("misc", m.misc) + createModule('animation_keyframes', m.animation) + createModule('implicit_functions', m.implicit_functions) + createModule('piecewise_functions', m.piecewise_functions) + createModule("extended_sources", m.extended_sources) + createModule("incremental_point_locators", m.misc) + +def _createModules(m): + """Called when the module is loaded, this creates sub- + modules for all know proxy groups.""" + + m.sources = createModule('sources') + m.filters = createModule('filters') + m.writers = createModule('writers') + m.rendering = createModule('representations') + createModule('views', m.rendering) + createModule("lookup_tables", m.rendering) + createModule("textures", m.rendering) + createModule('cameramanipulators', m.rendering) + m.animation = createModule('animation') + createModule('animation_keyframes', m.animation) + m.implicit_functions = createModule('implicit_functions') + m.piecewise_functions = createModule('piecewise_functions') + m.extended_sources = createModule("extended_sources") + m.misc = createModule("misc") + createModule("incremental_point_locators", m.misc) + +class PVModule(object): + pass + +def _make_name_valid(name): + """Make a string into a valid Python variable name.""" + if not name: + return None + import string + valid_chars = "_%s%s" % (string.ascii_letters, string.digits) + name = str().join([c for c in name if c in valid_chars]) + if not name[0].isalpha(): + name = 'a' + name + return name + +def createModule(groupName, mdl=None): + """Populates a module with proxy classes defined in the given group. + If mdl is not specified, it also creates the module""" + global ActiveConnection + + if not ActiveConnection: + raise RuntimeError, "Please connect to a server using \"Connect\"" + + pxm = ProxyManager() + # Use prototypes to find all proxy types. + pxm.InstantiateGroupPrototypes(groupName) + + debug = False + if not mdl: + debug = True + mdl = PVModule() + definitionIter = pxm.NewDefinitionIterator(groupName) + for i in definitionIter: + proxyName = i['key'] + proto = pxm.GetPrototypeProxy(groupName, proxyName) + if not proto: + print "Error while loading %s/%s %s"%(groupName, i['group'], proxyName) + continue + pname = proxyName + if proto.GetXMLLabel(): + pname = proto.GetXMLLabel() + pname = _make_name_valid(pname) + if not pname: + continue + if pname in mdl.__dict__: + if debug: + print "Warning: %s is being overwritten. This may point to an issue in the ParaView configuration files" % pname + cdict = {} + # Create an Initialize() method for this sub-class. + cdict['Initialize'] = _createInitialize(groupName, proxyName) + iter = PropertyIterator(proto) + # Add all properties as python properties. + for prop in iter: + propName = iter.GetKey() + if (prop.GetInformationOnly() and propName != "TimestepValues" ) \ + or prop.GetIsInternal(): + continue + names = [propName] + names = [iter.PropertyLabel] + + propDoc = None + if prop.GetDocumentation(): + propDoc = prop.GetDocumentation().GetDescription() + for name in names: + name = _make_name_valid(name) + if name: + cdict[name] = property(_createGetProperty(propName), + _createSetProperty(propName), + None, + propDoc) + # Add the documentation as the class __doc__ + if proto.GetDocumentation() and \ + proto.GetDocumentation().GetDescription(): + doc = proto.GetDocumentation().GetDescription() + else: + doc = Proxy.__doc__ + cdict['__doc__'] = doc + # Create the new type + if proto.GetXMLName() == "ExodusIIReader": + superclasses = (ExodusIIReaderProxy,) + elif proto.IsA("vtkSMSourceProxy"): + superclasses = (SourceProxy,) + elif proto.IsA("vtkSMViewLayoutProxy"): + superclasses = (ViewLayoutProxy,) + else: + superclasses = (Proxy,) + + cobj = type(pname, superclasses, cdict) + # Add it to the modules dictionary + mdl.__dict__[pname] = cobj + return mdl + + +def __determineGroup(proxy): + """Internal method""" + if not proxy: + return None + xmlgroup = proxy.GetXMLGroup() + xmlname = proxy.GetXMLName() + if xmlgroup == "sources": + if xmlname in ["BlockSelectionSource", + "FrustumSelectionSource", + "GlobalIDSelectionSource", + "PedigreeIDSelectionSource", + "IDSelectionSource", + "CompositeDataIDSelectionSource", + "HierarchicalDataIDSelectionSource", + "ThresholdSelectionSource", + "LocationSelectionSource"]: + return "selection_sources" + return "sources" + elif xmlgroup == "filters": + return "sources" + elif xmlgroup == "representations": + if xmlname == "ScalarBarWidgetRepresentation": + return "scalar_bars" + return "representations" + elif xmlgroup == "animation_keyframes": + return "animation" + return xmlgroup + +__nameCounter = {} +def __determineName(proxy, group): + global __nameCounter + name = _make_name_valid(proxy.GetXMLLabel()) + if not name: + return None + if not __nameCounter.has_key(name): + __nameCounter[name] = 1 + val = 1 + else: + __nameCounter[name] += 1 + val = __nameCounter[name] + return "%s%d" % (name, val) + +def __getName(proxy, group): + pxm = ProxyManager(proxy.GetSession()) + if isinstance(proxy, Proxy): + proxy = proxy.SMProxy + return pxm.GetProxyName(group, proxy) + +class MissingRegistrationInformation(Exception): + """Exception for missing registration information. Raised when a name or group + is not specified or when a group cannot be deduced.""" + pass + +class MissingProxy(Exception): + """Exception fired when the requested proxy is missing.""" + pass + +def Register(proxy, **extraArgs): + """Registers a proxy with the proxy manager. If no 'registrationGroup' is + specified, then the group is inferred from the type of the proxy. + 'registrationName' may be specified to register with a particular name + otherwise a default name will be created.""" + # TODO: handle duplicate registration + if "registrationGroup" in extraArgs: + registrationGroup = extraArgs["registrationGroup"] + else: + registrationGroup = __determineGroup(proxy) + + if "registrationName" in extraArgs: + registrationName = extraArgs["registrationName"] + else: + registrationName = __determineName(proxy, registrationGroup) + if registrationGroup and registrationName: + pxm = ProxyManager() + pxm.RegisterProxy(registrationGroup, registrationName, proxy) + else: + raise MissingRegistrationInformation, "Registration error %s %s." % (registrationGroup, registrationName) + return (registrationGroup, registrationName) + +def UnRegister(proxy, **extraArgs): + """UnRegisters proxies registered using Register().""" + if "registrationGroup" in extraArgs: + registrationGroup = extraArgs["registrationGroup"] + else: + registrationGroup = __determineGroup(proxy) + + if "registrationName" in extraArgs: + registrationName = extraArgs["registrationName"] + else: + registrationName = __getName(proxy, registrationGroup) + + if registrationGroup and registrationName: + pxm = ProxyManager() + pxm.UnRegisterProxy(registrationGroup, registrationName, proxy) + else: + raise RuntimeError, "UnRegistration error." + return (registrationGroup, registrationName) + +def demo1(): + """This simple demonstration creates a sphere, renders it and delivers + it to the client using Fetch. It returns a tuple of (data, render + view)""" + if not ActiveConnection: + Connect() + ss = sources.Sphere(Radius=2, ThetaResolution=32) + shr = filters.Shrink(Input=OutputPort(ss,0)) + cs = sources.Cone() + app = filters.AppendDatasets() + app.Input = [shr, cs] + rv = CreateRenderView() + rep = CreateRepresentation(app, rv) + rv.ResetCamera() + rv.StillRender() + data = Fetch(ss) + + return (data, rv) + +def demo2(fname="/Users/berk/Work/ParaViewData/Data/disk_out_ref.ex2"): + """This method demonstrates the user of a reader, representation and + view. It also demonstrates how meta-data can be obtained using proxies. + Make sure to pass the full path to an exodus file. Also note that certain + parameters are hard-coded for disk_out_ref.ex2 which can be found + in ParaViewData. This method returns the render view.""" + if not ActiveConnection: + Connect() + # Create the exodus reader and specify a file name + reader = sources.ExodusIIReader(FileName=fname) + # Get the list of point arrays. + arraySelection = reader.PointVariables + print arraySelection.Available + # Select all arrays + arraySelection.SetData(arraySelection.Available) + + # Next create a default render view appropriate for the session type. + rv = CreateRenderView() + # Create the matching representation + rep = CreateRepresentation(reader, rv) + rep.Representation = 1 # Wireframe + # Black background is not pretty + rv.Background = [0.4, 0.4, 0.6] + rv.StillRender() + # Reset the camera to include the whole thing + rv.ResetCamera() + rv.StillRender() + # Change the elevation of the camera. See VTK documentation of vtkCamera + # for camera parameters. + c = rv.GetActiveCamera() + c.Elevation(45) + rv.StillRender() + # Now that the reader execute, 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. + lt = rendering.PVLookupTable() + # Assign it to the representation + rep.LookupTable = lt + # Color by point array called Pres + rep.ColorAttributeType = 0 # point data + rep.ColorArrayName = "Pres" + # Add to RGB points. These are tuples of 4 values. First one is + # the scalar values, the other 3 the RGB values. This list has + # 2 points: Pres: 0.00678, color: blue, Pres: 0.0288, color: red + lt.RGBPoints = [0.00678, 0, 0, 1, 0.0288, 1, 0, 0] + lt.ColorSpace = 1 # HSV + rv.StillRender() + return rv + +def demo3(): + """This method demonstrates the use of servermanager with numpy as + well as pylab for plotting. It creates an artificial data sources, + probes it with a line, delivers the result to the client using Fetch + and plots it using pylab. This demo requires numpy and pylab installed. + It returns a tuple of (data, render view).""" + import paraview.numpy_support + import pylab + + if not ActiveConnection: + Connect() + # Create a synthetic data source + source = sources.Wavelet() + # Let's get some information about the data. First, for the + # source to execute + source.UpdatePipeline() + + di = source.GetDataInformation() + print "Data type:", di.GetPrettyDataTypeString() + print "Extent:", di.GetExtent() + print "Array name:", \ + source[0].PointData[0].Name + + rv = CreateRenderView() + + rep1 = CreateRepresentation(source, rv) + rep1.Representation = 3 # outline + + # Let's apply a contour filter + cf = filters.Contour(Input=source, ContourValues=[200]) + + # Select the array to contour by + #cf.SelectInputScalars = 'RTData' + + rep2 = CreateRepresentation(cf, rv) + + rv.Background = (0.4, 0.4, 0.6) + # Reset the camera to include the whole thing + rv.StillRender() + rv.ResetCamera() + rv.StillRender() + + # Now, let's probe the data + probe = filters.ResampleWithDataset(Input=source) + # with a line + line = sources.Line(Resolution=60) + # that spans the dataset + bounds = di.GetBounds() + print "Bounds: ", bounds + line.Point1 = bounds[0:6:2] + line.Point2 = bounds[1:6:2] + + probe.Source = line + + # Render with the line + rep3 = CreateRepresentation(line, rv) + rv.StillRender() + + # Now deliver it to the client. Remember, this is for small data. + data = Fetch(probe) + # Convert it to a numpy array + data = paraview.numpy_support.vtk_to_numpy( + data.GetPointData().GetArray("RTData")) + # Plot it using matplotlib + pylab.plot(data) + pylab.show() + + return (data, rv, probe) + +def demo4(fname="/Users/berk/Work/ParaViewData/Data/can.ex2"): + """This method demonstrates the user of AnimateReader for + creating animations.""" + if not ActiveConnection: + Connect() + reader = sources.ExodusIIReader(FileName=fname) + view = CreateRenderView() + repr = CreateRepresentation(reader, view) + view.StillRender() + view.ResetCamera() + view.StillRender() + c = view.GetActiveCamera() + c.Elevation(95) + return AnimateReader(reader, view) + + +def demo5(): + """ Simple sphere animation""" + if not ActiveConnection: + Connect() + sphere = sources.Sphere() + view = CreateRenderView() + repr = CreateRepresentation(sphere, view) + + view.StillRender() + view.ResetCamera() + view.StillRender() + + # Create an animation scene + scene = animation.AnimationScene() + # Add 1 view + scene.ViewModules = [view] + + # Create a cue to animate the StartTheta property + cue = animation.KeyFrameAnimationCue() + cue.AnimatedProxy = sphere + cue.AnimatedPropertyName = "StartTheta" + # Add it to the scene's cues + scene.Cues = [cue] + + # Create 2 keyframes for the StartTheta track + keyf0 = animation.CompositeKeyFrame() + keyf0.Type = 2 # Set keyframe interpolation type to Ramp. + # At time = 0, value = 0 + keyf0.KeyTime = 0 + keyf0.KeyValues= [0] + + keyf1 = animation.CompositeKeyFrame() + # At time = 1.0, value = 200 + keyf1.KeyTime = 1.0 + keyf1.KeyValues= [200] + + # Add keyframes. + cue.KeyFrames = [keyf0, keyf1] + + scene.Play() + return scene + +ASSOCIATIONS = { 'POINTS' : 0, 'CELLS' : 1, 'VERTICES' : 4, 'EDGES' : 5, 'ROWS' : 6} + +# Users can set the active connection which will be used by API +# to create proxies etc when no connection argument is passed. +# Connect() automatically sets this if it is not already set. +ActiveConnection = None + +# Fields for multi-server support +MultiServerConnections = None + +# API for multi-server support +def enableMultiServer(multiServer=True): + """This method enable the current servermanager to support several + connections. Once we enable the multi-server support, the user can create + as many connection as he want and switch from one to another in order to + create and manage proxy.""" + global MultiServerConnections, ActiveConnection + if not multiServer and MultiServerConnections: + raise RuntimeError, "Once we enable Multi-Server support we can not get back" + MultiServerConnections = [] + if ActiveConnection: + MultiServerConnections.append(ActiveConnection) + +def switchActiveConnection(newActiveConnection=None): + """Switch active connection to be the provided one or if none just pick the + other one""" + global MultiServerConnections, ActiveConnection + if MultiServerConnections == None: + raise RuntimeError, "enableMultiServer() must be called before" + + # Manage the case when no connection is provided + if newActiveConnection: + ActiveConnection = newActiveConnection + __exposeActiveModules__() + # Update active session for ParaView + if vtkSMProxyManager.GetProxyManager().GetActiveSession() != ActiveConnection.Session: + vtkSMProxyManager.GetProxyManager().SetActiveSession(ActiveConnection.Session) + return ActiveConnection + else: + for connection in MultiServerConnections: + if connection != ActiveConnection: + ActiveConnection = connection + __exposeActiveModules__() + # Update active session for ParaView + if vtkSMProxyManager.GetProxyManager().GetActiveSession() != ActiveConnection.Session: + vtkSMProxyManager.GetProxyManager().SetActiveSession(ActiveConnection.Session) + return ActiveConnection + return None + +# Needs to be called when paraview module is loaded from python instead +# of pvpython, pvbatch or GUI. +if not vtkProcessModule.GetProcessModule(): +# pvoptions = None Not applicable for SALOME Python console +# if paraview.options.batch: +# pvoptions = vtkPVOptions(); +# pvoptions.SetProcessType(0x40) +# if paraview.options.symmetric: +# pvoptions.SetSymmetricMPIMode(True) + vtkInitializationHelper.Initialize(sys.executable, + vtkProcessModule.PROCESS_CLIENT, pvoptions) + +# Initialize progress printing. Can be turned off by calling +# ToggleProgressPrinting() again. +progressObserverTag = None +currentAlgorithm = False +currentProgress = 0 +fromGUI = False +ToggleProgressPrinting() + +_pyproxies = {} + +# Create needed sub-modules +# We can no longer create modules, unless we have connected to a server. +# _createModules() + +# Set up our custom importer (if possible) +loader = _ModuleLoader() +sys.meta_path.append(loader) + +def __InitAfterConnect__(connection): + """ + This function is called everytime after a server connection is made. + Since the ProxyManager and all proxy definitions are changed every time a + new connection is made, we re-create all the modules + """ + _createModules(connection.Modules) + ## VSV fromFilter is alwais False for SALOME because it can't be changed from ParaView code + #if not paraview.fromFilter: + # fromFilter is set when this module is imported from the programmable + # filter +# global _defUpdater +# _defUpdater = __DefinitionUpdater() + connection.AttachDefinitionUpdater() + pass + +def __exposeActiveModules__(): + """Update servermanager submodules to point to the current + ActiveConnection.Modules.*""" + # Expose all active module to the current servermanager module + if ActiveConnection: + for m in [mName for mName in dir(ActiveConnection.Modules) if mName[0] != '_' ]: + exec "global %s;%s = ActiveConnection.Modules.%s" % (m,m,m) + +# Definitions for working in SALOME GUI mode +#aParams = myParavis.GetConnectionParameters() +#ActiveConnection = Connect() +##Connection(aParams[0]) +#ActiveConnection.SetHost(aParams[1], aParams[2], aParams[3], aParams[4], aParams[5]) +#ToggleProgressPrinting() +#fromGUI = True + +InitFromGUI() + +if hasattr(sys, "ps1"): + # session is interactive. + print vtkSMProxyManager.GetParaViewSourceVersion(); + +def GetConnectionFromId(id): + for connection in MultiServerConnections: + if connection.ID == id: + return connection + return None + +def GetConnectionFromSession(session): + for connection in MultiServerConnections: + if connection.Session == session: + return connection + return None + +def GetConnectionAt(index): + return MultiServerConnections[index] + +def GetNumberOfConnections(): + return len(MultiServerConnections) + +#VTN: Problem during execution +#atexit.register(vtkPythonProgrammableFilter.DeleteGlobalPythonInterpretor) diff --git a/src/PV_SWIG/VTKWrapping/presentations.py b/src/PV_SWIG/VTKWrapping/presentations.py new file mode 100644 index 00000000..05b78de4 --- /dev/null +++ b/src/PV_SWIG/VTKWrapping/presentations.py @@ -0,0 +1,2647 @@ +# Copyright (C) 2010-2013 CEA/DEN, EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +""" +This module is intended to provide Python API for building presentations +typical for Post-Pro module (Scalar Map, Deformed Shape, Vectors, etc.) +""" + + +from __future__ import division +##from __future__ import print_function + +import os +import re +import warnings +from math import sqrt, sin, cos, radians +from string import upper + +import pvsimple as pv +#try: +# # TODO(MZN): to be removed (issue with Point Sprite texture) +# #import paravisSM as sm +#except: +# import paraview.simple as pv +# import paraview.servermanager as sm + + +# Constants +EPS = 1E-3 +FLT_MIN = 1E-37 +VTK_LARGE_FLOAT = 1E+38 +GAP_COEFFICIENT = 0.0001 + + +# Globals +_current_bar = None + + +# Enumerations +class PrsTypeEnum: + """ + Post-Pro presentation types. + """ + MESH = 0 + SCALARMAP = 1 + ISOSURFACES = 2 + CUTPLANES = 3 + CUTLINES = 4 + DEFORMEDSHAPE = 5 + DEFORMEDSHAPESCALARMAP = 6 + VECTORS = 7 + PLOT3D = 8 + STREAMLINES = 9 + GAUSSPOINTS = 10 + + _type2name = {MESH: 'Mesh', + SCALARMAP: 'Scalar Map', + ISOSURFACES: 'Iso Surfaces', + CUTPLANES: 'Cut Planes', + CUTLINES: 'Cut Lines', + DEFORMEDSHAPE: 'Deformed Shape', + DEFORMEDSHAPESCALARMAP: 'Deformed Shape And Scalar Map', + VECTORS: 'Vectors', + PLOT3D: 'Plot3D', + STREAMLINES: 'Stream Lines', + GAUSSPOINTS: 'Gauss Points'} + + @classmethod + def get_name(cls, type): + """Return presentaion name by its type.""" + return cls._type2name[type] + + +class EntityType: + """ + Entity types. + """ + NODE = 0 + CELL = 1 + + _type2name = {NODE: 'OnPoint', + CELL: 'OnCell'} + + _name2type = {'OnPoint': NODE, + 'OnCell': CELL} + + _type2pvtype = {NODE: 'POINT_DATA', + CELL: 'CELL_DATA'} + + @classmethod + def get_name(cls, type): + """Return entity name (used in full group names) by its type.""" + return cls._type2name[type] + + @classmethod + def get_type(cls, name): + """Return entity type by its name (used in full group names).""" + return cls._name2type[name] + + @classmethod + def get_pvtype(cls, type): + """Return entity type from ['CELL_DATA', 'POINT_DATA']""" + return cls._type2pvtype[type] + + +class Orientation: + """Orientation types. + + Defines a set of plane orientation possibilities: + AUTO: plane orientation should be calculated. + XY: plane formed by X and Y axis. + YZ: plane formed by Y and Z axis. + ZX: plane formed by Z and X axis + + """ + AUTO = 0 + XY = 1 + YZ = 2 + ZX = 3 + + +class GlyphPos: + """Glyph positions. + + Set of elements defining the position of the vector head: + CENTER: in the center of the vector + TAIL: in the tail of the vector + HEAD: in the head of the vector + + """ + CENTER = 0 + TAIL = 1 + HEAD = 2 + + +class GaussType: + """ + Gauss Points primitive types. + """ + SPRITE = 0 + POINT = 1 + SPHERE = 2 + + _type2mode = {SPRITE: 'Texture', + POINT: 'SimplePoint', + SPHERE: 'Sphere (Texture)'} + + @classmethod + def get_mode(cls, type): + """Return paraview point sprite mode by the primitive type.""" + return cls._type2mode[type] + + +# Auxiliary functions +def process_prs_for_test(prs, view, picture_name, show_bar=True): + """Show presentation and record snapshot image. + + Arguments: + prs: the presentation to show + view: the render view + picture_name: the full name of the graphics file to save + show_bar: to show scalar bar or not + + """ + # Show the presentation only + display_only(prs, view) + + # Show scalar bar + if show_bar and _current_bar: + _current_bar.Visibility = 1 + + # Reset the view + reset_view(view) + + # Create a directory for screenshot if necessary + file_name = re.sub("\s+", "_", picture_name) + pic_dir = os.path.dirname(picture_name) + if not os.path.exists(pic_dir): + os.makedirs(pic_dir) + + # Save picture + pv.WriteImage(file_name, view=view, Magnification=1) + + +def reset_view(view=None): + """Reset the view. + + Set predefined (taken from Post-Pro) camera settings. + If the view is not passed, the active view is used. + + """ + if not view: + view = pv.GetRenderView() + + # Camera preferences + view.CameraFocalPoint = [0.0, 0.0, 0.0] + view.CameraViewUp = [0.0, 0.0, 1.0] + view.CameraPosition = [738.946, -738.946, 738.946] + + # Turn on the headligth + view.LightSwitch = 1 + view.LightIntensity = 0.5 + + # Use parallel projection + view.CameraParallelProjection = 1 + + view.ResetCamera() + pv.Render(view=view) + + +def hide_all(view, to_remove=False): + """Hide all representations in the view.""" + if not view: + view = pv.GetRenderView() + + rep_list = view.Representations + for rep in rep_list: + if hasattr(rep, 'Visibility') and rep.Visibility != 0: + rep.Visibility = 0 + if to_remove: + view.Representations.remove(rep) + pv.Render(view=view) + + +def display_only(prs, view=None): + """Display only the given presentation in the view.""" + hide_all(view) + if (hasattr(prs, 'Visibility') and prs.Visibility != 1): + prs.Visibility = 1 + pv.Render(view=view) + + +def set_visible_lines(xy_prs, lines): + """Set visible only the given lines for XYChartRepresentation.""" + sv = xy_prs.GetProperty("SeriesVisibilityInfo").GetData() + visible = '0' + + for i in xrange(0, len(sv)): + if i % 2 == 0: + line_name = sv[i] + if line_name in lines: + visible = '1' + else: + visible = '0' + else: + sv[i] = visible + + xy_prs.SeriesVisibility = sv + + +def check_vector_mode(vector_mode, nb_components): + """Check vector mode. + + Check if vector mode is correct for the data array with the + given number of components. + + Arguments: + vector_mode: 'Magnitude', 'X', 'Y' or 'Z' + nb_components: number of component in the data array + + Raises: + ValueError: in case of the vector mode is unexistent + or nonapplicable. + + """ + if vector_mode not in ('Magnitude', 'X', 'Y', 'Z'): + raise ValueError("Unexistent vector mode: " + vector_mode) + + if ((nb_components == 1 and (vector_mode == 'Y' or vector_mode == 'Z')) or + (nb_components == 2 and vector_mode == 'Z')): + raise ValueError("Incorrect vector mode " + vector_mode + " for " + + nb_components + "-component field") + + +def get_vector_component(vector_mode): + """Get vector component as ineger. + + Translate vector component notation from string + to integer: + 'Magnitude': -1 + 'X': 0 + 'Y': 1 + 'Z': 2 + + """ + vcomponent = -1 + + if vector_mode == 'X': + vcomponent = 0 + elif vector_mode == 'Y': + vcomponent = 1 + elif vector_mode == 'Z': + vcomponent = 2 + + return vcomponent + + +def get_data_range(proxy, entity, field_name, vector_mode='Magnitude', + cut_off=False): + """Get data range for the field. + + Arguments: + proxy: the pipeline object, containig data array for the field + entity: the field entity + field_name: the field name + vector_mode: the vector mode ('Magnitude', 'X', 'Y' or 'Z') + + Returns: + Data range as [min, max] + + """ + entity_data_info = None + field_data = proxy.GetFieldDataInformation() + + if field_name in field_data.keys(): + entity_data_info = field_data + elif entity == EntityType.CELL: + entity_data_info = proxy.GetCellDataInformation() + elif entity == EntityType.NODE: + entity_data_info = proxy.GetPointDataInformation() + + data_range = [] + + if field_name in entity_data_info.keys(): + vcomp = get_vector_component(vector_mode) + data_range = entity_data_info[field_name].GetComponentRange(vcomp) + else: + pv_entity = EntityType.get_pvtype(entity) + warnings.warn("Field " + field_name + + " is unknown for " + pv_entity + "!") + + # Cut off the range + if cut_off and (data_range[0] <= data_range[1]): + data_range = list(data_range) + delta = abs(data_range[1] - data_range[0]) * GAP_COEFFICIENT + data_range[0] += delta + data_range[1] -= delta + + return data_range + + +def get_bounds(proxy): + """Get bounds of the proxy in 3D.""" + dataInfo = proxy.GetDataInformation() + bounds_info = dataInfo.GetBounds() + return bounds_info + + +def get_x_range(proxy): + """Get X range of the proxy bounds in 3D.""" + bounds_info = get_bounds(proxy) + return bounds_info[0:2] + + +def get_y_range(proxy): + """Get Y range of the proxy bounds in 3D.""" + bounds_info = get_bounds(proxy) + return bounds_info[2:4] + + +def get_z_range(proxy): + """Get Z range of the proxy bounds in 3D.""" + bounds_info = get_bounds(proxy) + return bounds_info[4:6] + + +def is_planar_input(proxy): + """Check if the given input is planar.""" + bounds_info = get_bounds(proxy) + + if (abs(bounds_info[0] - bounds_info[1]) <= FLT_MIN or + abs(bounds_info[2] - bounds_info[3]) <= FLT_MIN or + abs(bounds_info[4] - bounds_info[5]) <= FLT_MIN): + return True + + return False + + +def is_data_on_cells(proxy, field_name): + """Check the existence of a field on cells with the given name.""" + cell_data_info = proxy.GetCellDataInformation() + return (field_name in cell_data_info.keys()) + + +def is_empty(proxy): + """Check if the object contains any points or cells. + + Returns: + True: if the given proxy doesn't contain any points or cells + False: otherwise + + """ + data_info = proxy.GetDataInformation() + + nb_cells = data_info.GetNumberOfCells() + nb_points = data_info.GetNumberOfPoints() + + return not(nb_cells + nb_points) + + +def get_orientation(proxy): + """Get the optimum cutting plane orientation for Plot 3D.""" + orientation = Orientation.XY + + bounds = get_bounds(proxy) + delta = [bounds[1] - bounds[0], + bounds[3] - bounds[2], + bounds[5] - bounds[4]] + + if (delta[0] >= delta[1] and delta[0] >= delta[2]): + if (delta[1] >= delta[2]): + orientation = Orientation.XY + else: + orientation = Orientation.ZX + elif (delta[1] >= delta[0] and delta[1] >= delta[2]): + if (delta[0] >= delta[2]): + orientation = Orientation.XY + else: + orientation = Orientation.YZ + elif (delta[2] >= delta[0] and delta[2] >= delta[1]): + if (delta[0] >= delta[1]): + orientation = Orientation.ZX + else: + orientation = Orientation.YZ + + return orientation + + +def dot_product(a, b): + """Dot product of two 3-vectors.""" + dot = a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + return dot + + +def multiply3x3(a, b): + """Mutltiply one 3x3 matrix by another.""" + c = [[0, 0, 0], + [0, 0, 0], + [0, 0, 0]] + + for i in xrange(3): + c[0][i] = a[0][0] * b[0][i] + a[0][1] * b[1][i] + a[0][2] * b[2][i] + c[1][i] = a[1][0] * b[0][i] + a[1][1] * b[1][i] + a[1][2] * b[2][i] + c[2][i] = a[2][0] * b[0][i] + a[2][1] * b[1][i] + a[2][2] * b[2][i] + + return c + + +def get_rx(ang): + """Get X rotation matrix by angle.""" + rx = [[1.0, 0.0, 0.0], + [0.0, cos(ang), -sin(ang)], + [0.0, sin(ang), cos(ang)]] + + return rx + + +def get_ry(ang): + """Get Y rotation matrix by angle.""" + ry = [[cos(ang), 0.0, sin(ang)], + [0.0, 1.0, 0.0], + [-sin(ang), 0.0, cos(ang)]] + + return ry + + +def get_rz(ang): + """Get Z rotation matrix by angle.""" + rz = [[cos(ang), -sin(ang), 0.0], + [sin(ang), cos(ang), 0.0], + [0.0, 0.0, 1.0]] + + return rz + + +def get_normal_by_orientation(orientation, ang1=0, ang2=0): + """Get normal for the plane by its orientation.""" + i_plane = 0 + rotation = [[], [], []] + rx = ry = rz = [[1.0, 0.0, 0.0], + [0.0, 1.0, 0.0], + [0.0, 0.0, 1.0]] + + normal = [0.0, 0.0, 0.0] + if orientation == Orientation.XY: + if abs(ang1) > EPS: + rx = get_rx(ang1) + if abs(ang2) > EPS: + ry = get_ry(ang2) + rotation = multiply3x3(rx, ry) + i_plane = 2 + elif orientation == Orientation.ZX: + if abs(ang1) > EPS: + rz = get_rz(ang1) + if abs(ang2) > EPS: + rx = get_rx(ang2) + rotation = multiply3x3(rz, rx) + i_plane = 1 + elif orientation == Orientation.YZ: + if abs(ang1) > EPS: + ry = get_ry(ang1) + if abs(ang2) > EPS: + rz = get_rz(ang2) + rotation = multiply3x3(ry, rz) + i_plane = 0 + + for i in xrange(0, 3): + normal[i] = rotation[i][i_plane] + + return normal + + +def get_bound_project(bound_box, dir): + """Get bounds projection""" + bound_points = [[bound_box[0], bound_box[2], bound_box[4]], + [bound_box[1], bound_box[2], bound_box[4]], + [bound_box[0], bound_box[3], bound_box[4]], + [bound_box[1], bound_box[3], bound_box[4]], + [bound_box[0], bound_box[2], bound_box[5]], + [bound_box[1], bound_box[2], bound_box[5]], + [bound_box[0], bound_box[3], bound_box[5]], + [bound_box[1], bound_box[3], bound_box[5]]] + + bound_prj = [0, 0, 0] + bound_prj[0] = dot_product(dir, bound_points[0]) + bound_prj[1] = bound_prj[0] + + for i in xrange(1, 8): + tmp = dot_product(dir, bound_points[i]) + if bound_prj[1] < tmp: + bound_prj[1] = tmp + if bound_prj[0] > tmp: + bound_prj[0] = tmp + + bound_prj[2] = bound_prj[1] - bound_prj[0] + bound_prj[1] = bound_prj[0] + (1.0 - EPS) * bound_prj[2] + bound_prj[0] = bound_prj[0] + EPS * bound_prj[2] + bound_prj[2] = bound_prj[1] - bound_prj[0] + + return bound_prj + + +def get_positions(nb_planes, dir, bounds, displacement): + """Compute plane positions.""" + positions = [] + bound_prj = get_bound_project(bounds, dir) + if nb_planes > 1: + step = bound_prj[2] / (nb_planes - 1) + abs_displacement = step * displacement + start_pos = bound_prj[0] - 0.5 * step + abs_displacement + for i in xrange(nb_planes): + pos = start_pos + i * step + positions.append(pos) + else: + pos = bound_prj[0] + bound_prj[2] * displacement + positions.append(pos) + + return positions + + +def get_contours(scalar_range, nb_contours): + """Generate contour values.""" + contours = [] + for i in xrange(nb_contours): + pos = scalar_range[0] + i * ( + scalar_range[1] - scalar_range[0]) / (nb_contours - 1) + contours.append(pos) + + return contours + + +def get_nb_components(proxy, entity, field_name): + """Return number of components for the field.""" + entity_data_info = None + field_data = proxy.GetFieldDataInformation() + + if field_name in field_data.keys(): + entity_data_info = field_data + elif entity == EntityType.CELL: + entity_data_info = proxy.GetCellDataInformation() + elif entity == EntityType.NODE: + entity_data_info = proxy.GetPointDataInformation() + + nb_comp = None + if field_name in entity_data_info.keys(): + nb_comp = entity_data_info[field_name].GetNumberOfComponents() + else: + pv_entity = EntityType.get_pvtype(entity) + raise ValueError("Field " + field_name + + " is unknown for " + pv_entity + "!") + + return nb_comp + + +def get_scale_factor(proxy): + """Compute scale factor.""" + if not proxy: + return 0.0 + + proxy.UpdatePipeline() + data_info = proxy.GetDataInformation() + + nb_cells = data_info.GetNumberOfCells() + nb_points = data_info.GetNumberOfPoints() + nb_elements = nb_cells if nb_cells > 0 else nb_points + bounds = get_bounds(proxy) + + volume = 1 + vol = dim = 0 + + for i in xrange(0, 6, 2): + vol = abs(bounds[i + 1] - bounds[i]) + if vol > 0: + dim += 1 + volume *= vol + + if nb_elements == 0 or dim < 1 / VTK_LARGE_FLOAT: + return 0 + + volume /= nb_elements + + return pow(volume, 1 / dim) + + +def get_default_scale(prs_type, proxy, entity, field_name): + """Get default scale factor.""" + data_range = get_data_range(proxy, entity, field_name) + + if prs_type == PrsTypeEnum.DEFORMEDSHAPE: + EPS = 1.0 / VTK_LARGE_FLOAT + if abs(data_range[1]) > EPS: + scale_factor = get_scale_factor(proxy) + return scale_factor / data_range[1] + elif prs_type == PrsTypeEnum.PLOT3D: + bounds = get_bounds(proxy) + length = sqrt((bounds[1] - bounds[0]) ** 2 + + (bounds[3] - bounds[2]) ** 2 + + (bounds[5] - bounds[4]) ** 2) + + EPS = 0.3 + if data_range[1] > 0: + return length / data_range[1] * EPS + + return 0 + + +def get_calc_magnitude(proxy, array_entity, array_name): + """Compute magnitude for the given vector array via Calculator. + + Returns: + the calculator object. + + """ + calculator = None + + # Transform vector array to scalar array if possible + nb_components = get_nb_components(proxy, array_entity, array_name) + if (nb_components > 1): + calculator = pv.Calculator(proxy) + attribute_mode = "Point Data" + if array_entity != EntityType.NODE: + attribute_mode = "Cell Data" + calculator.AttributeMode = attribute_mode + if (nb_components == 2): + # Workaroud: calculator unable to compute magnitude + # if number of components equal to 2 + func = "sqrt(" + array_name + "_X^2+" + array_name + "_Y^2)" + calculator.Function = func + else: + calculator.Function = "mag(" + array_name + ")" + calculator.ResultArrayName = array_name + "_magnitude" + calculator.UpdatePipeline() + + return calculator + + +def get_add_component_calc(proxy, array_entity, array_name): + """Creates 3-component array from 2-component. + + The first two components is from the original array. The 3rd component + is zero. + If the number of components is not equal to 2 - return original array name. + + Returns: + the calculator object. + + """ + calculator = None + + nb_components = get_nb_components(proxy, array_entity, array_name) + if nb_components == 2: + calculator = pv.Calculator(proxy) + attribute_mode = "Point Data" + if array_entity != EntityType.NODE: + attribute_mode = "Cell Data" + calculator.AttributeMode = attribute_mode + expression = "iHat * " + array_name + "_X + jHat * " + array_name + "_Y + kHat * 0" + calculator.Function = expression + calculator.ResultArrayName = array_name + "_3c" + calculator.UpdatePipeline() + + return calculator + + +def select_all_cells(proxy): + """Select all cell types. + + Used in creation of mesh/submesh presentation. + + """ + ### Old API all_cell_types = proxy.CellTypes.Available + all_cell_types = proxy.Entity.Available + ### Old API proxy.CellTypes = all_cell_types + proxy.Entity = all_cell_types + proxy.UpdatePipeline() + + +def select_cells_with_data(proxy, on_points=None, on_cells=None): + """Select cell types with data. + + Only cell types with data for the given fields will be selected. + If no fields defined (neither on points nor on cells) only cell + types with data for even one field (from available) will be selected. + + """ + if not hasattr(proxy, 'Entity'): + return + + #all_cell_types = proxy.CellTypes.Available + all_cell_types = proxy.Entity.Available + all_arrays = list(proxy.CellArrays.GetData()) + all_arrays.extend(proxy.PointArrays.GetData()) + + if not all_arrays: + file_name = proxy.FileName.split(os.sep)[-1] + print "Warning: " + file_name + " doesn't contain any data array." + + # List of cell types to be selected + cell_types_on = [] + + for cell_type in all_cell_types: + #proxy.CellTypes = [cell_type] + proxy.Entity = [cell_type] + proxy.UpdatePipeline() + + cell_arrays = proxy.GetCellDataInformation().keys() + point_arrays = proxy.GetPointDataInformation().keys() + + if on_points or on_cells: + if on_points is None: + on_points = [] + if on_cells is None: + on_cells = [] + + if (all(array in cell_arrays for array in on_cells) and + all(array in point_arrays for array in on_points)): + # Add cell type to the list + cell_types_on.append(cell_type) + else: + in_arrays = lambda array: ((array in cell_arrays) or + (array in point_arrays)) + if any(in_arrays(array) for array in all_arrays): + cell_types_on.append(cell_type) + + # Select cell types + #proxy.CellTypes = cell_types_on + proxy.Entity = cell_types_on + proxy.UpdatePipeline() + + +def extract_groups_for_field(proxy, field_name, field_entity, force=False): + """Exctract only groups which have the field. + + Arguments: + proxy: the pipeline object, containig data + field_name: the field name + field_entity: the field entity + force: if True - ExtractGroup object will be created in any case + + Returns: + ExtractGroup object: if not all groups have the field or + the force argument is true + The initial proxy: if no groups had been filtered. + + """ + source = proxy + + # Remember the state + initial_groups = list(proxy.Groups) + + # Get data information for the field entity + entity_data_info = None + field_data = proxy.GetFieldDataInformation() + + if field_name in field_data.keys(): + entity_data_info = field_data + elif field_entity == EntityType.CELL: + entity_data_info = proxy.GetCellDataInformation() + elif field_entity == EntityType.NODE: + entity_data_info = proxy.GetPointDataInformation() + + # Collect groups for extraction + groups_to_extract = [] + + for group in initial_groups: + proxy.Groups = [group] + proxy.UpdatePipeline() + if field_name in entity_data_info.keys(): + groups_to_extract.append(group) + + # Restore state + proxy.Groups = initial_groups + proxy.UpdatePipeline() + + # Extract groups if necessary + if force or (len(groups_to_extract) < len(initial_groups)): + extract_group = pv.ExtractGroup(proxy) + extract_group.Groups = groups_to_extract + extract_group.UpdatePipeline() + source = extract_group + + return source + + +def if_possible(proxy, field_name, entity, prs_type): + """Check if the presentation creation is possible on the given field.""" + result = True + if (prs_type == PrsTypeEnum.DEFORMEDSHAPE or + prs_type == PrsTypeEnum.DEFORMEDSHAPESCALARMAP or + prs_type == PrsTypeEnum.VECTORS or + prs_type == PrsTypeEnum.STREAMLINES): + nb_comp = get_nb_components(proxy, entity, field_name) + result = (nb_comp > 1) + elif (prs_type == PrsTypeEnum.GAUSSPOINTS): + result = (entity == EntityType.CELL or + field_name in proxy.QuadraturePointArrays.Available) + elif (prs_type == PrsTypeEnum.MESH): + result = len(get_group_names(proxy, field_name, entity)) > 0 + + return result + + +def add_scalar_bar(field_name, nb_components, + vector_mode, lookup_table, time_value): + """Add scalar bar with predefined properties.""" + global _current_bar + + # Construct bar title + title = "\n".join([field_name, str(time_value)]) + if nb_components > 1: + title = "\n".join([title, vector_mode]) + + # Create scalar bar + scalar_bar = pv.CreateScalarBar(Enabled=1) + scalar_bar.Orientation = 'Vertical' + scalar_bar.Title = title + scalar_bar.LookupTable = lookup_table + + # Set default properties same as in Post-Pro + scalar_bar.NumberOfLabels = 5 + scalar_bar.AutomaticLabelFormat = 0 + scalar_bar.LabelFormat = '%-#6.6g' + # Title + scalar_bar.TitleFontFamily = 'Arial' + scalar_bar.TitleFontSize = 8 + scalar_bar.TitleBold = 1 + scalar_bar.TitleItalic = 1 + scalar_bar.TitleShadow = 1 + # Labels + scalar_bar.LabelFontFamily = 'Arial' + scalar_bar.LabelFontSize = 8 + scalar_bar.LabelBold = 1 + scalar_bar.LabelItalic = 1 + scalar_bar.LabelShadow = 1 + + # Add the scalar bar to the view + pv.GetRenderView().Representations.append(scalar_bar) + + # Reassign the current bar + _current_bar = scalar_bar + + return scalar_bar + + +def get_bar(): + """Get current scalar bar.""" + global _current_bar + + return _current_bar + + +def get_lookup_table(field_name, nb_components, vector_mode='Magnitude'): + """Get lookup table for the given field.""" + lookup_table = pv.GetLookupTableForArray(field_name, nb_components) + + if vector_mode == 'Magnitude': + lookup_table.VectorMode = vector_mode + elif vector_mode == 'X': + lookup_table.VectorMode = 'Component' + lookup_table.VectorComponent = 0 + elif vector_mode == 'Y': + lookup_table.VectorMode = 'Component' + lookup_table.VectorComponent = 1 + elif vector_mode == 'Z': + lookup_table.VectorMode = 'Component' + lookup_table.VectorComponent = 2 + else: + raise ValueError("Incorrect vector mode: " + vector_mode) + + lookup_table.Discretize = 0 + lookup_table.ColorSpace = 'HSV' + lookup_table.LockScalarRange = 0 + + return lookup_table + + +def get_group_mesh_name(full_group_name): + """Return mesh name of the group by its full name.""" + aList = full_group_name.split('/') + if len(aList) >= 2 : + group_name = full_group_name.split('/')[1] + return group_name + + +def get_group_entity(full_group_name): + """Return entity type of the group by its full name.""" + aList = full_group_name.split('/') + if len(aList) >= 3 : + entity_name = full_group_name.split('/')[2] + entity = EntityType.get_type(entity_name) + return entity + + +def get_group_short_name(full_group_name): + """Return short name of the group by its full name.""" + aList = full_group_name.split('/') + if len(aList) >= 4 : + short_name = full_group_name.split('/')[3] + return short_name + + +def get_mesh_names(proxy): + """Return all mesh names in the given proxy as a set.""" + groups = proxy.Groups.Available + mesh_names = set([get_group_mesh_name(item) for item in groups]) + + return mesh_names + + +def get_group_names(proxy, mesh_name, entity, wo_nogroups=False): + """Return full names of all groups of the given entity type + from the mesh with the given name as a list. + """ + groups = proxy.Groups.Available + + condition = lambda item: (get_group_mesh_name(item) == mesh_name and + get_group_entity(item) == entity) + group_names = [item for item in groups if condition(item)] + + if wo_nogroups: + # Remove "No_Group" group + not_no_group = lambda item: get_group_short_name(item) != "No_Group" + group_names = filter(not_no_group, group_names) + + return group_names + + +def get_time(proxy, timestamp_nb): + """Get time value by timestamp number.""" + # Check timestamp number + timestamps = [] + + if (hasattr(proxy, 'TimestepValues')): + timestamps = proxy.TimestepValues.GetData() + elif (hasattr(proxy.Input, 'TimestepValues')): + timestamps = proxy.Input.TimestepValues.GetData() + + if ((timestamp_nb - 1) not in xrange(len(timestamps))): + raise ValueError("Timestamp number is out of range: " + str(timestamp_nb)) + + # Return time value + return timestamps[timestamp_nb - 1] + + +def create_prs(prs_type, proxy, field_entity, field_name, timestamp_nb): + """Auxiliary function. + + Build presentation of the given type on the given field and + timestamp number. + Set the presentation properties like visu.CreatePrsForResult() do. + + """ + prs = None + + if prs_type == PrsTypeEnum.SCALARMAP: + prs = ScalarMapOnField(proxy, field_entity, field_name, timestamp_nb) + elif prs_type == PrsTypeEnum.CUTPLANES: + prs = CutPlanesOnField(proxy, field_entity, field_name, timestamp_nb, + orientation=Orientation.ZX) + elif prs_type == PrsTypeEnum.CUTLINES: + prs = CutLinesOnField(proxy, field_entity, field_name, timestamp_nb, + orientation1=Orientation.XY, + orientation2=Orientation.ZX) + elif prs_type == PrsTypeEnum.DEFORMEDSHAPE: + prs = DeformedShapeOnField(proxy, field_entity, + field_name, timestamp_nb) + elif prs_type == PrsTypeEnum.DEFORMEDSHAPESCALARMAP: + prs = DeformedShapeAndScalarMapOnField(proxy, field_entity, + field_name, timestamp_nb) + elif prs_type == PrsTypeEnum.VECTORS: + prs = VectorsOnField(proxy, field_entity, field_name, timestamp_nb) + elif prs_type == PrsTypeEnum.PLOT3D: + prs = Plot3DOnField(proxy, field_entity, field_name, timestamp_nb) + elif prs_type == PrsTypeEnum.ISOSURFACES: + prs = IsoSurfacesOnField(proxy, field_entity, field_name, timestamp_nb) + elif prs_type == PrsTypeEnum.GAUSSPOINTS: + prs = GaussPointsOnField(proxy, field_entity, field_name, timestamp_nb) + elif prs_type == PrsTypeEnum.STREAMLINES: + prs = StreamLinesOnField(proxy, field_entity, field_name, timestamp_nb) + else: + raise ValueError("Unexistent presentation type.") + + return prs + + +# Functions for building Post-Pro presentations +def ScalarMapOnField(proxy, entity, field_name, timestamp_nb, + vector_mode='Magnitude'): + """Creates Scalar Map presentation on the given field. + + Arguments: + proxy: the pipeline object, containig data + entity: the entity type from PrsTypeEnum + field_name: the field name + timestamp_nb: the number of time step (1, 2, ...) + vector_mode: the mode of transformation of vector values + into scalar values, applicable only if the field contains vector values. + Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. + + Returns: + Scalar Map as representation object. + + """ + # We don't need mesh parts with no data on them + if entity == EntityType.NODE: + select_cells_with_data(proxy, on_points=[field_name]) + else: + select_cells_with_data(proxy, on_cells=[field_name]) + + # Check vector mode + nb_components = get_nb_components(proxy, entity, field_name) + check_vector_mode(vector_mode, nb_components) + + # Get time value + time_value = get_time(proxy, timestamp_nb) + + # Set timestamp + pv.GetRenderView().ViewTime = time_value + pv.UpdatePipeline(time_value, proxy) + + # Extract only groups with data for the field + new_proxy = extract_groups_for_field(proxy, field_name, entity, + force=True) + + # Get Scalar Map representation object + scalarmap = pv.GetRepresentation(new_proxy) + + # Get lookup table + lookup_table = get_lookup_table(field_name, nb_components, vector_mode) + + # Set field range if necessary + data_range = get_data_range(proxy, entity, + field_name, vector_mode) + lookup_table.LockScalarRange = 1 + lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] + # Set properties + scalarmap.ColorAttributeType = EntityType.get_pvtype(entity) + scalarmap.ColorArrayName = field_name + scalarmap.LookupTable = lookup_table + + # Add scalar bar + bar_title = field_name + ", " + str(time_value) + if (nb_components > 1): + bar_title += "\n" + vector_mode + add_scalar_bar(field_name, nb_components, vector_mode, + lookup_table, time_value) + + return scalarmap + + +def CutPlanesOnField(proxy, entity, field_name, timestamp_nb, + nb_planes=10, orientation=Orientation.YZ, + angle1=0, angle2=0, + displacement=0.5, vector_mode='Magnitude'): + """Creates Cut Planes presentation on the given field. + + Arguments: + proxy: the pipeline object, containig data + entity: the entity type from PrsTypeEnum + field_name: the field name + timestamp_nb: the number of time step (1, 2, ...) + nb_planes: number of cutting planes + orientation: cutting planes orientation in 3D space + angle1: rotation of the planes in 3d space around the first axis of the + selected orientation (X axis for XY, Y axis for YZ, Z axis for ZX). + The angle of rotation is set in degrees. Acceptable range: [-45, 45]. + angle2: rotation of the planes in 3d space around the second axis of the + selected orientation. Acceptable range: [-45, 45]. + displacement: the displacement of the planes into one or another side + vector_mode: the mode of transformation of vector values + into scalar values, applicable only if the field contains vector values. + Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. + + Returns: + Cut Planes as representation object. + + """ + # Check vector mode + nb_components = get_nb_components(proxy, entity, field_name) + check_vector_mode(vector_mode, nb_components) + + # Get time value + time_value = get_time(proxy, timestamp_nb) + + # Set timestamp + pv.GetRenderView().ViewTime = time_value + pv.UpdatePipeline(time_value, proxy) + + # Create slice filter + slice_filter = pv.Slice(proxy) + slice_filter.SliceType = "Plane" + + # Set cut planes normal + normal = get_normal_by_orientation(orientation, + radians(angle1), radians(angle2)) + slice_filter.SliceType.Normal = normal + + # Set cut planes positions + positions = get_positions(nb_planes, normal, + get_bounds(proxy), displacement) + slice_filter.SliceOffsetValues = positions + + # Get Cut Planes representation object + cut_planes = pv.GetRepresentation(slice_filter) + + # Get lookup table + lookup_table = get_lookup_table(field_name, nb_components, vector_mode) + + # Set field range if necessary + data_range = get_data_range(proxy, entity, + field_name, vector_mode) + lookup_table.LockScalarRange = 1 + lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] + + # Set properties + cut_planes.ColorAttributeType = EntityType.get_pvtype(entity) + cut_planes.ColorArrayName = field_name + cut_planes.LookupTable = lookup_table + + # Add scalar bar + add_scalar_bar(field_name, nb_components, + vector_mode, lookup_table, time_value) + + return cut_planes + + +def CutLinesOnField(proxy, entity, field_name, timestamp_nb, + nb_lines=10, + orientation1=Orientation.XY, + base_angle1=0, base_angle2=0, + orientation2=Orientation.YZ, + cut_angle1=0, cut_angle2=0, + displacement1=0.5, displacement2=0.5, + generate_curves=False, + vector_mode='Magnitude'): + """Creates Cut Lines presentation on the given field. + + Arguments: + proxy: the pipeline object, containig data + entity: the entity type from PrsTypeEnum + field_name: the field name + timestamp_nb: the number of time step (1, 2, ...) + nb_lines: number of lines + orientation1: base plane orientation in 3D space + base_angle1: rotation of the base plane in 3d space around the first + axis of the orientation1 (X axis for XY, Y axis for YZ, Z axis for ZX). + The angle of rotation is set in degrees. Acceptable range: [-45, 45]. + base_angle2: rotation of the base plane in 3d space around the second + axis of the orientation1. Acceptable range: [-45, 45]. + orientation2: cutting planes orientation in 3D space + cut_angle1: rotation of the cut planes in 3d space around the first + axis of the orientation2. Acceptable range: [-45, 45]. + cut_angle2: rotation of the cuting planes in 3d space around the second + axis of the orientation2. Acceptable range: [-45, 45]. + displacement1: base plane displacement + displacement2: cutting planes displacement + generate_curves: if true, 'PlotOverLine' filter will be created + for each cut line + vector_mode: the mode of transformation of vector values + into scalar values, applicable only if the field contains vector values. + Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. + + Returns: + Cut Lines as representation object if generate_curves == False, + (Cut Lines as representation object, list of 'PlotOverLine') otherwise + + """ + # Check vector mode + nb_components = get_nb_components(proxy, entity, field_name) + check_vector_mode(vector_mode, nb_components) + + # Get time value + time_value = get_time(proxy, timestamp_nb) + + # Set timestamp + pv.GetRenderView().ViewTime = time_value + pv.UpdatePipeline(time_value, proxy) + + # Create base plane + base_plane = pv.Slice(proxy) + base_plane.SliceType = "Plane" + + # Set base plane normal + base_normal = get_normal_by_orientation(orientation1, + radians(base_angle1), + radians(base_angle2)) + base_plane.SliceType.Normal = base_normal + + # Set base plane position + base_position = get_positions(1, base_normal, + get_bounds(proxy), displacement1) + base_plane.SliceOffsetValues = base_position + + # Check base plane + base_plane.UpdatePipeline() + if (base_plane.GetDataInformation().GetNumberOfCells() == 0): + base_plane = proxy + + # Create cutting planes + cut_planes = pv.Slice(base_plane) + cut_planes.SliceType = "Plane" + + # Set cutting planes normal and get positions + cut_normal = get_normal_by_orientation(orientation2, + radians(cut_angle1), + radians(cut_angle2)) + cut_planes.SliceType.Normal = cut_normal + + # Set cutting planes position + cut_positions = get_positions(nb_lines, cut_normal, + get_bounds(base_plane), displacement2) + + # Generate curves + curves = [] + if generate_curves: + index = 0 + for pos in cut_positions: + # Get points for plot over line objects + cut_planes.SliceOffsetValues = pos + cut_planes.UpdatePipeline() + bounds = get_bounds(cut_planes) + point1 = [bounds[0], bounds[2], bounds[4]] + point2 = [bounds[1], bounds[3], bounds[5]] + + # Create plot over line filter + pol = pv.PlotOverLine(cut_planes, + Source="High Resolution Line Source") + pv.RenameSource('Y' + str(index), pol) + pol.Source.Point1 = point1 + pol.Source.Point2 = point2 + pol.UpdatePipeline() + curves.append(pol) + + index += 1 + + cut_planes.SliceOffsetValues = cut_positions + cut_planes.UpdatePipeline() + + # Get Cut Lines representation object + cut_lines = pv.GetRepresentation(cut_planes) + + # Get lookup table + lookup_table = get_lookup_table(field_name, nb_components, vector_mode) + + # Set field range if necessary + data_range = get_data_range(proxy, entity, + field_name, vector_mode) + lookup_table.LockScalarRange = 1 + lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] + + # Set properties + cut_lines.ColorAttributeType = EntityType.get_pvtype(entity) + cut_lines.ColorArrayName = field_name + cut_lines.LookupTable = lookup_table + + # Set wireframe represenatation mode + cut_lines.Representation = 'Wireframe' + + # Add scalar bar + add_scalar_bar(field_name, nb_components, + vector_mode, lookup_table, time_value) + + result = cut_lines + # If curves were generated return tuple (cut lines, list of curves) + if curves: + result = cut_lines, curves + + return result + + +def CutSegmentOnField(proxy, entity, field_name, timestamp_nb, + point1, point2, vector_mode='Magnitude'): + """Creates Cut Segment presentation on the given field. + + Arguments: + proxy: the pipeline object, containig data + entity: the entity type from PrsTypeEnum + field_name: the field name + timestamp_nb: the number of time step (1, 2, ...) + point1: set the first point of the segment (as [x, y, z]) + point1: set the second point of the segment (as [x, y, z]) + vector_mode: the mode of transformation of vector values + into scalar values, applicable only if the field contains vector values. + Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. + + Returns: + Cut Segment as 3D representation object. + + """ + # Check vector mode + nb_components = get_nb_components(proxy, entity, field_name) + check_vector_mode(vector_mode, nb_components) + + # Get time value + time_value = get_time(proxy, timestamp_nb) + + # Set timestamp + pv.GetRenderView().ViewTime = time_value + pv.UpdatePipeline(time_value, proxy) + + # Create plot over line filter + pol = pv.PlotOverLine(proxy, Source="High Resolution Line Source") + pol.Source.Point1 = point1 + pol.Source.Point2 = point2 + pol.UpdatePipeline() + + # Get Cut Segment representation object + cut_segment = pv.GetRepresentation(pol) + + # Get lookup table + lookup_table = get_lookup_table(field_name, nb_components, vector_mode) + + # Set field range if necessary + data_range = get_data_range(proxy, entity, + field_name, vector_mode) + lookup_table.LockScalarRange = 1 + lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] + + # Set properties + cut_segment.ColorAttributeType = EntityType.get_pvtype(entity) + cut_segment.ColorArrayName = field_name + cut_segment.LookupTable = lookup_table + + # Set wireframe represenatation mode + cut_segment.Representation = 'Wireframe' + + # Add scalar bar + add_scalar_bar(field_name, nb_components, + vector_mode, lookup_table, time_value) + + return cut_segment + + +def VectorsOnField(proxy, entity, field_name, timestamp_nb, + scale_factor=None, + glyph_pos=GlyphPos.TAIL, glyph_type='2D Glyph', + is_colored=False, vector_mode='Magnitude'): + """Creates Vectors presentation on the given field. + + Arguments: + proxy: the pipeline object, containig data + entity: the entity type from PrsTypeEnum + field_name: the field name + timestamp_nb: the number of time step (1, 2, ...) + scale_factor: scale factor + glyph_pos: the position of glyphs + glyph_type: the type of glyphs + is_colored: this option allows to color the presentation according to + the corresponding data array values + vector_mode: the mode of transformation of vector values + into scalar values, applicable only if the field contains vector values. + Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. + + Returns: + Vectors as representation object. + + """ + # Check vector mode + nb_components = get_nb_components(proxy, entity, field_name) + check_vector_mode(vector_mode, nb_components) + + # Get time value + time_value = get_time(proxy, timestamp_nb) + + # Set timestamp + pv.GetRenderView().ViewTime = time_value + pv.UpdatePipeline(time_value, proxy) + + # Extract only groups with data for the field + new_proxy = extract_groups_for_field(proxy, field_name, entity) + source = new_proxy + + # Cell centers + if is_data_on_cells(proxy, field_name): + cell_centers = pv.CellCenters(source) + cell_centers.VertexCells = 1 + source = cell_centers + + vector_array = field_name + # If the given vector array has only 2 components, add the third one + if nb_components == 2: + calc = get_add_component_calc(source, EntityType.NODE, field_name) + vector_array = calc.ResultArrayName + source = calc + + # Glyph + glyph = pv.Glyph(source) + glyph.Vectors = vector_array + glyph.ScaleMode = 'vector' + glyph.MaskPoints = 0 + + # Set glyph type + glyph.GlyphType = glyph_type + if glyph_type == '2D Glyph': + glyph.GlyphType.GlyphType = 'Arrow' + elif glyph_type == 'Cone': + glyph.GlyphType.Resolution = 7 + glyph.GlyphType.Height = 2 + glyph.GlyphType.Radius = 0.2 + + # Set glyph position if possible + if glyph.GlyphType.GetProperty("Center"): + if (glyph_pos == GlyphPos.TAIL): + glyph.GlyphType.Center = [0.5, 0.0, 0.0] + elif (glyph_pos == GlyphPos.HEAD): + glyph.GlyphType.Center = [-0.5, 0.0, 0.0] + elif (glyph_pos == GlyphPos.CENTER): + glyph.GlyphType.Center = [0.0, 0.0, 0.0] + + if scale_factor is not None: + glyph.SetScaleFactor = scale_factor + else: + def_scale = get_default_scale(PrsTypeEnum.DEFORMEDSHAPE, + new_proxy, entity, field_name) + glyph.SetScaleFactor = def_scale + + glyph.UpdatePipeline() + + # Get Vectors representation object + vectors = pv.GetRepresentation(glyph) + + # Get lookup table + lookup_table = get_lookup_table(field_name, nb_components, vector_mode) + + # Set field range if necessary + data_range = get_data_range(proxy, entity, + field_name, vector_mode) + lookup_table.LockScalarRange = 1 + lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] + + # Set properties + if (is_colored): + vectors.ColorArrayName = 'GlyphVector' + else: + vectors.ColorArrayName = '' + vectors.LookupTable = lookup_table + + vectors.LineWidth = 1.0 + + # Set wireframe represenatation mode + vectors.Representation = 'Wireframe' + + # Add scalar bar + add_scalar_bar(field_name, nb_components, + vector_mode, lookup_table, time_value) + + return vectors + + +def DeformedShapeOnField(proxy, entity, field_name, + timestamp_nb, + scale_factor=None, is_colored=False, + vector_mode='Magnitude'): + """Creates Defromed Shape presentation on the given field. + + Arguments: + proxy: the pipeline object, containig data + entity: the entity type from PrsTypeEnum + field_name: the field name + timestamp_nb: the number of time step (1, 2, ...) + scale_factor: scale factor of the deformation + is_colored: this option allows to color the presentation according to + the corresponding data array values + vector_mode: the mode of transformation of vector values + into scalar values, applicable only if the field contains vector values. + Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. + + Returns: + Defromed Shape as representation object. + + """ + # We don't need mesh parts with no data on them + if entity == EntityType.NODE: + select_cells_with_data(proxy, on_points=[field_name]) + else: + select_cells_with_data(proxy, on_cells=[field_name]) + + # Check vector mode + nb_components = get_nb_components(proxy, entity, field_name) + check_vector_mode(vector_mode, nb_components) + + # Get time value + time_value = get_time(proxy, timestamp_nb) + + # Set timestamp + pv.GetRenderView().ViewTime = time_value + pv.UpdatePipeline(time_value, proxy) + + # Extract only groups with data for the field + new_proxy = extract_groups_for_field(proxy, field_name, entity) + + # Do merge + source = pv.MergeBlocks(new_proxy) + + # Cell data to point data + if is_data_on_cells(proxy, field_name): + cell_to_point = pv.CellDatatoPointData() + cell_to_point.PassCellData = 1 + source = cell_to_point + + vector_array = field_name + # If the given vector array has only 2 components, add the third one + if nb_components == 2: + calc = get_add_component_calc(source, EntityType.NODE, field_name) + vector_array = calc.ResultArrayName + source = calc + + # Warp by vector + warp_vector = pv.WarpByVector(source) + warp_vector.Vectors = [vector_array] + if scale_factor is not None: + warp_vector.ScaleFactor = scale_factor + else: + def_scale = get_default_scale(PrsTypeEnum.DEFORMEDSHAPE, + proxy, entity, field_name) + warp_vector.ScaleFactor = def_scale + + # Get Deformed Shape representation object + defshape = pv.GetRepresentation(warp_vector) + + # Get lookup table + lookup_table = get_lookup_table(field_name, nb_components, vector_mode) + + # Set field range if necessary + data_range = get_data_range(proxy, entity, + field_name, vector_mode) + lookup_table.LockScalarRange = 1 + lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] + + # Set properties + if is_colored: + defshape.ColorAttributeType = EntityType.get_pvtype(entity) + defshape.ColorArrayName = field_name + else: + defshape.ColorArrayName = '' + defshape.LookupTable = lookup_table + + # Set wireframe represenatation mode + defshape.Representation = 'Wireframe' + + # Add scalar bar + add_scalar_bar(field_name, nb_components, + vector_mode, lookup_table, time_value) + + return defshape + + +def DeformedShapeAndScalarMapOnField(proxy, entity, field_name, + timestamp_nb, + scale_factor=None, + scalar_entity=None, + scalar_field_name=None, + vector_mode='Magnitude'): + """Creates Defromed Shape And Scalar Map presentation on the given field. + + Arguments: + proxy: the pipeline object, containig data + entity: the entity type from PrsTypeEnum + field_name: the field name + timestamp_nb: the number of time step (1, 2, ...) + scale_factor: scale factor of the deformation + scalar_entity: scalar field entity + scalar_field_name: scalar field, i.e. the field for coloring + vector_mode: the mode of transformation of vector values + into scalar values, applicable only if the field contains vector values. + Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. + + Returns: + Defromed Shape And Scalar Map as representation object. + + """ + # We don't need mesh parts with no data on them + on_points = [] + on_cells = [] + + if entity == EntityType.NODE: + on_points.append(field_name) + else: + on_cells.append(field_name) + + if scalar_entity and scalar_field_name: + if scalar_entity == EntityType.NODE: + on_points.append(scalar_field_name) + else: + on_cells.append(scalar_field_name) + + select_cells_with_data(proxy, on_points, on_cells) + + # Check vector mode + nb_components = get_nb_components(proxy, entity, field_name) + check_vector_mode(vector_mode, nb_components) + + # Get time value + time_value = get_time(proxy, timestamp_nb) + + # Set timestamp + pv.GetRenderView().ViewTime = time_value + pv.UpdatePipeline(time_value, proxy) + + # Set scalar field by default + scalar_field_entity = scalar_entity + scalar_field = scalar_field_name + if (scalar_field_entity is None) or (scalar_field is None): + scalar_field_entity = entity + scalar_field = field_name + + # Extract only groups with data for the field + new_proxy = extract_groups_for_field(proxy, field_name, entity) + + # Do merge + source = pv.MergeBlocks(new_proxy) + + # Cell data to point data + if is_data_on_cells(proxy, field_name): + cell_to_point = pv.CellDatatoPointData(source) + cell_to_point.PassCellData = 1 + source = cell_to_point + + vector_array = field_name + # If the given vector array has only 2 components, add the third one + if nb_components == 2: + calc = get_add_component_calc(source, EntityType.NODE, field_name) + vector_array = calc.ResultArrayName + source = calc + + # Warp by vector + warp_vector = pv.WarpByVector(source) + warp_vector.Vectors = [vector_array] + if scale_factor is not None: + warp_vector.ScaleFactor = scale_factor + else: + def_scale = get_default_scale(PrsTypeEnum.DEFORMEDSHAPE, + new_proxy, entity, field_name) + warp_vector.ScaleFactor = def_scale + + # Get Defromed Shape And Scalar Map representation object + defshapemap = pv.GetRepresentation(warp_vector) + + # Get lookup table + lookup_table = get_lookup_table(scalar_field, nb_components, vector_mode) + + # Set field range if necessary + data_range = get_data_range(proxy, scalar_field_entity, + scalar_field, vector_mode) + lookup_table.LockScalarRange = 1 + lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] + + # Set properties + defshapemap.ColorArrayName = scalar_field + defshapemap.LookupTable = lookup_table + defshapemap.ColorAttributeType = EntityType.get_pvtype(scalar_field_entity) + + # Add scalar bar + add_scalar_bar(field_name, nb_components, + vector_mode, lookup_table, time_value) + + return defshapemap + + +def Plot3DOnField(proxy, entity, field_name, timestamp_nb, + orientation=Orientation.AUTO, + angle1=0, angle2=0, + position=0.5, is_relative=True, + scale_factor=None, + is_contour=False, nb_contours=32, + vector_mode='Magnitude'): + """Creates Plot 3D presentation on the given field. + + Arguments: + proxy: the pipeline object, containig data + entity: the entity type from PrsTypeEnum + field_name: the field name + timestamp_nb: the number of time step (1, 2, ...) + orientation: the cut plane plane orientation in 3D space, if + the input is planar - will not be taken into account + angle1: rotation of the cut plane in 3d space around the first axis + of the selected orientation (X axis for XY, Y axis for YZ, + Z axis for ZX). + The angle of rotation is set in degrees. Acceptable range: [-45, 45]. + angle2: rotation of the cut plane in 3d space around the second axis + of the selected orientation. Acceptable range: [-45, 45]. + position: position of the cut plane in the object (ranging from 0 to 1). + The value 0.5 corresponds to cutting by halves. + is_relative: defines if the cut plane position is relative or absolute + scale_factor: deformation scale factor + is_contour: if True - Plot 3D will be represented with a set of contours, + otherwise - Plot 3D will be represented with a smooth surface + nb_contours: number of contours, applied if is_contour is True + vector_mode: the mode of transformation of vector values + into scalar values, applicable only if the field contains vector values. + Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. + + Returns: + Plot 3D as representation object. + + """ + # We don't need mesh parts with no data on them + if entity == EntityType.NODE: + select_cells_with_data(proxy, on_points=[field_name]) + else: + select_cells_with_data(proxy, on_cells=[field_name]) + + # Check vector mode + nb_components = get_nb_components(proxy, entity, field_name) + check_vector_mode(vector_mode, nb_components) + + # Get time value + time_value = get_time(proxy, timestamp_nb) + + # Set timestamp + pv.GetRenderView().ViewTime = time_value + pv.UpdatePipeline(time_value, proxy) + + # Extract only groups with data for the field + new_proxy = extract_groups_for_field(proxy, field_name, entity) + + # Do merge + merge_blocks = pv.MergeBlocks(new_proxy) + merge_blocks.UpdatePipeline() + + poly_data = None + + # Cutting plane + + # Define orientation if necessary (auto mode) + plane_orientation = orientation + if (orientation == Orientation.AUTO): + plane_orientation = get_orientation(proxy) + + # Get cutting plane normal + normal = None + + if (not is_planar_input(proxy)): + normal = get_normal_by_orientation(plane_orientation, + radians(angle1), radians(angle2)) + + # Create slice filter + slice_filter = pv.Slice(merge_blocks) + slice_filter.SliceType = "Plane" + + # Set cutting plane normal + slice_filter.SliceType.Normal = normal + + # Set cutting plane position + if (is_relative): + base_position = get_positions(1, normal, + get_bounds(proxy), position) + slice_filter.SliceOffsetValues = base_position + else: + slice_filter.SliceOffsetValues = position + + slice_filter.UpdatePipeline() + poly_data = slice_filter + else: + normal = get_normal_by_orientation(plane_orientation, 0, 0) + + use_normal = 0 + # Geometry filter + if not poly_data or poly_data.GetDataInformation().GetNumberOfCells() == 0: + geometry_filter = pv.GeometryFilter(merge_blocks) + poly_data = geometry_filter + use_normal = 1 # TODO(MZN): workaround + + warp_scalar = None + plot3d = None + source = poly_data + + if is_data_on_cells(poly_data, field_name): + # Cell data to point data + cell_to_point = pv.CellDatatoPointData(poly_data) + cell_to_point.PassCellData = 1 + source = cell_to_point + + scalars = ['POINTS', field_name] + + # Transform vector array to scalar array if necessary + if (nb_components > 1): + calc = get_calc_magnitude(source, EntityType.NODE, field_name) + scalars = ['POINTS', calc.ResultArrayName] + source = calc + + # Warp by scalar + warp_scalar = pv.WarpByScalar(source) + warp_scalar.Scalars = scalars + warp_scalar.Normal = normal + warp_scalar.UseNormal = use_normal + if scale_factor is not None: + warp_scalar.ScaleFactor = scale_factor + else: + def_scale = get_default_scale(PrsTypeEnum.PLOT3D, + proxy, entity, field_name) + warp_scalar.ScaleFactor = def_scale + + warp_scalar.UpdatePipeline() + source = warp_scalar + + if (is_contour): + # Contours + contour = pv.Contour(warp_scalar) + contour.PointMergeMethod = "Uniform Binning" + contour.ContourBy = ['POINTS', field_name] + scalar_range = get_data_range(proxy, entity, + field_name, vector_mode) + contour.Isosurfaces = get_contours(scalar_range, nb_contours) + contour.UpdatePipeline() + source = contour + + # Get Plot 3D representation object + plot3d = pv.GetRepresentation(source) + + # Get lookup table + lookup_table = get_lookup_table(field_name, nb_components, vector_mode) + + # Set field range if necessary + data_range = get_data_range(proxy, entity, + field_name, vector_mode) + lookup_table.LockScalarRange = 1 + lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] + + # Set properties + plot3d.ColorAttributeType = EntityType.get_pvtype(entity) + plot3d.ColorArrayName = field_name + plot3d.LookupTable = lookup_table + + # Add scalar bar + add_scalar_bar(field_name, nb_components, + vector_mode, lookup_table, time_value) + + return plot3d + + +def IsoSurfacesOnField(proxy, entity, field_name, timestamp_nb, + custom_range=None, nb_surfaces=10, + is_colored=True, color=None, vector_mode='Magnitude'): + """Creates Iso Surfaces presentation on the given field. + + Arguments: + proxy: the pipeline object, containig data + entity: the entity type from PrsTypeEnum + field_name: the field name + timestamp_nb: the number of time step (1, 2, ...) + custom_range: scalar range, if undefined the source range will be applied + nb_surfaces: number of surfaces, which will be generated + is_colored: this option allows to color the presentation according to + the corresponding data array values. If False - the presentation will + be one-coloured. + color: defines the presentation color as [R, G, B] triple. Taken into + account only if is_colored is False. + vector_mode: the mode of transformation of vector values + into scalar values, applicable only if the field contains vector values. + Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. + + Returns: + Iso Surfaces as representation object. + + """ + # We don't need mesh parts with no data on them + if entity == EntityType.NODE: + select_cells_with_data(proxy, on_points=[field_name]) + else: + select_cells_with_data(proxy, on_cells=[field_name]) + + # Check vector mode + nb_components = get_nb_components(proxy, entity, field_name) + check_vector_mode(vector_mode, nb_components) + + # Get time value + time_value = get_time(proxy, timestamp_nb) + + # Set timestamp + pv.GetRenderView().ViewTime = time_value + pv.UpdatePipeline(time_value, proxy) + + # Extract only groups with data for the field + new_proxy = extract_groups_for_field(proxy, field_name, entity) + + # Do merge + source = pv.MergeBlocks(new_proxy) + + # Transform cell data into point data if necessary + if is_data_on_cells(proxy, field_name): + cell_to_point = pv.CellDatatoPointData(source) + cell_to_point.PassCellData = 1 + source = cell_to_point + + contour_by = ['POINTS', field_name] + + # Transform vector array to scalar array if necessary + if (nb_components > 1): + calc = get_calc_magnitude(source, EntityType.NODE, field_name) + contour_by = ['POINTS', calc.ResultArrayName] + source = calc + + # Contour filter settings + contour = pv.Contour(source) + contour.ComputeScalars = 1 + contour.ContourBy = contour_by + + # Specify the range + scalar_range = custom_range + if (scalar_range is None): + scalar_range = get_data_range(proxy, entity, + field_name, cut_off=True) + + # Get contour values for the range + surfaces = get_contours(scalar_range, nb_surfaces) + + # Set contour values + contour.Isosurfaces = surfaces + + # Get Iso Surfaces representation object + isosurfaces = pv.GetRepresentation(contour) + + # Get lookup table + lookup_table = get_lookup_table(field_name, nb_components, vector_mode) + + # Set field range if necessary + data_range = get_data_range(proxy, entity, + field_name, vector_mode) + lookup_table.LockScalarRange = 1 + lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] + + # Set display properties + if (is_colored): + isosurfaces.ColorAttributeType = EntityType.get_pvtype(entity) + isosurfaces.ColorArrayName = field_name + else: + isosurfaces.ColorArrayName = '' + if color: + isosurfaces.DiffuseColor = color + isosurfaces.LookupTable = lookup_table + + # Add scalar bar + add_scalar_bar(field_name, nb_components, + vector_mode, lookup_table, time_value) + + return isosurfaces + + +def GaussPointsOnField(proxy, entity, field_name, + timestamp_nb, + is_deformed=True, scale_factor=None, + is_colored=True, color=None, + primitive=GaussType.SPRITE, + is_proportional=True, + max_pixel_size=256, + multiplier=None, vector_mode='Magnitude'): + """Creates Gauss Points on the given field. + + Arguments: + + proxy: the pipeline object, containig data + entity: the field entity type from PrsTypeEnum + field_name: the field name + timestamp_nb: the number of time step (1, 2, ...) + is_deformed: defines whether the Gauss Points will be deformed or not + scale_factor -- the scale factor for deformation. Will be taken into + account only if is_deformed is True. + If not passed by user, default scale will be computed. + is_colored -- defines whether the Gauss Points will be multicolored, + using the corresponding data values + color: defines the presentation color as [R, G, B] triple. Taken into + account only if is_colored is False. + primitive: primitive type from GaussType + is_proportional: if True, the size of primitives will depends on + the gauss point value + max_pixel_size: the maximum sizr of the Gauss Points primitive in pixels + multiplier: coefficient between data values and the size of primitives + If not passed by user, default scale will be computed. + vector_mode: the mode of transformation of vector values into + scalar values, applicable only if the field contains vector values. + Possible modes: 'Magnitude' - vector module; + 'X', 'Y', 'Z' - vector components. + + Returns: + Gauss Points as representation object. + + """ + # We don't need mesh parts with no data on them + if entity == EntityType.NODE: + select_cells_with_data(proxy, on_points=[field_name]) + else: + select_cells_with_data(proxy, on_cells=[field_name]) + + # Check vector mode + nb_components = get_nb_components(proxy, entity, field_name) + check_vector_mode(vector_mode, nb_components) + + # Get time value + time_value = get_time(proxy, timestamp_nb) + + # Set timestamp + pv.GetRenderView().ViewTime = time_value + proxy.UpdatePipeline(time=time_value) + + # Extract only groups with data for the field + source = extract_groups_for_field(proxy, field_name, entity) + + # Quadrature point arrays + qp_arrays = proxy.QuadraturePointArrays.Available + + # If no quadrature point array is passed, use cell centers + if field_name in qp_arrays: + generate_qp = pv.GenerateQuadraturePoints(source) + generate_qp.SelectSourceArray = ['CELLS', 'ELGA_Offset'] + source = generate_qp + else: + # Cell centers + cell_centers = pv.CellCenters(source) + cell_centers.VertexCells = 1 + source = cell_centers + + source.UpdatePipeline() + + # Check if deformation enabled + if is_deformed and nb_components > 1: + vector_array = field_name + # If the given vector array has only 2 components, add the third one + if nb_components == 2: + calc = get_add_component_calc(source, + EntityType.NODE, field_name) + vector_array = calc.ResultArrayName + source = calc + + # Warp by vector + warp_vector = pv.WarpByVector(source) + warp_vector.Vectors = [vector_array] + if scale_factor is not None: + warp_vector.ScaleFactor = scale_factor + else: + def_scale = get_default_scale(PrsTypeEnum.DEFORMEDSHAPE, proxy, + entity, field_name) + warp_vector.ScaleFactor = def_scale + warp_vector.UpdatePipeline() + source = warp_vector + + # Get Gauss Points representation object + gausspnt = pv.GetRepresentation(source) + + # Get lookup table + lookup_table = get_lookup_table(field_name, nb_components, vector_mode) + + # Set field range if necessary + data_range = get_data_range(proxy, entity, + field_name, vector_mode) + lookup_table.LockScalarRange = 1 + lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] + + # Set display properties + if is_colored: + gausspnt.ColorAttributeType = EntityType.get_pvtype(entity) + gausspnt.ColorArrayName = field_name + else: + gausspnt.ColorArrayName = '' + if color: + gausspnt.DiffuseColor = color + + gausspnt.LookupTable = lookup_table + + # Add scalar bar + add_scalar_bar(field_name, nb_components, + vector_mode, lookup_table, time_value) + + # Set point sprite representation + gausspnt.Representation = 'Point Sprite' + + # Point sprite settings + gausspnt.InterpolateScalarsBeforeMapping = 0 + gausspnt.MaxPixelSize = max_pixel_size + + # Render mode + gausspnt.RenderMode = GaussType.get_mode(primitive) + + #if primitive == GaussType.SPRITE: + # Set texture + # TODO(MZN): replace with pvsimple high-level interface + # texture = sm.CreateProxy("textures", "SpriteTexture") + # alphamprop = texture.GetProperty("AlphaMethod") + # alphamprop.SetElement(0, 2) # Clamp + # alphatprop = texture.GetProperty("AlphaThreshold") + # alphatprop.SetElement(0, 63) + # maxprop = texture.GetProperty("Maximum") + # maxprop.SetElement(0, 255) + # texture.UpdateVTKObjects() + + # gausspnt.Texture = texture + #gausspnt.Texture.AlphaMethod = 'Clamp' + #gausspnt.Texture.AlphaThreshold = 63 + #gausspnt.Texture.Maximum= 255 + + # Proportional radius + gausspnt.RadiusUseScalarRange = 0 + gausspnt.RadiusIsProportional = 0 + + if is_proportional: + mult = multiplier + if mult is None: + mult = abs(0.1 / data_range[1]) + + gausspnt.RadiusScalarRange = data_range + gausspnt.RadiusTransferFunctionEnabled = 1 + gausspnt.RadiusMode = 'Scalar' + gausspnt.RadiusArray = ['POINTS', field_name] + if nb_components > 1: + v_comp = get_vector_component(vector_mode) + gausspnt.RadiusVectorComponent = v_comp + gausspnt.RadiusTransferFunctionMode = 'Table' + gausspnt.RadiusScalarRange = data_range + gausspnt.RadiusUseScalarRange = 1 + gausspnt.RadiusIsProportional = 1 + gausspnt.RadiusProportionalFactor = mult + else: + gausspnt.RadiusTransferFunctionEnabled = 0 + gausspnt.RadiusMode = 'Constant' + gausspnt.RadiusArray = ['POINTS', 'Constant Radius'] + + return gausspnt + +def GaussPointsOnField1(proxy, entity, field_name, + timestamp_nb, + is_colored=True, color=None, + primitive=GaussType.SPHERE, + is_proportional=True, + max_pixel_size=256, + multiplier=None, + vector_mode='Magnitude'): + """Creates Gauss Points on the given field. Use GaussPoints() Paraview interface. + + Arguments: + proxy: the pipeline object, containig data + entity: the field entity type from PrsTypeEnum + field_name: the field name + timestamp_nb: the number of time step (1, 2, ...) + is_colored -- defines whether the Gauss Points will be multicolored, + using the corresponding data values + color: defines the presentation color as [R, G, B] triple. Taken into + account only if is_colored is False. + primitive: primitive type from GaussType + is_proportional: if True, the size of primitives will depends on + the gauss point value + max_pixel_size: the maximum sizr of the Gauss Points primitive in pixels + multiplier: coefficient between data values and the size of primitives + If not passed by user, default scale will be computed. + vector_mode: the mode of transformation of vector values into + scalar values, applicable only if the field contains vector values. + Possible modes: 'Magnitude' - vector module; + 'X', 'Y', 'Z' - vector components. + + Returns: + Gauss Points as representation object. + + """ + # Get time value + time_value = get_time(proxy, timestamp_nb) + + # Set timestamp + pv.GetRenderView().ViewTime = time_value + proxy.UpdatePipeline(time=time_value) + + # Create Gauss Points object + source = pv.GaussPoints(proxy) + source.UpdatePipeline() + + # Get Gauss Points representation object + gausspnt = pv.GetRepresentation(source) + + # Get lookup table + entity_data_info = None + point_data_info = source.GetPointDataInformation() + if field_name in point_data_info.keys(): + entity_data_info = point_data_info + else: + entity_data_info = source.GetCellDataInformation() + nb_components = entity_data_info[field_name].GetNumberOfComponents() + + lookup_table = get_lookup_table(field_name, nb_components, vector_mode) + + # Set field range if necessary + data_range = get_data_range(proxy, entity, + field_name, vector_mode) + lookup_table.LockScalarRange = 1 + lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] + + # Set display properties + if is_colored: + gausspnt.ColorAttributeType = EntityType.get_pvtype(entity) + gausspnt.ColorArrayName = field_name + else: + gausspnt.ColorArrayName = '' + if color: + gausspnt.DiffuseColor = color + + gausspnt.LookupTable = lookup_table + + # Add scalar bar + add_scalar_bar(field_name, nb_components, + vector_mode, lookup_table, time_value) + + # Set point sprite representation + gausspnt.Representation = 'Point Sprite' + + # Point sprite settings + gausspnt.InterpolateScalarsBeforeMapping = 0 + gausspnt.MaxPixelSize = max_pixel_size + + # Render mode + gausspnt.RenderMode = GaussType.get_mode(primitive) + + #if primitive == GaussType.SPRITE: + # Set texture + # TODO(MZN): replace with pvsimple high-level interface + # texture = sm.CreateProxy("textures", "SpriteTexture") + # alphamprop = texture.GetProperty("AlphaMethod") + # alphamprop.SetElement(0, 2) # Clamp + # alphatprop = texture.GetProperty("AlphaThreshold") + # alphatprop.SetElement(0, 63) + # maxprop = texture.GetProperty("Maximum") + # maxprop.SetElement(0, 255) + # texture.UpdateVTKObjects() + + # gausspnt.Texture = texture + #gausspnt.Texture.AlphaMethod = 'Clamp' + #gausspnt.Texture.AlphaThreshold = 63 + #gausspnt.Texture.Maximum= 255 + + # Proportional radius + gausspnt.RadiusUseScalarRange = 0 + gausspnt.RadiusIsProportional = 0 + + if is_proportional: + mult = multiplier + if mult is None: + mult = abs(0.1 / data_range[1]) + + gausspnt.RadiusScalarRange = data_range + gausspnt.RadiusTransferFunctionEnabled = 1 + gausspnt.RadiusMode = 'Scalar' + gausspnt.RadiusArray = ['POINTS', field_name] + if nb_components > 1: + v_comp = get_vector_component(vector_mode) + gausspnt.RadiusVectorComponent = v_comp + gausspnt.RadiusTransferFunctionMode = 'Table' + gausspnt.RadiusScalarRange = data_range + gausspnt.RadiusUseScalarRange = 1 + gausspnt.RadiusIsProportional = 1 + gausspnt.RadiusProportionalFactor = mult + else: + gausspnt.RadiusTransferFunctionEnabled = 0 + gausspnt.RadiusMode = 'Constant' + gausspnt.RadiusArray = ['POINTS', 'Constant Radius'] + + return gausspnt + +def StreamLinesOnField(proxy, entity, field_name, timestamp_nb, + direction='BOTH', is_colored=False, color=None, + vector_mode='Magnitude'): + """Creates Stream Lines presentation on the given field. + + Arguments: + proxy: the pipeline object, containig data + entity: the entity type from PrsTypeEnum + field_name: the field name + timestamp_nb: the number of time step (1, 2, ...) + direction: the stream lines direction ('FORWARD', 'BACKWARD' or 'BOTH') + is_colored: this option allows to color the presentation according to + the corresponding data values. If False - the presentation will + be one-coloured. + color: defines the presentation color as [R, G, B] triple. Taken into + account only if is_colored is False. + vector_mode: the mode of transformation of vector values + into scalar values, applicable only if the field contains vector values. + Possible modes: 'Magnitude', 'X', 'Y' or 'Z'. + + Returns: + Stream Lines as representation object. + + """ + # We don't need mesh parts with no data on them + if entity == EntityType.NODE: + select_cells_with_data(proxy, on_points=[field_name]) + else: + select_cells_with_data(proxy, on_cells=[field_name]) + + # Check vector mode + nb_components = get_nb_components(proxy, entity, field_name) + check_vector_mode(vector_mode, nb_components) + + # Get time value + time_value = get_time(proxy, timestamp_nb) + + # Set timestamp + pv.GetRenderView().ViewTime = time_value + pv.UpdatePipeline(time_value, proxy) + + # Extract only groups with data for the field + new_proxy = extract_groups_for_field(proxy, field_name, entity) + + # Do merge + source = pv.MergeBlocks(new_proxy) + + # Cell data to point data + if is_data_on_cells(proxy, field_name): + cell_to_point = pv.CellDatatoPointData(source) + cell_to_point.PassCellData = 1 + cell_to_point.UpdatePipeline() + source = cell_to_point + + vector_array = field_name + # If the given vector array has only 2 components, add the third one + if nb_components == 2: + calc = get_add_component_calc(source, EntityType.NODE, field_name) + vector_array = calc.ResultArrayName + calc.UpdatePipeline() + source = calc + + # Stream Tracer + stream = pv.StreamTracer(source) + stream.SeedType = "Point Source" + stream.Vectors = ['POINTS', vector_array] + stream.SeedType = "Point Source" + stream.IntegrationDirection = direction + stream.IntegratorType = 'Runge-Kutta 2' + stream.UpdatePipeline() + + # Get Stream Lines representation object + if is_empty(stream): + return None + streamlines = pv.GetRepresentation(stream) + + # Get lookup table + lookup_table = get_lookup_table(field_name, nb_components, vector_mode) + + # Set field range if necessary + data_range = get_data_range(new_proxy, entity, + field_name, vector_mode) + lookup_table.LockScalarRange = 1 + lookup_table.RGBPoints = [data_range[0], 0, 0, 1, data_range[1], 1, 0, 0] + + # Set properties + if is_colored: + streamlines.ColorAttributeType = EntityType.get_pvtype(entity) + streamlines.ColorArrayName = field_name + else: + streamlines.ColorArrayName = '' + if color: + streamlines.DiffuseColor = color + + streamlines.LookupTable = lookup_table + + # Add scalar bar + add_scalar_bar(field_name, nb_components, + vector_mode, lookup_table, time_value) + + return streamlines + + +def MeshOnEntity(proxy, mesh_name, entity): + """Creates submesh of the entity type for the mesh. + + Arguments: + proxy -- the pipeline object, containig data + mesh_name -- the mesh name + entity -- the entity type + + Returns: + Submesh as representation object of the given source. + + """ + # Select all cell types + select_all_cells(proxy) + + # Get subset of groups on the given entity + subset = get_group_names(proxy, mesh_name, entity) + + # Select only groups of the given entity type + proxy.Groups = subset + proxy.UpdatePipeline() + + # Get representation object if the submesh is not empty + prs = None + if (proxy.GetDataInformation().GetNumberOfPoints() or + proxy.GetDataInformation().GetNumberOfCells()): + prs = pv.GetRepresentation(proxy) + prs.ColorArrayName = '' + + return prs + + +def MeshOnGroup(proxy, group_name): + """Creates submesh on the group. + + Arguments: + proxy -- the pipeline object, containig data + group_name -- the full group name + + Returns: + Representation object of the given source with single group + selected. + + """ + # Select all cell types + select_all_cells(proxy) + + # Select only the group with the given name + one_group = [group_name] + proxy.Groups = one_group + proxy.UpdatePipeline() + + # Get representation object if the submesh is not empty + prs = None + + # Check if the group was set + if proxy.Groups.GetData() == one_group: + group_entity = get_group_entity(group_name) + # Check if the submesh is not empty + nb_items = 0 + if group_entity == EntityType.NODE: + nb_items = proxy.GetDataInformation().GetNumberOfPoints() + elif group_entity == EntityType.CELL: + nb_items = proxy.GetDataInformation().GetNumberOfCells() + + if nb_items: + prs = pv.GetRepresentation(proxy) + prs.ColorArrayName = '' + + return prs + + +def CreatePrsForFile(paravis_instance, file_name, prs_types, + picture_dir, picture_ext): + """Build presentations of the given types for the file. + + Build presentations for all fields on all timestamps. + + Arguments: + paravis_instance: ParaVis module instance object + file_name: full path to the MED file + prs_types: the list of presentation types to build + picture_dir: the directory path for saving snapshots + picture_ext: graphics files extension (determines file type) + + """ + # Import MED file + print "Import " + file_name.split(os.sep)[-1] + "..." + + try: + paravis_instance.ImportFile(file_name) + proxy = pv.GetActiveSource() + if proxy is None: + print "FAILED" + else: + proxy.UpdatePipeline() + print "OK" + except: + print "FAILED" + else: + # Get view + view = pv.GetRenderView() + + # Create required presentations for the proxy + CreatePrsForProxy(proxy, view, prs_types, + picture_dir, picture_ext) + + +def CreatePrsForProxy(proxy, view, prs_types, picture_dir, picture_ext): + """Build presentations of the given types for all fields of the proxy. + + Save snapshots in graphics files (type depends on the given extension). + Stores the files in the given directory. + + Arguments: + proxy: the pipeline object, containig data + view: the render view + prs_types: the list of presentation types to build + picture_dir: the directory path for saving snapshots + picture_ext: graphics files extension (determines file type) + + """ + # List of the field names + field_names = list(proxy.PointArrays.GetData()) + nb_on_nodes = len(field_names) + field_names.extend(proxy.CellArrays.GetData()) + + # Add path separator to the end of picture path if necessery + if not picture_dir.endswith(os.sep): + picture_dir += os.sep + + # Mesh Presentation + if PrsTypeEnum.MESH in prs_types: + # Create Mesh presentation. Build all possible submeshes. + + # Remember the current state + groups = list(proxy.Groups) + + # Iterate on meshes + mesh_names = get_mesh_names(proxy) + for mesh_name in mesh_names: + # Build mesh on nodes and cells + for entity in (EntityType.NODE, EntityType.CELL): + entity_name = EntityType.get_name(entity) + if if_possible(proxy, mesh_name, entity, PrsTypeEnum.MESH): + print "Creating submesh on " + entity_name + " for '" + mesh_name + "' mesh... " + prs = MeshOnEntity(proxy, mesh_name, entity) + if prs is None: + print "FAILED" + continue + else: + print "OK" + # Construct image file name + pic_name = picture_dir + mesh_name + "_" + entity_name + "." + picture_ext + + # Show and dump the presentation into a graphics file + process_prs_for_test(prs, view, pic_name, False) + + # Build submesh on all groups of the mesh + mesh_groups = get_group_names(proxy, mesh_name, + entity, wo_nogroups=True) + for group in mesh_groups: + print "Creating submesh on group " + group + "... " + prs = MeshOnGroup(proxy, group) + if prs is None: + print "FAILED" + continue + else: + print "OK" + # Construct image file name + pic_name = picture_dir + group.replace('/', '_') + "." + picture_ext + + # Show and dump the presentation into a graphics file + process_prs_for_test(prs, view, pic_name, False) + + # Restore the state + proxy.Groups = groups + proxy.UpdatePipeline() + + # Presentations on fields + for (i, field_name) in enumerate(field_names): + # Select only the current field: + # necessary for getting the right timestamps + cell_arrays = proxy.CellArrays.GetData() + point_arrays = proxy.PointArrays.GetData() + field_entity = None + if (i >= nb_on_nodes): + field_entity = EntityType.CELL + proxy.PointArrays.DeselectAll() + proxy.CellArrays = [field_name] + else: + field_entity = EntityType.NODE + proxy.CellArrays.DeselectAll() + proxy.PointArrays = [field_name] + + # Get timestamps + proxy.UpdatePipelineInformation() + timestamps = proxy.TimestepValues.GetData() + + # Restore fields selection state + proxy.CellArrays = cell_arrays + proxy.PointArrays = point_arrays + proxy.UpdatePipelineInformation() + + for prs_type in prs_types: + # Ignore mesh presentation + if prs_type == PrsTypeEnum.MESH: + continue + + # Get name of presentation type + prs_name = PrsTypeEnum.get_name(prs_type) + + # Build the presentation if possible + possible = if_possible(proxy, field_name, + field_entity, prs_type) + if possible: + # Presentation type for graphics file name + f_prs_type = prs_name.replace(' ', '').upper() + + for timestamp_nb in xrange(1, len(timestamps) + 1): + time = timestamps[timestamp_nb - 1] + print "Creating " + prs_name + " on " + field_name + ", time = " + str(time) + "... " + prs = create_prs(prs_type, proxy, + field_entity, field_name, timestamp_nb) + if prs is None: + print "FAILED" + continue + else: + print "OK" + + # Construct image file name + pic_name = picture_dir + field_name + "_" + str(time) + "_" + f_prs_type + "." + picture_ext + + # Show and dump the presentation into a graphics file + process_prs_for_test(prs, view, pic_name) diff --git a/src/PV_SWIG/VTKWrapping/pvsimple.py b/src/PV_SWIG/VTKWrapping/pvsimple.py new file mode 100644 index 00000000..6a77e5f2 --- /dev/null +++ b/src/PV_SWIG/VTKWrapping/pvsimple.py @@ -0,0 +1,1171 @@ +# Copyright (C) 2010-2013 CEA/DEN, EDF R&D +# +# This library is free software; you can redistribute it and/or +# modify it under the terms of the GNU Lesser General Public +# License as published by the Free Software Foundation; either +# version 2.1 of the License. +# +# This library is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY; without even the implied warranty of +# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +# Lesser General Public License for more details. +# +# You should have received a copy of the GNU Lesser General Public +# License along with this library; if not, write to the Free Software +# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +# +# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +# + +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() +""" + +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()) + xml_name = paraview.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() diff --git a/src/PV_SWIG/VTKWrapping/servermanager.diff b/src/PV_SWIG/VTKWrapping/servermanager.diff new file mode 100644 index 00000000..5280bd3d --- /dev/null +++ b/src/PV_SWIG/VTKWrapping/servermanager.diff @@ -0,0 +1,305 @@ +0a1,19 +> # Copyright (C) 2010-2013 CEA/DEN, EDF R&D +> # +> # This library is free software; you can redistribute it and/or +> # modify it under the terms of the GNU Lesser General Public +> # License as published by the Free Software Foundation; either +> # version 2.1 of the License. +> # +> # This library is distributed in the hope that it will be useful, +> # but WITHOUT ANY WARRANTY; without even the implied warranty of +> # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +> # Lesser General Public License for more details. +> # +> # You should have received a copy of the GNU Lesser General Public +> # License along with this library; if not, write to the Free Software +> # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +> # +> # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +> # +> +29,43d47 +< #============================================================================== +< # +< # Program: ParaView +< # Module: servermanager.py +< # +< # Copyright (c) Kitware, Inc. +< # All rights reserved. +< # See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details. +< # +< # This software is distributed WITHOUT ANY WARRANTY without even +< # the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +< # PURPOSE. See the above copyright notice for more information. +< # +< #============================================================================== +< import paraview, re, os, os.path, new, sys, vtk +45,53c49,54 +< if not paraview.compatibility.minor: +< paraview.compatibility.major = 3 +< if not paraview.compatibility.major: +< paraview.compatibility.minor = 5 +< +< from vtkPVClientServerCorePython import * +< from vtkPVServerImplementationPython import * +< from vtkPVServerManagerPython import * +< from vtkPVCommonPython import * +--- +> +> +> import re, os, new, sys +> from paravis import * +> +> +61,62c62 +< if paraview.compatibility.GetVersion() >= 3.5 and \ +< smproperty.IsA("vtkSMStringVectorProperty"): +--- +> if smproperty.IsA("vtkSMStringVectorProperty"): +251,252c251,253 +< return self.SMProxy == other.SMProxy +< return self.SMProxy == other +--- +> ## VSV using IsSame instead == +> return self.SMProxy.IsSame(other.SMProxy) +> return self.SMProxy.IsSame(other) +347,350c348,351 +< if not c.HasObserver("ModifiedEvent"): +< self.ObserverTag =c.AddObserver("ModifiedEvent", \ +< _makeUpdateCameraMethod(weakref.ref(self))) +< self.Observed = c +--- +> # VSV: Observers are not supported +> ## if not c.HasObserver("ModifiedEvent"): +> ## self.ObserverTag =c.AddObserver("ModifiedEvent", _makeUpdateCameraMethod(weakref.ref(self))) +> ## self.Observed = c +454,472c455,472 +< if paraview.compatibility.GetVersion() >= 3.5: +< def FileNameChanged(self): +< "Called when the filename changes. Selects all variables." +< SourceProxy.FileNameChanged(self) +< self.SelectAllVariables() +< +< def SelectAllVariables(self): +< "Select all available variables for reading." +< for prop in ('PointVariables', 'EdgeVariables', 'FaceVariables', +< 'ElementVariables', 'GlobalVariables'): +< f = getattr(self, prop) +< f.SelectAll() +< +< def DeselectAllVariables(self): +< "Deselects all variables." +< for prop in ('PointVariables', 'EdgeVariables', 'FaceVariables', +< 'ElementVariables', 'GlobalVariables'): +< f = getattr(self, prop) +< f.DeselectAll() +--- +> def FileNameChanged(self): +> "Called when the filename changes. Selects all variables." +> SourceProxy.FileNameChanged(self) +> self.SelectAllVariables() +> +> def SelectAllVariables(self): +> "Select all available variables for reading." +> for prop in ('PointVariables', 'EdgeVariables', 'FaceVariables', +> 'ElementVariables', 'GlobalVariables'): +> f = getattr(self, prop) +> f.SelectAll() +> +> def DeselectAllVariables(self): +> "Deselects all variables." +> for prop in ('PointVariables', 'EdgeVariables', 'FaceVariables', +> 'ElementVariables', 'GlobalVariables'): +> f = getattr(self, prop) +> f.DeselectAll() +1110c1110,1111 +< if proxy == px: +--- +> ## VSV: == +> if proxy.IsSame(px): +1329,1332d1329 +< if paraview.compatibility.GetVersion() <= 3.4: +< def Range(self, component=0): +< return self.GetRange(component) +< +1526c1523 +< aProxy = self.SMProxyManager.NewProxy(group, name) +--- +> aProxy = self.SMProxyManager.NewProxy(group, name, "NULL") +1838a1836 +> # VTN: Observers are not supported +1840c1838 +< self.DefinitionObserverTag = self.Session.GetProxyDefinitionManager().AddObserver(2000, _update_definitions) +--- +> ## self.DefinitionObserverTag = self.Session.GetProxyDefinitionManager().AddObserver(2000, _update_definitions) +1842c1840 +< self.CustomDefinitionObserverTag = self.Session.GetProxyDefinitionManager().AddObserver(2001, _update_definitions) +--- +> ## self.CustomDefinitionObserverTag = self.Session.GetProxyDefinitionManager().AddObserver(2001, _update_definitions) +2056c2054,2055 +< try: isRep = rep.Input == aProxy +--- +> #VSV: == +> try: isRep = rep.Input.IsSame(aProxy) +2287,2303c2286,2287 +< """Turn on/off printing of progress (by default, it is on). You can +< always turn progress off and add your own observer to the process +< module to handle progress in a custom way. See _printProgress for +< an example event observer.""" +< global progressObserverTag +< +< # If value is true and progress printing is currently off... +< if value and not GetProgressPrintingIsEnabled(): +< if fromGUI: +< raise RuntimeError("Printing progress in the GUI is not supported.") +< progressObserverTag = vtkProcessModule.GetProcessModule().AddObserver(\ +< "ProgressEvent", _printProgress) +< +< # If value is false and progress printing is currently on... +< elif GetProgressPrintingIsEnabled(): +< vtkProcessModule.GetProcessModule().RemoveObserver(progressObserverTag) +< progressObserverTag = None +--- +> """Is not supported because of not supported observers""" +> pass +2330,2332c2314,2315 +< if paraview.compatibility.GetVersion() >= 3.5: +< if smproxy.GetXMLLabel(): +< xmlName = smproxy.GetXMLLabel() +--- +> if smproxy.GetXMLLabel(): +> xmlName = smproxy.GetXMLLabel() +2375,2378c2358 +< if paraview.compatibility.GetVersion() >= 3.5: +< return self.GetPropertyValue(propName) +< else: +< return self.GetProperty(propName) +--- +> return self.GetPropertyValue(propName) +2494c2474,2482 +< return paraview.make_name_valid(name) +--- +> """Make a string into a valid Python variable name.""" +> if not name: +> return None +> import string +> valid_chars = "_%s%s" % (string.ascii_letters, string.digits) +> name = str().join([c for c in name if c in valid_chars]) +> if not name[0].isalpha(): +> name = 'a' + name +> return name +2520,2521c2508 +< if paraview.compatibility.GetVersion() >= 3.5 and\ +< proto.GetXMLLabel(): +--- +> if proto.GetXMLLabel(): +2536,2539c2523,2525 +< if paraview.compatibility.GetVersion() >= 3.5: +< if (prop.GetInformationOnly() and propName != "TimestepValues" ) \ +< or prop.GetIsInternal(): +< continue +--- +> if (prop.GetInformationOnly() and propName != "TimestepValues" ) \ +> or prop.GetIsInternal(): +> continue +2541,2542c2527 +< if paraview.compatibility.GetVersion() >= 3.5: +< names = [iter.PropertyLabel] +--- +> names = [iter.PropertyLabel] +2681,2690c2666,2669 +< if paraview.compatibility.GetVersion() <= 3.4: +< ss = sources.SphereSource(Radius=2, ThetaResolution=32) +< shr = filters.ShrinkFilter(Input=OutputPort(ss,0)) +< cs = sources.ConeSource() +< app = filters.Append() +< else: +< ss = sources.Sphere(Radius=2, ThetaResolution=32) +< shr = filters.Shrink(Input=OutputPort(ss,0)) +< cs = sources.Cone() +< app = filters.AppendDatasets() +--- +> ss = sources.Sphere(Radius=2, ThetaResolution=32) +> shr = filters.Shrink(Input=OutputPort(ss,0)) +> cs = sources.Cone() +> app = filters.AppendDatasets() +2711,2714c2690 +< if paraview.compatibility.GetVersion() <= 3.4: +< arraySelection = reader.PointResultArrayStatus +< else: +< arraySelection = reader.PointVariables +--- +> arraySelection = reader.PointVariables +2748,2751c2724 +< if paraview.compatibility.GetVersion() <= 3.4: +< print "Range:", ai.Range(j) +< else: +< print "Range:", ai.GetRange(j) +--- +> print "Range:", ai.GetRange(j) +2782,2785c2755 +< if paraview.compatibility.GetVersion() <= 3.4: +< source = sources.RTAnalyticSource() +< else: +< source = sources.Wavelet() +--- +> source = sources.Wavelet() +2816,2823c2786,2788 +< if paraview.compatibility.GetVersion() <= 3.4: +< probe = filters.Probe(Input=source) +< # with a line +< line = sources.LineSource(Resolution=60) +< else: +< probe = filters.ResampleWithDataset(Input=source) +< # with a line +< line = sources.Line(Resolution=60) +--- +> probe = filters.ResampleWithDataset(Input=source) +> # with a line +> line = sources.Line(Resolution=60) +2867,2870c2832 +< if paraview.compatibility.GetVersion() <= 3.4: +< sphere = sources.SphereSource() +< else: +< sphere = sources.Sphere() +--- +> sphere = sources.Sphere() +2960,2965c2922,2927 +< pvoptions = None +< if paraview.options.batch: +< pvoptions = vtkPVOptions(); +< pvoptions.SetProcessType(0x40) +< if paraview.options.symmetric: +< pvoptions.SetSymmetricMPIMode(True) +--- +> # pvoptions = None Not applicable for SALOME Python console +> # if paraview.options.batch: +> # pvoptions = vtkPVOptions(); +> # pvoptions.SetProcessType(0x40) +> # if paraview.options.symmetric: +> # pvoptions.SetSymmetricMPIMode(True) +2994,2995c2956,2957 +< +< if not paraview.fromFilter: +--- +> ## VSV fromFilter is alwais False for SALOME because it can't be changed from ParaView code +> #if not paraview.fromFilter: +2998,2999c2960,2963 +< connection.AttachDefinitionUpdater() +< pass +--- +> # global _defUpdater +> # _defUpdater = __DefinitionUpdater() +> connection.AttachDefinitionUpdater() +> pass +3008a2973,2982 +> # Definitions for working in SALOME GUI mode +> #aParams = myParavis.GetConnectionParameters() +> #ActiveConnection = Connect() +> ##Connection(aParams[0]) +> #ActiveConnection.SetHost(aParams[1], aParams[2], aParams[3], aParams[4], aParams[5]) +> #ToggleProgressPrinting() +> #fromGUI = True +> +> InitFromGUI() +> diff --git a/src/PV_SWIG/VTKWrapping/simple.diff b/src/PV_SWIG/VTKWrapping/simple.diff new file mode 100644 index 00000000..2df0d6e7 --- /dev/null +++ b/src/PV_SWIG/VTKWrapping/simple.diff @@ -0,0 +1,305 @@ +0a1,19 +> # Copyright (C) 2010-2013 CEA/DEN, EDF R&D +> # +> # This library is free software; you can redistribute it and/or +> # modify it under the terms of the GNU Lesser General Public +> # License as published by the Free Software Foundation; either +> # version 2.1 of the License. +> # +> # This library is distributed in the hope that it will be useful, +> # but WITHOUT ANY WARRANTY; without even the implied warranty of +> # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +> # Lesser General Public License for more details. +> # +> # You should have received a copy of the GNU Lesser General Public +> # License along with this library; if not, write to the Free Software +> # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +> # +> # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +> # +> +21,34d39 +< #============================================================================== +< # +< # Program: ParaView +< # Module: simple.py +< # +< # Copyright (c) Kitware, Inc. +< # All rights reserved. +< # See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details. +< # +< # This software is distributed WITHOUT ANY WARRANTY; without even +< # the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR +< # PURPOSE. See the above copyright notice for more information. +< # +< #============================================================================== +36,39c41 +< import paraview +< paraview.compatibility.major = 3 +< paraview.compatibility.minor = 5 +< import servermanager +--- +> import paravisSM +41,42c43 +< def enableMultiServer(): +< servermanager.enableMultiServer() +--- +> servermanager = paravisSM +44,56c45,46 +< 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()) +< servermanager.ProxyManager().DisableStateUpdateNotification() +--- +> def _disconnect(): +> if servermanager.ActiveConnection: +61d50 +< servermanager.Disconnect() +62a52 +> servermanager.Disconnect() +69,70c59,60 +< Disconnect(globals(), False) +< connection = servermanager.Connect(ds_host, ds_port, rs_host, rs_port) +--- +> _disconnect() +> session = servermanager.Connect(ds_host, ds_port, rs_host, rs_port) +73,88c63,67 +< 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 +--- +> tk = servermanager.misc.TimeKeeper() +> servermanager.ProxyManager().RegisterProxy("timekeeper", "tk", tk) +> scene = AnimationScene() +> scene.TimeKeeper = tk +> return session +93,94c72,73 +< Disconnect(globals(), False) +< connection = servermanager.ReverseConnect(port) +--- +> _disconnect() +> session = servermanager.ReverseConnect(port) +96,112c75,79 +< +< 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 +--- +> tk = servermanager.misc.TimeKeeper() +> servermanager.ProxyManager().RegisterProxy("timekeeper", "tk", tk) +> scene = AnimationScene() +> scene.TimeKeeper = tk +> return session +121c88 +< +--- +> +161a129,131 +> reader_factor = servermanager.ProxyManager().GetReaderFactory() +> if reader_factor.GetNumberOfRegisteredPrototypes() == 0: +> reader_factor.RegisterPrototypes("sources") +163,165d132 +< reader_factor = servermanager.vtkSMProxyManager.GetProxyManager().GetReaderFactory() +< if reader_factor.GetNumberOfRegisteredPrototypes() == 0: +< reader_factor.RegisterPrototypes(session, "sources") +170,171c137 +< msg = "File not readable: %s " % first_file +< raise RuntimeError, msg +--- +> raise RuntimeError, "File not readable: %s " % first_file +173,174c139 +< msg = "File not readable. No reader found for '%s' " % first_file +< raise RuntimeError, msg +--- +> raise RuntimeError, "File not readable. No reader found for '%s' " % first_file +192,193c157 +< session = servermanager.ActiveConnection.Session +< writer_factory = servermanager.vtkSMProxyManager.GetProxyManager().GetWriterFactory() +--- +> writer_factory = servermanager.ProxyManager().GetWriterFactory() +195c159 +< writer_factory.RegisterPrototypes(session, "writers") +--- +> writer_factory.RegisterPrototypes("writers") +441c405,406 +< if proxy == GetActiveSource(): +--- +> #VSV:== +> if proxy.IsSame(GetActiveSource()): +449c414,415 +< if rep.Input == proxy: +--- +> #VSV:== +> if rep.Input.IsSame(proxy): +453c419,420 +< if proxy == GetActiveView(): +--- +> ##VSV:== +> if proxy.IsSame(GetActiveView()): +691,693c658,659 +< activeModule = servermanager.ActiveConnection.Modules +< for m in [activeModule.filters, activeModule.sources, +< activeModule.writers, activeModule.animation]: +--- +> for m in [servermanager.filters, servermanager.sources, +> servermanager.writers, servermanager.animation]: +699d664 +< #print "add %s function" % key +703,715d667 +< 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 +< +844c796 +< if cue.AnimatedProxy == proxy and\ +--- +> if cue.AnimatedProxy.IsSame(proxy) and\ +846c798 +< if index == None or index == cue.AnimatedElement: +--- +> if index == None or index.IsSame(cue.AnimatedElement): ##index == cue.AnimatedElement: +870c822 +< if cue.AnimatedProxy == view and\ +--- +> if cue.AnimatedProxy.IsSame(view) and\ +887c839 +< if cue.GetXMLName() == "TimeAnimationCue" and cue.AnimatedProxy == tk\ +--- +> if cue.GetXMLName() == "TimeAnimationCue" and cue.AnimatedProxy.IsSame(tk)\ +929,931c881 +< if not servermanager.ActiveConnection: +< raise RuntimeError, "Cannot load a plugin without a session." +< plm = servermanager.vtkSMProxyManager.GetProxyManager().GetPluginManager() +--- +> plm = servermanager.ProxyManager().GetSession().GetPluginManager() +933,934c883 +< session = servermanager.ActiveConnection.Session +< info = plm.GetRemoteInformation(session) +--- +> info = plm.GetRemoteInformation() +942,959d890 +< 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 +966c897 +< def __get_selection_model(self, name, session=None): +--- +> def __get_selection_model(self, name): +968,970c899 +< if session and session != servermanager.ActiveConnection.Session: +< raise RuntimeError, "Try to set an active object with invalid active connection." +< pxm = servermanager.ProxyManager(session) +--- +> pxm = servermanager.ProxyManager() +979c908 +< active_view_model = self.__get_selection_model("ActiveView") +--- +> active_view_model = self.__get_selection_model("ActiveView") +981d909 +< active_view_model = self.__get_selection_model("ActiveView", view.GetSession()) +984d911 +< active_view_model = self.__get_selection_model("ActiveView") +994c921 +< active_sources_model = self.__get_selection_model("ActiveSources") +--- +> active_sources_model = self.__get_selection_model("ActiveSources") +997d923 +< active_sources_model = self.__get_selection_model("ActiveSources", source.GetSession()) +1000d925 +< active_sources_model = self.__get_selection_model("ActiveSources") +1107a1033,1041 +> def PrintTrace(): +> print paravisSM.myParavis.GetTrace() +> +> def SaveTrace(fileName): +> paravisSM.myParavis.SaveTrace(fileName) +> +> +> _add_functions(globals()) +> +1110,1111d1043 +< else: +< _add_functions(globals()) +1113c1045,1046 +< active_objects = ActiveObjects() +--- +> def ImportFile(theFileName): +> paravisSM.ImportFile(theFileName) +1115,1129c1048,1049 +< def _switchToActiveConnectionCallback(caller, event): +< if servermanager: +< session = servermanager.vtkSMProxyManager.GetProxyManager().GetActiveSession() +< if session and ((not servermanager.ActiveConnection) or session != servermanager.ActiveConnection.Session): +< switchActiveConnection(servermanager.GetConnectionFromSession(session)) +< +< class ActiveSessionObserver: +< def __init__(self): +< self.ObserverTag = servermanager.vtkSMProxyManager.GetProxyManager().AddObserver(9753, _switchToActiveConnectionCallback) +< +< def __del__(self): +< if servermanager: +< servermanager.vtkSMProxyManager.GetProxyManager().RemoveObserver(self.ObserverTag) +< +< active_session_observer = ActiveSessionObserver() +--- +> active_objects = ActiveObjects() +> active_objects.view = GetRenderView() diff --git a/src/PV_SWIG/paravis.py b/src/PV_SWIG/paravis.py index d5c228ed..7dbfa2df 100644 --- a/src/PV_SWIG/paravis.py +++ b/src/PV_SWIG/paravis.py @@ -67,31 +67,12 @@ def ImportFile(theFileName): "Import a file of any format supported by ParaView" myParavis.ImportFile(theFileName) - -def createFunction(theName): - "Create function - constructor of Paravis object" - def MyFunction(): - return myParavis.CreateClass(theName) - return MyFunction - - -def createConstructors(): - "Create constructor functions according to list of extracted classes" - g = globals() - aClassNames = myParavis.GetClassesList(); - for aName in aClassNames: - g[aName] = createFunction(aName) - -## Initialize of a PARAVIS interface +## Initialize PARAVIS interface myParavis = Initialize(orb, naming_service,lcc,myStudyManager,myStudy, 2) -## Initialize constructor functions -createConstructors() - ## Initialize Paravis static objects -vtkSMObject = vtkSMObject() -vtkProcessModule = vtkProcessModule() -vtkPVPythonModule = vtkPVPythonModule() -vtkSMProxyManager = vtkSMProxyManager() - +#vtkSMObject = vtkSMObject() +#vtkProcessModule = vtkProcessModule() +#vtkPVPythonModule = vtkPVPythonModule() +#vtkSMProxyManager = vtkSMProxyManager() diff --git a/src/PV_SWIG/paravisSM.py b/src/PV_SWIG/paravisSM.py index 8237dfc1..1586fcdf 100644 --- a/src/PV_SWIG/paravisSM.py +++ b/src/PV_SWIG/paravisSM.py @@ -17,2998 +17,16 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -r"""servermanager is a module for using paraview server manager in Python. -One can always use the server manager API directly. However, this module -provides an interface easier to use from Python by wrapping several VTK -classes around Python classes. - -Note that, upon load, this module will create several sub-modules: sources, -filters and rendering. These modules can be used to instantiate specific -proxy types. For a list, try "dir(servermanager.sources)" - -A simple example: - from paraview.servermanager import * - - # Creates a new built-in session and makes it the active session. - Connect() - - # Creates a new render view on the active session. - renModule = CreateRenderView() - - # Create a new sphere proxy on the active session and register it - # in the sources group. - sphere = sources.SphereSource(registrationGroup="sources", ThetaResolution=16, PhiResolution=32) - - # Create a representation for the sphere proxy and adds it to the render - # module. - display = CreateRepresentation(sphere, renModule) - - renModule.StillRender() +r""" This module is a direct forward to the initial +'servermanager' module of ParaView. """ - - -import re, os, new, sys +from paraview import servermanager from paravis import * -# VTN: Avoid paraview.* instructions in this file. -# It leads to problems during execution. - -def _wrap_property(proxy, smproperty): - """ Internal function. - Given a server manager property and its domains, returns the - appropriate python object. - """ - property = None - if smproperty.IsA("vtkSMStringVectorProperty"): - al = smproperty.GetDomain("array_list") - if al and al.IsA("vtkSMArraySelectionDomain") and \ - smproperty.GetRepeatable(): - property = ArrayListProperty(proxy, smproperty) - elif al and al.IsA("vtkSMArrayListDomain") and smproperty.GetNumberOfElements() == 5: - property = ArraySelectionProperty(proxy, smproperty) - else: - iter = smproperty.NewDomainIterator() - isFileName = False - while not iter.IsAtEnd(): - # Refer to BUG #9710 to see why optional domains need to be - # ignored. - if iter.GetDomain().IsA("vtkSMFileListDomain") and \ - iter.GetDomain().GetIsOptional() == 0 : - isFileName = True - break - iter.Next() - iter.UnRegister(None) - if isFileName: - property = FileNameProperty(proxy, smproperty) - elif _make_name_valid(smproperty.GetXMLLabel()) == 'ColorArrayName': - property = ColorArrayProperty(proxy, smproperty) - else: - property = VectorProperty(proxy, smproperty) - elif smproperty.IsA("vtkSMVectorProperty"): - if smproperty.IsA("vtkSMIntVectorProperty") and \ - smproperty.GetDomain("enum"): - property = EnumerationProperty(proxy, smproperty) - else: - property = VectorProperty(proxy, smproperty) - elif smproperty.IsA("vtkSMInputProperty"): - property = InputProperty(proxy, smproperty) - elif smproperty.IsA("vtkSMProxyProperty"): - property = ProxyProperty(proxy, smproperty) - else: - property = Property(proxy, smproperty) - return property - -class Proxy(object): - """Proxy for a server side object. A proxy manages the lifetime of - one or more server manager objects. It also provides an interface - to set and get the properties of the server side objects. These - properties are presented as Python properties. For example, - you can set a property Foo using the following: - proxy.Foo = (1,2) - or - proxy.Foo.SetData((1,2)) - or - proxy.Foo[0:2] = (1,2) - For more information, see the documentation of the property which - you can obtain with - help(proxy.Foo). - - This class also provides an iterator which can be used to iterate - over all properties. - eg: - proxy = Proxy(proxy=smproxy) - for property in proxy: - print property - - For advanced users: - This is a python class that wraps a vtkSMProxy.. Makes it easier to - set/get properties. - Instead of: - proxy.GetProperty("Foo").SetElement(0, 1) - proxy.GetProperty("Foo").SetElement(0, 2) - you can do: - proxy.Foo = (1,2) - or - proxy.Foo.SetData((1,2)) - or - proxy.Foo[0:2] = (1,2) - Instead of: - proxy.GetProperty("Foo").GetElement(0) - you can do: - proxy.Foo.GetData()[0] - or - proxy.Foo[0] - For proxy properties, you can use append: - proxy.GetProperty("Bar").AddProxy(foo) - you can do: - proxy.Bar.append(foo) - Properties support most of the list API. See VectorProperty and - ProxyProperty documentation for details. - - Please note that some of the methods accessible through the Proxy - class are not listed by help() because the Proxy objects forward - unresolved attributes to the underlying object. To get the full list, - see also dir(proxy.SMProxy). See also the doxygen based documentation - of the vtkSMProxy C++ class. - """ - - def __init__(self, **args): - """ Default constructor. It can be used to initialize properties - by passing keyword arguments where the key is the name of the - property. In addition registrationGroup and registrationName (optional) - can be specified (as keyword arguments) to automatically register - the proxy with the proxy manager. """ - self.add_attribute('Observed', None) - self.add_attribute('ObserverTag', -1) - self.add_attribute('_Proxy__Properties', {}) - self.add_attribute('_Proxy__LastAttrName', None) - self.add_attribute('SMProxy', None) - self.add_attribute('Port', 0) - - if 'port' in args: - self.Port = args['port'] - del args['port'] - - update = True - if 'no_update' in args: - if args['no_update']: - update = False - del args['no_update'] - - if 'proxy' in args: - self.InitializeFromProxy(args['proxy']) - del args['proxy'] - else: - self.Initialize(None, update) - if 'registrationGroup' in args: - registrationGroup = args['registrationGroup'] - del args['registrationGroup'] - registrationName = self.SMProxy.GetGlobalIDAsString() - if 'registrationName' in args: - registrationName = args['registrationName'] - del args['registrationName'] - pxm = ProxyManager() - pxm.RegisterProxy(registrationGroup, registrationName, self.SMProxy) - if update: - self.UpdateVTKObjects() - for key in args.keys(): - setattr(self, key, args[key]) - # Visit all properties so that they are created - for prop in self: - pass - - def __setattr__(self, name, value): - try: - setter = getattr(self.__class__, name) - setter = setter.__set__ - except AttributeError: - if not hasattr(self, name): - raise AttributeError("Attribute %s does not exist. " % name + - " This class does not allow addition of new attributes to avoid " + - "mistakes due to typos. Use add_attribute() if you really want " + - "to add this attribute.") - self.__dict__[name] = value - else: - setter(self, value) - - def add_attribute(self, name, value): - self.__dict__[name] = value - - def __del__(self): - """Destructor. Cleans up all observers as well as remove - the proxy from the _pyproxies dictionary""" - # Make sure that we remove observers we added - if self.Observed: - observed = self.Observed - tag = self.ObserverTag - self.Observed = None - self.ObserverTag = -1 - observed.RemoveObserver(tag) - if _pyproxies and self.SMProxy and (self.SMProxy, self.Port) in _pyproxies: - del _pyproxies[(self.SMProxy, self.Port)] - - def InitializeFromProxy(self, aProxy, update=True): - """Constructor. Assigns proxy to self.SMProxy, updates the server - object as well as register the proxy in _pyproxies dictionary.""" - import weakref - self.SMProxy = aProxy - if update: - self.SMProxy.UpdateVTKObjects() - _pyproxies[(self.SMProxy, self.Port)] = weakref.ref(self) - - def Initialize(self): - "Overridden by the subclass created automatically" - pass - - def __eq__(self, other): - "Returns true if the underlying SMProxies are the same." - if isinstance(other, Proxy): - try: - if self.Port != other.Port: - return False - except: - pass - ## VSV using IsSame instead == - return self.SMProxy.IsSame(other.SMProxy) - return self.SMProxy.IsSame(other) - - def __ne__(self, other): - "Returns false if the underlying SMProxies are the same." - return not self.__eq__(other) - - def __iter__(self): - "Creates an iterator for the properties." - return PropertyIterator(self) - - def SetPropertyWithName(self, pname, arg): - """Generic method for setting the value of a property.""" - prop = self.GetProperty(pname) - if prop is None: - raise RuntimeError, "Property %s does not exist. Please check the property name for typos." % pname - prop.SetData(arg) - - def GetPropertyValue(self, name): - """Returns a scalar for properties with 1 elements, the property - itself for vectors.""" - p = self.GetProperty(name) - if isinstance(p, VectorProperty): - if p.GetNumberOfElements() == 1 and not p.GetRepeatable(): - if p.SMProperty.IsA("vtkSMStringVectorProperty") or not p.GetArgumentIsArray(): - return p[0] - elif isinstance(p, InputProperty): - if not p.GetMultipleInput(): - if len(p) > 0: - return p[0] - else: - return None - elif isinstance(p, ProxyProperty): - if not p.GetRepeatable(): - if len(p) > 0: - return p[0] - else: - return None - return p - - def GetProperty(self, name): - """Given a property name, returns the property object.""" - if name in self.__Properties and self.__Properties[name](): - return self.__Properties[name]() - smproperty = self.SMProxy.GetProperty(name) - # Maybe they are looking by the label. Try to match that. - if not smproperty: - iter = PropertyIterator(self) - for prop in iter: - if name == _make_name_valid(iter.PropertyLabel): - smproperty = prop.SMProperty - break - if smproperty: - property = _wrap_property(self, smproperty) - if property is not None: - import weakref - self.__Properties[name] = weakref.ref(property) - return property - return None - - def ListProperties(self): - """Returns a list of all property names on this proxy.""" - property_list = [] - iter = self.__iter__() - for property in iter: - name = _make_name_valid(iter.PropertyLabel) - if name: - property_list.append(name) - return property_list - - def __ConvertArgumentsAndCall(self, *args): - """ Internal function. - Used to call a function on SMProxy. Converts input and - output values as appropriate. - """ - newArgs = [] - for arg in args: - if issubclass(type(arg), Proxy) or isinstance(arg, Proxy): - newArgs.append(arg.SMProxy) - else: - newArgs.append(arg) - func = getattr(self.SMProxy, self.__LastAttrName) - retVal = func(*newArgs) - if type(retVal) is type(self.SMProxy) and retVal.IsA("vtkSMProxy"): - return _getPyProxy(retVal) - elif type(retVal) is type(self.SMProxy) and retVal.IsA("vtkSMProperty"): - return _wrap_property(self, retVal) - else: - return retVal - - def __GetActiveCamera(self): - """ This method handles GetActiveCamera specially. It adds - an observer to the camera such that everytime it is modified - the render view updated""" - import weakref - c = self.SMProxy.GetActiveCamera() - # VSV: Observers are not supported -## if not c.HasObserver("ModifiedEvent"): -## self.ObserverTag =c.AddObserver("ModifiedEvent", _makeUpdateCameraMethod(weakref.ref(self))) -## self.Observed = c - return c - - def __getattr__(self, name): - """With the exception of a few overloaded methods, - returns the SMProxy method""" - if not self.SMProxy: - raise AttributeError("class %s has no attribute %s" % ("None", name)) - return None - # Handle GetActiveCamera specially. - if name == "GetActiveCamera" and \ - hasattr(self.SMProxy, "GetActiveCamera"): - return self.__GetActiveCamera - if name == "SaveDefinition" and hasattr(self.SMProxy, "SaveDefinition"): - return self.__SaveDefinition - # If not a property, see if SMProxy has the method - try: - proxyAttr = getattr(self.SMProxy, name) - self.__LastAttrName = name - return self.__ConvertArgumentsAndCall - except: - pass - return getattr(self.SMProxy, name) - -class SourceProxy(Proxy): - """Proxy for a source object. This class adds a few methods to Proxy - that are specific to sources. It also provides access to the output - ports. Output ports can be accessed by name or index: - > op = source[0] - or - > op = source['some name']. - """ - def UpdatePipeline(self, time=None): - """This method updates the server-side VTK pipeline and the associated - data information. Make sure to update a source to validate the output - meta-data.""" - if time != None: - self.SMProxy.UpdatePipeline(time) - else: - self.SMProxy.UpdatePipeline() - # This is here to cause a receive - # on the client side so that progress works properly. - if ActiveConnection and ActiveConnection.IsRemote(): - self.SMProxy.GetDataInformation() - - def FileNameChanged(self): - "Called when the filename of a source proxy is changed." - self.UpdatePipelineInformation() - - def UpdatePipelineInformation(self): - """This method updates the meta-data of the server-side VTK pipeline and - the associated information properties""" - self.SMProxy.UpdatePipelineInformation() - - def GetDataInformation(self, idx=None): - """This method returns a DataInformation wrapper around a - vtkPVDataInformation""" - if idx == None: - idx = self.Port - if self.SMProxy: - return DataInformation( \ - self.SMProxy.GetDataInformation(idx), \ - self.SMProxy, idx) - - def __getitem__(self, idx): - """Given a slice, int or string, returns the corresponding - output port""" - if isinstance(idx, slice): - indices = idx.indices(self.SMProxy.GetNumberOfOutputPorts()) - retVal = [] - for i in range(*indices): - retVal.append(OutputPort(self, i)) - return retVal - elif isinstance(idx, int): - if idx >= self.SMProxy.GetNumberOfOutputPorts() or idx < 0: - raise IndexError - return OutputPort(self, idx) - else: - return OutputPort(self, self.SMProxy.GetOutputPortIndex(idx)) - - def GetPointDataInformation(self): - """Returns the associated point data information.""" - self.UpdatePipeline() - return FieldDataInformation(self.SMProxy, self.Port, "PointData") - - def GetCellDataInformation(self): - """Returns the associated cell data information.""" - self.UpdatePipeline() - return FieldDataInformation(self.SMProxy, self.Port, "CellData") - - def GetFieldDataInformation(self): - """Returns the associated cell data information.""" - self.UpdatePipeline() - return FieldDataInformation(self.SMProxy, self.Port, "FieldData") - - PointData = property(GetPointDataInformation, None, None, "Returns point data information") - CellData = property(GetCellDataInformation, None, None, "Returns cell data information") - FieldData = property(GetFieldDataInformation, None, None, "Returns field data information") - - -class ExodusIIReaderProxy(SourceProxy): - """Special class to define convenience functions for array - selection.""" - - def FileNameChanged(self): - "Called when the filename changes. Selects all variables." - SourceProxy.FileNameChanged(self) - self.SelectAllVariables() - - def SelectAllVariables(self): - "Select all available variables for reading." - for prop in ('PointVariables', 'EdgeVariables', 'FaceVariables', - 'ElementVariables', 'GlobalVariables'): - f = getattr(self, prop) - f.SelectAll() - - def DeselectAllVariables(self): - "Deselects all variables." - for prop in ('PointVariables', 'EdgeVariables', 'FaceVariables', - 'ElementVariables', 'GlobalVariables'): - f = getattr(self, prop) - f.DeselectAll() - -class ViewLayoutProxy(Proxy): - """Special class to define convenience methods for View Layout""" - - def SplitViewHorizontal(self, view, fraction=0.5): - """Split the cell containing the specified view horizontally. - If no fraction is specified, the frame is split into equal parts. - On success returns a positve number that identifying the new cell - location that can be used to assign view to, or split further. - Return -1 on failure.""" - location = self.GetViewLocation(view) - if location == -1: - raise RuntimeError, "View is not present in this layout." - if fraction < 0.0 or fraction > 1.0: - raise RuntimeError, "'fraction' must be in the range [0.0, 1.0]" - return self.SMProxy.SplitHorizontal(location, fraction) - - def SplitViewVertical(self, view=None, fraction=0.5): - """Split the cell containing the specified view horizontally. - If no view is specified, active view is used. - If no fraction is specified, the frame is split into equal parts. - On success returns a positve number that identifying the new cell - location that can be used to assign view to, or split further. - Return -1 on failure.""" - location = self.GetViewLocation(view) - if location == -1: - raise RuntimeError, "View is not present in this layout." - if fraction < 0.0 or fraction > 1.0: - raise RuntimeError, "'fraction' must be in the range [0.0, 1.0]" - return self.SMProxy.SplitVertical(location, fraction) - - def AssignView(self, location, view): - """Assign a view at a particular location. Note that the view's position may - be changed by subsequent Split() calls. Returns true on success.""" - viewproxy = None - if isinstance(view, Proxy): - view = view.SMProxy - return self.SMProxy.AssignView(location, view) - - def GetViewLocation(self, view): - if isinstance(view, Proxy): - view = view.SMProxy - return self.SMProxy.GetViewLocation(view) - -class Property(object): - """Generic property object that provides access to one of the properties of - a server object. This class does not allow setting/getting any values but - provides an interface to update a property using __call__. This can be used - for command properties that correspond to function calls without arguments. - For example, - > proxy.Foo() - would push a Foo property which may cause the proxy to call a Foo method - on the actual VTK object. - - For advanced users: - Python wrapper around a vtkSMProperty with a simple interface. - In addition to all method provided by vtkSMProperty (obtained by - forwarding unknown attributes requests to the underlying SMProxy), - Property and sub-class provide a list API. - - Please note that some of the methods accessible through the Property - class are not listed by help() because the Property objects forward - unresolved attributes to the underlying object. To get the full list, - see also dir(proxy.SMProperty). See also the doxygen based documentation - of the vtkSMProperty C++ class. - """ - def __init__(self, proxy, smproperty): - """Default constructor. Stores a reference to the proxy.""" - import weakref - self.SMProperty = smproperty - self.Proxy = proxy - - def __repr__(self): - """Returns a string representation containing property name - and value""" - if not type(self) is Property: - if self.GetData() is not None: - repr = self.GetData().__repr__() - else: - repr = "None" - else: - repr = "Property name= " - name = self.Proxy.GetPropertyName(self.SMProperty) - if name: - repr += name - else: - repr += "Unknown" - - return repr - - def __call__(self): - """Forces a property update using InvokeCommand.""" - if type(self) is Property: - self.Proxy.SMProxy.InvokeCommand(self._FindPropertyName()) - else: - raise RuntimeError, "Cannot invoke this property" - - def _FindPropertyName(self): - "Returns the name of this property." - return self.Proxy.GetPropertyName(self.SMProperty) - - def _UpdateProperty(self): - "Pushes the value of this property to the server." - # For now, we are updating all properties. This is due to an - # issue with the representations. Their VTK objects are not - # created until Input is set therefore, updating a property - # has no effect. Updating all properties everytime one is - # updated has the effect of pushing values set before Input - # when Input is updated. - # self.Proxy.SMProxy.UpdateProperty(self._FindPropertyName()) - self.Proxy.SMProxy.UpdateVTKObjects() - - def __getattr__(self, name): - "Unknown attribute requests get forwarded to SMProperty." - return getattr(self.SMProperty, name) - - Name = property(_FindPropertyName, None, None, - "Returns the name for the property") - -class GenericIterator(object): - """Iterator for container type objects""" - - def __init__(self, obj): - self.Object = obj - self.index = 0 - - def __iter__(self): - return self - - def next(self): - if self.index >= len(self.Object): - raise StopIteration - - idx = self.index - self.index += 1 - return self.Object[idx] - -class VectorProperty(Property): - """A VectorProperty provides access to one or more values. You can use - a slice to get one or more property values: - > val = property[2] - or - > vals = property[0:5:2] - You can use a slice to set one or more property values: - > property[2] = val - or - > property[1:3] = (1,2) - """ - def ConvertValue(self, value): - return value - - def __len__(self): - """Returns the number of elements.""" - return self.SMProperty.GetNumberOfElements() - - def __iter__(self): - """Implementation of the sequence API""" - return GenericIterator(self) - - def __setitem__(self, idx, value): - """Given a list or tuple of values, sets a slice of values [min, max)""" - if isinstance(idx, slice): - indices = idx.indices(len(self)) - for i, j in zip(range(*indices), value): - self.SMProperty.SetElement(i, self.ConvertValue(j)) - self._UpdateProperty() - elif idx >= len(self) or idx < 0: - raise IndexError - else: - self.SMProperty.SetElement(idx, self.ConvertValue(value)) - self._UpdateProperty() - - def GetElement(self, index): - return self.SMProperty.GetElement(index) - - def __getitem__(self, idx): - """Returns the range [min, max) of elements. Raises an IndexError - exception if an argument is out of bounds.""" - ls = len(self) - if isinstance(idx, slice): - indices = idx.indices(ls) - retVal = [] - for i in range(*indices): - retVal.append(self.GetElement(i)) - return retVal - elif idx >= ls: - raise IndexError - elif idx < 0: - idx = ls + idx - if idx < 0: - raise IndexError - - return self.GetElement(idx) - - def GetData(self): - "Returns all elements as either a list or a single value." - property = self.SMProperty - if property.GetRepeatable() or \ - property.GetNumberOfElements() > 1: - return self[0:len(self)] - elif property.GetNumberOfElements() == 1: - return self.GetElement(0) - - def SetData(self, values): - """Allows setting of all values at once. Requires a single value or - a iterable object.""" - if not hasattr(values, "__iter__"): - values = (values,) - if not self.GetRepeatable() and len(values) != self.GetNumberOfElements(): - raise RuntimeError("This property requires %d values." % self.GetNumberOfElements()) - if self.GetRepeatable(): - # Clean up first - self.SMProperty.SetNumberOfElements(0) - idx = 0 - for val in values: - self.SMProperty.SetElement(idx, self.ConvertValue(val)) - idx += 1 - self._UpdateProperty() - - def Clear(self): - "Removes all elements." - self.SMProperty().SetNumberOfElements(0) - self._UpdateProperty() - -class ColorArrayProperty(VectorProperty): - """This subclass of VectorProperty handles setting of the array to - color by. It handles attribute type as well as well array name.""" - - def GetAvailable(self): - """Returns the list of available arrays as (attribute type, array name - tuples.""" - arrays = [] - for a in self.Proxy.Input.PointData: - arrays.append(('POINT_DATA', a.GetName())) - for a in self.Proxy.Input.CellData: - arrays.append(('CELL_DATA', a.GetName())) - return arrays - - def SetData(self, value): - """Overwritten to enable setting attribute type (the ColorAttributeType - property and the array name. The argument should be the array name - (in which case the first appropriate attribute type is picked) or - a tuple of attribute type and array name.""" - if isinstance(value, tuple) and len(value) == 2: - att = value[0] - arr = value[1] - elif isinstance(value, str): - att = None - arr = value - else: - raise ValueError("Expected a tuple of 2 values or a string.") - - if not arr: - self.SMProperty.SetElement(0, '') - self._UpdateProperty() - return - - found = False - for a in self.Available: - if a[1] == arr and (not att or att == a[0]): - att = a[0] - found = True - break - - if not found: - pvoptions = vtkProcessModule.GetProcessModule().GetOptions() - # if this process is from a parallel batch run in symmetric mpi mode - # then we may not have any points or cells on some processes in which - # case we'll probably be missing the point and cell data too. the - # check below makes sure that we avoid this situation. - if pvoptions.GetProcessType() != 0x40 or pvoptions.GetSymmetricMPIMode() == False \ - or len(self.Available) != 0: - raise ValueError("Could not locate array %s in the input." % arr) - - catt = self.Proxy.GetProperty("ColorAttributeType") - if att != None: - catt.SetData(att) - self.SMProperty.SetElement(0, arr) - self._UpdateProperty() - - Available = property(GetAvailable, None, None, \ - "This read-only property returns the list of arrays that can be colored by.") - - -class EnumerationProperty(VectorProperty): - """Subclass of VectorProperty that is applicable for enumeration type - properties.""" - - def GetElement(self, index): - """Returns the text for the given element if available. Returns - the numerical values otherwise.""" - val = self.SMProperty.GetElement(index) - domain = self.SMProperty.GetDomain("enum") - for i in range(domain.GetNumberOfEntries()): - if domain.GetEntryValue(i) == val: - return domain.GetEntryText(i) - return val - - def ConvertValue(self, value): - """Converts value to type suitable for vtSMProperty::SetElement()""" - if type(value) == str: - domain = self.SMProperty.GetDomain("enum") - if domain.HasEntryText(value): - return domain.GetEntryValueForText(value) - else: - raise ValueError("%s is not a valid value." % value) - return VectorProperty.ConvertValue(self, value) - - def GetAvailable(self): - "Returns the list of available values for the property." - retVal = [] - domain = self.SMProperty.GetDomain("enum") - for i in range(domain.GetNumberOfEntries()): - retVal.append(domain.GetEntryText(i)) - return retVal - - Available = property(GetAvailable, None, None, \ - "This read-only property contains the list of values that can be applied to this property.") - - -class FileNameProperty(VectorProperty): - """Property to set/get one or more file names. - This property updates the pipeline information everytime its value changes. - This is used to keep the array lists up to date.""" - - def _UpdateProperty(self): - "Pushes the value of this property to the server." - VectorProperty._UpdateProperty(self) - self.Proxy.FileNameChanged() - -class ArraySelectionProperty(VectorProperty): - "Property to select an array to be processed by a filter." - - def GetAssociation(self): - val = self.GetElement(3) - if val == "": - return None - for key, value in ASSOCIATIONS.iteritems(): - if value == int(val): - return key - - return None - - def GetArrayName(self): - return self.GetElement(4) - - def __len__(self): - """Returns the number of elements.""" - return 2 - - def __setitem__(self, idx, value): - raise RuntimeError, "This property cannot be accessed using __setitem__" - - def __getitem__(self, idx): - """Returns attribute type for index 0, array name for index 1""" - if isinstance(idx, slice): - indices = idx.indices(len(self)) - retVal = [] - for i in range(*indices): - if i >= 2 or i < 0: - raise IndexError - if i == 0: - retVal.append(self.GetAssociation()) - else: - retVal.append(self.GetArrayName()) - return retVal - elif idx >= 2 or idx < 0: - raise IndexError - - if i == 0: - return self.GetAssociation() - else: - return self.GetArrayName() - - def SetData(self, values): - """Allows setting of all values at once. Requires a single value, - a tuple or list.""" - if not isinstance(values, tuple) and \ - not isinstance(values, list): - values = (values,) - if len(values) == 1: - self.SMProperty.SetElement(4, values[0]) - elif len(values) == 2: - if isinstance(values[0], str): - val = str(ASSOCIATIONS[values[0]]) - else: - # In case user didn't specify valid association, - # just pick POINTS. - val = str(ASSOCIATIONS['POINTS']) - self.SMProperty.SetElement(3, str(val)) - self.SMProperty.SetElement(4, values[1]) - else: - raise RuntimeError, "Expected 1 or 2 values." - self._UpdateProperty() - - def UpdateDefault(self): - "Helper method to set default values." - if self.SMProperty.GetNumberOfElements() != 5: - return - if self.GetElement(4) != '' or \ - self.GetElement(3) != '': - return - - for i in range(0,3): - if self.GetElement(i) == '': - self.SMProperty.SetElement(i, '0') - al = self.SMProperty.GetDomain("array_list") - al.Update(self.SMProperty) - al.SetDefaultValues(self.SMProperty) - -class ArrayListProperty(VectorProperty): - """This property provides a simpler interface for selecting arrays. - Simply assign a list of arrays that should be loaded by the reader. - Use the Available property to get a list of available arrays.""" - - def __init__(self, proxy, smproperty): - VectorProperty.__init__(self, proxy, smproperty) - self.__arrays = [] - - def GetAvailable(self): - "Returns the list of available arrays" - dm = self.GetDomain("array_list") - retVal = [] - for i in range(dm.GetNumberOfStrings()): - retVal.append(dm.GetString(i)) - return retVal - - Available = property(GetAvailable, None, None, \ - "This read-only property contains the list of items that can be read by a reader.") - - def SelectAll(self): - "Selects all arrays." - self.SetData(self.Available) - - def DeselectAll(self): - "Deselects all arrays." - self.SetData([]) - - def __iter__(self): - """Implementation of the sequence API""" - return GenericIterator(self) - - def __len__(self): - """Returns the number of elements.""" - return len(self.GetData()) - - def __setitem__(self, idx, value): - """Given a list or tuple of values, sets a slice of values [min, max)""" - self.GetData() - if isinstance(idx, slice): - indices = idx.indices(len(self)) - for i, j in zip(range(*indices), value): - self.__arrays[i] = j - self.SetData(self.__arrays) - elif idx >= len(self) or idx < 0: - raise IndexError - else: - self.__arrays[idx] = self.ConvertValue(value) - self.SetData(self.__arrays) - - def __getitem__(self, idx): - """Returns the range [min, max) of elements. Raises an IndexError - exception if an argument is out of bounds.""" - self.GetData() - if isinstance(idx, slice): - indices = idx.indices(len(self)) - retVal = [] - for i in range(*indices): - retVal.append(self.__arrays[i]) - return retVal - elif idx >= len(self) or idx < 0: - raise IndexError - return self.__arrays[idx] - - def SetData(self, values): - """Allows setting of all values at once. Requires a single value, - a tuple or list.""" - # Clean up first - iup = self.SMProperty.GetImmediateUpdate() - self.SMProperty.SetImmediateUpdate(False) - # Clean up first - self.SMProperty.SetNumberOfElements(0) - if not isinstance(values, tuple) and \ - not isinstance(values, list): - values = (values,) - fullvalues = [] - - # WARNING: - # The order of the two loops below are delibrately set in this way - # so that values passed in will take precedence. - # This is needed for backward compatibility of the - # property ElementBlocks for vtkExodusIIReader. - # If you attemp to change this, please verify that - # python state files for opening old .ex2 file (<=3.14) still works. - for array in self.Available: - if not values.__contains__(array): - fullvalues.append(array) - fullvalues.append('0') - - for i in range(len(values)): - val = self.ConvertValue(values[i]) - fullvalues.append(val) - fullvalues.append('1') - - - i = 0 - for value in fullvalues: - self.SMProperty.SetElement(i, value) - i += 1 - - self._UpdateProperty() - self.SMProperty.SetImmediateUpdate(iup) - - def GetData(self): - "Returns all elements as a list." - property = self.SMProperty - nElems = property.GetNumberOfElements() - if nElems%2 != 0: - raise ValueError, "The SMProperty with XML label '%s' has a size that is not a multiple of 2." % property.GetXMLLabel() - self.__arrays = [] - for i in range(0, nElems, 2): - if self.GetElement(i+1) != '0': - self.__arrays.append(self.GetElement(i)) - return list(self.__arrays) - -class ProxyProperty(Property): - """A ProxyProperty provides access to one or more proxies. You can use - a slice to get one or more property values: - > proxy = property[2] - or - > proxies = property[0:5:2] - You can use a slice to set one or more property values: - > property[2] = proxy - or - > property[1:3] = (proxy1, proxy2) - You can also append and delete: - > property.append(proxy) - and - > del property[1:2] - - You can also remove all elements with Clear(). - - Note that some properties expect only 1 proxy and will complain if - you set the number of values to be something else. - """ - def __init__(self, proxy, smproperty): - """Default constructor. Stores a reference to the proxy. Also looks - at domains to find valid values.""" - Property.__init__(self, proxy, smproperty) - # Check to see if there is a proxy list domain and, if so, - # initialize ourself. (Should this go in ProxyProperty?) - listdomain = self.GetDomain('proxy_list') - if listdomain: - if listdomain.GetClassName() != 'vtkSMProxyListDomain': - raise ValueError, "Found a 'proxy_list' domain on an InputProperty that is not a ProxyListDomain." - pm = ProxyManager() - group = "pq_helper_proxies." + proxy.GetGlobalIDAsString() - if listdomain.GetNumberOfProxies() == 0: - for i in xrange(listdomain.GetNumberOfProxyTypes()): - igroup = listdomain.GetProxyGroup(i) - name = listdomain.GetProxyName(i) - iproxy = CreateProxy(igroup, name) - listdomain.AddProxy(iproxy) - pm.RegisterProxy(group, proxy.GetPropertyName(smproperty), iproxy) - listdomain.SetDefaultValues(self.SMProperty) - - def GetAvailable(self): - """If this proxy has a list domain, then this function returns the - strings you can use to select from the domain. If there is no such - list domain, the returned list is empty.""" - listdomain = self.GetDomain('proxy_list') - retval = [] - if listdomain: - for i in xrange(listdomain.GetNumberOfProxies()): - proxy = listdomain.GetProxy(i) - retval.append(proxy.GetXMLLabel()) - return retval - - Available = property(GetAvailable, None, None, - """This read only property is a list of strings you can - use to select from the list domain. If there is no - such list domain, the array is empty.""") - - def __iter__(self): - """Implementation of the sequence API""" - return GenericIterator(self) - - def __len__(self): - """Returns the number of elements.""" - return self.SMProperty.GetNumberOfProxies() - - def remove(self, proxy): - """Removes the first occurence of the proxy from the property.""" - self.SMProperty.RemoveProxy(proxy.SMProxy) - self._UpdateProperty() - - def __setitem__(self, idx, value): - """Given a list or tuple of values, sets a slice of values [min, max)""" - if isinstance(idx, slice): - indices = idx.indices(len(self)) - for i, j in zip(range(*indices), value): - self.SMProperty.SetProxy(i, j.SMProxy) - self._UpdateProperty() - elif idx >= len(self) or idx < 0: - raise IndexError - else: - self.SMProperty.SetProxy(idx, value.SMProxy) - self._UpdateProperty() - - def __delitem__(self,idx): - """Removes the element idx""" - if isinstance(idx, slice): - indices = idx.indices(len(self)) - # Collect the elements to delete to a new list first. - # Otherwise indices are screwed up during the actual - # remove loop. - toremove = [] - for i in range(*indices): - toremove.append(self[i]) - for i in toremove: - self.SMProperty.RemoveProxy(i.SMProxy) - self._UpdateProperty() - elif idx >= len(self) or idx < 0: - raise IndexError - else: - self.SMProperty.RemoveProxy(self[idx].SMProxy) - self._UpdateProperty() - - def __getitem__(self, idx): - """Returns the range [min, max) of elements. Raises an IndexError - exception if an argument is out of bounds.""" - if isinstance(idx, slice): - indices = idx.indices(len(self)) - retVal = [] - for i in range(*indices): - retVal.append(_getPyProxy(self.SMProperty.GetProxy(i))) - return retVal - elif idx >= len(self) or idx < 0: - raise IndexError - return _getPyProxy(self.SMProperty.GetProxy(idx)) - - def __getattr__(self, name): - "Unknown attribute requests get forwarded to SMProperty." - return getattr(self.SMProperty, name) - - def index(self, proxy): - idx = 0 - for px in self: - ## VSV: == - if proxy.IsSame(px): - return idx - idx += 1 - raise ValueError("proxy is not in the list.") - - def append(self, proxy): - "Appends the given proxy to the property values." - self.SMProperty.AddProxy(proxy.SMProxy) - self._UpdateProperty() - - def GetData(self): - "Returns all elements as either a list or a single value." - property = self.SMProperty - if property.GetRepeatable() or property.GetNumberOfProxies() > 1: - return self[0:len(self)] - else: - if property.GetNumberOfProxies() > 0: - return _getPyProxy(property.GetProxy(0)) - return None - - def SetData(self, values): - """Allows setting of all values at once. Requires a single value, - a tuple or list.""" - if isinstance(values, str): - position = -1 - try: - position = self.Available.index(values) - except: - raise ValueError, values + " is not a valid object in the domain." - values = self.GetDomain('proxy_list').GetProxy(position) - if not isinstance(values, tuple) and \ - not isinstance(values, list): - values = (values,) - self.SMProperty.RemoveAllProxies() - for value in values: - if isinstance(value, Proxy): - value_proxy = value.SMProxy - else: - value_proxy = value - self.SMProperty.AddProxy(value_proxy) - self._UpdateProperty() - - def Clear(self): - "Removes all elements." - self.SMProperty.RemoveAllProxies() - self._UpdateProperty() - -class InputProperty(ProxyProperty): - """An InputProperty allows making pipeline connections. You can set either - a source proxy or an OutputProperty to an input property: - - > property[0] = proxy - or - > property[0] = OuputPort(proxy, 1) - - > property.append(proxy) - or - > property.append(OutputPort(proxy, 0)) - """ - def __setitem__(self, idx, value): - """Given a list or tuple of values, sets a slice of values [min, max)""" - if isinstance(idx, slice): - indices = idx.indices(len(self)) - for i, j in zip(range(*indices), value): - op = value[i-min] - self.SMProperty.SetInputConnection(i, op.SMProxy, op.Port) - self._UpdateProperty() - elif idx >= len(self) or idx < 0: - raise IndexError - else: - self.SMProperty.SetInputConnection(idx, value.SMProxy, value.Port) - self._UpdateProperty() - - def __getitem__(self, idx): - """Returns the range [min, max) of elements. Raises an IndexError - exception if an argument is out of bounds.""" - if isinstance(idx, slice): - indices = idx.indices(len(self)) - retVal = [] - for i in range(*indices): - port = None - if self.SMProperty.GetProxy(i): - port = OutputPort(_getPyProxy(self.SMProperty.GetProxy(i)),\ - self.SMProperty.GetOutputPortForConnection(i)) - retVal.append(port) - return retVal - elif idx >= len(self) or idx < 0: - raise IndexError - return OutputPort(_getPyProxy(self.SMProperty.GetProxy(idx)),\ - self.SMProperty.GetOutputPortForConnection(idx)) - - def append(self, value): - """Appends the given proxy to the property values. - Accepts Proxy or OutputPort objects.""" - self.SMProperty.AddInputConnection(value.SMProxy, value.Port) - self._UpdateProperty() - - def GetData(self): - """Returns all elements as either a list of OutputPort objects or - a single OutputPort object.""" - property = self.SMProperty - if property.GetRepeatable() or property.GetNumberOfProxies() > 1: - return self[0:len(self)] - else: - if property.GetNumberOfProxies() > 0: - return OutputPort(_getPyProxy(property.GetProxy(0)),\ - self.SMProperty.GetOutputPortForConnection(0)) - return None - - def SetData(self, values): - """Allows setting of all values at once. Requires a single value, - a tuple or list. Accepts Proxy or OutputPort objects.""" - if isinstance(values, str): - ProxyProperty.SetData(self, values) - return - if not isinstance(values, tuple) and \ - not isinstance(values, list): - values = (values,) - self.SMProperty.RemoveAllProxies() - for value in values: - if value: - self.SMProperty.AddInputConnection(value.SMProxy, value.Port) - self._UpdateProperty() - - def _UpdateProperty(self): - "Pushes the value of this property to the server." - ProxyProperty._UpdateProperty(self) - iter = PropertyIterator(self.Proxy) - for prop in iter: - if isinstance(prop, ArraySelectionProperty): - prop.UpdateDefault() - - -class DataInformation(object): - """DataInformation is a contained for meta-data associated with an - output data. - - DataInformation is a python wrapper around a vtkPVDataInformation. - In addition to proving all methods of a vtkPVDataInformation, it provides - a few convenience methods. - - Please note that some of the methods accessible through the DataInformation - class are not listed by help() because the DataInformation objects forward - unresolved attributes to the underlying object. To get the full list, - see also dir(proxy.DataInformation). - See also the doxygen based documentation of the vtkPVDataInformation C++ - class. - """ - def __init__(self, dataInformation, proxy, idx): - """Default constructor. Requires a vtkPVDataInformation, a source proxy - and an output port id.""" - self.DataInformation = dataInformation - self.Proxy = proxy - self.Idx = idx - - def Update(self): - """****Deprecated**** There is no reason anymore to use this method - explicitly, it is called automatically when one gets any value from the - data information object. - Update the data information if necessary. Note that this - does not cause execution of the underlying object. In certain - cases, you may have to call UpdatePipeline() on the proxy.""" - if self.Proxy: - self.Proxy.GetDataInformation(self.Idx) - - def GetDataSetType(self): - """Returns the dataset type as defined in vtkDataObjectTypes.""" - self.Update() - if not self.DataInformation: - raise RuntimeError, "No data information is available" - if self.DataInformation.GetCompositeDataSetType() > -1: - return self.DataInformation.GetCompositeDataSetType() - return self.DataInformation.GetDataSetType() - - def GetDataSetTypeAsString(self): - """Returns the dataset type as a user-friendly string. This is - not the same as the enumaration used by VTK""" - return vtk.vtkDataObjectTypes.GetClassNameFromTypeId(self.GetDataSetType()) - - def __getattr__(self, name): - """Forwards unknown attribute requests to the underlying - vtkPVInformation.""" - if not self.DataInformation: - raise AttributeError("class has no attribute %s" % name) - return None - self.Update() - return getattr(self.DataInformation, name) - -class ArrayInformation(object): - """Meta-information associated with an array. Use the Name - attribute to get the array name. - - Please note that some of the methods accessible through the ArrayInformation - class are not listed by help() because the ArrayInformation objects forward - unresolved attributes to the underlying object. - See the doxygen based documentation of the vtkPVArrayInformation C++ - class for a full list. - """ - def __init__(self, proxy, field, name): - self.Proxy = proxy - self.FieldData = field - self.Name = name - - def __getattr__(self, name): - """Forward unknown methods to vtkPVArrayInformation""" - array = self.FieldData.GetFieldData().GetArrayInformation(self.Name) - if not array: return None - return getattr(array, name) - - def __repr__(self): - """Returns a user-friendly representation string.""" - return "Array: " + self.Name - - def GetRange(self, component=0): - """Given a component, returns its value range as a tuple of 2 values.""" - array = self.FieldData.GetFieldData().GetArrayInformation(self.Name) - range = array.GetComponentRange(component) - return (range[0], range[1]) - -class FieldDataInformationIterator(object): - """Iterator for FieldDataInformation""" - - def __init__(self, info, items=False): - self.FieldDataInformation = info - self.index = 0 - self.items = items - - def __iter__(self): - return self - - def next(self): - if self.index >= self.FieldDataInformation.GetNumberOfArrays(): - raise StopIteration - - self.index += 1 - ai = self.FieldDataInformation[self.index-1] - if self.items: - return (ai.GetName(), ai) - else: - return ai - - -class FieldDataInformation(object): - """Meta-data for a field of an output object (point data, cell data etc...). - Provides easy access to the arrays using the slice interface: - > narrays = len(field_info) - > for i in range(narrays): - > array_info = field_info[i] - - Full slice interface is supported: - > arrays = field_info[0:5:3] - where arrays is a list. - - Array access by name is also possible: - > array_info = field_info['Temperature'] - - The number of arrays can also be accessed using the NumberOfArrays - property. - """ - def __init__(self, proxy, idx, field): - self.Proxy = proxy - self.OutputPort = idx - self.FieldData = field - - def GetFieldData(self): - """Convenience method to get the underlying - vtkPVDataSetAttributesInformation""" - return getattr(self.Proxy.GetDataInformation(self.OutputPort), "Get%sInformation" % self.FieldData)() - - def GetNumberOfArrays(self): - """Returns the number of arrays.""" - self.Proxy.UpdatePipeline() - return self.GetFieldData().GetNumberOfArrays() - - def GetArray(self, idx): - """Given an index or a string, returns an array information. - Raises IndexError if the index is out of bounds.""" - self.Proxy.UpdatePipeline() - if not self.GetFieldData().GetArrayInformation(idx): - return None - if isinstance(idx, str): - return ArrayInformation(self.Proxy, self, idx) - elif idx >= len(self) or idx < 0: - raise IndexError - return ArrayInformation(self.Proxy, self, self.GetFieldData().GetArrayInformation(idx).GetName()) - - def __len__(self): - """Returns the number of arrays.""" - return self.GetNumberOfArrays() - - def __getitem__(self, idx): - """Implements the [] operator. Accepts an array name.""" - if isinstance(idx, slice): - indices = idx.indices(self.GetNumberOfArrays()) - retVal = [] - for i in range(*indices): - retVal.append(self.GetArray(i)) - return retVal - return self.GetArray(idx) - - def keys(self): - """Implementation of the dictionary API""" - kys = [] - narrays = self.GetNumberOfArrays() - for i in range(narrays): - kys.append(self.GetArray(i).GetName()) - return kys - - def values(self): - """Implementation of the dictionary API""" - vals = [] - narrays = self.GetNumberOfArrays() - for i in range(narrays): - vals.append(self.GetArray(i)) - return vals - - def iteritems(self): - """Implementation of the dictionary API""" - return FieldDataInformationIterator(self, True) - - def items(self): - """Implementation of the dictionary API""" - itms = [] - narrays = self.GetNumberOfArrays() - for i in range(narrays): - ai = self.GetArray(i) - itms.append((ai.GetName(), ai)) - return itms - - def has_key(self, key): - """Implementation of the dictionary API""" - if self.GetArray(key): - return True - return False - - def __iter__(self): - """Implementation of the dictionary API""" - return FieldDataInformationIterator(self) - - def __getattr__(self, name): - """Forwards unknown attributes to the underlying - vtkPVDataSetAttributesInformation""" - array = self.GetArray(name) - if array: return array - raise AttributeError("class has no attribute %s" % name) - return None - - NumberOfArrays = property(GetNumberOfArrays, None, None, "Returns the number of arrays.") - -def OutputPort(proxy, outputPort=0): - if not Proxy: - return None - if isinstance(outputPort, str): - outputPort = proxy.GetOutputPortIndex(outputPort) - if outputPort >= proxy.GetNumberOfOutputPorts(): - return None - if proxy.Port == outputPort: - return proxy - newinstance = _getPyProxy(proxy.SMProxy, outputPort) - newinstance.Port = outputPort - newinstance._Proxy__Properties = proxy._Proxy__Properties - return newinstance - -class ProxyManager(object): - """When running scripts from the python shell in the ParaView application, - registering proxies with the proxy manager is the only mechanism to - notify the graphical user interface (GUI) that a proxy - exists. Therefore, unless a proxy is registered, it will not show up in - the user interface. Also, the proxy manager is the only way to get - access to proxies created using the GUI. Proxies created using the GUI - are automatically registered under an appropriate group (sources, - filters, representations and views). To get access to these objects, - you can use proxyManager.GetProxy(group, name). The name is the same - as the name shown in the pipeline browser. - - This class is a python wrapper for vtkSMProxyManager. Note that the - underlying vtkSMProxyManager is a singleton. All instances of this - class will refer to the same object. In addition to all methods provided by - vtkSMProxyManager (all unknown attribute requests are forwarded - to the vtkSMProxyManager), this class provides several convenience - methods. - - Please note that some of the methods accessible through the ProxyManager - class are not listed by help() because the ProxyManager objects forwards - unresolved attributes to the underlying object. To get the full list, - see also dir(proxy.SMProxyManager). See also the doxygen based documentation - of the vtkSMProxyManager C++ class. - """ - - def __init__(self, session=None): - """Constructor. Assigned self.SMProxyManager to - vtkSMProxyManager.GetProxyManager().""" - global ActiveConnection - if not session: - session = ActiveConnection.Session - self.SMProxyManager = session.GetSessionProxyManager() - - def RegisterProxy(self, group, name, aProxy): - """Registers a proxy (either SMProxy or proxy) with the - server manager""" - if isinstance(aProxy, Proxy): - self.SMProxyManager.RegisterProxy(group, name, aProxy.SMProxy) - else: - self.SMProxyManager.RegisterProxy(group, name, aProxy) - - def NewProxy(self, group, name): - """Creates a new proxy of given group and name and returns an SMProxy. - Note that this is a server manager object. You should normally create - proxies using the class objects. For example: - obj = servermanager.sources.SphereSource()""" - if not self.SMProxyManager: - return None - aProxy = self.SMProxyManager.NewProxy(group, name, "NULL") - if not aProxy: - return None - aProxy.UnRegister(None) - return aProxy - - def GetProxy(self, group, name): - """Returns a Proxy registered under a group and name""" - if not self.SMProxyManager: - return None - aProxy = self.SMProxyManager.GetProxy(group, name) - if not aProxy: - return None - return _getPyProxy(aProxy) - - def GetPrototypeProxy(self, group, name): - """Returns a prototype proxy given a group and name. This is an - SMProxy. This is a low-level method. You should not normally - have to call it.""" - if not self.SMProxyManager: - return None - aProxy = self.SMProxyManager.GetPrototypeProxy(group, name) - if not aProxy: - return None - return aProxy - - def GetProxiesInGroup(self, groupname): - """Returns a map of proxies in a particular group.""" - proxies = {} - iter = self.NewGroupIterator(groupname) - for aProxy in iter: - proxies[(iter.GetKey(), aProxy.GetGlobalIDAsString())] = aProxy - return proxies - - def UnRegisterProxy(self, groupname, proxyname, aProxy): - """Unregisters a proxy.""" - if not self.SMProxyManager: - return - if aProxy != None and isinstance(aProxy,Proxy): - aProxy = aProxy.SMProxy - if aProxy: - self.SMProxyManager.UnRegisterProxy(groupname, proxyname, aProxy) - - def GetProxies(self, groupname, proxyname): - """Returns all proxies registered under the given group with the - given name. Note that it is possible to register more than one - proxy with the same name in the same group. Because the proxies - are different, there is no conflict. Use this method instead of - GetProxy() if you know that there are more than one proxy registered - with this name.""" - if not self.SMProxyManager: - return [] - collection = vtk.vtkCollection() - result = [] - self.SMProxyManager.GetProxies(groupname, proxyname, collection) - for i in range(0, collection.GetNumberOfItems()): - aProxy = _getPyProxy(collection.GetItemAsObject(i)) - if aProxy: - result.append(aProxy) - - return result - - def __iter__(self): - """Returns a new ProxyIterator.""" - iter = ProxyIterator() - iter.Begin() - return iter - - def NewGroupIterator(self, group_name): - """Returns a ProxyIterator for a group. The resulting object - can be used to traverse the proxies that are in the given - group.""" - iter = self.__iter__() - iter.SetModeToOneGroup() - iter.Begin(group_name) - return iter - - def NewDefinitionIterator(self, groupname=None): - """Returns an iterator that can be used to iterate over - all groups and types of proxies that the proxy manager - can create.""" - iter = None - if groupname != None: - iter = ProxyDefinitionIterator(self.GetProxyDefinitionManager().NewSingleGroupIterator(groupname,0)) - else: - iter = ProxyDefinitionIterator(self.GetProxyDefinitionManager().NewIterator(0)) - - return iter - - def __ConvertArgumentsAndCall(self, *args): - newArgs = [] - for arg in args: - if issubclass(type(arg), Proxy) or isinstance(arg, Proxy): - newArgs.append(arg.SMProxy) - else: - newArgs.append(arg) - func = getattr(self.SMProxyManager, self.__LastAttrName) - retVal = func(*newArgs) - if type(retVal) is type(self.SMProxyManager) and retVal.IsA("vtkSMProxy"): - return _getPyProxy(retVal) - else: - return retVal - - def __getattr__(self, name): - """Returns attribute from the ProxyManager""" - try: - pmAttr = getattr(self.SMProxyManager, name) - self.__LastAttrName = name - return self.__ConvertArgumentsAndCall - except: - pass - return getattr(self.SMProxyManager, name) - - def LoadState(self, filename, loader = None): - self.SMProxyManager.LoadXMLState(filename, loader) - - def SaveState(self, filename): - self.SMProxyManager.SaveXMLState(filename) - -class PropertyIterator(object): - """Wrapper for a vtkSMPropertyIterator class to satisfy - the python iterator protocol. Note that the list of - properties can also be obtained from the class object's - dictionary. - See the doxygen documentation for vtkSMPropertyIterator C++ - class for details. - """ - - def __init__(self, aProxy): - self.SMIterator = aProxy.NewPropertyIterator() - if self.SMIterator: - self.SMIterator.UnRegister(None) - self.SMIterator.Begin() - self.Key = None - self.PropertyLabel = None - self.Proxy = aProxy - - def __iter__(self): - return self - - def next(self): - if not self.SMIterator: - raise StopIteration - - if self.SMIterator.IsAtEnd(): - self.Key = None - raise StopIteration - self.Key = self.SMIterator.GetKey() - self.PropertyLabel = self.SMIterator.GetPropertyLabel() - self.SMIterator.Next() - return self.Proxy.GetProperty(self.Key) - - def GetProxy(self): - """Returns the proxy for the property last returned by the call to - 'next()'""" - return self.Proxy - - def GetKey(self): - """Returns the key for the property last returned by the call to - 'next()' """ - return self.Key - - def GetProperty(self): - """Returns the property last returned by the call to 'next()' """ - return self.Proxy.GetProperty(self.Key) - - def __getattr__(self, name): - """returns attributes from the vtkSMPropertyIterator.""" - return getattr(self.SMIterator, name) - -class ProxyDefinitionIterator(object): - """Wrapper for a vtkPVProxyDefinitionIterator class to satisfy - the python iterator protocol. - See the doxygen documentation of the vtkPVProxyDefinitionIterator - C++ class for more information.""" - def __init__(self, iter): - self.SMIterator = iter - if self.SMIterator: - self.SMIterator.UnRegister(None) - self.SMIterator.InitTraversal() - self.Group = None - self.Key = None - - def __iter__(self): - return self - - def next(self): - if self.SMIterator.IsDoneWithTraversal(): - self.Group = None - self.Key = None - raise StopIteration - self.Group = self.SMIterator.GetGroupName() - self.Key = self.SMIterator.GetProxyName() - self.SMIterator.GoToNextItem() - return {"group": self.Group, "key":self.Key } - - def GetProxyName(self): - """Returns the key for the proxy definition last returned by the call - to 'next()' """ - return self.Key - - def GetGroup(self): - """Returns the group for the proxy definition last returned by the - call to 'next()' """ - return self.Group - - def __getattr__(self, name): - """returns attributes from the vtkPVProxyDefinitionIterator.""" - return getattr(self.SMIterator, name) - - -class ProxyIterator(object): - """Wrapper for a vtkSMProxyIterator class to satisfy the - python iterator protocol. - See the doxygen documentation of vtkSMProxyIterator C++ class for - more information. - """ - def __init__(self): - self.SMIterator = vtkSMProxyIterator() - self.SMIterator.SetSession(ActiveConnection.Session) - self.SMIterator.Begin() - self.AProxy = None - self.Group = None - self.Key = None - - def __iter__(self): - return self - - def next(self): - if self.SMIterator.IsAtEnd(): - self.AProxy = None - self.Group = None - self.Key = None - raise StopIteration - return None - self.AProxy = _getPyProxy(self.SMIterator.GetProxy()) - self.Group = self.SMIterator.GetGroup() - self.Key = self.SMIterator.GetKey() - self.SMIterator.Next() - return self.AProxy - - def GetProxy(self): - """Returns the proxy last returned by the call to 'next()'""" - return self.AProxy - - def GetKey(self): - """Returns the key for the proxy last returned by the call to - 'next()' """ - return self.Key - - def GetGroup(self): - """Returns the group for the proxy last returned by the call to - 'next()' """ - return self.Group - - def __getattr__(self, name): - """returns attributes from the vtkSMProxyIterator.""" - return getattr(self.SMIterator, name) - -# Caution: Observers must be global methods otherwise we run into memory -# leak when the interpreter get reset from the C++ layer. -def _update_definitions(caller, event): - updateModules(ActiveConnection.Modules) - -class Connection(object): - """ - This is a python representation for a session/connection. - """ - def __init__(self, connectionId, session): - """Default constructor. Creates a Connection with the given - ID, all other data members initialized to None.""" - global MultiServerConnections - global ActiveConnection - self.ID = connectionId - self.Session = session - self.Modules = PVModule() - self.Alive = True - self.DefinitionObserverTag = 0 - self.CustomDefinitionObserverTag = 0 - if MultiServerConnections == None and ActiveConnection: - raise RuntimeError, "Concurrent connections not supported!" - if MultiServerConnections != None and not self in MultiServerConnections: - MultiServerConnections.append(self) - ActiveConnection = self - __InitAfterConnect__(self) - __exposeActiveModules__() - - def __eq__(self, other): - "Returns true if the connection ids are the same." - return (self.ID == other.ID) - - def __repr__(self): - """User friendly string representation""" - return "Connection (%s) [%d]" % (self.Session.GetURI(), self.ID) - - def GetURI(self): - """Get URI of the connection""" - return self.Session.GetURI() - - def IsRemote(self): - """Returns True if the connection to a remote server, False if - it is local (built-in)""" - if self.Session.IsA("vtkSMSessionClient"): - return True - return False - - def GetNumberOfDataPartitions(self): - """Returns the number of partitions on the data server for this - connection""" - return self.Session.GetServerInformation().GetNumberOfProcesses() - - def AttachDefinitionUpdater(self): - """Attach observer to automatically update modules when needed.""" - # VTN: Observers are not supported - # ProxyDefinitionsUpdated = 2000 -## self.DefinitionObserverTag = self.Session.GetProxyDefinitionManager().AddObserver(2000, _update_definitions) - # CompoundProxyDefinitionsUpdated = 2001 -## self.CustomDefinitionObserverTag = self.Session.GetProxyDefinitionManager().AddObserver(2001, _update_definitions) - pass - - def close(self): - if self.DefinitionObserverTag: - self.Session.GetProxyDefinitionManager().RemoveObserver(self.DefinitionObserverTag) - self.Session.GetProxyDefinitionManager().RemoveObserver(self.CustomDefinitionObserverTag) - self.Session = None - self.Modules = None - self.Alive = False - - def __del__(self): - if self.Alive: - self.close() - -def SaveState(filename): - """Given a state filename, saves the state of objects registered - with the proxy manager.""" - pm = ProxyManager() - pm.SaveState(filename) - -def LoadState(filename, connection=None): - """Given a state filename and an optional connection, loads the server - manager state.""" - if not connection: - connection = ActiveConnection - if not connection: - raise RuntimeError, "Cannot load state without a connection" - pm = ProxyManager() - pm.LoadState(filename, None) - views = GetRenderViews() - for view in views: - # Make sure that the client window size matches the - # ViewSize property. In paraview, the GUI takes care - # of this. - if view.GetClassName() == "vtkSMIceTDesktopRenderViewProxy": - view.GetRenderWindow().SetSize(view.ViewSize[0], \ - view.ViewSize[1]) - -def InitFromGUI(): - """ - Method used to initialize the Python Shell from the ParaView GUI. - """ - global fromGUI, ActiveConnection - if not fromGUI: - print "from paraview.simple import *" - fromGUI = True - # ToggleProgressPrinting() ### FIXME COLLABORATION - enableMultiServer(vtkProcessModule.GetProcessModule().GetMultipleSessionsSupport()) - iter = vtkProcessModule.GetProcessModule().NewSessionIterator(); - iter.InitTraversal() - ActiveConnection = None - activeSession = vtkSMProxyManager.GetProxyManager().GetActiveSession() - tmpActiveConnection = None - while not iter.IsDoneWithTraversal(): - c = Connection(iter.GetCurrentSessionId(), iter.GetCurrentSession()) - if c.Session == activeSession: - tmpActiveConnection = c - iter.GoToNextItem() - iter.UnRegister(None) - if tmpActiveConnection: - ActiveConnection = tmpActiveConnection - -def Connect(ds_host=None, ds_port=11111, rs_host=None, rs_port=22221): - """ - Use this function call to create a new session. On success, - it returns a vtkSMSession object that abstracts the connection. - Otherwise, it returns None. - There are several ways in which this function can be called: - * When called with no arguments, it creates a new session - to the built-in server on the client itself. - * When called with ds_host and ds_port arguments, it - attempts to connect to a server(data and render server on the same server) - on the indicated host:port. - * When called with ds_host, ds_port, rs_host, rs_port, it - creates a new connection to the data server on ds_host:ds_port and to the - render server on rs_host: rs_port. - """ - if ds_host == None: - session = vtkSMSession() - elif rs_host == None: - session = vtkSMSessionClient() - session.Connect("cs://%s:%d" % (ds_host, ds_port)) - else: - session = vtkSMSessionClient() - session.Connect("cdsrs://%s:%d/%s:%d" % (ds_host, ds_port, rs_host, rs_port)) - id = vtkProcessModule.GetProcessModule().RegisterSession(session) - connection = Connection(id, session) - return connection - -def ReverseConnect(port=11111): - """ - Use this function call to create a new session. On success, - it returns a Session object that abstracts the connection. - Otherwise, it returns None. - In reverse connection mode, the client waits for a connection - from the server (client has to be started first). The server - then connects to the client (run pvserver with -rc and -ch - option). - The optional port specified the port to listen to. - """ - session = vtkSMSessionClient() - session.Connect("csrc://hostname:" + port) - id = vtkProcessModule.GetProcessModule().RegisterSession(session) - connection = Connection(id, session) - return connection - -def Disconnect(session=None): - """Disconnects the connection. Make sure to clear the proxy manager - first.""" - global ActiveConnection - global MultiServerConnections - global fromGUI - if fromGUI: - # Let the UI know that we want to disconnect - ActiveConnection.Session.InvokeEvent('ExitEvent') - return - if ActiveConnection and (not session or session == ActiveConnection.Session): - session = ActiveConnection.Session - if MultiServerConnections: - MultiServerConnections.remove(ActiveConnection) - ActiveConnection.close() - ActiveConnection = None - switchActiveConnection() - else: - ActiveConnection.close() - ActiveConnection = None - elif MultiServerConnections: - for connection in MultiServerConnections: - if connection.Session == session: - connection.close() - MultiServerConnections.remove(connection) - if session: - vtkProcessModule.GetProcessModule().UnRegisterSession(session) - return - -def CreateProxy(xml_group, xml_name, session=None): - """Creates a proxy. If session is set, the proxy's session is - set accordingly. If session is None, the current Session is used, if - present. You should not have to use method normally. Instantiate the - appropriate class from the appropriate module, for example: - sph = servermanager.sources.SphereSource()""" - global ActiveConnection - if not session: - session = ActiveConnection.Session - if not session: - raise RuntimeError, "Cannot create objects without a session." - pxm = ProxyManager(session) - return pxm.NewProxy(xml_group, xml_name) - -def GetRenderView(connection=None): - """Return the render view in use. If more than one render view is in - use, return the first one.""" - - render_module = None - for aProxy in ProxyManager(): - if aProxy.IsA("vtkSMRenderViewProxy"): - render_module = aProxy - break - return render_module - -def GetRenderViews(connection=None): - """Returns the set of all render views.""" - render_modules = [] - for aProxy in ProxyManager(): - if aProxy.IsA("vtkSMRenderViewProxy"): - render_modules.append(aProxy) - return render_modules - -def GetContextViews(connection=None): - """Returns the set of all context views.""" - context_modules = [] - for aProxy in ProxyManager(): - if aProxy.IsA("vtkSMContextViewProxy"): - context_modules.append(aProxy) - return context_modules - -def CreateRenderView(session=None, **extraArgs): - """Creates a render window on the particular session. If session - is not specified, then the active session is used, if available. - - This method can also be used to initialize properties by passing - keyword arguments where the key is the name of the property. In addition - registrationGroup and registrationName (optional) can be specified (as - keyword arguments) to automatically register the proxy with the proxy - manager.""" - return _create_view("RenderView", session, **extraArgs) - -def _create_view(view_xml_name, session=None, **extraArgs): - """Creates a view on the particular session. If session - is not specified, then the active session is used, if available. - This method can also be used to initialize properties by passing - keyword arguments where the key is the name of the property.""" - if not session: - session = ActiveConnection.Session - if not session: - raise RuntimeError, "Cannot create view without session." - pxm = ProxyManager() - view_module = None - if view_xml_name: - view_module = CreateProxy("views", view_xml_name, session) - if not view_module: - return None - extraArgs['proxy'] = view_module - python_proxy_name = _make_name_valid(view_module.GetXMLName()) - proxy = rendering.__dict__[python_proxy_name](**extraArgs) - return proxy - -def GetRepresentation(aProxy, view): - for rep in view.Representations: - #VSV: == - try: isRep = rep.Input.IsSame(aProxy) - except: isRep = False - if isRep: return rep - return None - -def CreateRepresentation(aProxy, view, **extraArgs): - """Creates a representation for the proxy and adds it to the render - module. - - This method can also be used to initialize properties by passing - keyword arguments where the key is the name of the property.In addition - registrationGroup and registrationName (optional) can be specified (as - keyword arguments) to automatically register the proxy with the proxy - manager. - - This method tries to create the best possible representation for the given - proxy in the given view. Additionally, the user can specify proxyName - (optional) to create a representation of a particular type.""" - - global rendering - if not aProxy: - raise RuntimeError, "proxy argument cannot be None." - if not view: - raise RuntimeError, "view argument cannot be None." - if "proxyName" in extraArgs: - display = CreateProxy("representations", extraArgs['proxyName'], None) - del extraArgs['proxyName'] - else: - display = view.SMProxy.CreateDefaultRepresentation(aProxy.SMProxy, 0) - if display: - display.UnRegister(None) - if not display: - return None - extraArgs['proxy'] = display - proxy = rendering.__dict__[display.GetXMLName()](**extraArgs) - proxy.Input = aProxy - proxy.UpdateVTKObjects() - view.Representations.append(proxy) - return proxy - -class _ModuleLoader(object): - def find_module(self, fullname, path=None): - if vtkPVPythonModule.HasModule(fullname): - return self - else: - return None - def load_module(self, fullname): - import imp - moduleInfo = vtkPVPythonModule.GetModule(fullname) - if not moduleInfo: - raise ImportError - module = sys.modules.setdefault(fullname, imp.new_module(fullname)) - module.__file__ = "<%s>" % moduleInfo.GetFullName() - module.__loader__ = self - if moduleInfo.GetIsPackage: - module.__path__ = moduleInfo.GetFullName() - code = compile(moduleInfo.GetSource(), module.__file__, 'exec') - exec code in module.__dict__ - return module - -def LoadXML(xmlstring): - """DEPRECATED. Given a server manager XML as a string, parse and process it.""" - raise RuntimeError, "Deprecated. Use LoadPlugin(...) instead." - - -def LoadPlugin(filename, remote=True, connection=None): - """ Given a filename and a session (optional, otherwise uses - ActiveConnection), loads a plugin. It then updates the sources, - filters and rendering modules.""" - - if not connection: - connection = ActiveConnection - if not connection: - raise RuntimeError, "Cannot load a plugin without a connection." - plm = vtkSMProxyManager.GetProxyManager().GetPluginManager() - - if remote: - status = plm.LoadRemotePlugin(filename, connection.Session) - else: - status = plm.LoadLocalPlugin(filename) - - # shouldn't the extension check happend before attempting to load the plugin? - if not status: - raise RuntimeError, "Problem loading plugin %s" % (filename) - else: - # we should never have to call this. The modules should update automatically. - updateModules(connection.Modules) - - -def Fetch(input, arg1=None, arg2=None, idx=0): - """ - A convenience method that moves data from the server to the client, - optionally performing some operation on the data as it moves. - The input argument is the name of the (proxy for a) source or filter - whose output is needed on the client. - - You can use Fetch to do three things: - - If arg1 is None (the default) then all of the data is brought to the client. - In parallel runs an appropriate append Filter merges the - data on each processor into one data object. The filter chosen will be - vtkAppendPolyData for vtkPolyData, vtkAppendRectilinearGrid for - vtkRectilinearGrid, vtkMultiBlockDataGroupFilter for vtkCompositeData, - and vtkAppendFilter for anything else. - - If arg1 is an integer then one particular processor's output is brought to - the client. In serial runs the arg is ignored. If you have a filter that - computes results in parallel and brings them to the root node, then set - arg to be 0. - - If arg1 and arg2 are a algorithms, for example vtkMinMax, the algorithm - will be applied to the data to obtain some result. Here arg1 will be - applied pre-gather and arg2 will be applied post-gather. In parallel - runs the algorithm will be run on each processor to make intermediate - results and then again on the root processor over all of the - intermediate results to create a global result. - - Optional argument idx is used to specify the output port number to fetch the - data from. Default is port 0. - """ - - import types - - reducer = filters.ReductionFilter(Input=OutputPort(input,idx)) - - #create the pipeline that reduces and transmits the data - if arg1 == None: - cdinfo = input.GetDataInformation(idx).GetCompositeDataInformation() - if cdinfo.GetDataIsComposite(): - print "use composite data append" - reducer.PostGatherHelperName = "vtkMultiBlockDataGroupFilter" - - elif input.GetDataInformation(idx).GetDataClassName() == "vtkPolyData": - print "use append poly data filter" - reducer.PostGatherHelperName = "vtkAppendPolyData" - - elif input.GetDataInformation(idx).GetDataClassName() == "vtkRectilinearGrid": - print "use append rectilinear grid filter" - reducer.PostGatherHelperName = "vtkAppendRectilinearGrid" - - elif input.GetDataInformation(idx).IsA("vtkDataSet"): - print "use unstructured append filter" - reducer.PostGatherHelperName = "vtkAppendFilter" - - elif type(arg1) is types.IntType: - reducer.PassThrough = arg1 - - else: - reducer.PreGatherHelper = arg1 - reducer.PostGatherHelper = arg2 - - # reduce - reducer.UpdatePipeline() - dataInfo = reducer.GetDataInformation(0) - dataType = dataInfo.GetDataSetType() - if dataInfo.GetCompositeDataSetType() > 0: - dataType = dataInfo.GetCompositeDataSetType() - - fetcher = filters.ClientServerMoveData(Input=reducer) - fetcher.OutputDataType = dataType - fetcher.WholeExtent = dataInfo.GetExtent()[:] - #fetch - fetcher.UpdatePipeline() - - op = fetcher.GetClientSideObject().GetOutputDataObject(0) - opc = op.NewInstance() - opc.ShallowCopy(op) - opc.UnRegister(None) - return opc - -def AnimateReader(reader, view, 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: - raise RuntimeError, "No reader was specified, cannot animate." - if not view: - raise RuntimeError, "No view was specified, cannot animate." - # Create an animation scene - scene = animation.AnimationScene() - - # We need to have the reader and the view registered with - # the time keeper. This is how the scene gets its time values. - try: - tk = ProxyManager().GetProxiesInGroup("timekeeper").values()[0] - scene.TimeKeeper = tk - except IndexError: - tk = misc.TimeKeeper() - scene.TimeKeeper = tk - - if not reader in tk.TimeSources: - tk.TimeSources.append(reader) - if not view in tk.Views: - tk.Views.append(view) - - - # with 1 view - scene.ViewModules = [view] - # Update the reader to get the time information - reader.UpdatePipelineInformation() - # Animate from 1st time step to last - scene.StartTime = reader.TimestepValues.GetData()[0] - scene.EndTime = reader.TimestepValues.GetData()[-1] - - # Each frame will correspond to a time step - scene.PlayMode = 2 #Snap To Timesteps - - # Create a special animation cue for time. - cue = animation.TimeAnimationCue() - cue.AnimatedProxy = view - cue.AnimatedPropertyName = "ViewTime" - scene.Cues = [cue] - - if filename: - writer = vtkSMAnimationSceneImageWriter() - writer.SetFileName(filename) - writer.SetFrameRate(1) - writer.SetAnimationScene(scene.SMProxy) - - # Now save the animation. - if not writer.Save(): - raise RuntimeError, "Saving of animation failed!" - else: - scene.Play() - return scene - -def GetProgressPrintingIsEnabled(): - return progressObserverTag is not None - -def SetProgressPrintingEnabled(value): - """Is not supported because of not supported observers""" - pass - -def ToggleProgressPrinting(): - """Turn on/off printing of progress. See SetProgressPrintingEnabled.""" - SetProgressPrintingEnabled(not GetProgressPrintingIsEnabled()) - -def Finalize(): - """Although not required, this can be called at exit to cleanup.""" - global progressObserverTag - # Make sure to remove the observer - if progressObserverTag: - ToggleProgressPrinting() - vtkInitializationHelper.Finalize() - -# Internal methods - -def _getPyProxy(smproxy, outputPort=0): - """Returns a python wrapper for a server manager proxy. This method - first checks if there is already such an object by looking in the - _pyproxies group and returns it if found. Otherwise, it creates a - new one. Proxies register themselves in _pyproxies upon creation.""" - if not smproxy: - return None - if (smproxy, outputPort) in _pyproxies: - return _pyproxies[(smproxy, outputPort)]() - - xmlName = smproxy.GetXMLName() - if smproxy.GetXMLLabel(): - xmlName = smproxy.GetXMLLabel() - classForProxy = _findClassForProxy(_make_name_valid(xmlName), smproxy.GetXMLGroup()) - if classForProxy: - retVal = classForProxy(proxy=smproxy, port=outputPort) - else: - retVal = Proxy(proxy=smproxy, port=outputPort) - return retVal - -def _makeUpdateCameraMethod(rv): - """ This internal method is used to create observer methods """ - if not hasattr(rv(), "BlockUpdateCamera"): - rv().add_attribute("BlockUpdateCamera", False) - def UpdateCamera(obj, string): - if not rv().BlockUpdateCamera: - # used to avoid some nasty recursion that occurs when interacting in - # the GUI. - rv().BlockUpdateCamera = True - rv().SynchronizeCameraProperties() - rv().BlockUpdateCamera = False - return UpdateCamera - -def _createInitialize(group, name): - """Internal method to create an Initialize() method for the sub-classes - of Proxy""" - pgroup = group - pname = name - def aInitialize(self, connection=None, update=True): - if not connection: - connection = ActiveConnection - if not connection: - raise RuntimeError,\ - 'Cannot create a proxy without a session.' - if not connection.Session.GetProxyDefinitionManager().HasDefinition(pgroup, pname): - error_msg = "The connection does not provide any definition for %s." % pname - raise RuntimeError, error_msg - self.InitializeFromProxy(\ - CreateProxy(pgroup, pname, connection.Session), update) - return aInitialize - -def _createGetProperty(pName): - """Internal method to create a GetXXX() method where XXX == pName.""" - propName = pName - def getProperty(self): - return self.GetPropertyValue(propName) - return getProperty - -def _createSetProperty(pName): - """Internal method to create a SetXXX() method where XXX == pName.""" - propName = pName - def setProperty(self, value): - return self.SetPropertyWithName(propName, value) - return setProperty - -def _findClassForProxy(xmlName, xmlGroup): - """Given the xmlName for a proxy, returns a Proxy class. Note - that if there are duplicates, the first one is returned.""" - global sources, filters, writers, rendering, animation, implicit_functions,\ - piecewise_functions, extended_sources, misc - if not xmlName: - return None - if xmlGroup == "sources": - return sources.__dict__[xmlName] - elif xmlGroup == "filters": - return filters.__dict__[xmlName] - elif xmlGroup == "implicit_functions": - return implicit_functions.__dict__[xmlName] - elif xmlGroup == "piecewise_functions": - return piecewise_functions.__dict__[xmlName] - elif xmlGroup == "writers": - return writers.__dict__[xmlName] - elif xmlGroup == "extended_sources": - return extended_sources.__dict__[xmlName] - elif xmlName in rendering.__dict__: - return rendering.__dict__[xmlName] - elif xmlName in animation.__dict__: - return animation.__dict__[xmlName] - elif xmlName in misc.__dict__: - return misc.__dict__[xmlName] - else: - return None - -def _printProgress(caller, event): - """The default event handler for progress. Prints algorithm - name and 1 '.' per 10% progress.""" - global currentAlgorithm, currentProgress - - pm = vtkProcessModule.GetProcessModule() - progress = pm.GetLastProgress() / 10 - # If we got a 100% as the first thing, ignore - # This is to get around the fact that some vtk - # algorithms report 100% more than once (which is - # a bug) - if not currentAlgorithm and progress == 10: - return - alg = pm.GetLastProgressName() - if alg != currentAlgorithm and alg: - if currentAlgorithm: - while currentProgress <= 10: - import sys - sys.stdout.write(".") - currentProgress += 1 - print "]" - currentProgress = 0 - print alg, ": [ ", - currentAlgorithm = alg - while currentProgress <= progress: - import sys - sys.stdout.write(".") - #sys.stdout.write("%d " % pm.GetLastProgress()) - currentProgress += 1 - if progress == 10: - print "]" - currentAlgorithm = None - currentProgress = 0 - -def updateModules(m): - """Called when a plugin is loaded, this method updates - the proxy class object in all known modules.""" - - createModule("sources", m.sources) - createModule("filters", m.filters) - createModule("writers", m.writers) - createModule("representations", m.rendering) - createModule("views", m.rendering) - createModule("lookup_tables", m.rendering) - createModule("textures", m.rendering) - createModule('cameramanipulators', m.rendering) - createModule("animation", m.animation) - createModule("misc", m.misc) - createModule('animation_keyframes', m.animation) - createModule('implicit_functions', m.implicit_functions) - createModule('piecewise_functions', m.piecewise_functions) - createModule("extended_sources", m.extended_sources) - createModule("incremental_point_locators", m.misc) - -def _createModules(m): - """Called when the module is loaded, this creates sub- - modules for all know proxy groups.""" - - m.sources = createModule('sources') - m.filters = createModule('filters') - m.writers = createModule('writers') - m.rendering = createModule('representations') - createModule('views', m.rendering) - createModule("lookup_tables", m.rendering) - createModule("textures", m.rendering) - createModule('cameramanipulators', m.rendering) - m.animation = createModule('animation') - createModule('animation_keyframes', m.animation) - m.implicit_functions = createModule('implicit_functions') - m.piecewise_functions = createModule('piecewise_functions') - m.extended_sources = createModule("extended_sources") - m.misc = createModule("misc") - createModule("incremental_point_locators", m.misc) - -class PVModule(object): - pass - -def _make_name_valid(name): - """Make a string into a valid Python variable name.""" - if not name: - return None - import string - valid_chars = "_%s%s" % (string.ascii_letters, string.digits) - name = str().join([c for c in name if c in valid_chars]) - if not name[0].isalpha(): - name = 'a' + name - return name - -def createModule(groupName, mdl=None): - """Populates a module with proxy classes defined in the given group. - If mdl is not specified, it also creates the module""" - global ActiveConnection - - if not ActiveConnection: - raise RuntimeError, "Please connect to a server using \"Connect\"" - - pxm = ProxyManager() - # Use prototypes to find all proxy types. - pxm.InstantiateGroupPrototypes(groupName) - - debug = False - if not mdl: - debug = True - mdl = PVModule() - definitionIter = pxm.NewDefinitionIterator(groupName) - for i in definitionIter: - proxyName = i['key'] - proto = pxm.GetPrototypeProxy(groupName, proxyName) - if not proto: - print "Error while loading %s/%s %s"%(groupName, i['group'], proxyName) - continue - pname = proxyName - if proto.GetXMLLabel(): - pname = proto.GetXMLLabel() - pname = _make_name_valid(pname) - if not pname: - continue - if pname in mdl.__dict__: - if debug: - print "Warning: %s is being overwritten. This may point to an issue in the ParaView configuration files" % pname - cdict = {} - # Create an Initialize() method for this sub-class. - cdict['Initialize'] = _createInitialize(groupName, proxyName) - iter = PropertyIterator(proto) - # Add all properties as python properties. - for prop in iter: - propName = iter.GetKey() - if (prop.GetInformationOnly() and propName != "TimestepValues" ) \ - or prop.GetIsInternal(): - continue - names = [propName] - names = [iter.PropertyLabel] - - propDoc = None - if prop.GetDocumentation(): - propDoc = prop.GetDocumentation().GetDescription() - for name in names: - name = _make_name_valid(name) - if name: - cdict[name] = property(_createGetProperty(propName), - _createSetProperty(propName), - None, - propDoc) - # Add the documentation as the class __doc__ - if proto.GetDocumentation() and \ - proto.GetDocumentation().GetDescription(): - doc = proto.GetDocumentation().GetDescription() - else: - doc = Proxy.__doc__ - cdict['__doc__'] = doc - # Create the new type - if proto.GetXMLName() == "ExodusIIReader": - superclasses = (ExodusIIReaderProxy,) - elif proto.IsA("vtkSMSourceProxy"): - superclasses = (SourceProxy,) - elif proto.IsA("vtkSMViewLayoutProxy"): - superclasses = (ViewLayoutProxy,) - else: - superclasses = (Proxy,) - - cobj = type(pname, superclasses, cdict) - # Add it to the modules dictionary - mdl.__dict__[pname] = cobj - return mdl - - -def __determineGroup(proxy): - """Internal method""" - if not proxy: - return None - xmlgroup = proxy.GetXMLGroup() - xmlname = proxy.GetXMLName() - if xmlgroup == "sources": - if xmlname in ["BlockSelectionSource", - "FrustumSelectionSource", - "GlobalIDSelectionSource", - "PedigreeIDSelectionSource", - "IDSelectionSource", - "CompositeDataIDSelectionSource", - "HierarchicalDataIDSelectionSource", - "ThresholdSelectionSource", - "LocationSelectionSource"]: - return "selection_sources" - return "sources" - elif xmlgroup == "filters": - return "sources" - elif xmlgroup == "representations": - if xmlname == "ScalarBarWidgetRepresentation": - return "scalar_bars" - return "representations" - elif xmlgroup == "animation_keyframes": - return "animation" - return xmlgroup - -__nameCounter = {} -def __determineName(proxy, group): - global __nameCounter - name = _make_name_valid(proxy.GetXMLLabel()) - if not name: - return None - if not __nameCounter.has_key(name): - __nameCounter[name] = 1 - val = 1 - else: - __nameCounter[name] += 1 - val = __nameCounter[name] - return "%s%d" % (name, val) - -def __getName(proxy, group): - pxm = ProxyManager(proxy.GetSession()) - if isinstance(proxy, Proxy): - proxy = proxy.SMProxy - return pxm.GetProxyName(group, proxy) - -class MissingRegistrationInformation(Exception): - """Exception for missing registration information. Raised when a name or group - is not specified or when a group cannot be deduced.""" - pass - -class MissingProxy(Exception): - """Exception fired when the requested proxy is missing.""" - pass - -def Register(proxy, **extraArgs): - """Registers a proxy with the proxy manager. If no 'registrationGroup' is - specified, then the group is inferred from the type of the proxy. - 'registrationName' may be specified to register with a particular name - otherwise a default name will be created.""" - # TODO: handle duplicate registration - if "registrationGroup" in extraArgs: - registrationGroup = extraArgs["registrationGroup"] - else: - registrationGroup = __determineGroup(proxy) - - if "registrationName" in extraArgs: - registrationName = extraArgs["registrationName"] - else: - registrationName = __determineName(proxy, registrationGroup) - if registrationGroup and registrationName: - pxm = ProxyManager() - pxm.RegisterProxy(registrationGroup, registrationName, proxy) - else: - raise MissingRegistrationInformation, "Registration error %s %s." % (registrationGroup, registrationName) - return (registrationGroup, registrationName) - -def UnRegister(proxy, **extraArgs): - """UnRegisters proxies registered using Register().""" - if "registrationGroup" in extraArgs: - registrationGroup = extraArgs["registrationGroup"] - else: - registrationGroup = __determineGroup(proxy) - - if "registrationName" in extraArgs: - registrationName = extraArgs["registrationName"] - else: - registrationName = __getName(proxy, registrationGroup) - - if registrationGroup and registrationName: - pxm = ProxyManager() - pxm.UnRegisterProxy(registrationGroup, registrationName, proxy) - else: - raise RuntimeError, "UnRegistration error." - return (registrationGroup, registrationName) - -def demo1(): - """This simple demonstration creates a sphere, renders it and delivers - it to the client using Fetch. It returns a tuple of (data, render - view)""" - if not ActiveConnection: - Connect() - ss = sources.Sphere(Radius=2, ThetaResolution=32) - shr = filters.Shrink(Input=OutputPort(ss,0)) - cs = sources.Cone() - app = filters.AppendDatasets() - app.Input = [shr, cs] - rv = CreateRenderView() - rep = CreateRepresentation(app, rv) - rv.ResetCamera() - rv.StillRender() - data = Fetch(ss) - - return (data, rv) - -def demo2(fname="/Users/berk/Work/ParaViewData/Data/disk_out_ref.ex2"): - """This method demonstrates the user of a reader, representation and - view. It also demonstrates how meta-data can be obtained using proxies. - Make sure to pass the full path to an exodus file. Also note that certain - parameters are hard-coded for disk_out_ref.ex2 which can be found - in ParaViewData. This method returns the render view.""" - if not ActiveConnection: - Connect() - # Create the exodus reader and specify a file name - reader = sources.ExodusIIReader(FileName=fname) - # Get the list of point arrays. - arraySelection = reader.PointVariables - print arraySelection.Available - # Select all arrays - arraySelection.SetData(arraySelection.Available) - - # Next create a default render view appropriate for the session type. - rv = CreateRenderView() - # Create the matching representation - rep = CreateRepresentation(reader, rv) - rep.Representation = 1 # Wireframe - # Black background is not pretty - rv.Background = [0.4, 0.4, 0.6] - rv.StillRender() - # Reset the camera to include the whole thing - rv.ResetCamera() - rv.StillRender() - # Change the elevation of the camera. See VTK documentation of vtkCamera - # for camera parameters. - c = rv.GetActiveCamera() - c.Elevation(45) - rv.StillRender() - # Now that the reader execute, 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. - lt = rendering.PVLookupTable() - # Assign it to the representation - rep.LookupTable = lt - # Color by point array called Pres - rep.ColorAttributeType = 0 # point data - rep.ColorArrayName = "Pres" - # Add to RGB points. These are tuples of 4 values. First one is - # the scalar values, the other 3 the RGB values. This list has - # 2 points: Pres: 0.00678, color: blue, Pres: 0.0288, color: red - lt.RGBPoints = [0.00678, 0, 0, 1, 0.0288, 1, 0, 0] - lt.ColorSpace = 1 # HSV - rv.StillRender() - return rv - -def demo3(): - """This method demonstrates the use of servermanager with numpy as - well as pylab for plotting. It creates an artificial data sources, - probes it with a line, delivers the result to the client using Fetch - and plots it using pylab. This demo requires numpy and pylab installed. - It returns a tuple of (data, render view).""" - import paraview.numpy_support - import pylab - - if not ActiveConnection: - Connect() - # Create a synthetic data source - source = sources.Wavelet() - # Let's get some information about the data. First, for the - # source to execute - source.UpdatePipeline() - - di = source.GetDataInformation() - print "Data type:", di.GetPrettyDataTypeString() - print "Extent:", di.GetExtent() - print "Array name:", \ - source[0].PointData[0].Name - - rv = CreateRenderView() - - rep1 = CreateRepresentation(source, rv) - rep1.Representation = 3 # outline - - # Let's apply a contour filter - cf = filters.Contour(Input=source, ContourValues=[200]) - - # Select the array to contour by - #cf.SelectInputScalars = 'RTData' - - rep2 = CreateRepresentation(cf, rv) - - rv.Background = (0.4, 0.4, 0.6) - # Reset the camera to include the whole thing - rv.StillRender() - rv.ResetCamera() - rv.StillRender() - - # Now, let's probe the data - probe = filters.ResampleWithDataset(Input=source) - # with a line - line = sources.Line(Resolution=60) - # that spans the dataset - bounds = di.GetBounds() - print "Bounds: ", bounds - line.Point1 = bounds[0:6:2] - line.Point2 = bounds[1:6:2] - - probe.Source = line - - # Render with the line - rep3 = CreateRepresentation(line, rv) - rv.StillRender() - - # Now deliver it to the client. Remember, this is for small data. - data = Fetch(probe) - # Convert it to a numpy array - data = paraview.numpy_support.vtk_to_numpy( - data.GetPointData().GetArray("RTData")) - # Plot it using matplotlib - pylab.plot(data) - pylab.show() - - return (data, rv, probe) - -def demo4(fname="/Users/berk/Work/ParaViewData/Data/can.ex2"): - """This method demonstrates the user of AnimateReader for - creating animations.""" - if not ActiveConnection: - Connect() - reader = sources.ExodusIIReader(FileName=fname) - view = CreateRenderView() - repr = CreateRepresentation(reader, view) - view.StillRender() - view.ResetCamera() - view.StillRender() - c = view.GetActiveCamera() - c.Elevation(95) - return AnimateReader(reader, view) - - -def demo5(): - """ Simple sphere animation""" - if not ActiveConnection: - Connect() - sphere = sources.Sphere() - view = CreateRenderView() - repr = CreateRepresentation(sphere, view) - - view.StillRender() - view.ResetCamera() - view.StillRender() - - # Create an animation scene - scene = animation.AnimationScene() - # Add 1 view - scene.ViewModules = [view] - - # Create a cue to animate the StartTheta property - cue = animation.KeyFrameAnimationCue() - cue.AnimatedProxy = sphere - cue.AnimatedPropertyName = "StartTheta" - # Add it to the scene's cues - scene.Cues = [cue] - - # Create 2 keyframes for the StartTheta track - keyf0 = animation.CompositeKeyFrame() - keyf0.Type = 2 # Set keyframe interpolation type to Ramp. - # At time = 0, value = 0 - keyf0.KeyTime = 0 - keyf0.KeyValues= [0] - - keyf1 = animation.CompositeKeyFrame() - # At time = 1.0, value = 200 - keyf1.KeyTime = 1.0 - keyf1.KeyValues= [200] - - # Add keyframes. - cue.KeyFrames = [keyf0, keyf1] - - scene.Play() - return scene - -ASSOCIATIONS = { 'POINTS' : 0, 'CELLS' : 1, 'VERTICES' : 4, 'EDGES' : 5, 'ROWS' : 6} - -# Users can set the active connection which will be used by API -# to create proxies etc when no connection argument is passed. -# Connect() automatically sets this if it is not already set. -ActiveConnection = None - -# Fields for multi-server support -MultiServerConnections = None - -# API for multi-server support -def enableMultiServer(multiServer=True): - """This method enable the current servermanager to support several - connections. Once we enable the multi-server support, the user can create - as many connection as he want and switch from one to another in order to - create and manage proxy.""" - global MultiServerConnections, ActiveConnection - if not multiServer and MultiServerConnections: - raise RuntimeError, "Once we enable Multi-Server support we can not get back" - MultiServerConnections = [] - if ActiveConnection: - MultiServerConnections.append(ActiveConnection) - -def switchActiveConnection(newActiveConnection=None): - """Switch active connection to be the provided one or if none just pick the - other one""" - global MultiServerConnections, ActiveConnection - if MultiServerConnections == None: - raise RuntimeError, "enableMultiServer() must be called before" - - # Manage the case when no connection is provided - if newActiveConnection: - ActiveConnection = newActiveConnection - __exposeActiveModules__() - # Update active session for ParaView - if vtkSMProxyManager.GetProxyManager().GetActiveSession() != ActiveConnection.Session: - vtkSMProxyManager.GetProxyManager().SetActiveSession(ActiveConnection.Session) - return ActiveConnection - else: - for connection in MultiServerConnections: - if connection != ActiveConnection: - ActiveConnection = connection - __exposeActiveModules__() - # Update active session for ParaView - if vtkSMProxyManager.GetProxyManager().GetActiveSession() != ActiveConnection.Session: - vtkSMProxyManager.GetProxyManager().SetActiveSession(ActiveConnection.Session) - return ActiveConnection - return None - -# Needs to be called when paraview module is loaded from python instead -# of pvpython, pvbatch or GUI. -if not vtkProcessModule.GetProcessModule(): -# pvoptions = None Not applicable for SALOME Python console -# if paraview.options.batch: -# pvoptions = vtkPVOptions(); -# pvoptions.SetProcessType(0x40) -# if paraview.options.symmetric: -# pvoptions.SetSymmetricMPIMode(True) - vtkInitializationHelper.Initialize(sys.executable, - vtkProcessModule.PROCESS_CLIENT, pvoptions) - -# Initialize progress printing. Can be turned off by calling -# ToggleProgressPrinting() again. -progressObserverTag = None -currentAlgorithm = False -currentProgress = 0 -fromGUI = False -ToggleProgressPrinting() - -_pyproxies = {} - -# Create needed sub-modules -# We can no longer create modules, unless we have connected to a server. -# _createModules() - -# Set up our custom importer (if possible) -loader = _ModuleLoader() -sys.meta_path.append(loader) - -def __InitAfterConnect__(connection): - """ - This function is called everytime after a server connection is made. - Since the ProxyManager and all proxy definitions are changed every time a - new connection is made, we re-create all the modules - """ - _createModules(connection.Modules) - ## VSV fromFilter is alwais False for SALOME because it can't be changed from ParaView code - #if not paraview.fromFilter: - # fromFilter is set when this module is imported from the programmable - # filter -# global _defUpdater -# _defUpdater = __DefinitionUpdater() - connection.AttachDefinitionUpdater() - pass - -def __exposeActiveModules__(): - """Update servermanager submodules to point to the current - ActiveConnection.Modules.*""" - # Expose all active module to the current servermanager module - if ActiveConnection: - for m in [mName for mName in dir(ActiveConnection.Modules) if mName[0] != '_' ]: - exec "global %s;%s = ActiveConnection.Modules.%s" % (m,m,m) - -# Definitions for working in SALOME GUI mode -#aParams = myParavis.GetConnectionParameters() -#ActiveConnection = Connect() -##Connection(aParams[0]) -#ActiveConnection.SetHost(aParams[1], aParams[2], aParams[3], aParams[4], aParams[5]) -#ToggleProgressPrinting() -#fromGUI = True +for name in dir(servermanager): + if name != "__file__": + globals()[name] = getattr(servermanager, name) +del servermanager InitFromGUI() - -if hasattr(sys, "ps1"): - # session is interactive. - print vtkSMProxyManager.GetParaViewSourceVersion(); - -def GetConnectionFromId(id): - for connection in MultiServerConnections: - if connection.ID == id: - return connection - return None - -def GetConnectionFromSession(session): - for connection in MultiServerConnections: - if connection.Session == session: - return connection - return None - -def GetConnectionAt(index): - return MultiServerConnections[index] - -def GetNumberOfConnections(): - return len(MultiServerConnections) - -#VTN: Problem during execution -#atexit.register(vtkPythonProgrammableFilter.DeleteGlobalPythonInterpretor) diff --git a/src/PV_SWIG/pvsimple.py b/src/PV_SWIG/pvsimple.py index 6a77e5f2..28b84303 100644 --- a/src/PV_SWIG/pvsimple.py +++ b/src/PV_SWIG/pvsimple.py @@ -17,1155 +17,25 @@ # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com # -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() +r""" This module is a direct forward to the initial +'simple' module of ParaView. """ -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()) - xml_name = paraview.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() +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 diff --git a/src/PV_SWIG/servermanager.diff b/src/PV_SWIG/servermanager.diff deleted file mode 100644 index 5280bd3d..00000000 --- a/src/PV_SWIG/servermanager.diff +++ /dev/null @@ -1,305 +0,0 @@ -0a1,19 -> # Copyright (C) 2010-2013 CEA/DEN, EDF R&D -> # -> # This library is free software; you can redistribute it and/or -> # modify it under the terms of the GNU Lesser General Public -> # License as published by the Free Software Foundation; either -> # version 2.1 of the License. -> # -> # This library is distributed in the hope that it will be useful, -> # but WITHOUT ANY WARRANTY; without even the implied warranty of -> # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -> # Lesser General Public License for more details. -> # -> # You should have received a copy of the GNU Lesser General Public -> # License along with this library; if not, write to the Free Software -> # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -> # -> # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com -> # -> -29,43d47 -< #============================================================================== -< # -< # Program: ParaView -< # Module: servermanager.py -< # -< # Copyright (c) Kitware, Inc. -< # All rights reserved. -< # See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details. -< # -< # This software is distributed WITHOUT ANY WARRANTY without even -< # the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR -< # PURPOSE. See the above copyright notice for more information. -< # -< #============================================================================== -< import paraview, re, os, os.path, new, sys, vtk -45,53c49,54 -< if not paraview.compatibility.minor: -< paraview.compatibility.major = 3 -< if not paraview.compatibility.major: -< paraview.compatibility.minor = 5 -< -< from vtkPVClientServerCorePython import * -< from vtkPVServerImplementationPython import * -< from vtkPVServerManagerPython import * -< from vtkPVCommonPython import * ---- -> -> -> import re, os, new, sys -> from paravis import * -> -> -61,62c62 -< if paraview.compatibility.GetVersion() >= 3.5 and \ -< smproperty.IsA("vtkSMStringVectorProperty"): ---- -> if smproperty.IsA("vtkSMStringVectorProperty"): -251,252c251,253 -< return self.SMProxy == other.SMProxy -< return self.SMProxy == other ---- -> ## VSV using IsSame instead == -> return self.SMProxy.IsSame(other.SMProxy) -> return self.SMProxy.IsSame(other) -347,350c348,351 -< if not c.HasObserver("ModifiedEvent"): -< self.ObserverTag =c.AddObserver("ModifiedEvent", \ -< _makeUpdateCameraMethod(weakref.ref(self))) -< self.Observed = c ---- -> # VSV: Observers are not supported -> ## if not c.HasObserver("ModifiedEvent"): -> ## self.ObserverTag =c.AddObserver("ModifiedEvent", _makeUpdateCameraMethod(weakref.ref(self))) -> ## self.Observed = c -454,472c455,472 -< if paraview.compatibility.GetVersion() >= 3.5: -< def FileNameChanged(self): -< "Called when the filename changes. Selects all variables." -< SourceProxy.FileNameChanged(self) -< self.SelectAllVariables() -< -< def SelectAllVariables(self): -< "Select all available variables for reading." -< for prop in ('PointVariables', 'EdgeVariables', 'FaceVariables', -< 'ElementVariables', 'GlobalVariables'): -< f = getattr(self, prop) -< f.SelectAll() -< -< def DeselectAllVariables(self): -< "Deselects all variables." -< for prop in ('PointVariables', 'EdgeVariables', 'FaceVariables', -< 'ElementVariables', 'GlobalVariables'): -< f = getattr(self, prop) -< f.DeselectAll() ---- -> def FileNameChanged(self): -> "Called when the filename changes. Selects all variables." -> SourceProxy.FileNameChanged(self) -> self.SelectAllVariables() -> -> def SelectAllVariables(self): -> "Select all available variables for reading." -> for prop in ('PointVariables', 'EdgeVariables', 'FaceVariables', -> 'ElementVariables', 'GlobalVariables'): -> f = getattr(self, prop) -> f.SelectAll() -> -> def DeselectAllVariables(self): -> "Deselects all variables." -> for prop in ('PointVariables', 'EdgeVariables', 'FaceVariables', -> 'ElementVariables', 'GlobalVariables'): -> f = getattr(self, prop) -> f.DeselectAll() -1110c1110,1111 -< if proxy == px: ---- -> ## VSV: == -> if proxy.IsSame(px): -1329,1332d1329 -< if paraview.compatibility.GetVersion() <= 3.4: -< def Range(self, component=0): -< return self.GetRange(component) -< -1526c1523 -< aProxy = self.SMProxyManager.NewProxy(group, name) ---- -> aProxy = self.SMProxyManager.NewProxy(group, name, "NULL") -1838a1836 -> # VTN: Observers are not supported -1840c1838 -< self.DefinitionObserverTag = self.Session.GetProxyDefinitionManager().AddObserver(2000, _update_definitions) ---- -> ## self.DefinitionObserverTag = self.Session.GetProxyDefinitionManager().AddObserver(2000, _update_definitions) -1842c1840 -< self.CustomDefinitionObserverTag = self.Session.GetProxyDefinitionManager().AddObserver(2001, _update_definitions) ---- -> ## self.CustomDefinitionObserverTag = self.Session.GetProxyDefinitionManager().AddObserver(2001, _update_definitions) -2056c2054,2055 -< try: isRep = rep.Input == aProxy ---- -> #VSV: == -> try: isRep = rep.Input.IsSame(aProxy) -2287,2303c2286,2287 -< """Turn on/off printing of progress (by default, it is on). You can -< always turn progress off and add your own observer to the process -< module to handle progress in a custom way. See _printProgress for -< an example event observer.""" -< global progressObserverTag -< -< # If value is true and progress printing is currently off... -< if value and not GetProgressPrintingIsEnabled(): -< if fromGUI: -< raise RuntimeError("Printing progress in the GUI is not supported.") -< progressObserverTag = vtkProcessModule.GetProcessModule().AddObserver(\ -< "ProgressEvent", _printProgress) -< -< # If value is false and progress printing is currently on... -< elif GetProgressPrintingIsEnabled(): -< vtkProcessModule.GetProcessModule().RemoveObserver(progressObserverTag) -< progressObserverTag = None ---- -> """Is not supported because of not supported observers""" -> pass -2330,2332c2314,2315 -< if paraview.compatibility.GetVersion() >= 3.5: -< if smproxy.GetXMLLabel(): -< xmlName = smproxy.GetXMLLabel() ---- -> if smproxy.GetXMLLabel(): -> xmlName = smproxy.GetXMLLabel() -2375,2378c2358 -< if paraview.compatibility.GetVersion() >= 3.5: -< return self.GetPropertyValue(propName) -< else: -< return self.GetProperty(propName) ---- -> return self.GetPropertyValue(propName) -2494c2474,2482 -< return paraview.make_name_valid(name) ---- -> """Make a string into a valid Python variable name.""" -> if not name: -> return None -> import string -> valid_chars = "_%s%s" % (string.ascii_letters, string.digits) -> name = str().join([c for c in name if c in valid_chars]) -> if not name[0].isalpha(): -> name = 'a' + name -> return name -2520,2521c2508 -< if paraview.compatibility.GetVersion() >= 3.5 and\ -< proto.GetXMLLabel(): ---- -> if proto.GetXMLLabel(): -2536,2539c2523,2525 -< if paraview.compatibility.GetVersion() >= 3.5: -< if (prop.GetInformationOnly() and propName != "TimestepValues" ) \ -< or prop.GetIsInternal(): -< continue ---- -> if (prop.GetInformationOnly() and propName != "TimestepValues" ) \ -> or prop.GetIsInternal(): -> continue -2541,2542c2527 -< if paraview.compatibility.GetVersion() >= 3.5: -< names = [iter.PropertyLabel] ---- -> names = [iter.PropertyLabel] -2681,2690c2666,2669 -< if paraview.compatibility.GetVersion() <= 3.4: -< ss = sources.SphereSource(Radius=2, ThetaResolution=32) -< shr = filters.ShrinkFilter(Input=OutputPort(ss,0)) -< cs = sources.ConeSource() -< app = filters.Append() -< else: -< ss = sources.Sphere(Radius=2, ThetaResolution=32) -< shr = filters.Shrink(Input=OutputPort(ss,0)) -< cs = sources.Cone() -< app = filters.AppendDatasets() ---- -> ss = sources.Sphere(Radius=2, ThetaResolution=32) -> shr = filters.Shrink(Input=OutputPort(ss,0)) -> cs = sources.Cone() -> app = filters.AppendDatasets() -2711,2714c2690 -< if paraview.compatibility.GetVersion() <= 3.4: -< arraySelection = reader.PointResultArrayStatus -< else: -< arraySelection = reader.PointVariables ---- -> arraySelection = reader.PointVariables -2748,2751c2724 -< if paraview.compatibility.GetVersion() <= 3.4: -< print "Range:", ai.Range(j) -< else: -< print "Range:", ai.GetRange(j) ---- -> print "Range:", ai.GetRange(j) -2782,2785c2755 -< if paraview.compatibility.GetVersion() <= 3.4: -< source = sources.RTAnalyticSource() -< else: -< source = sources.Wavelet() ---- -> source = sources.Wavelet() -2816,2823c2786,2788 -< if paraview.compatibility.GetVersion() <= 3.4: -< probe = filters.Probe(Input=source) -< # with a line -< line = sources.LineSource(Resolution=60) -< else: -< probe = filters.ResampleWithDataset(Input=source) -< # with a line -< line = sources.Line(Resolution=60) ---- -> probe = filters.ResampleWithDataset(Input=source) -> # with a line -> line = sources.Line(Resolution=60) -2867,2870c2832 -< if paraview.compatibility.GetVersion() <= 3.4: -< sphere = sources.SphereSource() -< else: -< sphere = sources.Sphere() ---- -> sphere = sources.Sphere() -2960,2965c2922,2927 -< pvoptions = None -< if paraview.options.batch: -< pvoptions = vtkPVOptions(); -< pvoptions.SetProcessType(0x40) -< if paraview.options.symmetric: -< pvoptions.SetSymmetricMPIMode(True) ---- -> # pvoptions = None Not applicable for SALOME Python console -> # if paraview.options.batch: -> # pvoptions = vtkPVOptions(); -> # pvoptions.SetProcessType(0x40) -> # if paraview.options.symmetric: -> # pvoptions.SetSymmetricMPIMode(True) -2994,2995c2956,2957 -< -< if not paraview.fromFilter: ---- -> ## VSV fromFilter is alwais False for SALOME because it can't be changed from ParaView code -> #if not paraview.fromFilter: -2998,2999c2960,2963 -< connection.AttachDefinitionUpdater() -< pass ---- -> # global _defUpdater -> # _defUpdater = __DefinitionUpdater() -> connection.AttachDefinitionUpdater() -> pass -3008a2973,2982 -> # Definitions for working in SALOME GUI mode -> #aParams = myParavis.GetConnectionParameters() -> #ActiveConnection = Connect() -> ##Connection(aParams[0]) -> #ActiveConnection.SetHost(aParams[1], aParams[2], aParams[3], aParams[4], aParams[5]) -> #ToggleProgressPrinting() -> #fromGUI = True -> -> InitFromGUI() -> diff --git a/src/PV_SWIG/simple.diff b/src/PV_SWIG/simple.diff deleted file mode 100644 index 2df0d6e7..00000000 --- a/src/PV_SWIG/simple.diff +++ /dev/null @@ -1,305 +0,0 @@ -0a1,19 -> # Copyright (C) 2010-2013 CEA/DEN, EDF R&D -> # -> # This library is free software; you can redistribute it and/or -> # modify it under the terms of the GNU Lesser General Public -> # License as published by the Free Software Foundation; either -> # version 2.1 of the License. -> # -> # This library is distributed in the hope that it will be useful, -> # but WITHOUT ANY WARRANTY; without even the implied warranty of -> # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -> # Lesser General Public License for more details. -> # -> # You should have received a copy of the GNU Lesser General Public -> # License along with this library; if not, write to the Free Software -> # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -> # -> # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com -> # -> -21,34d39 -< #============================================================================== -< # -< # Program: ParaView -< # Module: simple.py -< # -< # Copyright (c) Kitware, Inc. -< # All rights reserved. -< # See Copyright.txt or http://www.paraview.org/HTML/Copyright.html for details. -< # -< # This software is distributed WITHOUT ANY WARRANTY; without even -< # the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR -< # PURPOSE. See the above copyright notice for more information. -< # -< #============================================================================== -36,39c41 -< import paraview -< paraview.compatibility.major = 3 -< paraview.compatibility.minor = 5 -< import servermanager ---- -> import paravisSM -41,42c43 -< def enableMultiServer(): -< servermanager.enableMultiServer() ---- -> servermanager = paravisSM -44,56c45,46 -< 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()) -< servermanager.ProxyManager().DisableStateUpdateNotification() ---- -> def _disconnect(): -> if servermanager.ActiveConnection: -61d50 -< servermanager.Disconnect() -62a52 -> servermanager.Disconnect() -69,70c59,60 -< Disconnect(globals(), False) -< connection = servermanager.Connect(ds_host, ds_port, rs_host, rs_port) ---- -> _disconnect() -> session = servermanager.Connect(ds_host, ds_port, rs_host, rs_port) -73,88c63,67 -< 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 ---- -> tk = servermanager.misc.TimeKeeper() -> servermanager.ProxyManager().RegisterProxy("timekeeper", "tk", tk) -> scene = AnimationScene() -> scene.TimeKeeper = tk -> return session -93,94c72,73 -< Disconnect(globals(), False) -< connection = servermanager.ReverseConnect(port) ---- -> _disconnect() -> session = servermanager.ReverseConnect(port) -96,112c75,79 -< -< 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 ---- -> tk = servermanager.misc.TimeKeeper() -> servermanager.ProxyManager().RegisterProxy("timekeeper", "tk", tk) -> scene = AnimationScene() -> scene.TimeKeeper = tk -> return session -121c88 -< ---- -> -161a129,131 -> reader_factor = servermanager.ProxyManager().GetReaderFactory() -> if reader_factor.GetNumberOfRegisteredPrototypes() == 0: -> reader_factor.RegisterPrototypes("sources") -163,165d132 -< reader_factor = servermanager.vtkSMProxyManager.GetProxyManager().GetReaderFactory() -< if reader_factor.GetNumberOfRegisteredPrototypes() == 0: -< reader_factor.RegisterPrototypes(session, "sources") -170,171c137 -< msg = "File not readable: %s " % first_file -< raise RuntimeError, msg ---- -> raise RuntimeError, "File not readable: %s " % first_file -173,174c139 -< msg = "File not readable. No reader found for '%s' " % first_file -< raise RuntimeError, msg ---- -> raise RuntimeError, "File not readable. No reader found for '%s' " % first_file -192,193c157 -< session = servermanager.ActiveConnection.Session -< writer_factory = servermanager.vtkSMProxyManager.GetProxyManager().GetWriterFactory() ---- -> writer_factory = servermanager.ProxyManager().GetWriterFactory() -195c159 -< writer_factory.RegisterPrototypes(session, "writers") ---- -> writer_factory.RegisterPrototypes("writers") -441c405,406 -< if proxy == GetActiveSource(): ---- -> #VSV:== -> if proxy.IsSame(GetActiveSource()): -449c414,415 -< if rep.Input == proxy: ---- -> #VSV:== -> if rep.Input.IsSame(proxy): -453c419,420 -< if proxy == GetActiveView(): ---- -> ##VSV:== -> if proxy.IsSame(GetActiveView()): -691,693c658,659 -< activeModule = servermanager.ActiveConnection.Modules -< for m in [activeModule.filters, activeModule.sources, -< activeModule.writers, activeModule.animation]: ---- -> for m in [servermanager.filters, servermanager.sources, -> servermanager.writers, servermanager.animation]: -699d664 -< #print "add %s function" % key -703,715d667 -< 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 -< -844c796 -< if cue.AnimatedProxy == proxy and\ ---- -> if cue.AnimatedProxy.IsSame(proxy) and\ -846c798 -< if index == None or index == cue.AnimatedElement: ---- -> if index == None or index.IsSame(cue.AnimatedElement): ##index == cue.AnimatedElement: -870c822 -< if cue.AnimatedProxy == view and\ ---- -> if cue.AnimatedProxy.IsSame(view) and\ -887c839 -< if cue.GetXMLName() == "TimeAnimationCue" and cue.AnimatedProxy == tk\ ---- -> if cue.GetXMLName() == "TimeAnimationCue" and cue.AnimatedProxy.IsSame(tk)\ -929,931c881 -< if not servermanager.ActiveConnection: -< raise RuntimeError, "Cannot load a plugin without a session." -< plm = servermanager.vtkSMProxyManager.GetProxyManager().GetPluginManager() ---- -> plm = servermanager.ProxyManager().GetSession().GetPluginManager() -933,934c883 -< session = servermanager.ActiveConnection.Session -< info = plm.GetRemoteInformation(session) ---- -> info = plm.GetRemoteInformation() -942,959d890 -< 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 -966c897 -< def __get_selection_model(self, name, session=None): ---- -> def __get_selection_model(self, name): -968,970c899 -< if session and session != servermanager.ActiveConnection.Session: -< raise RuntimeError, "Try to set an active object with invalid active connection." -< pxm = servermanager.ProxyManager(session) ---- -> pxm = servermanager.ProxyManager() -979c908 -< active_view_model = self.__get_selection_model("ActiveView") ---- -> active_view_model = self.__get_selection_model("ActiveView") -981d909 -< active_view_model = self.__get_selection_model("ActiveView", view.GetSession()) -984d911 -< active_view_model = self.__get_selection_model("ActiveView") -994c921 -< active_sources_model = self.__get_selection_model("ActiveSources") ---- -> active_sources_model = self.__get_selection_model("ActiveSources") -997d923 -< active_sources_model = self.__get_selection_model("ActiveSources", source.GetSession()) -1000d925 -< active_sources_model = self.__get_selection_model("ActiveSources") -1107a1033,1041 -> def PrintTrace(): -> print paravisSM.myParavis.GetTrace() -> -> def SaveTrace(fileName): -> paravisSM.myParavis.SaveTrace(fileName) -> -> -> _add_functions(globals()) -> -1110,1111d1043 -< else: -< _add_functions(globals()) -1113c1045,1046 -< active_objects = ActiveObjects() ---- -> def ImportFile(theFileName): -> paravisSM.ImportFile(theFileName) -1115,1129c1048,1049 -< def _switchToActiveConnectionCallback(caller, event): -< if servermanager: -< session = servermanager.vtkSMProxyManager.GetProxyManager().GetActiveSession() -< if session and ((not servermanager.ActiveConnection) or session != servermanager.ActiveConnection.Session): -< switchActiveConnection(servermanager.GetConnectionFromSession(session)) -< -< class ActiveSessionObserver: -< def __init__(self): -< self.ObserverTag = servermanager.vtkSMProxyManager.GetProxyManager().AddObserver(9753, _switchToActiveConnectionCallback) -< -< def __del__(self): -< if servermanager: -< servermanager.vtkSMProxyManager.GetProxyManager().RemoveObserver(self.ObserverTag) -< -< active_session_observer = ActiveSessionObserver() ---- -> active_objects = ActiveObjects() -> active_objects.view = GetRenderView()