yapCAD 0.3.0__py2.py3-none-any.whl → 0.3.1__py2.py3-none-any.whl

yapcad/poly.py

@@ -1,4 +1,4 @@
-# Polyline and Polygon geometry generating classes for yapCAD
+## Derived Geometry clases for yapCAD
 from yapcad.geom import *
 from yapcad.geometry import *
 
@@ -26,229 +26,136 @@ from yapcad.geometry import *
 # CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 # SOFTWARE.
 
-## These geometry-generating classes are somewhat analogous to the
-## polygonal representations available by way of poly() point lists.
-## There are two important diferences that might lead you to use these
-## classes rather than the point-list based representations.
-
-## First, because instances of these classes can cache
-## meta-information about the geometry, it means that sampling and
-## intersection operations might be more efficient for class instances
-## than utilizing the functions avalable for the list-based
-## representations. 
-
-## Seond, and more importantly, these geometry-generating classes,
-## they can support a richer set of representations and operations.
-## For example, the Polygon() class for closed figures allows you to
-## specify points, lines, arcs, or circles as elements of the
-## geometry, and will intelligently interpolate between these to
-## generate the resulting geometry.  This means you can use circles to
-## represented rounded corners without having to worry about
-## converting them into just the right arc, since the tangent lines
-## and arc trimming are done automatically.
-
-
-class Polyline(IntersectGeometry):
-    """Generalized multi-element open figure class"""
-
-    def __init__(self,a=False):
-        self._elem=[]
-        self._length=0.0
-        self._lengths=[]
-        self._lines=[]
-        self._update=True
-        self._closed=False
-        self._center=point(0,0,0)
-        self._bbox=line(point(-epsilon,-epsilon),
-                        point(epsilon,epsilon))
-        if isinstance(a,Polyline):
-            self._elem = deepcopy(a._elem)
-            self._updateInternals()
-        elif isgeomlist(a):
-            for i in a:
-                if ispoint(i) or isarc(i) or isline(i): 
-                    self._elem.append(deepcopy(i))
-                elif ispoly(i):
-                    self._elem = self._elem + i
-                else:
-                    raise ValueError("bad argument to Polyline constructor")
-        elif a != False:
-            raise ValueError("bad argument passed to Polyline constructor")
+"""
+Derived Geometry Classes
+========================
 
-    def __repr__(self):
-        return 'Polyline({})'.format(vstr(self._elem))
+These subclasses of Geometry compute a figure based on the contents
+of their elements list, rather than simply providing a wrapper around
+the contents of their elements.  
 
-    ## add another drawing element
-    def addPoint(self,element):
-        if ispoint(element):
-            self._update=True  # flag that we need to recalculate stuff
-            self._elem.append(element)
-        else:
-            raise ValueError('attempt to add a non point to Polyline')
+The Polygon class is an intepolating closed figure class that will
+interpolate lines between each point or open figure element in its
+element list.  It will also treat circles as rounded convex conrners
+of the specified radius.  
 
-    ## set a point to a specified value
-    def setPoint(self,i,p):
-        if not ispoint(p):
-            raise ValueError('bad point passed to Polyline.setPoint(): '.format(p))
-        if i < len(self._elem):
-            self._elem[i]=point(p)
-        elif i == len(self._elem):
-            self._elem.append(p)
-        else:
-            raise ValueError('index out of range in PolylinesetPoint(): '.format(i))
-        self._update=True
-        
-    ## return a copy of the elem list
-    def getElem(self):
-        return deepcopy(self._elem)
-    
-    def _updateInternals(self):
-        if self._update:
-            self._updateCenter()
-            self._updateLines()
-            self._update=False
-
-
-    ## compute barycentric center of figure by equally weighting the
-    ## points.  If last and first points are the same, ignore the
-    ## last point.
-    def _updateCenter(self):
-        l = len(self._elem)
-        if l == 0:
-            return
-        elif l == 1:
-            self._center = center(self._elem[0]) # center is sole point
-            self._bbox = bbox(self._elem[0])
-        else:
-            
-            if dist(center(self._elem[0]),
-                    center(self._elem[-1])) < epsilon:
-                l -= 1
-
-            
-            p = center(self._elem[0])
-            for i in range(1,l):
-                p = add(center(self._elem[i]),p)
-
-            self._center = scale3(p,1/l)
-            self._bbox = bbox(self._elem)
-        return
-
-    ## return the center of the figure.  If necessary, recompute that
-    def getCenter(self):
-        if self._update:
-            self._updateInternals()
-        return self._center
-
-
-    def getLength(self):
-        if self._update:
-            self._updateInternals()
-        return self._length
-    
-    ## function to take the points in the elem[] list and build a
-    ## list of the individual lines, line lengths and total length to
-    ## facilitate sampling
-    
-    def _updateLines(self):
-        for i in range(1,len(self._elem)):
-            p0=  center(self._elem[i-1])
-            p1=  center(self._elem[i])
-            self._lines.append(line(p0,p1))
-            l = dist(p0,p1)
-            self._lengths.append(l)
-            self._length += l
-        if len(self._elem) > 2 and dist(center(self._elem[0]),
-                                        center(self._elem[-1])) < epsilon:
-            self._closed = True
-
-    def geom(self):
-        if self._update:
-            self._updateInternals()
-        return deepcopy(self._lines)
-
-    def sample(self,u):
-        if self._update:
-            self._updateInternals()
-        dist = u * self._length;
-        d = 0
-        if self._closed:
-            u = u%1.0
-        if u < 1.0:
-            for i in range(len(self._lines)):
-                l=self._lengths[i]
-                if dist <= d+l:
-                    uu = 1.0 - (d+l-dist)/l
-                    return sampleline(self._lines[i],uu)
-                else:
-                    d+=l
-        else:
-            uu = (dist-self._length+self._lengths[-1])/self._lengths[-1]
-            return sampleline(self._lines[-1],uu)
-        
+By treating circles as rounded corners, polygon instances can be
+"grown" to create new figures that are a fixed distance larger, which
+is very useful for offsetting drill holes from the edge of a boundary,
+etc.  """
 
-class Polygon(Polyline):
-    """Generalized multi-element closed figure geometry generation class"""
+class Polygon(Geometry):
+    """Multi-element closed figure derived geometry class"""
 
-    def __init__(self,a=False):
+    def __init__(self,a=None):
         super().__init__()
+        self._setDerived(True)
+        self._setClosed(True)
+        self.__lengths=0
+        self.__outline=[]
+        
         if isinstance(a,Polygon):
-            self._elem = deepcopy(a._elem)
-            self._updateInternals()
+            self._setElem(deepcopy(a.elem))
+            self._setUpdate(True)
         elif isgeomlist(a):
             for i in a:
                 if ispoint(i) or isarc(i):
-                    self._elem.append(i)
+                    self.elem.append(i)
                 elif isline(i):
                     pass
                 elif ispoly(i):
-                    self._elem = self._elem + i
+                    self._setElem(self.elem + i)
                 else:
                     raise ValueError("bad argument to Polygon constructor")
 
-        elif a != False:
+        elif a != None:
             raise ValueError("bad argument to Polygon constructor")
 
-        elm = self._elem
+        elm = self.elem
 
         l = len(elm)
         if l > 2:
             # if first and last element are identicial points or circles,
             # remove them
-            if (ispoint(elm[0]) and ispoint(elm[-1]) and \
-                dist(elm[0],elm[-1]) < epsilon) or \
-               (iscircle(elm[0]) and iscircle(elm[-1]) and \
-               abs(elm[0][1][0] - elm[-1][1][0]) < epsilon):
-                self._elem.pop()
+            if ((ispoint(elm[0]) and ispoint(elm[-1]) and 
+                 dist(elm[0],elm[-1]) < epsilon) or 
+                (iscircle(elm[0]) and iscircle(elm[-1]) and 
+                 abs(elm[0][1][0] - elm[-1][1][0]) < epsilon)):
+                self.elem.pop()
         
     def __repr__(self):
-        return 'Polygon({})'.format(vstr(self._elem))
+        return 'Polygon({})'.format(vstr(self.elem))
 
+    ## compute barycentric center of figure by equally weighting the
+    ## points.  If last and first points are the same, ignore the
+    ## last point.
+    def _calcCenter(self):
+        l = len(self.elem)
+        if l == 0:
+            return None
+        elif l == 1:
+            return center(self.elem[0]) # center is sole point
+        else:
+            
+            if dist(center(self.elem[0]),
+                    center(self.elem[-1])) < epsilon:
+                l -= 1
+
+            
+            p = center(self.elem[0])
+            for i in range(1,l):
+                p = add(center(self.elem[i]),p)
+
+            return scale3(p,1/l)
+
+    
     def _updateInternals(self):
-        if self._update:
-            self._updateCenter()
+        if self.update:
+            self._setUpdate(False)
             self._makeoutline()
-            self._update=False
+            self._setCenter(self._calcCenter())
+            self._setBbox(bbox(self.__outline))
+
+    def addPoint(self,element):
+        if ispoint(element):
+            self._setUpdate(True)  # flag that we need to recalculate stuff
+            self.elem.append(deepcopy(element))
+        else:
+            raise ValueError('attempt to add a non point to Polyline')
+
+    ## set a point to a specified value
+    def setPoint(self,i,p):
+        if not ispoint(p):
+            raise ValueError('bad point passed to Polyline.setPoint(): '.format(p))
+        elem = self.elem
+        if i < len(elem):
+            elem[i]=point(p)
+        elif i == len(elem):
+            elem.append(p)
+        else:
+            raise ValueError('index out of range in PolylinesetPoint(): '.format(i))
+        self._setElem(elem)
+        self._setUpdate(True)
 
     ## add another drawing element
     def addLine(self,element):
         if isline(element):
-            self._update=True  # flag that we need to recalculate stuff
-            self._elem.append(deepcopy(element))
+            self._setUpdate(True)  # flag that we need to recalculate stuff
+            self.elem.append(deepcopy(element))
         else:
             raise ValueError('attempt to add a non point, line or arc to poly')
     
     ## add another drawing element
     def addArc(self,element):
         if isarc(element):
-            self._update=True  # flag that we need to recalculate stuff
-            self._elem.append(deepcopy(element))
+            self._setUpdate(True)  # flag that we need to recalculate stuff
+            self.elem.append(deepcopy(element))
         else:
             raise ValueError('attempt to add a non point, line or arc to poly')
                 
     def remove(self,element):
-        self._update=True  # flag that we need to recalculate stuff
-        self._elem.remove(element)
+        self._setUpdate(True)
+        self.elem.remove(element)
                 
     ## function to take the elements in the elem[] list and
     ## construct the full outline.  For example, consider a list of
@@ -260,23 +167,24 @@ class Polygon(Polyline):
     ## non-circular arcs are joined to adjacent elements by lines
 
     def _makeoutline(self):
+        # import pdb; pdb.set_trace()
         def _calclength():
             l = 0
             ll = []
             length = 0
-            for o in self._outline:
+            for o in self.__outline:
                 if isarc(o):
                     length=arclength(o)
                 elif isline(o): # line
                     length=linelength(o)
                 else:
-                    #print("self._outline: ",vstr(self._outline))
+                    #print("self.__outline: ",vstr(self.__outline))
                     #print("o: ",vstr(o))
                     raise ValueError("bad element in outline list for _calclength()")
                 l += length
                 ll.append(length)
-            self._length = l
-            self._lengths=ll
+            self._setLength(l)
+            self.__lengths=ll
 
         def _handleCircle(e0,e1,e2):
             ## get the two tangent lines from circle e1 to the circle
@@ -315,33 +223,33 @@ class Polygon(Polyline):
                 else:
                     l = ll[1]
                         
-            self._outline.append(line(l))
+            self.__outline.append(line(l))
             
         def _fromPointAdd(e0,p1,e2):
             if ispoint(e2): #r1 is a point -- simplest case
                 #ll = dist(p1,e2)
-                self._outline.append(line(p1,e2))
+                self.__outline.append(line(p1,e2))
             elif isline(e2):
-                self._outline.append(line(p1,e2[0]))
-                self._outline.append(line(e2))
+                self.__outline.append(line(p1,e2[0]))
+                self.__outline.append(line(e2))
             elif isarc(e2) and not iscircle(e2):
                 p = samplearc(e2,1*epsilon)
-                self._outline.append(line(p1,p))
-                self._outline.append(arc(e2))
+                self.__outline.append(line(p1,p))
+                self.__outline.append(arc(e2))
             elif iscircle(e2): 
                 _handleCircle(e0,arc(p1,1*epsilon),e2)
-                self._outline.append(arc(e2))
+                self.__outline.append(arc(e2))
             else:
                 raise ValueError('bad object in element list')
             
-        self._outline=[]
-        self._length=0
-        self._lengths=[]
+        self.__outline=[]
+        self._setLength(0.0)
+        self.__lengths=[]
 
-        if len(self._elem) < 2:
+        if len(self.elem) < 2:
             ## if one element, the outline is the element
-            if len(self._elem) == 1:
-                self._outline=deepcopy(self._elem)
+            if len(self.elem) == 1:
+                self.__outline=deepcopy(self.elem)
                 _calclength()
             ## if there are fewer than one elem, there is nothing to do
             return
@@ -351,16 +259,16 @@ class Polygon(Polyline):
         ## total length and length list for use in sample() function.
 
         
-        for i in range(len(self._elem)):
+        for i in range(len(self.elem)):
             if i == 0:
-                e0 = self._elem[-1]
+                e0 = self.elem[-1]
             else:
-                e0 = self._elem[i-1]
-            e1 = self._elem[i]
-            if i == len(self._elem)-1: #last item
-                e2 = self._elem[0]
+                e0 = self.elem[i-1]
+            e1 = self.elem[i]
+            if i == len(self.elem)-1: #last item
+                e2 = self.elem[0]
             else:
-                e2 = self._elem[i+1]
+                e2 = self.elem[i+1]
             ## work through element types
             if ispoint(e1): #e1 is a point
                 _fromPointAdd(e0,e1,e2)
@@ -381,18 +289,18 @@ class Polygon(Polyline):
                 _handleCircle(e0,e1,c2)
                 
                 if not ispoint(e2):
-                    self._outline.append(deepcopy(e2))
+                    self.__outline.append(deepcopy(e2))
 
         ## OK, now go back through and replace full circles with arcs
         ## and catch any intersecting lines due to non-convex
         ## curvature
-        for i in range(1,len(self._outline)):
-            e0 = self._outline[i-1]
-            e1 = self._outline[i]
-            if i == len(self._outline)-1: #last item
-                e2 = self._outline[0]
+        for i in range(1,len(self.__outline)):
+            e0 = self.__outline[i-1]
+            e1 = self.__outline[i]
+            if i == len(self.__outline)-1: #last item
+                e2 = self.__outline[0]
             else:
-                e2 = self._outline[i+1]
+                e2 = self.__outline[i+1]
             if isline(e1) and isline(e2):
                 pi = lineLineIntersectXY(e1,e2,inside=True)
                 if pi == False:
@@ -403,8 +311,8 @@ class Polygon(Polyline):
                         print("odd parallel? adjacent line condition")
                         continue
                     else:
-                        self._outline[i] = line(e1[0],pi)
-                        self._outline[(i+1)%len(self._outline)] = line(pi,e2[1])
+                        self.__outline[i] = line(e1[0],pi)
+                        self.__outline[(i+1)%len(self.__outline)] = line(pi,e2[1])
             if iscircle(e1):
                 if not isline(e0) or not isline(e2):
                     raise ValueError('circle not bracketed by lines')
@@ -422,95 +330,36 @@ class Polygon(Polyline):
                 start = (atan2(p0[1],p0[0]) % pi2) * 360.0/pi2
                 end = (atan2(p1[1],p1[0]) % pi2) * 360.0/pi2
                 newarc = arc(e1[0],e1[1][0],start,end)
-                self._outline[i]=newarc
+                self.__outline[i]=newarc
 
-        self._outline = cullZeroLength(self._outline)
+        self.__outline = cullZeroLength(self.__outline)
                 
         _calclength()
-        self._bbox = geomlistbbox(self._outline)
-        
+
+    # sample function uses cached length and lengths[], otherwise
+    # behavior is identical to superclass
     def sample(self,u):
-        if self._update:
+        if self.update:
             self._updateInternals()
-        if len(self._outline) == 0:
+        if len(self.__outline) == 0:
             raise ValueError('no geometry to sample, empty poly')
-        dist = (u % 1.0) * self._length
+        dist = (u % 1.0) * self.length
         d = 0
-        for i in range(len(self._outline)):
-            l=self._lengths[i]
+        for i in range(len(self.__outline)):
+            l=self.__lengths[i]
             if dist <= d+l:
                 u = 1.0 - (d+l-dist)/l
-                e = self._outline[i]
+                e = self.__outline[i]
                 return sample(e,u)
             else:
                 d=d+l
-
-    def segment(self,u1,u2,reverse=False):
-        return segmentgeomlist(self.geom(),u1,u2,closed=True,reverse=reverse)
-
-    def mirror(self,plane,poly=False):
-        if poly:
-            p = Polygon()
-            p._elem = deepcopy(self._elem)
-            p._elem.reverse()
-            p._elem = mirror(p._elem,plane)
-            p._update=True
-            return p
-        
-        return mirror(self.geom(),plane)
-
-    def rotate(self,angle,cent=point(0,0,0),axis=point(0,0,1),poly=False):
-        if poly:
-            p = Polygon(self)
-            p._elem = rotate(self._elem,angle,cent,axis)
-            p._update = True
-            return p
-        
-        return rotate(self.geom(),angle,cent,axis)
-
-    def scale(self,sx,sy=False,sz=False,cent=point(0,0),poly=False):
-        if poly:
-            p = Polygon(self)
-            p._elem = scale(self._elem,sx,sy,sz,cent)
-            p._update = True
-            return p
-
-        return scale(self.geom(),sx,sy,sz,cent)
-
-    def translate(self,delta,poly=False):
-        if poly:
-            p = Polygon(self)
-            p._elem = translate(self._elem,delta)
-            p._update = True
-            return p
-
-        return translate(self.geom(),delta)
-    
+                
+    @property
     def geom(self):
-        if self._update:
+        if self.update:
             self._updateInternals()
-        return deepcopy(self._outline)
+        return deepcopy(self.__outline)
                 
-    def bbox(self):
-        if self._update:
-            self._updateInternals()
-        return line(self._bbox)
-
-    def isinside(self,p):
-        if self._update:
-            self._updateInternals()
-        bb = self._bbox
-        if not isinsidebbox(bb,p):
-            return False
-        p2 = add([1,1,0,1],bb[1])
-        if vclose(p2,p): ## did we randomly pick an outside point near the
-                         ## test point?
-            p2 = sub(bb[0],[1,1,0,1])
-        l = line(p,p2)
-        pp = intersectGeomListXY(l,self.geom())
-        if pp == False:
-            return False
-        return len(pp) % 2 == 1
 
     def grow(self,r):
         if close(r,0.0):
@@ -535,10 +384,12 @@ class Polygon(Polyline):
                 elif isgeomlist(e):
                     ne += _growgeom(e)
             return ne
-        self._elem = _growgeom(self._elem)
-        self._update=True
+        self._setElem(_growgeom(self.elem))
+        self._setUpdate(True)
 
+        
     def shrink(self,r):
+        raise NotImplementedError('shrink operation not yet implemented')
         return False
 
     
@@ -565,17 +416,20 @@ def cullZeroLength(geom):
 
 
 
-## make a poly containing a single circle
+## make a Polygon instance containing a circle as two half-arcs
 
-def makeCircle(center=point(0,0,0),radius=1.0):
-    poly = Polygon()
-    poly.addArc(arc(center,radius,0.0,180.0))
-    poly.addArc(arc(center,radius,180.0,359.99))
-    return poly
+# def Circle(center=point(0,0,0),radius=1.0):
+#     poly = Polygon()
+#     poly.addArc(arc(center,radius,0.0,180.0))
+#     poly.addArc(arc(center,radius,180.0,360.0))
+#     return poly
+
+def Circle(center=point(0,0,0),radius=1.0):
+    return Geometry(arc(center,radius,0,360))
 
 ## make a rectangle with the specified width and height
 
-def makeRect(width,height,center=point(0,0,0)):
+def Rect(width,height,center=point(0,0,0)):
     w=width/2.0
     h=height/2.0
     p0=add(point(-w,h),center)
@@ -592,7 +446,7 @@ def makeRect(width,height,center=point(0,0,0)):
 ## make rounded rectangle with specified width, height, and chamfer,
 ## centered at the origin by default
 
-def makeRoundRect(width,height,chamf,center=point(0,0,0)):
+def RoundRect(width,height,chamf,center=point(0,0,0)):
     cr=chamf/2.0
     wid=width-chamf
     hei=height-chamf