Source code for

##  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


Graphic Tools for pyFormex.
from __future__ import absolute_import, division, print_function
from pyformex import zip

import pyformex as pf
from pyformex.coords import *
from pyformex.collection import Collection
from pyformex.mesh import Mesh
from pyformex.formex import Formex
from pyformex.trisurface import TriSurface
from pyformex.plugins.nurbs import NurbsCurve, NurbsSurface

class Plane(object):

    def __init__(self, points, normal=None, size=(1.0, 1.0)):
        pts = Coords(points)
        if pts.shape == (3,) and normal is not None:
            P = pts
            n = Coords(normal)
            if n.shape != (3,):
                raise ValueError("normal does not have correct shape")
        elif pts.shape == (3, 3,):
            P = pts.centroid()
            n = cross(pts[1]-pts[0], pts[2]-pts[0])
            raise ValueError("points has incorrect shape (%s)" % str(pts.shape))
        s = Coords(size)
        self.P = P
        self.n = n
        self.s = s

    def point(self):
        return self.P

    def normal(self):
        return self.n

    def size(self):
        return self.s

    def bbox(self):
        return self.P.bbox()

    def __str__(self):
        return 'P:%s n:%s s:%s' % (list(self.P), list(self.n), (list(self.s[0]), list(self.s[1])))

    def actor(self, **kargs):
        from pyformex.opengl import actors
        actor = actors.PlaneActor(n=self.n, P=self.P, **kargs)
        return actor

################# Report information about picked objects ################

def report(K):
    if K is not None and hasattr(K, 'obj_type'):
        if K.obj_type == 'actor':
            return reportActors(K)
        elif K.obj_type == 'element':
            return reportElements(K)
        elif K.obj_type == 'point':
            return reportPoints(K)
        elif K.obj_type == 'edge':
            return reportEdges(K)
        elif K.obj_type == 'prop':
            return reportProps(K)
        elif K.obj_type == 'partition':
            return reportPartitions(K)
    return ''

def reportActors(K):
    s = "Actor report\n"
    v = K.get(-1, [])
    s += "Actors %s\n" % v
    for k in v:
        A = pf.canvas.actors[k]
        t = A.getType()
        s += "  Actor %s (type %s)\n" % (k, t)
    return s

def reportElements(K):
    s = "Element report\n"
    for k in K.keys():
        v = K[k]
        A = pf.canvas.actors[k]
        t = A.getType()
        s += "Actor %s (type %s); Elements %s\n" % (k, t, v)
        if t == Formex:
            e = A.coords
        elif t == TriSurface or  t == Mesh:
            e = A.elems
        for p in v:
            s += "  Element %s: %s\n" % (p, e[p])
    return s

def reportProps(K):
    s = "Property report\n"
    for k in K.keys():
        v = K[k]
        A = pf.canvas.actors[k]
        t = A.getType()
        s += "Actor %s (type %s); Props %s\n" % (k, t, v)
        for p in v:
            w = where(A.object.prop == p)[0]
            s += "  Elements with prop %s: %s\n" % (p, w)
    return s

def reportPoints(K):
    s = "Point report\n"
    for k in K.keys():
        v = K[k]
        A = pf.canvas.actors[k]
        s += "Actor %s (type %s); Points %s\n" % (k, A.getType(), v)
        x = A.object.points()
        for p in v:
            s += "  Point %s: %s\n" % (p, x[p])
    return s

def reportEdges(K):
    s = "Edge report\n"
    for k in K.keys():
        v = K[k]
        A = pf.canvas.actors[k]
        s += "Actor %s (type %s); Edges %s\n" % (k, A.getType(), v)
        e = A.edges()
        for p in v:
            s += "  Edge %s: %s\n" % (p, e[p])

def reportPartitions(K):
    s = "Partition report\n"
    for k in K.keys():
        P = K[k][0]
        A = pf.canvas.actors[k]
        t = A.getType()
        for l in P.keys():
            v = P[l]
            s += "Actor %s (type %s); Partition %s; Elements %s\n" % (k, t, l, v)
            if t == 'Formex':
                e = A
            elif t == 'TriSurface':
                e = A.getElems()
            for p in v:
                s += "  Element %s: %s\n" % (p, e[p])
    return s

[docs]def getObjectItems(obj, items, mode): """Get the specified items from object.""" if mode == 'actor': return [obj[i].object for i in items if hasattr(obj[i], 'object')] elif mode in ['element', 'partition']: if hasattr(obj, 'object') and hasattr(obj.object, 'select'): return elif mode == 'point': if hasattr(obj, 'points'): return obj.object.points()[items] return None
[docs]def getCollection(K): """Returns a collection.""" if K.obj_type == 'actor': return [pf.canvas.actors[int(i)].object for i in K.get(-1, []) if hasattr(pf.canvas.actors[int(i)], 'object')] elif K.obj_type in ['element', 'point']: return [getObjectItems(pf.canvas.actors[k], K[k], K.obj_type) for k in K.keys()] elif K.obj_type == 'partition': return [getObjectItems(pf.canvas.actors[k], K[k][0][prop], K.obj_type) for k in K.keys() for prop in K[k][0].keys()] else: return None
[docs]def growCollection(K, **kargs): """Grow the collection with n frontal rings. K should be a collection of elements. This should work on any objects that have a growSelection method. """ if K.obj_type == 'element': for k in K.keys(): o = pf.canvas.actors[k] if hasattr(o, 'growSelection'): K[k] = o.growSelection(K[k], **kargs)
[docs]def partitionCollection(K): """Partition the collection according to node adjacency. The actor numbers will be connected to a collection of property numbers, e.g. 0 [1 [4,12] 2 [6,20]], where 0 is the actor number, 1 and 2 are the property numbers and 4, 12, 6 and 20 are the element numbers. """ sel = getCollection(K) if len(sel) == 0: print("Nothing to partition!") return if K.obj_type == 'actor': actor_numbers = K.get(-1, []) K.clear() for i in actor_numbers: K.add(arange(sel[int(i)].nelems()), i) prop = 1 j = 0 for i in K.keys(): p = sel[j].partitionByConnection() + prop print("Actor %s partitioned in %s parts" % (i, p.max()-p.min()+1)) C = Collection() C.set(transpose(asarray([p, K[i]]))) K[i] = C prop += p.max()-p.min()+1 j += 1 K.setType('partition')
[docs]def getPartition(K, prop): """ Remove all partitions with property not in prop.""" for k in K.keys(): for p in K[k][0].keys(): if not p in prop: K[k][0].remove(K[k][0][p], p)
[docs]def exportObjects(obj, name, single=False): """Export a list of objects under the given name. If obj is a list, and single=True, each element of the list is exported as a single item. The items will be given the names name-0, name-1, etc. Else, the obj is exported as is under the name. """ if single and isinstance(obj, list): export(dict([("name-%s"%i, v) for i, v in enumerate(obj)])) else: export({name: obj})
[docs]def actorDialog(actorids): """Create an actor dialog for the specified actors (by index) """ from pyformex.gui.draw import _T, _G, _I, askItems print("actorDialog %s" % actorids) actors = [pf.canvas.actors[i] for i in actorids] items = [_T("actor_%s" % i, [ _I('name', str(, _I('type', str(a.getType()), readonly=True), _I('visible', bool(a.visible)), _I('alpha', float(a.alpha)), _I('objcolor', str(a.objcolor), itemtype='color'), ]) for i, a in zip(actorids, actors)] res = askItems(items) print(res)
# End