pycad/py_src/primitives.py

# $Id:$

"""
Geometrical Primitives

the concept is inspired by gmsh and very much focused on the fact that
the classes are used to wrk with gmsh.

@var __author__: name of author
@var __copyright__: copyrights
@var __license__: licence agreement
@var __url__: url entry point on documentation
@var __version__: version
@var __date__: date of the version
"""


__author__="Lutz Gross, l.gross@uq.edu.au"
__copyright__="""  Copyright (c) 2006 by ACcESS MNRF
                    http://www.access.edu.au
                Primary Business: Queensland, Australia"""
__license__="""Licensed under the Open Software License version 3.0
             http://www.opensource.org/licenses/osl-3.0.php"""
__url__="http://www.iservo.edu.au/esys/escript"
__version__="$Revision:$"
__date__="$Date:$"

import numarray
from transformations import _TYPE

global global_primitive_id_counter
global_primitive_id_counter=1

class Primitive(object):
    """
    template for elementary geometrical object
    """
    def __init__(self): 
       """
       """ 
       global global_primitive_id_counter
       self.__ID=global_primitive_id_counter
       global_primitive_id_counter+=1
    def getID(self):
       return self.__ID
    def __repr__(self):
       return "%s(%s)"%(self.__class__.__name__,self.getID())
    def __cmp__(self,other):
       return cmp(self.getID(),other.getID())
    def getPoints(self):
        """
        returns the C{set} of points used to construct the primitive
        """
        out=set()
        for i in self.getHistory(): 
           if isinstance(i,Point): out.add(i)
        return out

    def setLocalScale(self,factor=1.):
        """
        sets the local refinement factor
        """
        for p in self.getPoints(): p.setLocalScale(factor)

    def isPoint(self):
        """
        returns C{True} is the primitive is a L{Point}
        """
        return False
    def isCurve(self):
        """
        returns C{True} is the primitive is a L{Curve}
        """
        return False
    def isSurface(self):
        """
        returns C{True} is the primitive is a L{Surface}
        """
        return False
    def isCurveLoop(self):
        """
        returns C{True} is the primitive is a L{CurveLoop}
        """
        return False
    def isSurfaceLoop(self):
        """
        returns C{True} is the primitive is a L{SurfaceLoop}
        """
        return False
    def getHistory(self):
        """
        returns C{set} of primitive used to construct the primitive
        """
        return set()
        

    #==================================================
    def __neg__(self):
        return ReversedPrimitive(self)
    def __pos__(self):
        return self.copy()
    def __add__(self,other):
       out=self.copy()
       out+=other
       return out
    def __iadd__(self,other):
       self.shift()
    def shift(self,shift):
        for p in self.getPoints(): p+=shift
    def copy(self):
        return Primitive()
    def getGmshCommand(self):
        raise NotImplementedError("getGmshCommand is not implemented for this class %s."%self.__class__.__name__)
    def translate(self,shift):
        raise NotImplementedError("translate is not implemented for this class %s."%self.__class__.__name__)

class Point(Primitive):
    """
    a three dimensional point
    """
    def __init__(self,x=0.,y=0.,z=0.,local_scale=1.): 
       """
       creates a point with coorinates x,y,z with the local refinement factor local_scale
       """ 
       super(Point, self).__init__()
       self.setCoordinates(x,y,z)
       self.setLocalScale(local_scale)
    def setLocalScale(self,factor=1.):
       """
       sets the local refinement factor
       """
       if factor<=0.:
          raise ValueError("scaling factor must be positive.")
       self.__local_scale=factor
    def getLocalScale(self):
       """
       returns the local refinement factor
       """
       return self.__local_scale
    def getCoordinates(self):
       """
       returns the coodinates of the point as L{numarray.NumArray} object
       """
       return self._x
    def setCoordinates(self,x,y,z):
       """
       returns the coodinates of the point as L{numarray.NumArray} object
       """
       self._x=numarray.array([x,y,z],_TYPE)
    def getHistory(self):
       """
       returns C{set} of primitive used to construct the primitive
       """
       return set([self])
 
    def isColocated(self,point,tol=1.e-11):
       """
       returns True if L{Point} point is colocation (same coordinates) 
       that means if |self-point| <= tol * max(|self|,|point|)
       """
       if isinstance(point,Point):
          point=point.getCoordinates()
       c=self.getCoordinates()
       d=c-point
       return numarray.dot(d,d)<=tol**2*max(numarray.dot(c,c),numarray.dot(point,point))
    

    #=============================================================
    def copy(self):
       c=self.getCoordinates()
       return Point(c[0],c[1],c[2],local_scale=self.getLocalScale())
    def isPoint(self):
        return True
    def getGmshCommand(self):
        c=self.getCoordinates()
        return "Point(%s) = {%e , %e, %e , %e * scale};"%(self.getID(),c[0],c[1],c[2], self.getLocalScale())
    def shift(self,shift): 
       """
       shifts the point by a given shift
       """
       self._x+=numarray.array(shift,numarray.Float64)
    def translate(self,shift):
       """
       returns the point shifted by shift
       """
       out=self.copy()
       out+=other
       return out


class Curve(Primitive):
      """
      a curve
      """
      def __init__(self,*args):
          """
          defines a curve form a set of control points
          """
          super(Curve, self).__init__()
          l=len(args)
          for i in range(l):
              if not args[i].isPoint():
                 raise TypeError("%s-th argument is not a Point object."%i)
          self.__nodes=args
      def __len__(self):
          return len(self.__nodes)
      def isCurve(self):
        return True
      def getStart(self):
         """
         returns start point
         """
         return self.__nodes[0]

      def getEnd(self):
         """
         returns end point
         """
         return self.__nodes[-1]

      def getNodes(self):
         """
         returns a list of the nodes
         """
         return self.__nodes
      def getGmshCommand(self):
        out=""
        for i in self.getNodes():
            if len(out)>0: 
                out+=", %s"%i.getID()
            else:
                out="%s"%i.getID()
        return "Spline(%s) = {%s};"%(self.getID(),out)
      def getHistory(self):
          out=set([self])
          for i in self.getNodes(): out|=i.getHistory()
          return out
      def getPoints(self):
        out=set()
        for i in self.getNodes(): out|=i.getPoints()
        return out


class BezierCurve(Curve):
    """
    a Bezier curve
    """
    def __neg__(self):
         """
         returns the line segment with swapped start and end points
         """
         return BezierCurve(self.getNodes()[::-1])
    def __add__(self,other):
         return BezierCurve([p+other for p in self.getNodes()])
    def getGmshCommand(self):
        out=""
        for i in self.getNodes():
            if len(out)>0: 
                out+=", %s"%i.getID()
            else:
                out="%s"%i.getID()
        return "Bezier(%s) = {%s};"%(self.getID(),out)

class BSplineCurve(Curve):
    """
    a BSpline curve. Control points may be repeated.
    """
    def __neg__(self):
         """
         returns the line segment with swapped start and end points
         """
         return BSplineCurve(self.getNodes()[::-1])
    def __add__(self,other):
         return BSplineCurve([p+other for p in self.getNodes()])
    def getGmshCommand(self):
        out=""
        for i in self.getNodes():
            if len(out)>0: 
                out+=", %s"%i.getID()
            else:
                out="%s"%i.getID()
        return "BSpline(%s) = {%s};"%(self.getID(),out)

class Line(Curve):
    """
    a line is defined by two L{Point}s
    """
    def __init__(self,start,end):
        """
        defines a curve form a set of control points
        """
        super(Line, self).__init__(start,end)
    def __neg__(self):
       return ReversedPrimitive(self)
    def __add__(self,other):
       return Line(self.getEnd()+other,self.getStart()+other)
    def getGmshCommand(self):
        return "Line(%s) = {%s, %s};"%(self.getID(),self.getStart().getID(),self.getEnd().getID())

class Arc(Curve):
    """
    defines an arc
    """
    def __init__(self,center,start,end):
       """
       creates an arc by the start point, end point and center
       """
       if center.isPoint():
           raise TypeError("center needs to be a Point object.")
       super(Arc, self).__init__(start,end)
       self.__center=center

    def getCenter(self):
       """
       returns center
       """
       return self.__center
    def __add__(self,other):
       return Arc(self.getCenter()+other,self.getStart()+other,self.getEnd()+other)

    def getHistory(self):
          out=set([self])
          out|=self.getCenter().getHistory()
          for i in self.getNodes(): out|=i.getHistory()
          return out
    def getPoints(self):
          out=self.getCenter().getPoints()
          for i in self.getNodes(): out|=i.getPoints()
          return out
    def getGmshCommand(self):
        return "Circle(%s) = {%s, %s, %s};"%(self.getID(),self.getStart().getID(),self.getCenter().getID(),self.getEnd().getID())

class CurveLoop(Primitive):
    """
    An oriented loop of curves. 

    The loop must be closed and the L{Curves}s should be oriented consistently.
    """
    def __init__(self,*curves):
       """
       creates a polygon from a list of line curves. The curves must form a closed loop.
       """
       super(CurveLoop, self).__init__()
       self.__curves=[]
       self.addCurve(*curves)
    def addCurve(self,*curves):
       for i in range(len(curves)):
           if not curves[i].isCurve():
              raise TypeError("%s-th argument is not a Curve object."%i)
       self.__curves+=curves

    def isCurveLoop(self):
        return True
    def getCurves(self):
       return self.__curves
    def __add__(self,other):
       return CurveLoop(*tuple([c+other for c in self.getCurves()[::-1]]))
    def __len__(self):
       return len(self.__curves)
    def getHistory(self):
          out=set([self])
          for i in self.getCurves(): out|=i.getHistory()
          return out
    def getPoints(self):
          out=set()
          for i in self.getCurves(): out|=i.getPoints()
          return out
    def getGmshCommand(self):
        out=""
        for i in self.getCurves():
            if len(out)>0: 
                out+=", %s"%i.getID()
            else:
                out="%s"%i.getID()
        return "Line Loop(%s) = {%s};"%(self.getID(),out)

class Surface(Primitive):
    """
    a surface
    """
    def __init__(self,loop):
       """
       creates a  surface with boundary loop

       @param loop: L{CurveLoop} defining the boundary of the surface
       """
       super(Surface, self).__init__()
       if not loop.isCurveLoop():
           raise TypeError("argument loop needs to be a CurveLoop object.")
       self.__loop=loop
    def isSurface(self):
        return True
    def getBoundaryLoop(self):
       return self.__loop
    def __add__(self,other):
       return Surface(self.getBoundaryLoop()+other)
    def getHistory(self):
        out=set([self]) | self.getBoundaryLoop().getHistory()
        return out
    def getPoints(self):
        return self.getBoundaryLoop().getPoints()
    def getGmshCommand(self):
        return "Ruled Surface(%s) = {%s};"%(self.getID(),self.getBoundaryLoop().getID())

class PlaneSurface(Surface):
    """
    a plane surface with holes
    """
    def __init__(self,loop,holes=[]):
       """
       creates a  plane surface. 

       @param loop: L{CurveLoop} defining the boundary of the surface
       @param holes: list of L{CurveLoop} defining holes in the surface. 
       @note: A CurveLoop defining a hole should not have any lines in common with the exterior CurveLoop.  
              A CurveLoop defining a hole should not have any lines in common with another CurveLoop defining a hole in the same surface.
       """
       super(PlaneSurface, self).__init__(loop)
       for i in range(len(holes)):
            if not holes[i].inCurveLoop():
                 raise TypeError("%i th hole needs to be a CurveLoop object.")
       self.__holes=holes
    def getHoles(self):
       return self.__holes
    def __add__(self,other):
       return PlaneSurface(self.getBoundaryLoop()+other, holes=[h+other for h in self.getHoles()])
    def getHistory(self):
        out=set([self]) | self.getBoundaryLoop().getHistory()
        for i in self.getHoles(): out|=i.getHistory()
        return out
    def getPoints(self):
        out=self.getBoundaryLoop().getPoints()
        for i in self.getHoles(): out|=i.getPoints()
        return out
    def getGmshCommand(self):
        out=""
        for i in self.getHoles():
            if len(out)>0: 
                out+=", %s"%i.getID()
            else:
                out="%s"%i.getID()
        if len(out)>0:
          return "Plane Surface(%s) = {%s, %s};"%(self.getID(),self.getBoundaryLoop().getID(), out)
        else:
          return "Plane Surface(%s) = {%s};"%(self.getID(),self.getBoundaryLoop().getID())

class RuledSurface(Surface):
    """
   A ruled surface, i.e., a surface that can be interpolated using transfinite interpolation
    """
    def __init__(self,loop):
       """
       creates a ruled surface from a 

       @param loop: L{CurveLoop} defining the boundary of the surface. There is a restriction of composed of either three or four L{Curve} objects.
       """
       if not loop.isCurveLoop():
           raise TypeError("argument loop needs to be a CurveLoop object.")
       if len(loop)<3:
           raise TypeError("the loop must contain at least three Curves.")
       super(RuledSurface, self).__init__(loop)
    def __add__(self,other):
       return RuledSurface(self.getBoundaryLoop()+other)
    def getGmshCommand(self):
        return "Ruled Surface(%s) = {%s};"%(self.getID(),self.getBoundaryLoop().getID())

class SurfaceLoop(Primitive):
    """
    a surface loop. It defines the shell of a volume. 

    The loop must represent a closed shell, and the L{Surface}s should be oriented consistently.
    """
    def __init__(self,*surfaces):
       """
       creates a surface loop
       """
       super(SurfaceLoop, self).__init__()
       self.__surfaces=[]
       self.addSurface(*surfaces)
    def addSurface(self,*surfaces):
       for i in range(len(surfaces)):
           if not surfaces[i].isSurface():
              raise TypeError("%s-th argument is not a Surface object."%i)
       self.__surfaces+=surfaces

    def isSurfaceLoop(self):
        return True
    def getSurfaces(self):
       return self.__surfaces
    def __add__(self,other):
       return SurfaceLoop([c+other for c in self.getSurfaces])
    def __len__(self):
       return len(self.__surfaces)
    def getHistory(self):
          out=set([self])
          for i in self.getSurfaces(): out|=i.getHistory()
          return out
    def getPoints(self):
          out=set()
          for i in self.getSurfaces(): out|=i.getPoints()
          return out
    def getGmshCommand(self):
        out=""
        for i in self.getSurfaces():
            if len(out)>0: 
                out+=", %s"%i.getID()
            else:
                out="%s"%i.getID()
        return "Surface Loop(%s) = {%s};"%(self.getID(),out)

class Volume(Primitive):
    """
    a volume with holes.
    """
    def __init__(self,loop,holes=[]):
       """
       creates a volume

       @param loop: L{SurfaceLoop} defining the boundary of the surface
       @param holes: list of L{SurfaceLoop} defining holes in the surface. 
       @note: A SurfaceLoop defining a hole should not have any surfaces in common with the exterior SurfaceLoop.  
              A SurfaceLoop defining a hole should not have any surfaces in common with another SurfaceLoop defining a hole in the same volume.
       """
       super(Volume, self).__init__()
       if not loop.isSurfaceLoop():
           raise TypeError("argument loop needs to be a SurfaceLoop object.")
       for i in range(len(holes)):
            if not holes[i].isSurfaceLoop():
                 raise TypeError("%i th hole needs to be a SurfaceLoop object.")
       self.__loop=loop
       self.__holes=holes
    def getHoles(self):
       return self.__holes
    def getSurfaceLoop(self):
       return self.__loop
    def __add__(self,other):
       return Volume(self.getSurfaceLoop()+other, holes=[h+other for h in self.getHoles()])
    def getHistory(self):
        out=set([self]) | self.getSurfaceLoop().getHistory()
        for i in self.getHoles(): out|=i.getHistory()
        return out
    def getPoints(self):
        out=self.getSurfaceLoop().getPoints()
        for i in self.getHoles(): out|=i.Points()
        return out
    def getGmshCommand(self):
        out=""
        for i in self.getHoles():
            if len(out)>0: 
                out+=", %s"%i.getID()
            else:
                out="%s"%i.getID()
        if len(out)>0:
          return "Volume(%s) = {%s, %s};"%(self.getID(),self.getSurfaceLoop().getID(), out)
        else:
          return "Volume(%s) = {%s};"%(self.getID(),self.getSurfaceLoop().getID())

class ReversedPrimitive(object):
    def __init__(self,prim):
       self.__prim=prim
    def __getattr__(self,name):
       if name == "getID":
          return self.getReverseID
       else:
          return getattr(self.__prim,name)
    def getReverseID(self):
        return -self.__prim.getID()

class PropertySet(Primitive):
    """
    defines a group L{Primitive} objects. 
    """
    def __init__(self,tag=None,*items):
       super(PropertySet, self).__init__()
       self.__items=items
       self.__tag=tag
    def getHistory(self):
        out=set([self, self.getBoundaryLoop().getHistory()])
        for i in self.getHoles(): out|=i.getHistory()
        return out

class PrimitiveStack(object):
      def __init__(self,*items):
        self.__prims=set()
        for i in items:
            self.__prims|=i.getHistory()
        self.__prims=list(self.__prims)
        self.__prims.sort()

      def getGmshCommands(self):
        out=""
        for i in self.__prims:
           out+=i.getGmshCommand()+"\n"
        return out
1	gross	898	# $Id:$
2
3			"""
4	gross	899	Geometrical Primitives
5	gross	898
6			the concept is inspired by gmsh and very much focused on the fact that
7			the classes are used to wrk with gmsh.
8
9			@var __author__: name of author
10			@var __copyright__: copyrights
11			@var __license__: licence agreement
12			@var __url__: url entry point on documentation
13			@var __version__: version
14			@var __date__: date of the version
15			"""
16
17
18			__author__="Lutz Gross, l.gross@uq.edu.au"
19			__copyright__=""" Copyright (c) 2006 by ACcESS MNRF
20			http://www.access.edu.au
21			Primary Business: Queensland, Australia"""
22			__license__="""Licensed under the Open Software License version 3.0
23			http://www.opensource.org/licenses/osl-3.0.php"""
24			__url__="http://www.iservo.edu.au/esys/escript"
25			__version__="$Revision:$"
26			__date__="$Date:$"
27
28	gross	899	import numarray
29	gross	912	from transformations import _TYPE
30	gross	899
31			global global_primitive_id_counter
32	gross	912	global_primitive_id_counter=1
33	gross	899
34			class Primitive(object):
35	gross	898	"""
36			template for elementary geometrical object
37			"""
38			def __init__(self):
39			"""
40			"""
41	gross	899	global global_primitive_id_counter
42			self.__ID=global_primitive_id_counter
43			global_primitive_id_counter+=1
44			def getID(self):
45			return self.__ID
46			def __repr__(self):
47			return "%s(%s)"%(self.__class__.__name__,self.getID())
48			def __cmp__(self,other):
49			return cmp(self.getID(),other.getID())
50	gross	912	def getPoints(self):
51			"""
52			returns the C{set} of points used to construct the primitive
53			"""
54			out=set()
55			for i in self.getHistory():
56			if isinstance(i,Point): out.add(i)
57			return out
58
59			def setLocalScale(self,factor=1.):
60			"""
61			sets the local refinement factor
62			"""
63			for p in self.getPoints(): p.setLocalScale(factor)
64
65	gross	899	def isPoint(self):
66	gross	912	"""
67			returns C{True} is the primitive is a L{Point}
68			"""
69	gross	899	return False
70			def isCurve(self):
71	gross	912	"""
72			returns C{True} is the primitive is a L{Curve}
73			"""
74	gross	899	return False
75			def isSurface(self):
76	gross	912	"""
77			returns C{True} is the primitive is a L{Surface}
78			"""
79	gross	899	return False
80			def isCurveLoop(self):
81	gross	912	"""
82			returns C{True} is the primitive is a L{CurveLoop}
83			"""
84	gross	899	return False
85			def isSurfaceLoop(self):
86	gross	912	"""
87			returns C{True} is the primitive is a L{SurfaceLoop}
88			"""
89	gross	899	return False
90	gross	912	def getHistory(self):
91			"""
92			returns C{set} of primitive used to construct the primitive
93			"""
94			return set()
95
96
97			#==================================================
98	gross	899	def __neg__(self):
99			return ReversedPrimitive(self)
100	gross	902	def __pos__(self):
101			return self.copy()
102			def __add__(self,other):
103			out=self.copy()
104			out+=other
105			return out
106			def __iadd__(self,other):
107			self.shift()
108			def shift(self,shift):
109			for p in self.getPoints(): p+=shift
110			def copy(self):
111			return Primitive()
112			def getGmshCommand(self):
113			raise NotImplementedError("getGmshCommand is not implemented for this class %s."%self.__class__.__name__)
114			def translate(self,shift):
115			raise NotImplementedError("translate is not implemented for this class %s."%self.__class__.__name__)
116	gross	898
117	gross	899	class Point(Primitive):
118	gross	898	"""
119			a three dimensional point
120			"""
121			def __init__(self,x=0.,y=0.,z=0.,local_scale=1.):
122			"""
123	gross	912	creates a point with coorinates x,y,z with the local refinement factor local_scale
124	gross	898	"""
125			super(Point, self).__init__()
126	gross	912	self.setCoordinates(x,y,z)
127	gross	899	self.setLocalScale(local_scale)
128	gross	898	def setLocalScale(self,factor=1.):
129	gross	902	"""
130	gross	912	sets the local refinement factor
131	gross	902	"""
132	gross	912	if factor<=0.:
133			raise ValueError("scaling factor must be positive.")
134	gross	898	self.__local_scale=factor
135	gross	902	def getLocalScale(self):
136	gross	912	"""
137			returns the local refinement factor
138			"""
139	gross	902	return self.__local_scale
140	gross	912	def getCoordinates(self):
141			"""
142			returns the coodinates of the point as L{numarray.NumArray} object
143			"""
144			return self._x
145			def setCoordinates(self,x,y,z):
146			"""
147			returns the coodinates of the point as L{numarray.NumArray} object
148			"""
149			self._x=numarray.array([x,y,z],_TYPE)
150			def getHistory(self):
151			"""
152			returns C{set} of primitive used to construct the primitive
153			"""
154			return set([self])
155
156			def isColocated(self,point,tol=1.e-11):
157			"""
158			returns True if L{Point} point is colocation (same coordinates)
159			that means if \|self-point\| <= tol * max(\|self\|,\|point\|)
160			"""
161			if isinstance(point,Point):
162			point=point.getCoordinates()
163			c=self.getCoordinates()
164			d=c-point
165			return numarray.dot(d,d)<=tol*2max(numarray.dot(c,c),numarray.dot(point,point))
166
167
168			#=============================================================
169	gross	902	def copy(self):
170			c=self.getCoordinates()
171			return Point(c[0],c[1],c[2],local_scale=self.getLocalScale())
172	gross	899	def isPoint(self):
173			return True
174			def getGmshCommand(self):
175			c=self.getCoordinates()
176			return "Point(%s) = {%e , %e, %e , %e * scale};"%(self.getID(),c[0],c[1],c[2], self.getLocalScale())
177	gross	902	def shift(self,shift):
178			"""
179			shifts the point by a given shift
180			"""
181			self._x+=numarray.array(shift,numarray.Float64)
182			def translate(self,shift):
183			"""
184			returns the point shifted by shift
185			"""
186			out=self.copy()
187			out+=other
188			return out
189	gross	898
190	gross	902
191	gross	899	class Curve(Primitive):
192	gross	898	"""
193			a curve
194			"""
195			def __init__(self,*args):
196			"""
197			defines a curve form a set of control points
198			"""
199			super(Curve, self).__init__()
200			l=len(args)
201			for i in range(l):
202	gross	899	if not args[i].isPoint():
203			raise TypeError("%s-th argument is not a Point object."%i)
204			self.__nodes=args
205	gross	898	def __len__(self):
206			return len(self.__nodes)
207	gross	899	def isCurve(self):
208			return True
209	gross	898	def getStart(self):
210			"""
211			returns start point
212			"""
213			return self.__nodes[0]
214
215			def getEnd(self):
216			"""
217			returns end point
218			"""
219			return self.__nodes[-1]
220
221			def getNodes(self):
222			"""
223			returns a list of the nodes
224			"""
225			return self.__nodes
226	gross	899	def getGmshCommand(self):
227			out=""
228			for i in self.getNodes():
229			if len(out)>0:
230			out+=", %s"%i.getID()
231			else:
232			out="%s"%i.getID()
233			return "Spline(%s) = {%s};"%(self.getID(),out)
234	gross	902	def getHistory(self):
235			out=set([self])
236			for i in self.getNodes(): out\|=i.getHistory()
237			return out
238			def getPoints(self):
239			out=set()
240			for i in self.getNodes(): out\|=i.getPoints()
241			return out
242	gross	898
243	gross	902
244	gross	898	class BezierCurve(Curve):
245			"""
246			a Bezier curve
247			"""
248			def __neg__(self):
249	gross	899	"""
250			returns the line segment with swapped start and end points
251			"""
252			return BezierCurve(self.getNodes()[::-1])
253			def __add__(self,other):
254			return BezierCurve([p+other for p in self.getNodes()])
255			def getGmshCommand(self):
256			out=""
257			for i in self.getNodes():
258			if len(out)>0:
259			out+=", %s"%i.getID()
260			else:
261			out="%s"%i.getID()
262			return "Bezier(%s) = {%s};"%(self.getID(),out)
263	gross	898
264			class BSplineCurve(Curve):
265			"""
266			a BSpline curve. Control points may be repeated.
267			"""
268			def __neg__(self):
269	gross	899	"""
270			returns the line segment with swapped start and end points
271			"""
272			return BSplineCurve(self.getNodes()[::-1])
273			def __add__(self,other):
274			return BSplineCurve([p+other for p in self.getNodes()])
275			def getGmshCommand(self):
276			out=""
277			for i in self.getNodes():
278			if len(out)>0:
279			out+=", %s"%i.getID()
280			else:
281			out="%s"%i.getID()
282			return "BSpline(%s) = {%s};"%(self.getID(),out)
283	gross	898
284			class Line(Curve):
285			"""
286			a line is defined by two L{Point}s
287			"""
288	gross	899	def __init__(self,start,end):
289			"""
290			defines a curve form a set of control points
291			"""
292			super(Line, self).__init__(start,end)
293	gross	898	def __neg__(self):
294	gross	899	return ReversedPrimitive(self)
295			def __add__(self,other):
296			return Line(self.getEnd()+other,self.getStart()+other)
297			def getGmshCommand(self):
298			return "Line(%s) = {%s, %s};"%(self.getID(),self.getStart().getID(),self.getEnd().getID())
299	gross	898
300			class Arc(Curve):
301			"""
302			defines an arc
303			"""
304			def __init__(self,center,start,end):
305			"""
306			creates an arc by the start point, end point and center
307			"""
308	gross	899	if center.isPoint():
309	gross	898	raise TypeError("center needs to be a Point object.")
310			super(Arc, self).__init__(start,end)
311			self.__center=center
312
313			def getCenter(self):
314			"""
315			returns center
316			"""
317			return self.__center
318	gross	899	def __add__(self,other):
319			return Arc(self.getCenter()+other,self.getStart()+other,self.getEnd()+other)
320	gross	898
321	gross	899	def getHistory(self):
322			out=set([self])
323			out\|=self.getCenter().getHistory()
324			for i in self.getNodes(): out\|=i.getHistory()
325			return out
326	gross	902	def getPoints(self):
327			out=self.getCenter().getPoints()
328			for i in self.getNodes(): out\|=i.getPoints()
329			return out
330	gross	899	def getGmshCommand(self):
331			return "Circle(%s) = {%s, %s, %s};"%(self.getID(),self.getStart().getID(),self.getCenter().getID(),self.getEnd().getID())
332
333			class CurveLoop(Primitive):
334	gross	898	"""
335			An oriented loop of curves.
336
337			The loop must be closed and the L{Curves}s should be oriented consistently.
338			"""
339			def __init__(self,*curves):
340			"""
341			creates a polygon from a list of line curves. The curves must form a closed loop.
342			"""
343			super(CurveLoop, self).__init__()
344	gross	899	self.__curves=[]
345			self.addCurve(*curves)
346			def addCurve(self,*curves):
347			for i in range(len(curves)):
348			if not curves[i].isCurve():
349			raise TypeError("%s-th argument is not a Curve object."%i)
350			self.__curves+=curves
351	gross	898
352	gross	899	def isCurveLoop(self):
353			return True
354	gross	898	def getCurves(self):
355			return self.__curves
356	gross	899	def __add__(self,other):
357			return CurveLoop(*tuple([c+other for c in self.getCurves()[::-1]]))
358	gross	898	def __len__(self):
359			return len(self.__curves)
360	gross	899	def getHistory(self):
361			out=set([self])
362			for i in self.getCurves(): out\|=i.getHistory()
363			return out
364	gross	902	def getPoints(self):
365			out=set()
366			for i in self.getCurves(): out\|=i.getPoints()
367			return out
368	gross	899	def getGmshCommand(self):
369			out=""
370			for i in self.getCurves():
371			if len(out)>0:
372			out+=", %s"%i.getID()
373			else:
374			out="%s"%i.getID()
375			return "Line Loop(%s) = {%s};"%(self.getID(),out)
376	gross	898
377	gross	899	class Surface(Primitive):
378	gross	898	"""
379			a surface
380			"""
381			def __init__(self,loop):
382			"""
383			creates a surface with boundary loop
384
385			@param loop: L{CurveLoop} defining the boundary of the surface
386			"""
387			super(Surface, self).__init__()
388	gross	899	if not loop.isCurveLoop():
389	gross	898	raise TypeError("argument loop needs to be a CurveLoop object.")
390			self.__loop=loop
391	gross	899	def isSurface(self):
392			return True
393	gross	898	def getBoundaryLoop(self):
394			return self.__loop
395	gross	899	def __add__(self,other):
396			return Surface(self.getBoundaryLoop()+other)
397			def getHistory(self):
398			out=set([self]) \| self.getBoundaryLoop().getHistory()
399			return out
400	gross	902	def getPoints(self):
401			return self.getBoundaryLoop().getPoints()
402	gross	899	def getGmshCommand(self):
403			return "Ruled Surface(%s) = {%s};"%(self.getID(),self.getBoundaryLoop().getID())
404
405	gross	898	class PlaneSurface(Surface):
406			"""
407			a plane surface with holes
408			"""
409			def __init__(self,loop,holes=[]):
410			"""
411			creates a plane surface.
412
413			@param loop: L{CurveLoop} defining the boundary of the surface
414			@param holes: list of L{CurveLoop} defining holes in the surface.
415			@note: A CurveLoop defining a hole should not have any lines in common with the exterior CurveLoop.
416			A CurveLoop defining a hole should not have any lines in common with another CurveLoop defining a hole in the same surface.
417			"""
418			super(PlaneSurface, self).__init__(loop)
419			for i in range(len(holes)):
420	gross	899	if not holes[i].inCurveLoop():
421	gross	898	raise TypeError("%i th hole needs to be a CurveLoop object.")
422			self.__holes=holes
423			def getHoles(self):
424			return self.__holes
425	gross	899	def __add__(self,other):
426			return PlaneSurface(self.getBoundaryLoop()+other, holes=[h+other for h in self.getHoles()])
427			def getHistory(self):
428			out=set([self]) \| self.getBoundaryLoop().getHistory()
429			for i in self.getHoles(): out\|=i.getHistory()
430			return out
431	gross	902	def getPoints(self):
432			out=self.getBoundaryLoop().getPoints()
433			for i in self.getHoles(): out\|=i.getPoints()
434			return out
435	gross	899	def getGmshCommand(self):
436			out=""
437			for i in self.getHoles():
438			if len(out)>0:
439			out+=", %s"%i.getID()
440			else:
441			out="%s"%i.getID()
442			if len(out)>0:
443			return "Plane Surface(%s) = {%s, %s};"%(self.getID(),self.getBoundaryLoop().getID(), out)
444			else:
445			return "Plane Surface(%s) = {%s};"%(self.getID(),self.getBoundaryLoop().getID())
446	gross	898
447			class RuledSurface(Surface):
448			"""
449			A ruled surface, i.e., a surface that can be interpolated using transfinite interpolation
450			"""
451			def __init__(self,loop):
452			"""
453			creates a ruled surface from a
454
455			@param loop: L{CurveLoop} defining the boundary of the surface. There is a restriction of composed of either three or four L{Curve} objects.
456			"""
457	gross	899	if not loop.isCurveLoop():
458	gross	898	raise TypeError("argument loop needs to be a CurveLoop object.")
459			if len(loop)<3:
460			raise TypeError("the loop must contain at least three Curves.")
461			super(RuledSurface, self).__init__(loop)
462	gross	899	def __add__(self,other):
463			return RuledSurface(self.getBoundaryLoop()+other)
464			def getGmshCommand(self):
465			return "Ruled Surface(%s) = {%s};"%(self.getID(),self.getBoundaryLoop().getID())
466	gross	898
467	gross	899	class SurfaceLoop(Primitive):
468	gross	898	"""
469			a surface loop. It defines the shell of a volume.
470
471			The loop must represent a closed shell, and the L{Surface}s should be oriented consistently.
472			"""
473			def __init__(self,*surfaces):
474			"""
475			creates a surface loop
476			"""
477			super(SurfaceLoop, self).__init__()
478	gross	899	self.__surfaces=[]
479			self.addSurface(*surfaces)
480			def addSurface(self,*surfaces):
481			for i in range(len(surfaces)):
482			if not surfaces[i].isSurface():
483			raise TypeError("%s-th argument is not a Surface object."%i)
484			self.__surfaces+=surfaces
485	gross	898
486	gross	899	def isSurfaceLoop(self):
487			return True
488	gross	898	def getSurfaces(self):
489			return self.__surfaces
490	gross	899	def __add__(self,other):
491			return SurfaceLoop([c+other for c in self.getSurfaces])
492	gross	898	def __len__(self):
493			return len(self.__surfaces)
494	gross	899	def getHistory(self):
495			out=set([self])
496			for i in self.getSurfaces(): out\|=i.getHistory()
497			return out
498	gross	902	def getPoints(self):
499			out=set()
500			for i in self.getSurfaces(): out\|=i.getPoints()
501			return out
502	gross	899	def getGmshCommand(self):
503			out=""
504			for i in self.getSurfaces():
505			if len(out)>0:
506			out+=", %s"%i.getID()
507			else:
508			out="%s"%i.getID()
509			return "Surface Loop(%s) = {%s};"%(self.getID(),out)
510	gross	898
511	gross	899	class Volume(Primitive):
512	gross	898	"""
513			a volume with holes.
514			"""
515			def __init__(self,loop,holes=[]):
516			"""
517			creates a volume
518
519			@param loop: L{SurfaceLoop} defining the boundary of the surface
520			@param holes: list of L{SurfaceLoop} defining holes in the surface.
521			@note: A SurfaceLoop defining a hole should not have any surfaces in common with the exterior SurfaceLoop.
522			A SurfaceLoop defining a hole should not have any surfaces in common with another SurfaceLoop defining a hole in the same volume.
523			"""
524			super(Volume, self).__init__()
525	gross	899	if not loop.isSurfaceLoop():
526	gross	898	raise TypeError("argument loop needs to be a SurfaceLoop object.")
527			for i in range(len(holes)):
528	gross	899	if not holes[i].isSurfaceLoop():
529	gross	898	raise TypeError("%i th hole needs to be a SurfaceLoop object.")
530			self.__loop=loop
531			self.__holes=holes
532			def getHoles(self):
533			return self.__holes
534			def getSurfaceLoop(self):
535			return self.__loop
536	gross	899	def __add__(self,other):
537			return Volume(self.getSurfaceLoop()+other, holes=[h+other for h in self.getHoles()])
538			def getHistory(self):
539			out=set([self]) \| self.getSurfaceLoop().getHistory()
540			for i in self.getHoles(): out\|=i.getHistory()
541			return out
542	gross	902	def getPoints(self):
543			out=self.getSurfaceLoop().getPoints()
544			for i in self.getHoles(): out\|=i.Points()
545			return out
546	gross	899	def getGmshCommand(self):
547			out=""
548			for i in self.getHoles():
549			if len(out)>0:
550			out+=", %s"%i.getID()
551			else:
552			out="%s"%i.getID()
553			if len(out)>0:
554			return "Volume(%s) = {%s, %s};"%(self.getID(),self.getSurfaceLoop().getID(), out)
555			else:
556			return "Volume(%s) = {%s};"%(self.getID(),self.getSurfaceLoop().getID())
557	gross	898
558	gross	912	class ReversedPrimitive(object):
559			def __init__(self,prim):
560			self.__prim=prim
561			def __getattr__(self,name):
562			if name == "getID":
563			return self.getReverseID
564			else:
565			return getattr(self.__prim,name)
566			def getReverseID(self):
567			return -self.__prim.getID()
568
569	gross	899	class PropertySet(Primitive):
570	gross	898	"""
571	gross	899	defines a group L{Primitive} objects.
572	gross	898	"""
573			def __init__(self,tag=None,*items):
574			super(PropertySet, self).__init__()
575			self.__items=items
576			self.__tag=tag
577	gross	899	def getHistory(self):
578			out=set([self, self.getBoundaryLoop().getHistory()])
579			for i in self.getHoles(): out\|=i.getHistory()
580			return out
581
582			class PrimitiveStack(object):
583			def __init__(self,*items):
584			self.__prims=set()
585			for i in items:
586			self.__prims\|=i.getHistory()
587			self.__prims=list(self.__prims)
588			self.__prims.sort()
589
590			def getGmshCommands(self):
591			out=""
592			for i in self.__prims:
593			out+=i.getGmshCommand()+"\n"
594			return out