Source code for plugins.objects

##  This file is part of pyFormex 1.0.7  (Mon Jun 17 12:20:39 CEST 2019)
##  pyFormex is a tool for generating, manipulating and transforming 3D
##  geometrical models by sequences of mathematical operations.
##  Home page:
##  Project page:
##  Copyright 2004-2019 (C) Benedict Verhegghe (
##  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
##  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

"""Selection of objects from the global dictionary.

This is a support module for other pyFormex plugins.
from __future__ import absolute_import, division, print_function

import pyformex as pf
from pyformex import zip
from pyformex import geomfile
from pyformex.coords import bbox
from pyformex.script import named
from collections import OrderedDict

from copy import deepcopy

[docs]class Objects(object): """A selection of objects from the pyFormex Globals(). The class provides facilities to filter the global objects by their type and select one or more objects by their name(s). The values of these objects can be changed and the changes can be undone. """ def __init__(self, clas=None, like=None, filter=None, namelist=[]): """Create a new selection of objects. If a filter is given, only objects passing it will be accepted. The filter will be applied dynamically on the dict. If a list of names is given, the current selection will be set to those names (provided they are in the dictionary). """ self.clas = clas = like self.filter = filter self.names = [] self.values = [] self.clear() if namelist: self.set(namelist)
[docs] def object_type(self): """Return the type of objects in this selection.""" if self.clas: return self.clas.__name__+' ' else: return ''
[docs] def set(self, names): """Set the selection to a list of names. namelist can be a single object name or a list of names. This will also store the current values of the variables. """ if isinstance(names, str): names = [names] self.names = [s for s in names if isinstance(s, str)] self.values = [named(s) for s in self.names]
[docs] def append(self, name, value=None): """Add a name,value to a selection. If no value is given, its current value is used. If a value is given, it is exported. """ self.names.append(name) if value is None: value = named(name) else: export({name: value}) self.values.append(value)
[docs] def clear(self): """Clear the selection.""" self.set([])
def __getitem__(self, i): """Return selection item i""" return self.names[i]
[docs] def listAll(self): """Return a list with all selectable objects. This lists all the global names in pyformex.PF that match the class and/or filter (if specified). """ return listAll(clas=self.clas,, filtr=self.filter)
def selectAll(self): self.set(self.listAll())
[docs] def remember(self, copy=False): """Remember the current values of the variables in selection. If copy==True, the values are copied, so that the variables' current values can be changed inplace without affecting the remembered values. """ self.values = [named(n) for n in self.names] if copy: self.values = [deepcopy(n) for n in self.values]
[docs] def changeValues(self, newvalues): """Replace the current values of selection by new ones. The old values are stored locally, to enable undo operations. This is only needed to change the values of objects that can not be changed inplace! """ self.remember() export2(self.names, newvalues)
[docs] def undoChanges(self): """Undo the last changes of the values.""" export2(self.names, self.values)
[docs] def check(self, single=False, warn=True): """Check that we have a current selection. Returns the list of Objects corresponding to the current selection. If single==True, the selection should hold exactly one Object name and a single Object instance is returned. If there is no selection, or more than one in case of single==True, an error message is displayed and None is returned """ self.names = [n for n in self.names if n in pf.PF] if len(self.names) == 0: if warn: warning("No %sobjects were selected" % self.object_type()) return None if single and len(self.names) > 1: if warn: warning("You should select exactly one %sobject" % self.object_type()) return None if single: return named(self.names[0]) else: return [named(n) for n in self.names]
[docs] def odict(self): """Return the currently selected items as a dictionary. Returns an OrderedDict with the currently selected objects in the order of the selection.names. """ return OrderedDict(zip(self.names, self.check(warn=False)))
[docs] def ask(self, mode='multi'): """Show the names of known objects and let the user select one or more. mode can be set to'single' to select a single item. Return a list with the selected names, possibly empty (if nothing was selected by the user), or None if there is nothing to choose from. This also sets the current selection to the selected names, unless the return value is None, in which case the selection remains unchanged. """ choices = self.listAll() if not choices: return None res = widgets.ListSelection( caption='Known %sobjects' % self.object_type(), choices=self.listAll(), default=self.names, sort=True).getResults() if res is None: res = [] self.set(res) return res
[docs] def ask1(self): """Select a single object from the list. Returns the object, not its name! """ if self.ask('single'): return named(self.names[0]) else: return None
[docs] def forget(self): """Remove the selection from the globals.""" forget(self.names) self.clear()
[docs] def keep(self): """Remove everything except the selection from the globals.""" forget([n for n in self.listAll() if not n in self.names])
def printNames(self): print(self.names)
[docs] def printval(self): """Print the selection.""" objects = self.check() if objects: for n, o in zip(self.names, objects): print("%s = %s" % (n, str(o)))
[docs] def printbbox(self): """Print the bbox of the current selection.""" objects = self.check() if objects: for n, o in zip(self.names, objects): bb = o.bbox() print("* %s (%s): bbox [%s, %s]" % (n, o.__class__.__name__, bb[0], bb[1])) if len(self.names) > 1: print("** Overal bbox: [%s, %s]" % (bb[0], bb[1]))
[docs] def writeToFile(self, filename): """Write objects to a geometry file.""" objects = self.odict() if objects: writeGeomFile(filename, objects)
[docs] def readFromFile(self, filename): """Read objects from a geometry file.""" res = readGeomFile(filename) export(res) self.set(res.keys())
###################### Drawable Objects ############################# from pyformex.gui.draw import * # Default Annotations
[docs]def draw_object_name(n): """Draw the name of an object at its center.""" return drawText3D(n, named(n).center())
[docs]def draw_elem_numbers(n): """Draw the numbers of an object's elements.""" return drawNumbers(named(n), color='blue')
[docs]def draw_nodes(n): """Draw the nodes of an object.""" return draw(named(n).coords, nolight=True, wait=False)
[docs]def draw_node_numbers(n): """Draw the numbers of an object's nodes.""" return drawNumbers(named(n).coords, color='red')
[docs]def draw_free_edges(n): """Draw the feature edges of an object.""" return drawFreeEdges(named(n), color='black')
[docs]def draw_bbox(n): """Draw the bbox of an object.""" from pyformex.gui.draw import drawBbox return drawBbox(named(n))
[docs]class DrawableObjects(Objects): """A selection of drawable objects from the globals(). This is a subclass of Objects. The constructor has the same arguments as the Objects class, plus the following: - `annotations`: a set of functions that draw annotations of the objects. Each function should take an object name as argument, and draw the requested annotation for the named object. If the object does not have the annotation, it should be silently ignored. Default annotation functions available are: - draw_object_name - draw_elem_numbers - draw_nodes - draw_node_numbers - draw_bbox No annotation functions are activated by default. """ def __init__(self, **kargs): Objects.__init__(self, **kargs) self.autodraw = False self.annotations = set() # Active annotations self._annotations = {} # Drawn annotations self._actors = []
[docs] def ask(self, mode='multi'): """Interactively sets the current selection.""" new = Objects.ask(self, mode) if new is not None: self.draw() return new
def draw(self, **kargs): from pyformex.gui.draw import busyCursor clear() pf.debug("Drawing SELECTION: %s" % self.names, pf.DEBUG.DRAW) with busyCursor(): self._actors = draw(self.names, clear=False, wait=False, **kargs) for f in self.annotations: pf.debug("Drawing ANNOTATION: %s" % f, pf.DEBUG.DRAW) self.drawAnnotation(f)
[docs] def drawChanges(self): """Draws old and new version of a Formex with different colors. old and new can be a either Formex instances or names or lists thereof. old are drawn in yellow, new in the current color. """ self.draw() draw(self.values, color='yellow', bbox=None, clear=False, wait=False)
[docs] def undoChanges(self): """Undo the last changes of the values.""" Objects.undoChanges(self) self.draw()
[docs] def toggleAnnotation(self, f, onoff=None): """Toggle the display of an annotation On or Off. If given, onoff is True or False. If no onoff is given, this works as a toggle. """ if onoff is None: # toggle active = f not in self.annotations else: active = onoff if active: self.annotations.add(f) self.drawAnnotation(f) else: self.annotations.discard(f) self.removeAnnotation(f)
[docs] def drawAnnotation(self, f): """Draw some annotation for the current selection.""" self._annotations[f] = [f(n) for n in self.names]
[docs] def removeAnnotation(self, f): """Remove the annotation f.""" if f in self._annotations: # pf.canvas.removeAnnotation(self._annotations[f]) # Use removeAny, because some annotations are not canvas # annotations but actors! pf.canvas.removeAny(self._annotations[f]) pf.canvas.update() del self._annotations[f]
[docs] def editAnnotations(self, ontop=None): """Edit the annotation properties Currently only changes the ontop attribute for all drawn annotations. Values: True, False or '' (toggle). Other values have no effect. """ for f in self._annotations.values(): if ontop in [True, False, '']: if not isinstance(f, list): f = [f] for a in f: if ontop == '': ontop = not a.ontop print(a, ontop) a.ontop = ontop
[docs] def hasAnnotation(self, f): """Return the status of annotation f""" return f in self.annotations
def hasNames(self): return self.hasAnnotation(draw_object_name) def hasNumbers(self): return self.hasAnnotation(draw_elem_numbers) def hasNodeNumbers(self): return self.hasAnnotation(draw_node_numbers) def hasFreeEdges(self): return self.hasAnnotation(draw_free_edges) def hasNodeMarks(self): return self.hasAnnotation(draw_nodes) def hasBbox(self): return self.hasAnnotation(draw_bbox) def toggleNames(self, onoff=None): self.toggleAnnotation(draw_object_name, onoff) def toggleNumbers(self, onoff=None): self.toggleAnnotation(draw_elem_numbers, onoff) def toggleNodeNumbers(self, onoff=None): self.toggleAnnotation(draw_node_numbers, onoff) def toggleFreeEdges(self, onoff=None): self.toggleAnnotation(draw_free_edges, onoff) def toggleNodes(self, onoff=None): self.toggleAnnotation(draw_nodes, onoff) def toggleBbox(self, onoff=None): self.toggleAnnotation(draw_bbox, onoff)
[docs] def setProp(self, prop=None): """Set the property of the current selection. prop should be a single integer value or None. If None is given, a value will be asked from the user. If a negative value is given, the property is removed. If a selected object does not have a setProp method, it is ignored. """ objects = self.check() if objects: if prop is None: res = askItems([['property', 0]], caption = 'Set Property Number for Selection (negative value to remove)') if res: prop = int(res['property']) if prop < 0: prop = None for o in objects: if hasattr(o, 'setProp'): o.setProp(prop) self.draw()
[docs] def delProp(self): """Delete the property of the current selection. This well reset the `prop` attribute of all selected objects to None. """ objects = self.check() if objects: for o in objects: if hasattr(o, 'prop'): o.prop=None self.draw()
if __name__ == '__draw__': # If executed as a pyformex script pf.debug('Reloading module %s' % __file__) elif __name__ == '__main__': print(__doc__) # End