Merge branch 'master' into issue_2047_cdat_info

Author: doutriaux1

Packages/vcs/vcs/Canvas.py

@@ -688,21 +688,16 @@ def plot(self, data1, data2, template, gtype, gname, bg, *args, **kargs):
         self.scaleLogo()
 
         # Decide whether to rasterize background in vector outputs
-        # Current criteria to rasterize:
+        # Current limitation to vectorize:
         #       * if fillarea style is either pattern or hatch
-        #       * if fillarea opacity is less than 100 for solid fill
         try:
             if gm.style and all(style != 'solid' for style in gm.style):
                 self._rasterPropsInVectorFormats = True
-            elif gm.opacity and not all(o == 100 for o in gm.opacity):
-                self._rasterPropsInVectorFormats = True
         except:
             pass
         try:
             if gm.fillareastyle in ['pattern', 'hatch']:
                 self._rasterPropsInVectorFormats = True
-            elif not all(o == 100 for o in gm.fillareaopacity):
-                self._rasterPropsInVectorFormats = True
         except:
             pass
 
@@ -1109,6 +1104,7 @@ def vectorGraphics(self, output_type, file, width=None, height=None,
 
         # Since the patterns are applied as textures on vtkPolyData, enabling
         # background rasterization is required to write them out
+
         if self._rasterPropsInVectorFormats:
             gl.Write3DPropsAsRasterImageOn()
 
@@ -1117,9 +1113,10 @@ def vectorGraphics(self, output_type, file, width=None, height=None,
         gl.SetFilePrefix(".".join(file.split(".")[:-1]))
 
         if textAsPaths:
-            gl.TextAsPathOff()
-        else:
             gl.TextAsPathOn()
+        else:
+            gl.TextAsPathOff()
+
         if output_type == "svg":
             gl.SetFileFormatToSVG()
         elif output_type == "ps":
@@ -1243,7 +1240,38 @@ def Animate(self, *args, **kargs):
         return VTKAnimate.VTKAnimate(*args, **kargs)
 
     def gettextextent(self, textorientation, texttable):
-        warnings.warn("Please implement gettextextent for VTK Backend")
+        # Ensure renwin exists
+        self.createRenWin()
+
+        if isinstance(textorientation, (str, unicode)):
+            textorientation = vcs.gettextorientation(textorientation)
+        if isinstance(texttable, (str, unicode)):
+            texttable = vcs.gettexttable(texttable)
+
+        from vtk_ui.text import text_dimensions
+
+        text_property = vtk.vtkTextProperty()
+        info = self.canvasinfo()
+        win_size = info["width"], info["height"]
+        vcs2vtk.prepTextProperty(text_property, win_size, to=textorientation, tt=texttable)
+
+        dpi = self.renWin.GetDPI()
+
+        length = max(len(texttable.string), len(texttable.x), len(texttable.y))
+
+        strings = texttable.string + [texttable.string[-1]] * (length - len(texttable.string))
+        xs = texttable.x + [texttable.x[-1]] * (length - len(texttable.x))
+        ys = texttable.y + [texttable.y[-1]] * (length - len(texttable.y))
+
+        labels = zip(strings, xs, ys)
+
+        extents = []
+
+        for s, x, y in labels:
+            width, height = text_dimensions(s, text_property, dpi)
+            extents.append([x, x + float(width) / win_size[0], y, y + float(height) / win_size[1]])
+
+        return extents
 
     def getantialiasing(self):
         if self.renWin is None:
@@ -1553,3 +1581,9 @@ def png_dimensions(self, path):
         img = reader.GetOutput()
         size = img.GetDimensions()
         return size[0], size[1]
+
+    def raisecanvas(self):
+        if self.renWin is None:
+            warnings.warn("Cannot raise if you did not open the canvas yet.")
+            return
+        self.renWin.MakeCurrent()

Packages/vcs/vcs/VTKPlots.py

@@ -1,27 +1,48 @@
 """
-# VCS Visualization and Control System - (VCS) module
-#
-#################################################################################
-#                                                                               #
-# Module:       vcs module                                                      #
-#                                                                               #
-# Authors:      PCMDI Software Team                                             #
-#               support@pcmdi.llnl.gov                                          #
-#               http://cdat.sf.net/cdat                                         #
-#                                                                               #
-# Description:  Python command wrapper for VCS's functionality. VCS is computer #
-#               software for the selection, manipulation, and display of        #
-#               scientific data. By specification of the desired data, the      #
-#               graphics method, and the display template, the VCS user gains   #
-#               virtually complete control of the appearance of the data        #
-#               display and associated text and animation.                      #
-#                                                                               #
-# Upgrade to VTK:                                                               #
-# Author: Charles Doutriaux                                                     #
-# Description: Took out all C code and used VTK's python bindings instead       #
-#                                                                               #
-#################################################################################
+=====================================
+VCS: Visualization and Control System
+=====================================
+
+-------
+Authors
+-------
+
+Creator: Dean Williams (LLNL, AIMS Team)
+
+Lead Developer: Charles Doutriaux (LLNL, AIMS Team)
+
+Contributors: https://github.com/UV-CDAT/uvcdat/graphs/contributors
+
+Support Email: uvcdat-support@llnl.gov
+
+Project Site: http://uvcdat.llnl.gov/
+
+Project Repo: https://github.com/UV-CDAT/uvcdat/graphs/contributors
+
+-----------
+Description
+-----------
+VCS is a visualization library for scientific data. It has a simple
+model for defining a plot, that is decomposed into three parts:
+
+1. **Data**: If it's iterable, we'll plot it... or at least try!
+   Currently we support numpy arrays, lists (nested and not),
+   and CDMS2 variables (there's some special support for metadata
+   from CDMS2 that gives some niceties in your plot, but it's not
+   mandatory).
+2. **Graphics Method**: We have a variety of plot types that we
+   support out-of-the box; you can easily customize every aspect
+   of them to create the effect that you're looking for. If you can't,
+   we also support defining your own graphics methods, which you can
+   share with other users using standard python infrastructure (conda, pip).
+3. **Template**: Templates control the appearance of everything that
+   *isn't* your data. They position labels, control fonts, adjust borders,
+   place legends, and more. They're very flexible, and give the fine-grained
+   control of your plot that is needed for the truly perfect plot. Once you've
+   customized them, you can also save them out for later use, and distribute
+   them to other users.
 """
+
 _doValidation = True
 next_canvas_id = 1
 import cdat_info  # noqa
@@ -223,37 +244,45 @@
     vcs.scriptrun(user_init)
 
 canvaslist = []
-#
-#
-# Construct a VCS Canvas Object.                                                #
-#
-#
 
 
 def init(mode=1, pause_time=0, call_from_gui=0, size=None,
          backend="vtk", geometry=None, bg=None):
     '''
- Function: init   # Initialize, Construct a VCS Canvas Object
-
- Description of Function:
-    Construct the VCS Canas object.
-
- Example of Use:
-    import vcs,cdms2
-
-    file=cdms2.open('filename.nc')
-    slab=file.getslab('variable')
-    a=vcs.init()                        # This examples constructs 4 VCS Canvas
-    a.plot(slab)                        # Plot slab using default settings
-    b=vcs.init()                        # Construct VCS object
-    template=b.gettemplate('AMIP')      # Get 'example' template object
-    b.plot(slab,template)               # Plot slab using template 'AMIP'
-    c=vcs.init()                        # Construct new VCS object
-    isofill=c.getisofill('quick')       # Get 'quick' isofill graphics method
-    c.plot(slab,template,isofill)       # Plot slab using template and isofill objects
-    d=vcs.init()                        # Construct new VCS object
-    isoline=c.getisoline('quick')       # Get 'quick' isoline graphics method
-    c.plot(isoline,slab,template)       # Plot slab using isoline and template objects
+    Initialize and construct a VCS Canvas object.
+
+    :Example:
+
+::
+
+    import vcs
+
+    # Portrait orientation of 1 width per 2 height
+    portrait = vcs.init(size=.5)
+    # also accepts "usletter"
+    letter = vcs.init(size="letter")
+    a4 = vcs.init(size="a4")
+
+    import vtk
+    # Useful for embedding VCS inside another application
+    my_win = vtk.vtkRenderWindow()
+    embedded = vcs.init(backend=my_win)
+
+    dict_init = vcs.init(geometry={"width": 1200, "height": 600})
+    tuple_init = vcs.init(geometry=(1200, 600))
+
+    bg_canvas = vcs.init(bg=True)
+
+:param size: Aspect ratio for canvas (width / height)
+:param backend: Which VCS backend to use
+:param geometry: Size (in pixels) you want the canvas to be.
+:param bg: Initialize a canvas to render in "background" mode (without displaying a window)
+:type size: float or case-insensitive str
+:type backend: str, `vtk.vtkRenderWindow`
+:type geometry: dict or tuple
+:type bg: bool
+:return: an initialized canvas
+:rtype: `vcs.Canvas.Canvas`
 '''
     canvas = Canvas.Canvas(
         mode=mode,