Source code for pyformex.opengl.draw

## $Id$
##
##  This file is part of pyFormex 1.0.5  (Sat Feb 16 10:40:32 CET 2019)
##  pyFormex is a tool for generating, manipulating and transforming 3D
##  geometrical models by sequences of mathematical operations.
##  Home page: http://pyformex.org
##  Project page:  http://savannah.nongnu.org/projects/pyformex/
##  Copyright 2004-2018 (C) Benedict Verhegghe (benedict.verhegghe@ugent.be)
##  Distributed under the GNU General Public License version 3 or later.
##
##  This program is free software: you can redistribute it and/or modify
##  it under the terms of the GNU General Public License as published by
##  the Free Software Foundation, either version 3 of the License, or
##  (at your option) any later version.
##
##  This program 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 General Public License for more details.
##
##  You should have received a copy of the GNU General Public License
##  along with this program.  If not, see http://www.gnu.org/licenses/.
##
"""Create 3D graphical representations.

The draw module provides the basic user interface to the OpenGL
rendering capabilities of pyFormex. The full contents of this module
is available to scripts running in the pyFormex GUI without the need
to import it.
"""
from __future__ import absolute_import, division, print_function


import pyformex as pf
from pyformex import utils
from pyformex import coords
from pyformex.attributes import Attributes
from pyformex.formex import Formex,connect
from pyformex.arraytools import normalize, isInt

from pyformex.gui import toolbar
from pyformex.gui import image

from . import colors
from . import actors
from . import decors

from pyformex.script import getcfg, named

import numpy as np
import os

############################## drawing functions ########################

[docs]def flatten(objects,recurse=True): """Flatten a list of geometric objects. Each item in the list should be either: - a drawable object, - a string with the name of such an object, - a list of any of these three. This function will flatten the lists and replace the string items with the object they point to. The result is a single list of drawable objects. This function does not enforce the objects to be drawable. That should be done by the caller. """ r = [] for i in objects: if isinstance(i, str): i = named(i) if isinstance(i, list): if recurse: r.extend(flatten(i, True)) else: r.extend(i) else: r.append(i) return r
[docs]def drawable(objects): """Filters the drawable objects from a list. The input is a list, usually of drawable objects. For each item in the list, the following is done: - if the item is drawable, it is kept as is, - if the item is not drawable but can be converted to a Formex, it is converted, - if it is neither drawable nor convertible to Formex, it is removed. The result is a list of drawable objects (since a Formex is drawable). """ def fltr(i): if hasattr(i, 'actor'): return i elif hasattr(i, 'toFormex'): return i.toFormex() elif hasattr(i, 'toMesh'): return i.toMesh() else: return None r = [ fltr(i) for i in objects ] return [ i for i in r if i is not None ]
[docs]def draw(F, ## color='prop',colormap=None,alpha=None, ## bkcolor=None,bkcolormap=None,bkalpha=None, ## mode=None,linewidth=None,linestipple=None, ## marksize=None,nolight=False,ontop=False, ## view=None,bbox=None,shrink=None,clear=None, ## wait=True,allviews=False,highlight=False,silent=True, # A trick to allow 'clear' argument, but not inside kargs clear=None, single=False, **kargs): """Draw geometrical object(s) with specified drawing options and settings. This is the generic drawing function in pyFormex. The user can specifies the Geometry and optional drawing parameters. The function returns the Actor(s) resulting from the drawing operation. The Actors can further be used to change the rendering. Parameters: - `F`: specifies all geometry that will be drawn in a single argument. It can be one of the following: - a drawable object (a Geometry object like Formex, Mesh or TriSurface, or another object having a proper `actor` method), - the name of a global pyFormex variable refering to such an object, - a list or nested list of any of the above items. The possibility of a nested list means that any complex collections of geometry can be drawn in a single operation. The (nested) list is recursively flattened, replacing string values by the corresponding value from the pyFormex global variables dictionary, until a single list of drawable objects results. Next the undrawable items are removed from the list. The resulting list of drawable objects are drawn in a single pass, with the same options and default drawing attributes. - `clear`: clear the scene before drawing. - `single`: specifies the type of result if `F` is a list. If False, a flat list with all Actors for all Geometries in F is returned. If True, a single Actor is returned, corresponding with F[0] (in the flattened list). The other actors in the flattened list are set as its children. The remaining parameters are the default drawing parameters to be used. They will apply unless overridden by attributes set in the Geometry itself (see :meth:`geometry.Geometry.attrib`). There is a long list of possible settings, but in most case only a few will be needed. .. warning:: The remainder of this docstring is from the old version (<= 0.9) of pyFormex. While most of the arguments are still valid and the documentation below is useful, there might be some slight changes in the behavior. .. note:: DEVS: TODO: THIS DOCSTRING NEEDS TO BE UPDATED ! Settings: specify how the geometry will be drawn. These arguments will be passed to the corresponding Actor for the object. The Actor is the graphical representation of the geometry. Not all Actors use all of the settings that can be specified here. But they all accept specifying any setting even if unused. The settings hereafter are thus a superset of the settings used by the different Actors. Settings have a default value per viewport, and if unspecified, most Actors will use the viewport default for that value. - `color`, `colormap`: specifies the color of the object (see below) - `alpha`: float (0.0..1.0): alpha value to use in transparent mode - `bkcolor`, `bkcolormap`: color for the backside of surfaces, if different from the front side. Specification as for front color. - `bkalpha`: float (0.0..1.0): alpha value for back side. - `linewidth`: float, thickness of line drawing - `linestipple`: stipple pattern for line drawing - `marksize`: float: point size for dot drawing - `nolight`: bool: render object as unlighted in modes with lights on - `ontop`: bool: render object as if it is on top. This will make the object fully visible, even when it is hidden by other objects. If more than one objects is drawn with `ontop=True` the visibility of the object will depend on the order of drawing. Options: these arguments modify the working of the draw functions. If None, they are filled in from the current viewport drawing options. These can be changed with the :func:`setDrawOptions` function. The initial defaults are: view='last', bbox='auto', shrink=False, clear=False, shrinkfactor=0.8. - `view`: is either the name of a defined view or 'last' or None. Predefined views are 'front', 'back', 'top', 'bottom', 'left', 'right', 'iso'. With view=None the camera settings remain unchanged (but might be changed interactively through the user interface). This may make the drawn object out of view! With view='last', the camera angles will be set to the same camera angles as in the last draw operation, undoing any interactive changes. On creation of a viewport, the initial default view is 'front' (looking in the -z direction). - `bbox`: specifies the 3D volume at which the camera will be aimed (using the angles set by `view`). The camera position will be set so that the volume comes in view using the current lens (default 45 degrees). bbox is a list of two points or compatible (array with shape (2,3)). Setting the bbox to a volume not enclosing the object may make the object invisible on the canvas. The special value bbox='auto' will use the bounding box of the objects getting drawn (object.bbox()), thus ensuring that the camera will focus on these objects. The special value bbox=None will use the bounding box of the previous drawing operation, thus ensuring that the camera's target volume remains unchanged. - `shrink`: bool: if specified, each object will be transformed by the :meth:`Coords.shrink` transformation (with the current set shrinkfactor as a parameter), thus showing all the elements of the object separately. (Some other softwares call this an 'exploded' view). - `clear`: bool. By default each new draw operation adds the newly drawn objects to the shown scene. Using `clear=True` will clear the scene before drawing and thus only show the objects of the current draw action. - `wait`: bool. If True (default) the draw action activates a locking mechanism for the next draw action, which will only be allowed after `drawdelay` seconds have elapsed. This makes it easier to see subsequent renderings and is far more efficient than adding an explicit sleep() operation, because the script processing can continue up to the next drawing instruction. The value of drawdelay can be changed in the user settings or using the :func:`delay` function. Setting this value to 0 will disable the waiting mechanism for all subsequent draw statements (until set > 0 again). But often the user wants to specifically disable the waiting lock for some draw operation(s). This can be done without changing the `drawdelay` setting by specifyin `wait=False`. This means that the *next* draw operation does not have to wait. - `allviews`: currently not used - `highlight`: bool. If True, the object(s) will not be drawn as normal geometry, but as highlight (usually on top of other geometry), making them removeable by the remove highlight functions - `silent`: bool. If True (default), non-drawable objects will be silently ignored. If set False, an error is raised if an object is not drawable. - `**kargs`: any not-recognized keyword parameters are passed to the object's Actor constructor. This allows the user to create customized Actors with new parameters. Specifying color: Color specification can take many different forms. Some Actors recognize up to six different color modes and the draw function adds even another mode (property color) - no color: `color=None`. The object will be drawn in the current viewport foreground color. - single color: the whole object is drawn with the specified color. - element color: each element of the object has its own color. The specified color will normally contain precisely `nelems` colors, but will be resized to the required size if not. - vertex color: each vertex of each element of the object has its color. In smooth shading modes intermediate points will get an interpolated color. - element index color: like element color, but the color values are not specified directly, but as indices in a color table (the `colormap` argument). - vertex index color: like vertex color, but the colors are indices in a color table (the `colormap` argument). - property color: as an extra mode in the draw function, if `color='prop'` is specified, and the object has an attribute 'prop', that attribute will be used as a color index and the object will be drawn in element index color mode. If the object has no such attribute, the object is drawn in no color mode. Element and vertex color modes are usually only used with a single object in the `F` parameter, because they require a matching set of colors. Though the color set will be automatically resized if not matching, the result will seldomly be what the user expects. If single colors are specified as a tuple of three float values (see below), the correct size of a color array for an object with `nelems` elements of plexitude `nplex` would be: (nelems,3) in element color mode, and (nelems,nplex,3) in vertex color mode. In the index modes, color would then be an integer array with shape respectively (nelems,) and (nelems,nplex). Their values are indices in the colormap array, which could then have shape (ncolors,3), where ncolors would be larger than the highest used value in the index. If the colormap is insufficiently large, it will again be wrapped around. If no colormap is specified, the current viewport colormap is used. The default contains eight colors: black=0, red=1, green=2, blue=3, cyan=4, magenta=5, yellow=6, white=7. A color value can be specified in multiple ways, but should be convertible to a normalized OpenGL color using the :func:`colors.GLcolor` function. The normalized color value is a tuple of three values in the range 0.0..1.0. The values are the contributions of the red, green and blue components. """ if clear is not None: kargs['clear_'] = clear draw_options = [ 'silent','shrink','clear_','view','bbox', 'allviews' ] # For simplicity of the code, put objects to draw always in a list if isinstance(F, list): FL = F else: FL = [ F ] single = True # Flatten the list, replacing named objects with their value FL = flatten(FL) ntot = len(FL) # Transform to list of drawable objects FL = drawable(FL) nres = len(FL) # Get default drawing options and overwrite with specified values opts = Attributes(pf.canvas.drawoptions) opts.update(utils.selectDict(kargs,draw_options,remove=True)) if nres < ntot and not opts.silent: raise ValueError("Data contains undrawable objects (%s/%s)" % (ntot-nres, ntot)) # Shrink the objects if requested if opts.shrink: FL = [ _shrink(Fi, opts.shrink_factor) for Fi in FL ] ## # Execute the drawlock wait before doing first canvas change pf.GUI.drawlock.wait() if opts.clear_: clear_canvas() if opts.view not in [ None, 'last', 'cur']: pf.debug("SETTING VIEW to %s" % opts.view, pf.DEBUG.DRAW) setView(opts.view) pf.GUI.setBusy() try: # Catch errors to make sure we can reset busy cursor pf.app.processEvents() actors = [] # loop over the objects for Fi in FL: # Create the actor actor = Fi.actor(**kargs) if single and len(actors) > 0: # append the new actor to the children of the first actors[0].children.append(actor) else: # append the actor to the list of actors actors.append(actor) if actor is not None and not single: # Immediately show the new actor pf.canvas.addActor(actor) if single: # Return a single actor actors = actors[0] if len(actors) > 0 else None if actors is not None: # Draw all actors in a single shot pf.canvas.addActor(actors) view = opts.view bbox = opts.bbox pf.debug(pf.canvas.drawoptions, pf.DEBUG.OPENGL) pf.debug(opts, pf.DEBUG.OPENGL) pf.debug(view, pf.DEBUG.OPENGL) pf.debug(bbox, pf.DEBUG.OPENGL) # Adjust the camera if view not in [None, 'cur'] or bbox not in [None, 'last']: if view == 'last': view = pf.canvas.drawoptions['view'] # bbox can be an ndarray, for which '==' would fail if isinstance(bbox,str): if bbox == 'auto': bbox = pf.canvas.scene.bbox elif bbox == 'last': bbox = None pf.canvas.setCamera(bbox, view) # Update the rendering pf.canvas.update() pf.app.processEvents() # Save the rendering if autosave on pf.debug("AUTOSAVE %s" % image.autoSaveOn()) if image.autoSaveOn(): image.saveNext() # Make sure next drawing operation is retarded if opts.wait: pf.GUI.drawlock.lock() finally: pf.GUI.setBusy(False) # Return the created Actor(s) return actors
def _setFocus(object, bbox, view): """Set focus after a draw operation""" if view is not None or bbox not in [None, 'last']: if view == 'last': view = pf.canvas.drawoptions['view'] if bbox == 'auto': bbox = coords.bbox(object) pf.canvas.setCamera(bbox, view) pf.canvas.update()
[docs]def setDrawOptions(kargs0={},**kargs): """Set default values for the draw options. Draw options are a set of options that hold default values for the draw() function arguments and for some canvas settings. The draw options can be specified either as a dictionary, or as keyword arguments. """ d = {} d.update(kargs0) d.update(kargs) pf.canvas.setOptions(d)
def showDrawOptions(): print("Current Drawing Options: %s" % pf.canvas.drawoptions) print("Current Viewport Settings: %s" % pf.canvas.settings)
[docs]def reset(): """reset the canvas""" pf.canvas.resetDefaults() pf.canvas.resetOptions() pf.GUI.drawwait = pf.cfg['draw/wait'] try: if len(pf.GUI.viewports.all) == 1: size = (-1, -1) canvasSize(*size) except: print("Warning: Resetting canvas before initialization?") clear() view('front')
def resetAll(): reset() wireframe()
[docs]def shrink(onoff,factor=None): """Set shrinking on or off, and optionally set shrink factor""" data = {'shrink':bool(onoff)} try: data['shrink_factor'] = float(factor) except: pass setDrawOptions(data)
def _shrink(F, factor): """Return a shrinked object. A shrinked object is one where each element is shrinked with a factor around its own center. """ if not isinstance(F, Formex): F = F.toFormex() return F.shrink(factor)
[docs]def drawVectors(P,v,size=None,nolight=True,**drawOptions): """Draw a set of vectors. If size is None, draws the vectors v at the points P. If size is specified, draws the vectors size*normalize(v) P, v and size are single points or sets of points. If sets, they should be of the same size. Other drawoptions can be specified and will be passed to the draw function. """ if size is None: Q = P + v else: Q = P + size*normalize(v) return draw(connect([P, Q]),nolight=nolight,**drawOptions)
def drawPlane(P,N,size,**drawOptions): from pyformex.plugins.tools import Plane p = Plane(P, N, size) return draw(p,bbox='last',**drawOptions)
[docs]def drawMarks(X,M,color='black',prefix='',ontop=True,**kargs): """Draw a list of marks at points X. Parameters: - `X`: Coords. - `M`: list of length X.ncoords(). The string representation of the items in the list are drawn at the corresponding 3D coordinate of X. - `prefix`: string. If specified, it is prepended to all drawn strings. - `ontop`: bool. If True, the marks are drawn on top, meaning they will all be visible, even those drawn at points hidden by the geometry. If False, hidden marks can be hidden by the drawn geometry. Other parameters can be passed to the :class:`actors.TextArray` class. """ from pyformex.gui.draw import ack _large_ = 20000 if len(M) > _large_: if not ack("You are trying to draw marks at %s points. This may take a long time, and the results will most likely not be readible anyway. If you insist on drawing these marks, anwer YES." % len(M)): return None A = actors.TextArray(val=M, pos=X, color=color, prefix=prefix, **kargs) drawActor(A) return A
[docs]def drawFreeEdges(M,color='black'): """Draw the feature edges of a Mesh""" B = M.getFreeEdgesMesh() return draw(B, color=color, nolight=True)
[docs]def drawNumbers(G,numbers=None,color='black',trl=None,offset=0,prefix='',ontop=None,**kargs): """Draw numbers on all elements of a Geometry G. Parameters: - `G`: Geometry like (Coords, Formex, Mesh) - `numbers`: int array of length F.nelems(). If not specified, the range from 0 to F.nelems()-1 is used. - `color`: color to be used in drawing the numbers. - `trl`: If unspecified, the numbers are drawn at the centroids of the elements. A translation (x,y,z) may be given to put the numbers out of the centroids, e.g. to put them in front of the objects to make them visible, or to allow to view a mark at the centroids. - `offset`: int. If specified, this value is added to the numbers. This is an easy ways to compare the drawing with systems using base 1 numbering. - `prefix`: string. If specified, it is added before every drawn number. Other parameters are passed to the :func:`drawMarks` function. """ if ontop is None: ontop = getcfg('draw/numbersontop') try: X = G.centroids() except: return None if trl is not None: X = X.trl(trl) X = X.reshape(-1, 3) if numbers is None: numbers = np.arange(X.shape[0]) return drawMarks(X, numbers+offset, color=color, prefix=prefix, ontop=ontop,**kargs)
[docs]def drawPropNumbers(F,**kargs): """Draw property numbers on all elements of F. This calls drawNumbers to draw the property numbers on the elements. All arguments of drawNumbers except `numbers` may be passed. If the object F thus not have property numbers, -1 values are drawn. """ if F.prop is None: nrs = -np.ones(F.nelems(), dtype=np.Int) else: nrs = F.prop drawNumbers(F,nrs,**kargs)
[docs]def drawVertexNumbers(F,color='black',trl=None,ontop=False): """Draw (local) numbers on all vertices of F. Normally, the numbers are drawn at the location of the vertices. A translation may be given to put the numbers out of the location, e.g. to put them in front of the objects to make them visible, or to allow to view a mark at the vertices. """ FC = F.coords.reshape((-1, 3)) if trl is not None: FC = FC.trl(trl) return drawMarks(FC, np.resize(np.arange(F.coords.shape[-2]), (FC.shape[0])), color=color, ontop=ontop)
[docs]def drawBbox(F,color='black',**kargs): """Draw the bounding box of the geometric object F. F is any object that has a `bbox` method. Returns the drawn Annotation. """ A = actors.BboxActor(F.bbox(), color=color, **kargs) drawActor(A) return A
[docs]def drawText(text,pos,**kargs): """Show a text at position pos. Draws a text at a given position. The position can be either a 2D canvas position, specified in pixel coordinates (int), or a 3D position, specified in global world coordinates (float). In the latter case the text will be displayed on the canvas at the projected world point, and will move with that projection, while keeping the text unscaled and oriented to the viewer. The 3D mode is especially useful to annotate parts of the geometry with a label. Parameters: - `text`: string to be displayed. - `pos`: (2,) int or (3,) float: canvas or world position. - any other parameters are passed to :class:`opengl.textext.Text`. """ utils.warn("warn_drawText") A = actors.Text(text, pos, **kargs) drawActor(A) return A
drawText3D = drawText # This function should be completed
[docs]def drawViewportAxes3D(pos,color=None): """Draw two viewport axes at a 3D position.""" A = actors.Mark((0,200,0),image,size=40,color=colors.red) drawActor(A) return A
[docs]def drawAxes(cs=None,**kargs): """Draw the axes of a coordinate system. Parameters: - `cs`: a :class:`coordsys.CoordSys` If not specified, the global coordinate system is used. Other arguments can be added just like in the :class:`candy.Axes` class. By default this draws the positive parts of the axes in the colors R,G,B and the negative parts in C,M,Y. """ from pyformex.candy import Axes from pyformex.coordsys import CoordSys if cs is None: cs = CoordSys() A = draw(Axes(cs,**kargs)) return A
[docs]def drawPrincipal(F,weight=None,**kargs): """Draw the principal axes of the geometric object F. F is Coords or Geometry. If weight is specified, it is an array of weights attributed to the points of F. It should have the same length as `F.coords`. Other parameter are drawing attributes passed to :func:`drawAxes`. """ return drawAxes(F.principalCS(weight),**kargs)
[docs]def drawImage3D(image,nx=0,ny=0,pixel='dot'): """Draw an image as a colored Formex Draws a raster image as a colored Formex. While there are other and better ways to display an image in pyFormex (such as using the imageView widget), this function allows for interactive handling the image using the OpenGL infrastructure. Parameters: - `image`: a QImage or any data that can be converted to a QImage, e.g. the name of a raster image file. - `nx`,`ny`: width and height (in cells) of the Formex grid. If the supplied image has a different size, it will be rescaled. Values <= 0 will be replaced with the corresponding actual size of the image. - `pixel`: the Formex representing a single pixel. It should be either a single element Formex, or one of the strings 'dot' or 'quad'. If 'dot' a single point will be used, if 'quad' a unit square. The difference will be important when zooming in. The default is 'dot'. Returns the drawn Actor. See also :func:`drawImage`. """ pf.GUI.setBusy() from pyformex.plugins.imagearray import qimage2glcolor, resizeImage from pyformex.opengl.colors import GLcolorA # Create the colors #print("TYPE %s" % type(image)) if isinstance(image,np.ndarray): # undocumented feature: allow direct draw of 2d array color = GLcolorA(image) nx,ny = color.shape[:2] colortable = None print(color) else: image = resizeImage(image, nx, ny) nx, ny = image.width(), image.height() color, colortable = qimage2glcolor(image) # Create a 2D grid of nx*ny elements # !! THIS CAN PROBABLY BE DONE FASTER if isinstance(pixel, Formex) and pixel.nelems()==1: F = pixel elif pixel == 'quad': F = Formex('4:0123') else: F = Formex('1:0') F = F.replicm((nx, ny)).centered() F._imageshape_ = (nx,ny) # Draw the grid using the image colors FA = draw(F, color=color, colormap=colortable, nolight=True) pf.GUI.setBusy(False) return FA
[docs]def drawImage(image,w=0,h=0,x=-1,y=-1,color=colors.white,ontop=False): """Draws an image as a viewport decoration. Parameters: - `image`: a QImage or any data that can be converted to a QImage, e.g. the name of a raster image file. See also the :func:`loadImage` function. - `w`,`h`: width and height (in pixels) of the displayed image. If the supplied image has a different size, it will be rescaled. A value <= 0 will be replaced with the corresponding actual size of the image. - `x`,`y`: position of the lower left corner of the image. If negative, the image will be centered on the current viewport. - `color`: the color to mix in (AND) with the image. The default (white) will make all pixels appear as in the image. - `ontop`: determines whether the image will appear as a background (default) or at the front of the 3D scene (as on the camera glass). Returns the Decoration drawn. Note that the Decoration has a fixed size (and position) on the canvas and will not scale when the viewport size is changed. The :func:`bgcolor` function can be used to draw an image that completely fills the background. """ utils.warn("warn_drawImage_changed") from pyformex.plugins.imagearray import qimage2numpy from pyformex.opengl.decors import Rectangle image = qimage2numpy(image, resize=(w, h), indexed=False) w, h = image.shape[:2] if x < 0: x = (pf.canvas.width() - w) // 2 if y < 0: y = (pf.canvas.height() - h) // 2 R = Rectangle(x, y, x+w, y+h, color=color, texture=image, ontop=ontop) decorate(R) return R
[docs]def drawField(fld,comp=0,scale='RAINBOW',symmetric_scale=False,cvalues=None,**kargs): """Draw intensity of a scalar field over a Mesh. Parameters: - `fld`: a Field, specifying some value over a Geometry. - `comp`: int: if fld is a vectorial Field, specifies the component that is to be drawn. - `scale`: one of the color palettes defined in :mod:`colorscale`. If an empty string is specified, the scale is not drawn. - `symmetric_scale`: bool : if `True` the mid value of the color scale will be set to the value corresponding to the middle value of the `fld` data range. If `False` the mid value of the color scale will be set to 0.0 if the range extends over negative and positive values. - `cvalues`: None or list : specify the values between which to span the color palette. If `None` the min , max and mid values are taken from the field data. If `list` the values can be defined by the user as a list of 2 values (min, max) or 3 values (min, mid, max). - `**kargs`: any not-recognized keyword parameters are passed to the draw function to draw the Geometry. Draws the Field's Geometry with the Field data converted to colors. A color legend is added to convert colors to values. NAN data are converted to numerical values using numpy.nan_to_num. """ from pyformex.gui.colorscale import ColorScale from pyformex.opengl.decors import ColorLegend # Get the data data = np.nan_to_num(fld.comp(comp)) # create a colorscale and draw the colorlegend vmid = None if cvalues is None: vmin, vmax = data.min(), data.max() else: vmin, vmax = cvalues[0], cvalues[-1] if len(cvalues) == 3: vmid = cvalues[1] if vmid is None: if vmin*vmax < 0.0 and not symmetric_scale: vmid = 0.0 else: vmid = 0.5*(vmin+vmax) scalev = [vmin, vmid, vmax] if max(scalev) > 0.0: logv = [ abs(a) for a in scalev if a != 0.0 ] logs = np.log10(logv) logma = int(logs.max()) else: # All data = 0.0 logma = 0 if logma < 0: multiplier = 3 * ((2 - logma) // 3 ) else: multiplier = 0 CS = ColorScale(scale, vmin, vmax, vmid, 1., 1.) cval = np.array([CS.color(v) for v in data.flat]) cval = cval.reshape(data.shape+(3,)) CLA = ColorLegend(CS, 256, 20, 20, 30, 200, scale=multiplier) drawActor(CLA) decorate(drawText("{} (1.e{})".format(fld.fldname,-multiplier),(20, 250),size=18,color='black')) if fld.fldtype == 'node': draw(fld.geometry, color=cval[fld.geometry.elems], **kargs) else: draw(fld.geometry, color=cval, **kargs)
[docs]def drawActor(A): """Draw an actor and update the screen.""" pf.canvas.addActor(A) pf.canvas.update()
[docs]def drawAny(A): """Draw an Actor/Annotation/Decoration and update the screen.""" pf.canvas.addAny(A) pf.canvas.update()
[docs]def undraw(items): """Remove an item or a number of items from the canvas. Use the return value from one of the draw... functions to remove the item that was drawn from the canvas. A single item or a list of items may be specified. """ pf.canvas.removeAny(items) pf.canvas.update()
# pf.app.processEvents()
[docs]def view(v,wait=True): """Show a named view, either a builtin or a user defined. This shows the current scene from another viewing angle. Switching views of a scene is much faster than redrawing a scene. Therefore this function is prefered over :func:`draw` when the actors in the scene remain unchanged and only the camera viewpoint changes. Just like :func:`draw`, this function obeys the drawing lock mechanism, and by default it will restart the lock to retard the next draing operation. """ pf.GUI.drawlock.wait() if v != 'last': angles = pf.canvas.view_angles.get(v) if not angles: utils.warn("A view named '%s' has not been created yet" % v) return pf.canvas.setCamera(None, angles) setView(v) pf.canvas.update() if wait: pf.GUI.drawlock.lock()
[docs]def setTriade(on=None,pos='lb',siz=50,triade=None): """Toggle the display of the global axes on or off. This is a convenient feature to display the global axes directions with rotating actor at fixed viewport size and position. Parameters: - `on`: boolean. If True, the global axes triade is displayed. If False, it is removed. The default (None) toggles between on and off. The remaining parameters are only used on enabling the triade. - `pos`: string of two characters. The characters define the horizontal (one of 'l', 'c', or 'r') and vertical (one of 't', 'c', 'b') position on the camera's viewport. Default is left-bottom. - `siz`: size (in pixels) of the triade. - `triade`: None, Geometry or str: defines the Geometry to be used for representing the global axes. If None: use the previously set triade, or set a default if no previous. If Geometry: use this to represent the axes. To be useful and properly displayed, the Geometry's bbox should be around [(-1,-1,-1),(1,1,1)]. Drawing attributes may be set on the Geometry to influence the appearence. This allows to fully customize the Triade. If str: use one of the predefined Triade Geometries. Currently, the following are available: - 'axes': axes and coordinate planes as in :class:`candy.Axes` - 'man': a model of a man as in data file 'man.pgf' """ if on is None: on = not pf.canvas.hasTriade() if on: if triade is None and pf.canvas.triade is None: triade = 'axes' if triade == 'axes': from pyformex import candy triade = candy.Axes(reverse=False) elif triade == 'man': triade = Formex.read(os.path.join(pf.cfg['datadir'],'man.pgf')) #print(type(triade)) #print(triade.attrib) pf.canvas.setTriade(pos,siz,triade) else: pf.canvas.removeTriade() pf.canvas.update() pf.app.processEvents()
[docs]def setGrid(on=None,d=None,s=None,**kargs): """Toggle the display of the canvas grid on or off. This is a convenient feature to display a grid on the canvas. Parameters: - `on`: boolean. If True, the grid is displayed. If False, it is removed. The default (None) toggles between on and off. The remaining parameters are only used on enabling the grid. - `d`: None, int or (int,int). Distance in pixels between the grid lines. A tuple of two values specifies the distance in x,y direction. If not specified, the previous grid is used, or a default grid with d=100 is created. - `s`: None, int or (int,int). Half the size of the grid in pixels. A tuple of two values specifies size in x,y direction. If not specified the size is set equal to the current openGL canvas size. The grid is currently centered on the canvas, but we intend to add parameters to align it on any of the corners. Extra drawing parameters may be added to influence the appearence of the grid. An example:: setGrid(d=200,linewidth=3,color=red,ontop=True) """ if on is None: # toggle on = not pf.canvas.hasGrid() if on: # show grid w,h = pf.canvas.width(),pf.canvas.height() x,y = w//2,h//2 if s is None: s = (w,h) if d is None: # reuse or default if pf.canvas.grid is None: # create default d = 100 else: # reuse previous grid = None if d is not None: # create grid if isInt(d): dx,dy = d,d else: dx,dy = d if isInt(s): sx,sy = s,s else: sx,sy = s nx,ny = int(np.ceil(float(sx)/dx/2)), int(np.ceil(float(sy)/dy/2)) x0,y0 = x-nx*dx, y-ny*dy x1,y1 = x+nx*dx, y+ny*dy grid = decors.Grid2D(x0,y0,x1,y1,2*nx,2*ny,rendertype=2,**kargs) pf.canvas.setGrid(grid) else: # hide grid pf.canvas.removeGrid() pf.canvas.update() pf.app.processEvents()
[docs]def annotate(annot): """Draw an annotation.""" pf.canvas.addAnnotation(annot) pf.canvas.update()
def unannotate(annot): pf.canvas.removeAnnotation(annot) pf.canvas.update()
[docs]def decorate(decor): """Draw a decoration.""" pf.canvas.addDecoration(decor) pf.canvas.update()
def undecorate(decor): pf.canvas.removeDecoration(decor) pf.canvas.update()
[docs]def createView(name,angles,addtogui=False): """Create a new named view (or redefine an old). The angles are (longitude, latitude, twist). By default, the view is local to the script's viewport. If addtogui is True, a view button to set this view is added to the GUI. """ pf.canvas.view_angles[name] = angles if addtogui: pf.GUI.createView(name, angles)
[docs]def setView(name,angles=None): """Set the default view for future drawing operations. If no angles are specified, the name should be an existing view, or the predefined value 'last'. If angles are specified, this is equivalent to createView(name,angles) followed by setView(name). """ if name != 'last' and angles: createView(name, angles) setDrawOptions({'view':name})
def saveView(name,addtogui=False): pf.GUI.saveView(name) def frontView(): view("front") def backView(): view("back") def leftView(): view("left") def rightView(): view("right") def topView(): view("top"); def bottomView(): view("bottom") def isoView(): view("iso")
[docs]def bgcolor(color=None,image=None): """Change the background color and image. Parameters: - `color`: a single color or a list of 4 colors. A single color sets a solid background color. A list of four colors specifies a gradient. These 4 colors are those of the Bottom Left, Bottom Right, Top Right and Top Left corners respectively. - `image`: the name of an image file. If specified, the image will be overlayed on the background colors. Specify a solid white background color to sea the image unaltered. """ pf.canvas.setBackground(color=color, image=image) pf.canvas.display() pf.canvas.update()
[docs]def fgcolor(color): """Set the default foreground color.""" pf.canvas.setFgColor(color)
[docs]def hicolor(color): """Set the highlight color.""" pf.canvas.setSlColor(color)
[docs]def colormap(color=None): """Gets/Sets the current canvas color map""" return pf.canvas.settings.colormap
[docs]def colorindex(color): """Return the index of a color in the current colormap""" cmap = pf.canvas.settings.colormap color = np.array(color) i = np.where((cmap==color).all(axis=1))[0] if len(i) > 0: return i[0] else: i = len(cmap) print("Add color %s = %s to viewport colormap" % (i, color)) color = color.reshape(1, 3) pf.canvas.settings.colormap = np.concatenate([cmap, color], axis=0) return i
[docs]def renderModes(): """Return a list of predefined render profiles.""" from pyformex.opengl.canvas import CanvasSettings return list(CanvasSettings.RenderProfiles.keys())
[docs]def renderMode(mode,light=None): """Change the rendering profile to a predefined mode. Currently the following modes are defined: - wireframe - smooth - smoothwire - flat - flatwire - smooth_avg """ # ERROR The following redraws twice !!! pf.canvas.setRenderMode(mode, light) pf.canvas.update() toolbar.updateViewportButtons(pf.canvas) #toolbar.updateNormalsButton() #toolbar.updateTransparencyButton() #toolbar.updateLightButton() pf.GUI.processEvents()
[docs]def wireMode(mode): """Change the wire rendering mode. Currently the following modes are defined: 'none', 'border', 'feature','all' """ modes = [ 'all', 'border', 'feature' ] if mode in modes: state = True mode = 1 + modes.index(mode) elif mode == 'none': state = False mode = None else: return pf.canvas.setWireMode(state, mode) pf.canvas.update() pf.GUI.processEvents()
def wireframe(): renderMode("wireframe") def smooth(): renderMode("smooth") def smoothwire(): renderMode("smoothwire") def flat(): renderMode("flat") def flatwire(): renderMode("flatwire") def smooth_avg(): renderMode("smooth_avg") ## def opacity(alpha): ## """Set the viewports transparency.""" ## pf.canvas.alpha = float(alpha)
[docs]def lights(state=True): """Set the lights on or off""" pf.canvas.setLighting(state) pf.canvas.update() toolbar.updateLightButton() pf.GUI.processEvents()
[docs]def transparent(state=True): """Set the transparency mode on or off.""" pf.canvas.setToggle('alphablend', state) pf.canvas.update() toolbar.updateTransparencyButton() pf.GUI.processEvents()
def perspective(state=True): pf.canvas.camera.setPerspective(state) pf.canvas.update() toolbar.updatePerspectiveButton() pf.GUI.processEvents()
[docs]def set_material_value(typ, val): """Set the value of one of the material lighting parameters typ is one of 'ambient','specular','emission','shininess' val is a value between 0.0 and 1.0 """ setattr(pf.canvas, typ, val) pf.canvas.setLighting(True) pf.canvas.update() pf.app.processEvents()
def set_light(light,**args): light = int(light) pf.canvas.lights.set(light,**args) pf.canvas.setLighting(True) pf.canvas.update() pf.app.processEvents() def set_light_value(light, key, val): light = int(light) pf.canvas.lights.set_value(light, key, val) pf.canvas.setLighting(True) pf.canvas.update() pf.app.processEvents()
[docs]def linewidth(wid): """Set the linewidth to be used in line drawings.""" pf.canvas.setLineWidth(wid)
[docs]def linestipple(factor, pattern): """Set the linewidth to be used in line drawings.""" pf.canvas.setLineStipple(factor, pattern)
[docs]def pointsize(siz): """Set the size to be used in point drawings.""" pf.canvas.setPointSize(siz)
[docs]def canvasSize(width, height): """Resize the canvas to (width x height). If a negative value is given for either width or height, the corresponding size is set equal to the maximum visible size (the size of the central widget of the main window). Note that changing the canvas size when multiple viewports are active is not approved. """ pf.canvas.changeSize(width, height)
# This is not intended for the user def clear_canvas(sticky=False): pf.canvas.removeAll(sticky) pf.canvas.triade = None pf.canvas.grid = None pf.canvas.clearCanvas()
[docs]def clear(sticky=False): """Clear the canvas. Removes everything from the current scene and displays an empty background. This function waits for the drawing lock to be released, but will not reset it. """ pf.GUI.drawlock.wait() clear_canvas() pf.canvas.update()
def redraw(): pf.canvas.redrawAll() pf.canvas.update() #### End