/[escript]/trunk/pycad/py_src/primitives.py
ViewVC logotype

Diff of /trunk/pycad/py_src/primitives.py

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 912 by gross, Wed Dec 6 03:29:49 2006 UTC revision 923 by gross, Tue Jan 9 22:50:43 2007 UTC
# Line 26  __version__="$Revision:$" Line 26  __version__="$Revision:$"
26  __date__="$Date:$"  __date__="$Date:$"
27    
28  import numarray  import numarray
29  from transformations import _TYPE  from transformations import _TYPE, Translation, Dilation, Transformation
30    
31  global global_primitive_id_counter  
32  global_primitive_id_counter=1  def resetGlobalPrimitiveIdCounter():
33       """
34       initializes the global primitive ID counter
35       """
36       global global_primitive_id_counter
37       global_primitive_id_counter=1
38    
39    def setToleranceForColocation(tol=1.e-11):
40       """
41       set the global tolerance for colocation checks to tol
42       """
43       global global_tolerance_for_colocation
44       global_tolerance_for_colocation=tol
45    
46    def getToleranceForColocation():
47       """
48       returns the global tolerance for colocation checks
49       """
50       return global_tolerance_for_colocation
51    
52    resetGlobalPrimitiveIdCounter()
53    setToleranceForColocation()
54    
55  class Primitive(object):  class Primitive(object):
56      """      """
# Line 37  class Primitive(object): Line 58  class Primitive(object):
58      """      """
59      def __init__(self):      def __init__(self):
60         """         """
61          
62         """         """
63         global global_primitive_id_counter         global global_primitive_id_counter
64         self.__ID=global_primitive_id_counter         self.__ID=global_primitive_id_counter
65         global_primitive_id_counter+=1         global_primitive_id_counter+=1
66    
67      def getID(self):      def getID(self):
68         return self.__ID         return self.__ID
69    
70      def __repr__(self):      def __repr__(self):
71         return "%s(%s)"%(self.__class__.__name__,self.getID())         return "%s(%s)"%(self.__class__.__name__,self.getID())
72    
73      def __cmp__(self,other):      def __cmp__(self,other):
74         return cmp(self.getID(),other.getID())         return cmp(self.getID(),other.getID())
75      def getPoints(self):  
76        def getConstructionPoints(self):
77          """          """
78          returns the C{set} of points used to construct the primitive          returns the points used to construct the primitive
79          """          """
80          out=set()          out=set()
81          for i in self.getHistory():          for i in self.getPrimitives():
82             if isinstance(i,Point): out.add(i)             if isinstance(i,Point): out.add(i)
83          return out          return list(out)
84    
85      def setLocalScale(self,factor=1.):      def getPrimitives(self):
86          """          """
87          sets the local refinement factor          returns primitives used to construct the primitive
88          """          """
89          for p in self.getPoints(): p.setLocalScale(factor)          return []
90    
91      def isPoint(self):      def copy(self):
92          """         """
93          returns C{True} is the primitive is a L{Point}         returns a deep copy of the object
94          """         """
95          return False         return Primitive()
96      def isCurve(self):  
97    
98        def modifyBy(self,transformation):
99           """
100           modifies the coordinates by applying a transformation
101           """
102           for p in self.getConstructionPoints(): p.modifyBy(transformation)
103    
104    
105        def __add__(self,other):
106          """          """
107          returns C{True} is the primitive is a L{Curve}          returns a new object shifted by other
108          """          """
109          return False          return self.apply(Translation(numarray.array(other,_TYPE)))
110      def isSurface(self):  
111        def __sub__(self,other):
112          """          """
113          returns C{True} is the primitive is a L{Surface}          returns a new object shifted by other
114          """          """
115          return False          return self.apply(Translation(-numarray.array(other,_TYPE)))
116      def isCurveLoop(self):  
117        def __iadd__(self,other):
118          """          """
119          returns C{True} is the primitive is a L{CurveLoop}          shifts the point by other
120          """          """
121          return False          self.modifyBy(Translation(numarray.array(other,_TYPE)))
122      def isSurfaceLoop(self):          return self
123    
124        def __isub__(self,other):
125          """          """
126          returns C{True} is the primitive is a L{SurfaceLoop}          shifts the point by -other
127          """          """
128          return False          self.modifyBy(Translation(-numarray.array(other,_TYPE)))
129      def getHistory(self):          return self
130    
131        def __imul__(self,other):
132          """          """
133          returns C{set} of primitive used to construct the primitive          modifies object by applying L{Transformation} other. If other is not a L{Transformation} it will try convert it.
134          """          """
135          return set()          if isinstance(other,int) or isinstance(other,float):
136                        trafo=Dilation(other)
137            elif isinstance(other,numarray.NumArray):
138                trafo=Translation(other)
139            elif isinstance(other,Transformation):
140                trafo=other
141            else:
142                raise TypeError, "cannot convert argument to Trnsformation class object."
143            self.modifyBy(trafo)
144            return self
145    
146        def __rmul__(self,other):
147            """
148            applies L{Transformation} other to object. If other is not a L{Transformation} it will try convert it.
149            """
150            if isinstance(other,int) or isinstance(other,float):
151                trafo=Dilation(other)
152            elif isinstance(other,numarray.NumArray):
153                trafo=Translation(other)
154            elif isinstance(other,Transformation):
155                trafo=other
156            else:
157                raise TypeError, "cannot convert argument to Transformation class object."
158            return self.apply(trafo)
159    
     #==================================================  
160      def __neg__(self):      def __neg__(self):
161          return ReversedPrimitive(self)          return ReversedPrimitive(self)
162      def __pos__(self):  
163          return self.copy()      def setLocalScale(self,factor=1.):
164      def __add__(self,other):         """
165         out=self.copy()         sets the local refinement factor
166         out+=other         """
167         return out         for p in self.getConstructionPoints(): p.setLocalScale(factor)
168      def __iadd__(self,other):  
169         self.shift()      def getGmshCommand(self, local_scaling_factor=1.):
170      def shift(self,shift):          """
171          for p in self.getPoints(): p+=shift          returns the Gmsh command(s) to create the primitive
172      def copy(self):          """
         return Primitive()  
     def getGmshCommand(self):  
173          raise NotImplementedError("getGmshCommand is not implemented for this class %s."%self.__class__.__name__)          raise NotImplementedError("getGmshCommand is not implemented for this class %s."%self.__class__.__name__)
174      def translate(self,shift):  
175          raise NotImplementedError("translate is not implemented for this class %s."%self.__class__.__name__)      def apply(self,transformation):
176            """
177            returns a new object by applying the transformation
178            """
179            raise NotImplementedError("apply is not implemented for this class %s."%self.__class__.__name__)
180    
181        def isColocated(self,primitive):
182           """
183           returns True is the two primitives are located at the smae position
184           """
185           raise NotImplementedError("isColocated is not implemented for this class %s."%self.__class__.__name__)
186    
187  class Point(Primitive):  class Point(Primitive):
188      """      """
# Line 123  class Point(Primitive): Line 193  class Point(Primitive):
193         creates a point with coorinates x,y,z with the local refinement factor local_scale         creates a point with coorinates x,y,z with the local refinement factor local_scale
194         """         """
195         super(Point, self).__init__()         super(Point, self).__init__()
196         self.setCoordinates(x,y,z)         self.setCoordinates(numarray.array([x,y,z],_TYPE))
197         self.setLocalScale(local_scale)         self.setLocalScale(local_scale)
198    
199      def setLocalScale(self,factor=1.):      def setLocalScale(self,factor=1.):
200         """         """
201         sets the local refinement factor         sets the local refinement factor
# Line 142  class Point(Primitive): Line 213  class Point(Primitive):
213         returns the coodinates of the point as L{numarray.NumArray} object         returns the coodinates of the point as L{numarray.NumArray} object
214         """         """
215         return self._x         return self._x
216      def setCoordinates(self,x,y,z):      def setCoordinates(self,x):
217         """         """
218         returns the coodinates of the point as L{numarray.NumArray} object         returns the coodinates of the point as L{numarray.NumArray} object
219         """         """
220         self._x=numarray.array([x,y,z],_TYPE)         if not isinstance(x, numarray.NumArray):
221      def getHistory(self):            self._x=numarray.array(x,_TYPE)
222           else:
223              self._x=x
224    
225        def getPrimitives(self):
226         """         """
227         returns C{set} of primitive used to construct the primitive         returns primitives used to construct the primitive
228         """         """
229         return set([self])         return [self]
230    
231      def isColocated(self,point,tol=1.e-11):      def isColocated(self,primitive):
232         """         """
233         returns True if L{Point} point is colocation (same coordinates)         returns True if L{Point} primitive is colocation (same coordinates)
234         that means if |self-point| <= tol * max(|self|,|point|)         that means if |self-primitive| <= tol * max(|self|,|primitive|)
235         """         """
236         if isinstance(point,Point):         if isinstance(primitive,Point):
237            point=point.getCoordinates()            primitive=primitive.getCoordinates()
238         c=self.getCoordinates()            c=self.getCoordinates()
239         d=c-point            d=c-primitive
240         return numarray.dot(d,d)<=tol**2*max(numarray.dot(c,c),numarray.dot(point,point))            return numarray.dot(d,d)<=getToleranceForColocation()**2*max(numarray.dot(c,c),numarray.dot(primitive,primitive))
241               else:
242              return False
243    
     #=============================================================  
244      def copy(self):      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):  
245         """         """
246         shifts the point by a given shift         returns a deep copy of the point
247         """         """
248         self._x+=numarray.array(shift,numarray.Float64)         c=self.getCoordinates()
249      def translate(self,shift):         return Point(c[0],c[1],c[2],local_scale=self.getLocalScale())
250         """  
251         returns the point shifted by shift      def modifyBy(self,transformation):
252         """          """
253         out=self.copy()          modifies the coordinates by applying a transformation
254         out+=other          """
255         return out          self.setCoordinates(transformation(self.getCoordinates()))
256    
257        def apply(self,transformation):
258            """
259            returns a new L{Point} by applying the transformation
260            """
261            new_p=self.copy()
262            new_p.modifyBy(transformation)
263            return new_p
264    
265        def getGmshCommand(self, local_scaling_factor=1.):
266            """
267            returns the Gmsh command(s) to create the primitive
268            """
269            c=self.getCoordinates()
270            return "Point(%s) = {%s , %s, %s , %s };"%(self.getID(),c[0],c[1],c[2], self.getLocalScale()*local_scaling_factor)
271    
272  class Curve(Primitive):  class Primitive1D(Primitive):
273        """        """
274        a curve        general one-dimensional primitive
275        """        """
276        def __init__(self,*args):        def __init__(self,*args):
277            """            """
278            defines a curve form a set of control points            create a one-dimensional primitive
279            """            """
280              super(Primitive1D, self).__init__()
281          
282    class Curve(Primitive1D):
283        """
284        a curve defined through a list of control points.
285        """
286        def __init__(self,*points):
287              """
288              defines a curve form control points
289              """
290              if len(points)<2:
291                 raise TypeError("Curve needs at least two points")
292            super(Curve, self).__init__()            super(Curve, self).__init__()
293            l=len(args)            i=0
294            for i in range(l):            for p in points:
295                if not args[i].isPoint():                i+=1
296                   raise TypeError("%s-th argument is not a Point object."%i)                if not isinstance(p,Point): raise TypeError("%s-th argument is not a Point object."%i)
297            self.__nodes=args            self.__points=points
298        def __len__(self):  
299            return len(self.__nodes)      def __len__(self):
300        def isCurve(self):            """
301          return True            returns the number of control points
302        def getStart(self):            """
303              return len(self.__points)
304    
305        def getStartPoint(self):
306           """           """
307           returns start point           returns start point
308           """           """
309           return self.__nodes[0]           return self.__points[0]
310    
311        def getEnd(self):      def getEndPoint(self):
312           """           """
313           returns end point           returns end point
314           """           """
315           return self.__nodes[-1]           return self.__points[-1]
316    
317        def getNodes(self):      def getControlPoints(self):
318           """           """
319           returns a list of the nodes           returns a list of the points
320           """           """
321           return self.__nodes           return self.__points
322        def getGmshCommand(self):  
323        def getPrimitives(self):
324           """
325           returns primitives used to construct the Curve
326           """
327           out=set()
328           for p in self.getControlPoints(): out|=set(p.getPrimitives())
329           out.add(self)
330           return list(out)
331    
332        def copy(self):
333           """
334           returns a deep copy
335           """
336           new_p=[]
337           for p in self.getControlPoints(): new_p.append(p.copy())
338           return self.__class__(*tuple(new_p))
339    
340    
341        def apply(self,transformation):
342            """
343            applies transformation
344            """
345            new_p=[]
346            for p in self.getControlPoints(): new_p.append(p.apply(transformation))
347            return self.__class__(*tuple(new_p))
348    
349        def isColocated(self,primitive):
350           """
351           returns True curves are on the same position
352           """
353           if isinstance(primitive,self.__class__):
354              if len(primitive) == len(self):
355                 cp0=self.getControlPoints()
356                 cp1=primitive.getControlPoints()
357                 match=True
358                 for i in range(len(cp0)):
359                    if not cp0[i].isColocated(cp1[i]):
360                       match=False
361                       break
362                 if not match:
363                    for i in range(len(cp0)):
364                       if not cp0[i].isColocated(cp1[len(cp0)-1-i]):
365                          return False
366                 return True
367              else:
368                 return False
369           else:
370              return False
371    
372    class Spline(Curve):
373        """
374        a spline curve defined through a list of control points.
375        """
376        def getGmshCommand(self):
377            """
378            returns the Gmsh command(s) to create the Curve
379            """
380          out=""          out=""
381          for i in self.getNodes():          for i in self.getControlPoints():
382              if len(out)>0:              if len(out)>0:
383                  out+=", %s"%i.getID()                  out+=", %s"%i.getID()
384              else:              else:
385                  out="%s"%i.getID()                  out="%s"%i.getID()
386          return "Spline(%s) = {%s};"%(self.getID(),out)          return "Spline(%s) = {%s};"%(self.getID(),out)
387        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  
   
388    
389  class BezierCurve(Curve):  class BezierCurve(Curve):
390      """      """
391      a Bezier curve      a Bezier curve
392      """      """
     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()])  
393      def getGmshCommand(self):      def getGmshCommand(self):
394            """
395            returns the Gmsh command(s) to create the Curve
396            """
397          out=""          out=""
398          for i in self.getNodes():          for i in self.getControlPoints():
399              if len(out)>0:              if len(out)>0:
400                  out+=", %s"%i.getID()                  out+=", %s"%i.getID()
401              else:              else:
402                  out="%s"%i.getID()                  out="%s"%i.getID()
403          return "Bezier(%s) = {%s};"%(self.getID(),out)          return "Bezier(%s) = {%s};"%(self.getID(),out)
404    
405  class BSplineCurve(Curve):  class BSpline(Curve):
406      """      """
407      a BSpline curve. Control points may be repeated.      a BSpline curve. Control points may be repeated.
408      """      """
     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()])  
409      def getGmshCommand(self):      def getGmshCommand(self):
410            """
411            returns the Gmsh command(s) to create the Curve
412            """
413          out=""          out=""
414          for i in self.getNodes():          for i in self.getControlPoints():
415              if len(out)>0:              if len(out)>0:
416                  out+=", %s"%i.getID()                  out+=", %s"%i.getID()
417              else:              else:
# Line 285  class Line(Curve): Line 422  class Line(Curve):
422      """      """
423      a line is defined by two L{Point}s      a line is defined by two L{Point}s
424      """      """
425      def __init__(self,start,end):      def __init__(self,*points):
426          """          """
427          defines a curve form a set of control points          defines a line with start and end point
428          """          """
429          super(Line, self).__init__(start,end)          if len(points)!=2:
430      def __neg__(self):             raise TypeError("Line needs two points")
431         return ReversedPrimitive(self)          super(Line, self).__init__(*points)
     def __add__(self,other):  
        return Line(self.getEnd()+other,self.getStart()+other)  
432      def getGmshCommand(self):      def getGmshCommand(self):
433          return "Line(%s) = {%s, %s};"%(self.getID(),self.getStart().getID(),self.getEnd().getID())          """
434            returns the Gmsh command(s) to create the Curve
435            """
436            return "Line(%s) = {%s, %s};"%(self.getID(),self.getStartPoint().getID(),self.getEndPoint().getID())
437    
438    
439  class Arc(Curve):  class Arc(Primitive1D):
440      """      """
441      defines an arc      defines an arc which is strictly, smaller than Pi
442      """      """
443      def __init__(self,center,start,end):      def __init__(self,center,start,end):
444         """         """
445         creates an arc by the start point, end point and center         creates an arc by the start point, end point and center
446         """         """
447         if center.isPoint():         if not isinstance(center,Point): raise TypeError("center needs to be a Point object.")
448             raise TypeError("center needs to be a Point object.")         if not isinstance(end,Point): raise TypeError("end needs to be a Point object.")
449         super(Arc, self).__init__(start,end)         if not isinstance(start,Point): raise TypeError("start needs to be a Point object.")
450           # TODO: check length of circle.
451           super(Arc, self).__init__()
452         self.__center=center         self.__center=center
453           self.__start=start
454           self.__end=end
455    
456        def getStartPoint(self):
457           """
458           returns start point
459           """
460           return self.__start
461    
462      def getCenter(self):      def getEndPoint(self):
463           """
464           returns end point
465           """
466           return self.__end
467    
468        def getCenterPoint(self):
469         """         """
470         returns center         returns center
471         """         """
472         return self.__center         return self.__center
     def __add__(self,other):  
        return Arc(self.getCenter()+other,self.getStart()+other,self.getEnd()+other)  
473    
474      def getHistory(self):      def getPrimitives(self):
475            out=set([self])         """
476            out|=self.getCenter().getHistory()         returns the primitives used to construct the Curve
477            for i in self.getNodes(): out|=i.getHistory()         """
478            return out         out=set()
479      def getPoints(self):         out|=set(self.getStartPoint().getPrimitives())
480            out=self.getCenter().getPoints()         out|=set(self.getEndPoint().getPrimitives())
481            for i in self.getNodes(): out|=i.getPoints()         out|=set(self.getCenterPoint().getPrimitives())
482            return out         out.add(self)
483           return list(out)
484    
485      def getGmshCommand(self):      def getGmshCommand(self):
486          return "Circle(%s) = {%s, %s, %s};"%(self.getID(),self.getStart().getID(),self.getCenter().getID(),self.getEnd().getID())         """
487           returns the Gmsh command(s) to create the primitive
488           """
489           return "Circle(%s) = {%s, %s, %s};"%(self.getID(),self.getStartPoint().getID(),self.getCenterPoint().getID(),self.getEndPoint().getID())
490    
491        def copy(self):
492           """
493           returns a deep copy
494           """
495           return Arc(self.getCenterPoint().copy(),self.getStartPoint().copy(),self.getEndPoint().copy())
496    
497        def apply(self,transformation):
498            """
499            applies transformation
500            """
501            return Arc(self.getCenterPoint().apply(transformation),self.getStartPoint().apply(transformation),self.getEndPoint().apply(transformation))
502    
503        def isColocated(self,primitive):
504           """
505           returns True curves are on the same position
506           """
507           if isinstance(primitive,Arc):
508                return (self.getCenterPoint().isColocated(primitive.getCenterPoint())) and ( \
509                       (self.getEndPoint().isColocated(primitive.getEndPoint()) and self.getStartPoint().isColocated(primitive.getStartPoint()) ) \
510                    or (self.getEndPoint().isColocated(primitive.getStartPoint()) and self.getStartPoint().isColocated(primitive.getEndPoint()) ) )
511           else:
512              return False
513    
514  class CurveLoop(Primitive):  class Primitive2D(Primitive):
515          """
516          general two-dimensional primitive
517          """
518          def __init__(self,*args):
519              """
520              create a two-dimensional primitive
521              """
522              super(Primitive2D, self).__init__()
523    
524    class CurveLoop(Primitive2D):
525      """      """
526      An oriented loop of curves.      An oriented loop of curves.
527    
# Line 341  class CurveLoop(Primitive): Line 532  class CurveLoop(Primitive):
532         creates a polygon from a list of line curves. The curves must form a closed loop.         creates a polygon from a list of line curves. The curves must form a closed loop.
533         """         """
534         super(CurveLoop, self).__init__()         super(CurveLoop, self).__init__()
535         self.__curves=[]         if len(curves)<2:
536         self.addCurve(*curves)              raise TypeError("at least two curves have to be given.")
     def addCurve(self,*curves):  
537         for i in range(len(curves)):         for i in range(len(curves)):
538             if not curves[i].isCurve():             if not isinstance(curves[i],Primitive1D):
539                raise TypeError("%s-th argument is not a Curve object."%i)                raise TypeError("%s-th argument is not a Primitive1D object."%i)
540         self.__curves+=curves         # for the curves a loop:
541           used=[ False for i in curves]
542           self.__curves=[curves[0]]
543           used[0]=True
544           while not min(used):
545              found=False
546              for i in xrange(len(curves)):
547                 if not used[i]:
548                    if self.__curves[-1].getEndPoint() == curves[i].getStartPoint():
549                       self.__curves.append(curves[i])
550                       used[i]=True
551                       found=True
552                       break
553              if not found:
554                 raise ValueError("loop is not closed.")
555           if not self.__curves[0].getStartPoint() == self.__curves[-1].getEndPoint():
556              raise ValueError("loop is not closed.")
557    
     def isCurveLoop(self):  
         return True  
558      def getCurves(self):      def getCurves(self):
559           """
560           returns the curves defining the CurveLoop
561           """
562         return self.__curves         return self.__curves
     def __add__(self,other):  
        return CurveLoop(*tuple([c+other for c in self.getCurves()[::-1]]))  
563      def __len__(self):      def __len__(self):
564           """
565           return the number of curves in the CurveLoop
566           """
567         return len(self.__curves)         return len(self.__curves)
568      def getHistory(self):  
569            out=set([self])      def getPrimitives(self):
570            for i in self.getCurves(): out|=i.getHistory()         """
571            return out         returns primitives used to construct the CurveLoop
572      def getPoints(self):         """
573            out=set()         out=set()
574            for i in self.getCurves(): out|=i.getPoints()         for c in self.getCurves(): out|=set(c.getPrimitives())
575            return out         out.add(self)
576           return list(out)
577    
578        def copy(self):
579           """
580           returns a deep copy
581           """
582           new_c=[]
583           for c in self.getCurves(): new_c.append(c.copy())
584           return CurveLoop(*tuple(new_c))
585    
586    
587        def apply(self,transformation):
588            """
589            applies transformation
590            """
591            new_c=[]
592            for c in self.getCurves(): new_c.append(c.apply(transformation))
593            return CurveLoop(*tuple(new_c))
594    
595        def isColocated(self,primitive):
596           """
597           returns True if each curve is collocted with a curve in primitive
598           """
599           if isinstance(primitive,CurveLoop):
600              if len(primitive) == len(self):
601                 cp0=self.getCurves()
602                 cp1=primitive.getCurves()
603                 for c0 in cp0:
604                     collocated = False
605                     for c1 in cp1: collocated = collocated or c0.isColocated(c1)
606                     if not collocated: return False
607                 return True
608              else:
609                 return False
610           else:
611              return False
612    
613      def getGmshCommand(self):      def getGmshCommand(self):
614          out=""          out=""
615          for i in self.getCurves():          for i in self.getCurves():
# Line 374  class CurveLoop(Primitive): Line 619  class CurveLoop(Primitive):
619                  out="%s"%i.getID()                  out="%s"%i.getID()
620          return "Line Loop(%s) = {%s};"%(self.getID(),out)          return "Line Loop(%s) = {%s};"%(self.getID(),out)
621    
622    #=================================================================================================================================
623  class Surface(Primitive):  class Surface(Primitive):
624      """      """
625      a surface      a surface
# Line 394  class Surface(Primitive): Line 640  class Surface(Primitive):
640         return self.__loop         return self.__loop
641      def __add__(self,other):      def __add__(self,other):
642         return Surface(self.getBoundaryLoop()+other)         return Surface(self.getBoundaryLoop()+other)
643      def getHistory(self):      def getPrimitives(self):
644          out=set([self]) | self.getBoundaryLoop().getHistory()          out=set([self]) | self.getBoundaryLoop().getPrimitives()
645          return out          return out
646      def getPoints(self):      def getConstructionPoints(self):
647          return self.getBoundaryLoop().getPoints()          return self.getBoundaryLoop().getConstructionPoints()
648      def getGmshCommand(self):      def getGmshCommand(self):
649          return "Ruled Surface(%s) = {%s};"%(self.getID(),self.getBoundaryLoop().getID())          return "Ruled Surface(%s) = {%s};"%(self.getID(),self.getBoundaryLoop().getID())
650    
# Line 424  class PlaneSurface(Surface): Line 670  class PlaneSurface(Surface):
670         return self.__holes         return self.__holes
671      def __add__(self,other):      def __add__(self,other):
672         return PlaneSurface(self.getBoundaryLoop()+other, holes=[h+other for h in self.getHoles()])         return PlaneSurface(self.getBoundaryLoop()+other, holes=[h+other for h in self.getHoles()])
673      def getHistory(self):      def getPrimitives(self):
674          out=set([self]) | self.getBoundaryLoop().getHistory()          out=set([self]) | self.getBoundaryLoop().getPrimitives()
675          for i in self.getHoles(): out|=i.getHistory()          for i in self.getHoles(): out|=i.getPrimitives()
676          return out          return out
677      def getPoints(self):      def getConstructionPoints(self):
678          out=self.getBoundaryLoop().getPoints()          out=self.getBoundaryLoop().getConstructionPoints()
679          for i in self.getHoles(): out|=i.getPoints()          for i in self.getHoles(): out|=i.getConstructionPoints()
680          return out          return out
681      def getGmshCommand(self):      def getGmshCommand(self):
682          out=""          out=""
# Line 491  class SurfaceLoop(Primitive): Line 737  class SurfaceLoop(Primitive):
737         return SurfaceLoop([c+other for c in self.getSurfaces])         return SurfaceLoop([c+other for c in self.getSurfaces])
738      def __len__(self):      def __len__(self):
739         return len(self.__surfaces)         return len(self.__surfaces)
740      def getHistory(self):      def getPrimitives(self):
741            out=set([self])            out=set([self])
742            for i in self.getSurfaces(): out|=i.getHistory()            for i in self.getSurfaces(): out|=i.getPrimitives()
743            return out            return out
744      def getPoints(self):      def getConstructionPoints(self):
745            out=set()            out=set()
746            for i in self.getSurfaces(): out|=i.getPoints()            for i in self.getSurfaces(): out|=i.getConstructionPoints()
747            return out            return out
748      def getGmshCommand(self):      def getGmshCommand(self):
749          out=""          out=""
# Line 535  class Volume(Primitive): Line 781  class Volume(Primitive):
781         return self.__loop         return self.__loop
782      def __add__(self,other):      def __add__(self,other):
783         return Volume(self.getSurfaceLoop()+other, holes=[h+other for h in self.getHoles()])         return Volume(self.getSurfaceLoop()+other, holes=[h+other for h in self.getHoles()])
784      def getHistory(self):      def getPrimitives(self):
785          out=set([self]) | self.getSurfaceLoop().getHistory()          out=set([self]) | self.getSurfaceLoop().getPrimitives()
786          for i in self.getHoles(): out|=i.getHistory()          for i in self.getHoles(): out|=i.getPrimitives()
787          return out          return out
788      def getPoints(self):      def getConstructionPoints(self):
789          out=self.getSurfaceLoop().getPoints()          out=self.getSurfaceLoop().getConstructionPoints()
790          for i in self.getHoles(): out|=i.Points()          for i in self.getHoles(): out|=i.Points()
791          return out          return out
792      def getGmshCommand(self):      def getGmshCommand(self):
# Line 574  class PropertySet(Primitive): Line 820  class PropertySet(Primitive):
820         super(PropertySet, self).__init__()         super(PropertySet, self).__init__()
821         self.__items=items         self.__items=items
822         self.__tag=tag         self.__tag=tag
823      def getHistory(self):      def getPrimitives(self):
824          out=set([self, self.getBoundaryLoop().getHistory()])          out=set([self, self.getBoundaryLoop().getPrimitives()])
825          for i in self.getHoles(): out|=i.getHistory()          for i in self.getHoles(): out|=i.getPrimitives()
826          return out          return out
827    
828  class PrimitiveStack(object):  class PrimitiveStack(object):
829        def __init__(self,*items):        def __init__(self,*items):
830          self.__prims=set()          self.__prims=set()
831          for i in items:          for i in items:
832              self.__prims|=i.getHistory()              self.__prims|=i.getPrimitives()
833          self.__prims=list(self.__prims)          self.__prims=list(self.__prims)
834          self.__prims.sort()          self.__prims.sort()
835    

Legend:
Removed from v.912  
changed lines
  Added in v.923

  ViewVC Help
Powered by ViewVC 1.1.26