# # Copyright (c) 2002, 2003, 2004, 2005 Art Haas # # This file is part of PythonCAD. # # PythonCAD is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. # # PythonCAD is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with PythonCAD; if not, write to the Free Software # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA # # classes for points # from __future__ import generators import math from PythonCAD.Generic import tolerance from PythonCAD.Generic import util from PythonCAD.Generic import baseobject from PythonCAD.Generic import quadtree from PythonCAD.Generic import entity class Point(baseobject.Subpart): """A 2-D point Class. A Point has the following attributes: x: x-coordinate y: y-coordinate A Point object has the following methods: {get/set}x(): Get/Set the x-coordinate of the Point. {get/set}y(): Get/Set the y-coordinate of the Point. {get/set}Coords(): Get/Set both the x and y coordinates of the Point. move(): Move a Point. clone(): Return an identical copy of a Point. inRegion(): Returns True if the point is in some area. """ __messages = { 'moved' : True, } # member functions def __init__(self, x, y=None, **kw): """Initialize a Point. There are two ways to initialize a Point: Point(xc,yc) - Two arguments, with both arguments being floats Point((xc,yc)) - A single tuple containing two float objects """ super(Point, self).__init__(**kw) if isinstance(x, tuple): if y is not None: raise SyntaxError, "Invalid call to Point()" _x, _y = util.tuple_to_two_floats(x) elif y is not None: _x = util.get_float(x) _y = util.get_float(y) else: raise SyntaxError, "Invalid call to Point()." self.__x = _x self.__y = _y def __str__(self): return "(%g,%g)" % (self.__x, self.__y) def __sub__(self, p): """Return the separation between two points. This function permits the use of '-' to be an easy to read way to find the distance between two Point objects. """ if not isinstance(p, Point): raise TypeError, "Invalid type for Point subtraction: " + `type(p)` _px, _py = p.getCoords() return math.hypot((self.__x - _px), (self.__y - _py)) def __eq__(self, obj): """Compare a Point to either another Point or a tuple for equality. """ if not isinstance(obj, (Point,tuple)): return False if isinstance(obj, Point): if obj is self: return True _x, _y = obj.getCoords() else: _x, _y = util.tuple_to_two_floats(obj) if abs(self.__x - _x) < 1e-10 and abs(self.__y - _y) < 1e-10: return True return False def __ne__(self, obj): """Compare a Point to either another Point or a tuple for inequality. """ if not isinstance(obj, (Point,tuple)): return True if isinstance(obj, Point): if obj is self: return False _x, _y = obj.getCoords() else: _x, _y = util.tuple_to_two_floats(obj) if abs(self.__x - _x) < 1e-10 and abs(self.__y - _y) < 1e-10: return False return True def finish(self): self.__x = self.__y = None super(Point, self).finish() def getValues(self): """Return values comprising the Point. getValues() This method extends the Subpart::getValues() method. """ _data = super(Point, self).getValues() _data.setValue('type', 'point') _data.setValue('x', self.__x) _data.setValue('y', self.__y) return _data def getx(self): """Return the x-coordinate of a Point. getx() """ return self.__x def setx(self, val): """Set the x-coordinate of a Point setx(val) The argument 'val' must be a float. """ if self.isLocked(): raise RuntimeError, "Coordinate change not allowed - object locked." _v = util.get_float(val) _x = self.__x if abs(_x - _v) > 1e-10: self.startChange('moved') self.__x = _v self.endChange('moved') self.sendMessage('moved', _x, self.__y) self.modified() x = property(getx, setx, None, "x-coordinate value") def gety(self): """Return the y-coordinate of a Point. gety() """ return self.__y def sety(self, val): """Set the y-coordinate of a Point sety(val) The argument 'val' must be a float. """ if self.isLocked(): raise RuntimeError, "Coordinate change not allowed - object locked." _v = util.get_float(val) _y = self.__y if abs(_y - _v) > 1e-10: self.startChange('moved') self.__y = _v self.endChange('moved') self.sendMessage('moved', self.__x, _y) self.modified() y = property(gety, sety, None, "y-coordinate value") def getCoords(self): """Return the x and y Point coordinates in a tuple. getCoords() """ return self.__x, self.__y def setCoords(self, x, y): """Set both the coordinates of a Point. setCoords(x, y) Arguments 'x' and 'y' should be float values. """ _x = util.get_float(x) _y = util.get_float(y) _sx = self.__x _sy = self.__y if abs(_sx - _x) > 1e-10 or abs(_sy - _y) > 1e-10: self.startChange('moved') self.__x = _x self.__y = _y self.endChange('moved') self.sendMessage('moved', _sx, _sy) self.modified() def move(self, dx, dy): """Move a Point. move(dx, dy) The first argument gives the x-coordinate displacement, and the second gives the y-coordinate displacement. Both values should be floats. """ if self.isLocked(): raise RuntimeError, "Moving not allowed - object locked." _dx = util.get_float(dx) _dy = util.get_float(dy) if abs(_dx) > 1e-10 or abs(_dy) > 1e-10: _x = self.__x _y = self.__y self.startChange('moved') self.__x = _x + _dx self.__y = _y + _dy self.endChange('moved') self.sendMessage('moved', _x, _y) self.modified() def clone(self): """Create an identical copy of a Point. clone() """ return Point(self.__x, self.__y) def inRegion(self, xmin, ymin, xmax, ymax, fully=True): """Returns True if the Point is within the bounding values. inRegion(xmin, ymin, xmax, ymax) The four arguments define the boundary of an area, and the function returns True if the Point lies within that area. Otherwise, the function returns False. """ _xmin = util.get_float(xmin) _ymin = util.get_float(ymin) _xmax = util.get_float(xmax) if _xmax < _xmin: raise ValueError, "Illegal values: xmax < xmin" _ymax = util.get_float(ymax) if _ymax < _ymin: raise ValueError, "Illegal values: ymax < ymin" util.test_boolean(fully) _x = self.__x _y = self.__y return not ((_x < _xmin) or (_x > _xmax) or (_y < _ymin) or (_y > _ymax)) def sendsMessage(self, m): if m in Point.__messages: return True return super(Point, self).sendsMessage(m) # # Quadtree Point storage # class PointQuadtree(quadtree.Quadtree): def __init__(self): super(PointQuadtree, self).__init__() def getNodes(self, *args): _alen = len(args) if _alen != 2: raise ValueError, "Expected 2 arguments, got %d" % _alen _x = util.get_float(args[0]) _y = util.get_float(args[1]) _nodes = [self.getTreeRoot()] while len(_nodes): _node = _nodes.pop() _xmin, _ymin, _xmax, _ymax = _node.getBoundary() if ((_x < _xmin) or (_y < _ymin) or (_x > _xmax) or (_y > _ymax)): continue if _node.hasSubnodes(): _xmid = (_xmin + _xmax)/2.0 _ymid = (_ymin + _ymax)/2.0 _ne = _nw = _sw = _se = False # # NE node (xmid,ymid) to (xmax,ymax) # if not ((_x < _xmid) or (_y < _ymid)): _ne = True # # NW node (xmin,ymid) to (xmid,ymax) # if not ((_x > _xmid) or (_y < _ymid)): _nw = True # # SW node (xmin,ymin) to (xmid,ymid) # if not ((_x > _xmid) or (_y > _ymid)): _sw = True # # SE node (xmid,ymin) to (xmax,ymid) # if not ((_x < _xmid) or (_y > _ymid)): _se = True if _ne: _nodes.append(_node.getSubnode(quadtree.QTreeNode.NENODE)) if _nw: _nodes.append(_node.getSubnode(quadtree.QTreeNode.NWNODE)) if _sw: _nodes.append(_node.getSubnode(quadtree.QTreeNode.SWNODE)) if _se: _nodes.append(_node.getSubnode(quadtree.QTreeNode.SENODE)) else: yield _node def addObject(self, obj): if not isinstance(obj, Point): raise TypeError, "Invalid Point object: " + `type(obj)` if obj in self: return _x, _y = obj.getCoords() _bounds = self.getTreeRoot().getBoundary() _xmin = _ymin = _xmax = _ymax = None _resize = False if _bounds is None: # first node in tree _resize = True _xmin = _x - 1.0 _ymin = _y - 1.0 _xmax = _x + 1.0 _ymax = _y + 1.0 else: _xmin, _ymin, _xmax, _ymax = _bounds if _x < _xmin: _xmin = _x - 1.0 _resize = True if _x > _xmax: _xmax = _x + 1.0 _resize = True if _y < _ymin: _ymin = _y - 1.0 _resize = True if _y > _ymax: _ymax = _y + 1.0 _resize = True if _resize: self.resize(_xmin, _ymin, _xmax, _ymax) for _node in self.getNodes(_x, _y): _node.addObject(obj) super(PointQuadtree, self).addObject(obj) obj.connect('moved', self._movePoint) def delObject(self, obj): if obj not in self: return _x, _y = obj.getCoords() for _node in self.getNodes(_x, _y): _node.delObject(obj) _parent = _node.getParent() if _parent is not None: self.purgeSubnodes(_parent) super(PointQuadtree, self).delObject(obj) obj.disconnect(self) def find(self, *args): _alen = len(args) if _alen < 2: raise ValueError, "Invalid argument count: %d" % _alen _x = util.get_float(args[0]) _y = util.get_float(args[1]) _t = tolerance.TOL if _alen > 2 : _t = tolerance.toltest(args[2]) return self.getInRegion((_x - _t), (_y - _t), (_x + _t), (_y + _t)) def _movePoint(self, obj, *args): if obj not in self: raise ValueError, "Point not stored in Quadtree: " + `obj` _alen = len(args) if len(args) < 2: raise ValueError, "Invalid argument count: %d" % _alen _x = util.get_float(args[0]) _y = util.get_float(args[1]) for _node in self.getNodes(_x, _y): _node.delObject(obj) super(PointQuadtree, self).delObject(obj) obj.disconnect(self) self.addObject(obj) def getClosest(self, x, y, tol=tolerance.TOL): return self.find(x, y, tol) def getInRegion(self, xmin, ymin, xmax, ymax): _xmin = util.get_float(xmin) _ymin = util.get_float(ymin) _xmax = util.get_float(xmax) if _xmax < _xmin: raise ValueError, "Illegal values: xmax < xmin" _ymax = util.get_float(ymax) if _ymax < _ymin: raise ValueError, "Illegal values: ymax < ymin" _pts = [] if not len(self): return _pts _nodes = [self.getTreeRoot()] while len(_nodes): _node = _nodes.pop() if _node.hasSubnodes(): for _subnode in _node.getSubnodes(): _sxmin, _symin, _sxmax, _symax = _subnode.getBoundary() if ((_sxmin > _xmax) or (_symin > _ymax) or (_sxmax < _xmin) or (_symax < _ymin)): continue _nodes.append(_subnode) else: for _pt in _node.getObjects(): if _pt.inRegion(_xmin, _ymin, _xmax, _ymax): _pts.append(_pt) return _pts # # Point history class # class PointLog(entity.EntityLog): def __init__(self, p): if not isinstance(p, Point): raise TypeError, "Invalid point: " + `type(p)` super(PointLog, self).__init__(p) p.connect('moved', self.__movePoint) def __movePoint(self, p, *args): _alen = len(args) if _alen < 2: raise ValueError, "Invalid argument count: %d" % _alen _x = args[0] if not isinstance(_x, float): raise TypeError, "Unexpected type for 'x': " + `type(_x)` _y = args[1] if not isinstance(_y, float): raise TypeError, "Unexpected type for 'y': " + `type(_y)` self.saveUndoData('moved', _x, _y) def execute(self, undo, *args): util.test_boolean(undo) _alen = len(args) if _alen == 0: raise ValueError, "No arguments to execute()" _p = self.getObject() _op = args[0] if _op == 'moved': if _alen < 3: raise ValueError, "Invalid argument count: %d" % _alen _x = args[1] if not isinstance(_x, float): raise TypeError, "Unexpected type for 'x': " + `type(_x)` _y = args[2] if not isinstance(_y, float): raise TypeError, "Unexpected type for 'y': " + `type(_y)` _px, _py = _p.getCoords() self.ignore(_op) try: if undo: _p.startUndo() try: _p.setCoords(_x, _y) finally: _p.endUndo() else: _p.startRedo() try: _p.setCoords(_x, _y) finally: _p.endRedo() finally: self.receive(_op) self.saveData(undo, _op, _px, _py) else: super(PointLog, self).execute(undo, *args)