#
# Copyright (c) 2002, 2003, 2004, 2005, 2006 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
#
#
# arc class
#
from __future__ import generators
import math
from PythonCAD.Generic import style
from PythonCAD.Generic import util
from PythonCAD.Generic import graphicobject
from PythonCAD.Generic import linetype
from PythonCAD.Generic import color
from PythonCAD.Generic import point
from PythonCAD.Generic import tolerance
from PythonCAD.Generic import quadtree
_dtr = math.pi/180.0
_rtd = 180.0/math.pi
class Arc(graphicobject.GraphicObject):
"""A class for Arcs.
An Arc has four attributes:
center: A Point object
radius: The Arc's radius
start_angle: The start angle
end_angle: The end angle
An Arc has the following methods:
{get/set}Center(): Get/Set the center Point of an Arc.
{get/set}Radius(): Get/Set the radius of an Arc.
{get/set}StartAngle(): Get/Set the starting angle of an Arc.
{get/set}EndAngle(): Get/Set the end angle of an arc
move(): Move the Arc.
length(): Return the length of an Arc.
area(): Return the area of an Arc.
mapPoint(): Find the nearest Point on the Arc to some other Point.
mapCoords(): Find the nearest Point on the Arc to a coordinate pair.
inRegion(): Returns whether or not a Arc can be seen in a bounded area.
clone(): Return an indentical copy of a Arc.
"""
__defstyle = None
__messages = {
'moved' : True,
'center_changed' : True,
'radius_changed' : True,
'start_angle_changed' : True,
'end_angle_changed' : True
}
def __init__(self, center, radius, start_angle, end_angle,
st=None, lt=None, col=None, th=None, **kw):
"""Initialize a Arc.
Arc(center, radius, start_angle, end_angle)
The center should be a Point, or a two-entry tuple of floats,
and the radius should be a float greater than 0.
"""
_cp = center
if not isinstance(_cp, point.Point):
_cp = point.Point(center)
_r = util.get_float(radius)
if not _r > 0.0:
raise ValueError, "Invalid radius: %g" % _r
_st = st
_sa = util.make_c_angle(start_angle)
_ea = util.make_c_angle(end_angle)
if _st is None:
_st = self.getDefaultStyle()
super(Arc, self).__init__(_st, lt, col, th, **kw)
self.__radius = _r
self.__sa = _sa
self.__ea = _ea
self.__center = _cp
_cp.connect('moved', self.__movePoint)
_cp.connect('change_pending', self.__pointChangePending)
_cp.connect('change_complete', self.__pointChangeComplete)
_cp.storeUser(self)
def __eq__(self, obj):
"""Compare a Arc to another for equality.
"""
if not isinstance(obj, Arc):
return False
if obj is self:
return True
return ((self.__center == obj.getCenter()) and
(abs(self.__radius - obj.getRadius()) < 1e-10) and
(abs(self.__sa - obj.getStartAngle()) < 1e-10) and
(abs(self.__ea - obj.getEndAngle()) < 1e-10))
def __ne__(self, obj):
"""Compare a Arc to another for inequality.
"""
if not isinstance(obj, Arc):
return True
if obj is self:
return False
return ((self.__center != obj.getCenter()) or
(abs(self.__radius - obj.getRadius()) > 1e-10) or
(abs(self.__sa - obj.getStartAngle()) > 1e-10) or
(abs(self.__ea - obj.getEndAngle()) > 1e-10))
def getDefaultStyle(cls):
if cls.__defstyle is None:
_s = style.Style(u'Default Arc Style',
linetype.Linetype(u'Solid', None),
color.Color(0xffffff),
1.0)
cls.__defstyle = _s
return cls.__defstyle
getDefaultStyle = classmethod(getDefaultStyle)
def setDefaultStyle(cls, s):
if not isinstance(s, style.Style):
raise TypeError, "Invalid style: " + `type(s)`
cls.__defstyle = s
setDefaultStyle = classmethod(setDefaultStyle)
def finish(self):
self.__center.disconnect(self)
self.__center.freeUser(self)
self.__center = self.__radius = self.__sa = self.__ea = None
super(Arc, self).finish()
def setStyle(self, s):
"""Set the Style of the Arc.
setStyle(s)
This method extends GraphicObject::setStyle().
"""
_s = s
if _s is None:
_s = self.getDefaultStyle()
super(Arc, self).setStyle(_s)
def getValues(self):
"""Return values comprising the Arc.
getValues()
This method extends the GraphicObject::getValues() method.
"""
_data = super(Arc, self).getValues()
_data.setValue('type', 'arc')
_data.setValue('center', self.__center.getID())
_data.setValue('radius', self.__radius)
_data.setValue('start_angle', self.__sa)
_data.setValue('end_angle', self.__ea)
return _data
def getCenter(self):
"""Return the center Point of the Arc.
getCenter()
"""
return self.__center
def setCenter(self, c):
"""Set the center Point of the Arc.
setCenter(c)
The argument must be a Point or a tuple containing
two float values.
"""
if self.isLocked():
raise RuntimeError, "Setting center not allowed - object locked."
_cp = self.__center
if not isinstance(c, point.Point):
raise TypeError, "Invalid center point: " + `c`
if _cp is not c:
_cp.disconnect(self)
_cp.freeUser(self)
self.startChange('center_changed')
self.__center = c
self.endChange('center_changed')
self.sendMessage('center_changed', _cp)
c.connect('moved', self.__movePoint)
c.connect('change_pending', self.__pointChangePending)
c.connect('change_complete', self.__pointChangeComplete)
c.storeUser(self)
if abs(_cp.x - c.x) > 1e-10 or abs(_cp.y - c.y) > 1e-10:
self.sendMessage('moved', _cp.x, _cp.y, self.__radius,
self.__sa, self.__ea)
self.modified()
center = property(getCenter, setCenter, None, "Arc center")
def getRadius(self):
"""Return the radius of the the Arc.
getRadius()
"""
return self.__radius
def setRadius(self, radius):
"""Set the radius of the Arc.
setRadius(radius)
The argument must be float value greater than 0.
"""
if self.isLocked():
raise RuntimeError, "Setting radius not allowed - object locked."
_r = util.get_float(radius)
if not _r > 0.0:
raise ValueError, "Invalid radius: %g" % _r
_cr = self.__radius
if abs(_cr - _r) > 1e-10:
self.startChange('radius_changed')
self.__radius = _r
self.endChange('radius_changed')
self.sendMessage('radius_changed', _cr)
_cx, _cy = self.__center.getCoords()
self.sendMessage('moved', _cx, _cy, _cr, self.__sa, self.__ea)
self.modified()
radius = property(getRadius, setRadius, None, "Arc radius")
def getStartAngle(self):
"""Return the start_angle for the Arc.
getStartAngle()
"""
return self.__sa
def setStartAngle(self, angle):
"""Set the start_angle for the Arc.
setStartAngle(angle)
The argument angle should be a float.
"""
if self.isLocked():
raise RuntimeError, "Setting start angle not allowed - object locked."
_sa = self.__sa
_angle = util.make_c_angle(angle)
if abs(_sa - _angle) > 1e-10:
self.startChange('start_angle_changed')
self.__sa = _angle
self.endChange('start_angle_changed')
self.sendMessage('start_angle_changed', _sa)
_cx, _cy = self.__center.getCoords()
self.sendMessage('moved', _cx, _cy, self.__radius, _sa, self.__ea)
self.modified()
start_angle = property(getStartAngle, setStartAngle, None,
"Start angle for the Arc.")
def getEndAngle(self):
"""Return the end_angle for the Arc.
getEndAngle()
"""
return self.__ea
def setEndAngle(self, angle):
"""Set the end_angle for the Arc.
setEndAngle(angle)
The argument angle should be a float.
"""
if self.isLocked():
raise RuntimeError, "Setting end angle not allowed - object locked."
_ea = self.__ea
_angle = util.make_c_angle(angle)
if abs(_ea - _angle) > 1e-10:
self.startChange('end_angle_changed')
self.__ea = _angle
self.endChange('end_angle_changed')
self.sendMessage('end_angle_changed', _ea)
_cx, _cy = self.__center.getCoords()
self.sendMessage('moved', _cx, _cy, self.__radius, self.__sa, _ea)
self.modified()
end_angle = property(getEndAngle, setEndAngle, None,
"End angle for the Arc.")
def getAngle(self):
"""Return the angular sweep of the Arc.
getAngle()
"""
_sa = self.__sa
_ea = self.__ea
if abs(_ea - _sa) < 1e-10:
_angle = 360.0
elif _ea > _sa:
_angle = _ea - _sa
else:
_angle = 360.0 - _sa + _ea
return _angle
def throughAngle(self, angle):
"""Return True if an arc passes through some angle
throughAngle(angle)
The argument angle should be a float value. This method returns
True if the arc exists at that angle, otherwise the method returns False.
"""
_angle = math.fmod(util.get_float(angle), 360.0)
if _angle < 0.0:
_angle = _angle + 360.0
_sa = self.__sa
_ea = self.__ea
_val = True
if abs(_sa - _ea) > 1e-10:
if _sa > _ea:
if _angle > _ea and _angle < _sa:
_val = False
else:
if _angle > _ea or _angle < _sa:
_val = False
return _val
def getEndpoints(self):
"""Return where the two endpoints for the arc-segment lie.
getEndpoints(self)
This function returns two tuples, each containing the x-y coordinates
of the arc endpoints. The first tuple corresponds to the endpoint at
the start_angle, the second to the endpoint at the end_angle.
"""
_cx, _cy = self.__center.getCoords()
_r = self.__radius
_sa = self.__sa
_sax = _cx + _r * math.cos(_sa * _dtr)
_say = _cy + _r * math.sin(_sa * _dtr)
_ea = self.__ea
_eax = _cx + _r * math.cos(_ea * _dtr)
_eay = _cy + _r * math.sin(_ea * _dtr)
return (_sax, _say), (_eax, _eay)
def length(self):
"""Return the length of the Arc.
length()
"""
return 2.0 * math.pi * self.__radius * (self.getAngle()/360.0)
def area(self):
"""Return the area enclosed by the Arc.
area()
"""
return math.pi * pow(self.__radius, 2) * (self.getAngle()/360.0)
def move(self, dx, dy):
"""Move a Arc.
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, "Setting radius 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, _y = self.__center.getCoords()
self.ignore('moved')
try:
self.__center.move(_dx, _dy)
finally:
self.receive('moved')
self.sendMessage('moved', _x, _y, self.__radius,
self.__sa, self.__ea)
def mapCoords(self, x, y, tol=tolerance.TOL):
"""Return the nearest Point on the Arc to a coordinate pair.
mapCoords(x, y[, tol])
The function has two required arguments:
x: A Float value giving the x-coordinate
y: A Float value giving the y-coordinate
There is a single optional argument:
tol: A float value equal or greater than 0.0
This function is used to map a possibly near-by coordinate pair to
an actual Point on the Arc. If the distance between the actual
Point and the coordinates used as an argument is less than the tolerance,
the actual Point is returned. Otherwise, this function returns None.
"""
_x = util.get_float(x)
_y = util.get_float(y)
_t = tolerance.toltest(tol)
_cx, _cy = self.__center.getCoords()
_r = self.__radius
_dist = math.hypot((_x - _cx), (_y - _cy))
if abs(_dist - _r) < _t:
_ra = math.atan2((_y - _cy), (_x - _cx))
_da = _ra * _rtd
if _da < 0.0:
_da = _da + 360.0
if self.throughAngle(_da):
_xoff = _r * math.cos(_ra)
_yoff = _r * math.sin(_ra)
return (_cx + _xoff), (_cy + _yoff)
return None
def inRegion(self, xmin, ymin, xmax, ymax, fully=False):
"""Return whether or not an Arc exists within a region.
inRegion(xmin, ymin, xmax, ymax[, fully])
The first four arguments define the boundary. The optional
fifth argument fully indicates whether or not the Arc
must be completely contained within the region or just pass
through it.
"""
_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)
_xc, _yc = self.__center.getCoords()
_r = self.__radius
#
# cheap test to see if arc cannot be in region
#
_axmin, _aymin, _axmax, _aymax = self.getBounds()
if ((_axmin > _xmax) or
(_aymin > _ymax) or
(_axmax < _xmin) or
(_aymax < _ymin)):
return False
_val = False
_bits = 0
#
# calculate distances from center to region boundary
#
if abs(_xc - _xmin) < _r: _bits = _bits | 1 # left edge
if abs(_xc - _xmax) < _r: _bits = _bits | 2 # right edge
if abs(_yc - _ymin) < _r: _bits = _bits | 4 # bottom edge
if abs(_yc - _ymax) < _r: _bits = _bits | 8 # top edge
if _bits == 0:
#
# arc must be visible - the center is in
# the region and is more than the radius from
# each edge
#
_val = True
else:
#
# calculate distance to corners of region
#
if math.hypot((_xc - _xmin), (_yc - _ymax)) < _r:
_bits = _bits | 0x10 # upper left
if math.hypot((_xc - _xmax), (_yc - _ymin)) < _r:
_bits = _bits | 0x20 # lower right
if math.hypot((_xc - _xmin), (_yc - _ymin)) < _r:
_bits = _bits | 0x40 # lower left
if math.hypot((_xc - _xmax), (_yc - _ymax)) < _r:
_bits = _bits | 0x80 # upper right
#
# if all bits are set then distance from arc center
# to region endpoints is less than radius - arc
# entirely outside the region
#
_val = not ((_bits == 0xff) or fully)
#
# if the test value is still true, check that the
# arc boundary can overlap with the region
#
if _val:
_ep1, _ep2 = self.getEndpoints()
_axmin = min(_xc, _ep1[0], _ep2[0])
if self.throughAngle(180.0):
_axmin = _xc - _r
if _axmin > _xmax:
return False
_aymin = min(_yc, _ep1[1], _ep2[1])
if self.throughAngle(270.0):
_aymin = _yc - _r
if _aymin > _ymax:
return False
_axmax = max(_xc, _ep1[0], _ep2[0])
if self.throughAngle(0.0):
_axmax = _xc + _r
if _axmax < _xmin:
return False
_aymax = max(_yc, _ep1[1], _ep2[1])
if self.throughAngle(90.0):
_aymax = _yc + _r
if _aymax < _ymin:
return False
return _val
def getBounds(self):
_ep1, _ep2 = self.getEndpoints()
_xc, _yc = self.__center.getCoords()
_r = self.__radius
_xmin = min(_xc, _ep1[0], _ep2[0])
_ymin = min(_yc, _ep1[1], _ep2[1])
_xmax = max(_xc, _ep1[0], _ep2[0])
_ymax = max(_yc, _ep1[1], _ep2[1])
if self.throughAngle(0.0):
_xmax = _xc + _r
if self.throughAngle(90.0):
_ymax = _yc + _r
if self.throughAngle(180.0):
_xmin = _xc - _r
if self.throughAngle(270.0):
_ymin = _yc - _r
return _xmin, _ymin, _xmax, _ymax
def __pointChangePending(self, p, *args):
_alen = len(args)
if _alen < 1:
raise ValueError, "Invalid argument count: %d" % _alen
if args[0] == 'moved':
self.startChange('moved')
def __pointChangeComplete(self, p, *args):
_alen = len(args)
if _alen < 1:
raise ValueError, "Invalid argument count: %d" % _alen
if args[0] == 'moved':
self.endChange('moved')
def __movePoint(self, p, *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])
_cp = self.__center
if p is not _cp:
raise ValueError, "Point is not arc center: " + `p`
_x, _y = _cp.getCoords()
self.sendMessage('moved', _x, _y, self.__radius, self.__sa, self.__ea)
def clone(self):
"""Create an identical copy of a Arc
clone()
"""
_cp = self.__center.clone()
_r = self.__radius
_sa = self.__sa
_ea = self.__ea
_st = self.getStyle()
_lt = self.getLinetype()
_col = self.getColor()
_th = self.getThickness()
return Arc(_cp, _r, _sa, _ea, _st, _lt, _col, _th)
def sendsMessage(self, m):
if m in Arc.__messages:
return True
return super(Arc, self).sendsMessage(m)
#
# static functions for Arc class
#
def test_angle(s, e, a):
"""Returns if an angle lies between the start and end angle of an arc.
test_angle(s, e, a)
The arguments are:
s: arc start angle
e: arc end angle
a: angle being tested
"""
_val = False
if ((abs(e - s) < 1e-10) or
((s > e) and
((s <= a <= 360.0) or (0.0 <= a <= e))) or
(s <= a <= e)):
_val = True
return _val
test_angle = staticmethod(test_angle)
#
# Quadtree Arc storage
#
class ArcQuadtree(quadtree.Quadtree):
def __init__(self):
super(ArcQuadtree, self).__init__()
def getNodes(self, *args):
_alen = len(args)
if _alen != 4:
raise ValueError, "Expected 4 arguments, got %d" % _alen
_axmin = util.get_float(args[0])
_aymin = util.get_float(args[1])
_axmax = util.get_float(args[2])
if not _axmax > _axmin:
raise ValueError, "xmax not greater than xmin"
_aymax = util.get_float(args[3])
if not _aymax > _aymin:
raise ValueError, "ymax not greater than ymin"
_nodes = [self.getTreeRoot()]
while len(_nodes):
_node = _nodes.pop()
_xmin, _ymin, _xmax, _ymax = _node.getBoundary()
if ((_axmin > _xmax) or
(_axmax < _xmin) or
(_aymin > _ymax) or
(_aymax < _ymin)):
continue
if _node.hasSubnodes():
_xmid = (_xmin + _xmax)/2.0
_ymid = (_ymin + _ymax)/2.0
_ne = _nw = _sw = _se = True
if _axmax < _xmid: # arc on left side
_ne = _se = False
if _axmin > _xmid: # arc on right side
_nw = _sw = False
if _aymax < _ymid: # arc below
_nw = _ne = False
if _aymin > _ymid: # arc above
_sw = _se = False
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, Arc):
raise TypeError, "Invalid Arc object: " + `obj`
if obj in self:
return
_bounds = self.getTreeRoot().getBoundary()
_xmin = _ymin = _xmax = _ymax = None
_axmin, _aymin, _axmax, _aymax = obj.getBounds()
_resize = False
if _bounds is None: # first node in tree
_resize = True
_xmin = _axmin - 1.0
_ymin = _aymin - 1.0
_xmax = _axmax + 1.0
_ymax = _aymax + 1.0
else:
_xmin, _ymin, _xmax, _ymax = _bounds
if _axmin < _xmin:
_xmin = _axmin - 1.0
_resize = True
if _axmax > _xmax:
_xmax = _axmax + 1.0
_resize = True
if _aymin < _ymin:
_ymin = _aymin - 1.0
_resize = True
if _aymax > _ymax:
_ymax = _aymax + 1.0
_resize = True
if _resize:
self.resize(_xmin, _ymin, _xmax, _ymax)
for _node in self.getNodes(_axmin, _aymin, _axmax, _aymax):
_xmin, _ymin, _xmax, _ymax = _node.getBoundary()
if obj.inRegion(_xmin, _ymin, _xmax, _ymax):
_node.addObject(obj)
super(ArcQuadtree, self).addObject(obj)
obj.connect('moved', self._moveArc)
def delObject(self, obj):
if obj not in self:
return
_axmin, _aymin, _axmax, _aymax = obj.getBounds()
_pdict = {}
for _node in self.getNodes(_axmin, _aymin, _axmax, _aymax):
_node.delObject(obj) # arc may not be in the node ...
_parent = _node.getParent()
if _parent is not None:
_pid = id(_parent)
if _pid not in _pdict:
_pdict[_pid] = _parent
super(ArcQuadtree, self).delObject(obj)
obj.disconnect(self)
for _parent in _pdict.values():
self.purgeSubnodes(_parent)
def find(self, *args):
_alen = len(args)
if _alen < 5:
raise ValueError, "Invalid argument count: %d" % _alen
_x = util.get_float(args[0])
_y = util.get_float(args[1])
_r = util.get_float(args[2])
_sa = util.get_float(args[3])
_ea = util.get_float(args[4])
_t = tolerance.TOL
if _alen > 5:
_t = tolerance.toltest(args[5])
_axmin = _x - _r - _t
_axmax = _x + _r + _t
_aymin = _y - _r - _t
_aymax = _y + _r + _t
_arcs = []
for _arc in self.getInRegion(_axmin, _aymin, _axmax, _aymax):
_cx, _cy = _arc.getCenter().getCoords()
if ((abs(_cx - _x) < _t) and
(abs(_cy - _y) < _t) and
(abs(_arc.getRadius() - _r) < _t) and
(abs(_arc.getStartAngle() - _sa) < 1e-10) and
(abs(_arc.getEndAngle() - _ea) < 1e-10)):
_arcs.append(_arc)
return _arcs
def _moveArc(self, obj, *args):
if obj not in self:
raise ValueError, "Arc not stored in Quadtree: " + `obj`
_alen = len(args)
if _alen < 5:
raise ValueError, "Invalid argument count: %d" % _alen
_x = util.get_float(args[0])
_y = util.get_float(args[1])
_r = util.get_float(args[2])
_sa = util.get_float(args[3])
_ea = util.get_float(args[4])
_sax = _x + _r * math.cos(_sa * _dtr)
_say = _y + _r * math.sin(_sa * _dtr)
_eax = _x + _r * math.cos(_ea * _dtr)
_eay = _y + _r * math.sin(_ea * _dtr)
_axmin = min(_x, _sax, _eax)
if ((abs(_sa - 180.0) < 1e-10) or
(abs(_ea - 180.0) < 1e-10) or
((_sa < _ea) and (_sa < 180.0 < _ea)) or
((_ea < _sa) and (_sa < 180.0))):
_axmin = _x - _r
_axmax = max(_x, _sax, _eax)
if ((abs(_sa) < 1e-10) or
(abs(_ea) < 1e-10) or
((_sa > _ea) and (_ea > 0.0))):
_axmax = _x + _r
_aymin = min(_y, _say, _eay)
if ((abs(_sa - 270.0) < 1e-10) or
(abs(_ea - 270.0) < 1e-10) or
((_sa < _ea) and (_sa < 270.0 < _ea)) or
((_ea < _sa) and (_sa < 270.0))):
_aymin = _y - _r
_aymax = max(_y, _say, _eay)
if ((abs(_sa - 90.0) < 1e-10) or
(abs(_ea - 90.0) < 1e-10) or
((_sa < _ea) and (_sa < 90.0 < _ea)) or
((_ea < _sa) and (_sa < 90.0))):
_aymax = _y + _r
for _node in self.getNodes(_axmin, _aymin, _axmax, _aymax):
_node.delObject(obj) # arc may not be in node ...
super(ArcQuadtree, self).delObject(obj)
obj.disconnect(self)
self.addObject(obj)
def getClosest(self, x, y, tol=tolerance.TOL):
_x = util.get_float(x)
_y = util.get_float(y)
_t = tolerance.toltest(tol)
_arc = _tsep = None
_bailout = False
_adict = {}
_nodes = [self.getTreeRoot()]
while len(_nodes):
_node = _nodes.pop()
_xmin, _ymin, _xmax, _ymax = _node.getBoundary()
if ((_x < (_xmin - _t)) or
(_x > (_xmax + _t)) or
(_y < (_ymin - _t)) or
(_y > (_ymax + _t))):
continue
if _node.hasSubnodes():
_nodes.extend(_node.getSubnodes())
else:
for _a in _node.getObjects():
_aid = id(_a)
if _aid not in _adict:
_ap = _a.mapCoords(_x, _y, _t)
if _ap is not None:
_ax, _ay = _ap
_sep = math.hypot((_ax - _x), (_ay - _y))
if _tsep is None:
_tsep = _sep
_arc = _a
else:
if _sep < _tsep:
_tsep = _sep
_arc = _a
if _sep < 1e-10 and _arc is not None:
_bailout = True
break
if _bailout:
break
return _arc
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"
_arcs = []
if not len(self):
return _arcs
_nodes = [self.getTreeRoot()]
_adict = {}
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 _arc in _node.getObjects():
_aid = id(_arc)
if _aid not in _adict:
if _arc.inRegion(_xmin, _ymin, _xmax, _ymax):
_arcs.append(_arc)
_adict[_aid] = True
return _arcs
#
# Arc history class
#
class ArcLog(graphicobject.GraphicObjectLog):
def __init__(self, a):
if not isinstance(a, Arc):
raise TypeError, "Invalid arc: " + `a`
super(ArcLog, self).__init__(a)
a.connect('center_changed' ,self.__centerChanged)
a.connect('radius_changed', self.__radiusChanged)
a.connect('start_angle_changed', self.__saChanged)
a.connect('end_angle_changed', self.__eaChanged)
def __radiusChanged(self, a, *args):
_alen = len(args)
if _alen < 1:
raise ValueError, "Invalid argument count: %d" % _alen
_r = args[0]
if not isinstance(_r, float):
raise TypeError, "Unexpecte type for radius: " + `type(_r)`
self.saveUndoData('radius_changed', _r)
def __centerChanged(self, a, *args):
_alen = len(args)
if _alen < 1:
raise ValueError, "Invalid argument count: %d" % _alen
_old = args[0]
if not isinstance(_old, point.Point):
raise TypeError, "Invalid old center point: " + `_old`
self.saveUndoData('center_changed', _old.getID())
def __saChanged(self, a, *args):
_alen = len(args)
if _alen < 1:
raise ValueError, "Invalid argument count: %d" % _alen
_sa = args[0]
if not isinstance(_sa, float):
raise TypeError, "Unexpected type for angle: " + `type(_sa)`
self.saveUndoData('start_angle_changed', _sa)
def __eaChanged(self, a, *args):
_alen = len(args)
if _alen < 1:
raise ValueError, "Invalid argument count: %d" % _alen
_ea = args[0]
if not isinstance(_ea, float):
raise TypeError, "Unexpected type for angle: " + `type(_ea)`
self.saveUndoData('end_angle_changed', _ea)
def execute(self, undo, *args):
#
# fixme - deal with the endpoints ...
#
def _used_by(obj, plist):
_objpt = None
for _pt in plist:
for _user in _pt.getUsers():
if _user is obj:
_objpt = _pt
break
if _objpt is not None:
break
return _objpt
def _most_used(plist):
_pmax = plist.pop()
_max = _pmax.countUsers()
for _pt in plist:
_count = _pt.countUsers()
if _count > _max:
_max = _count
_pmax = _pt
return _pmax
util.test_boolean(undo)
_alen = len(args)
if _alen == 0:
raise ValueError, "No arguments to execute()"
_a = self.getObject()
_cp = _a.getCenter()
_op = args[0]
if _op == 'center_changed':
if _alen < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_oid = args[1]
_parent = _a.getParent()
if _parent is None:
raise ValueError, "Arc has no parent - cannot undo"
_pt = _parent.getObject(_oid)
if _pt is None or not isinstance(_pt, point.Point):
raise ValueError, "Center point missing: id=%d" % _oid
_ep1, _ep2 = _a.getEndpoints()
_pts = _parent.find('point', _ep1[0], _ep1[1])
_ep = _used_by(_a, _pts)
assert _ep is not None, "Arc endpoint not found in layer"
_ep.freeUser(_a)
_pts = _parent.find('point', _ep2[0], _ep2[1])
_ep = _used_by(_a, _pts)
assert _ep is not None, "Arc endpoint not found in layer"
_ep.freeUser(_a)
_sdata = _cp.getID()
self.ignore(_op)
try:
if undo:
_a.startUndo()
try:
_a.setCenter(_pt)
finally:
_a.endUndo()
else:
_a.startRedo()
try:
_a.setCenter(_pt)
finally:
_a.endRedo()
finally:
self.receive(_op)
_ep1, _ep2 = _a.getEndpoints()
_pts = _parent.find('point', _ep1[0], _ep1[1])
_ep = _most_used(_pts)
_ep.storeUser(_a)
_pts = _parent.find('point', _ep2[0], _ep2[1])
_ep = _most_used(_pts)
_ep.storeUser(_a)
self.saveData(undo, _op, _sdata)
elif _op == 'radius_changed':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_r = args[1]
if not isinstance(_r, float):
raise TypeError, "Unexpected type for radius: " + `type(_r)`
_sdata = _a.getRadius()
self.ignore(_op)
try:
if undo:
_a.startUndo()
try:
_a.setRadius(_r)
finally:
_a.endUndo()
else:
_a.startRedo()
try:
_a.setRadius(_r)
finally:
_a.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
elif _op == 'start_angle_changed':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_sa = args[1]
if not isinstance(_sa, float):
raise TypeError, "Unexpected type for angle: " + `type(_sa)`
_sdata = _a.getStartAngle()
self.ignore(_op)
try:
if undo:
_a.startUndo()
try:
_a.setStartAngle(_sa)
finally:
_a.endUndo()
else:
_a.startRedo()
try:
_a.setStartAngle(_sa)
finally:
_a.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
elif _op == 'end_angle_changed':
if len(args) < 2:
raise ValueError, "Invalid argument count: %d" % _alen
_ea = args[1]
if not isinstance(_ea, float):
raise TypeError, "Unexpected type for angle: " + `type(_ea)`
_sdata = _a.getEndAngle()
self.ignore(_op)
try:
if undo:
_a.startUndo()
try:
_a.setEndAngle(_ea)
finally:
_a.endUndo()
else:
_a.startRedo()
try:
_a.setEndAngle(_ea)
finally:
_a.endRedo()
finally:
self.receive(_op)
self.saveData(undo, _op, _sdata)
else:
super(ArcLog, self).execute(undo, *args)
