# # Copyright (c) 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 # # # class stuff for ellipses # # Ellipse info: # http://mathworld.wolfram.com/Ellipse.html # http://astronomy.swin.edu.au/~pbourke/geometry/ellipsecirc/ # import math from PythonCAD.Generic import baseobject from PythonCAD.Generic import tolerance from PythonCAD.Generic import point from PythonCAD.Generic import graphicobject from PythonCAD.Generic import style from PythonCAD.Generic import linetype from PythonCAD.Generic import color from PythonCAD.Generic import util class Ellipse(graphicobject.GraphicObject): """A base class for Ellipses An ellipse has the following attributes: center: A _point object major_axis: minor_axis: angle: A float from -90.0 to 90.0 degrees """ __defstyle = None __messages = { 'center_changed' : True, 'major_axis_changed' : True, 'minor_axis_changed' : True, 'angle_changed' : True, 'moved' : True, } def __init__(self, center, major, minor, angle, st=None, lt=None, col=None, t=None, **kw): _cp = center if not isinstance(_cp, point._Point): _cp = point.Point(center) _major = util.get_float(major) if not _major > 0.0: raise ValueError, "Invalid major axis value: %g" % _major _minor = util.get_float(minor) if not _minor > 0.0: raise ValueError, "Invalid minor axis value: %g" % _minor if _minor > _major: raise ValueError, "Minor axis must be less than major axis" _angle = util.make_angle(angle) _st = st if _st is None: _st = self.getDefaultStyle() super(Ellipse, self).__init__(_st, lt, col, t, **kw) self.__center = _cp self.__major = _major self.__minor = _minor self.__angle = _angle _cp.storeUser(self) _cp.connect('moved', self.__movePoint) _cp.connect('change_pending', self.__pointChangePending) _cp.connect('change_complete', self.__pointChangeComplete) def __eq__(self, obj): """Compare one ellipse to another for equality. """ if not isinstance(obj, Ellipse): return False if obj is self: return True return (self.__center == obj.getCenter() and abs(self.__major - obj.getMajorAxis()) < 1e-10 and abs(self.__minor - obj.getMinorAxis()) < 1e-10 and abs(self.__angle - obj.getAngle()) < 1e-10) def __ne__(self, obj): """Compare one ellipse to another for equality. """ if not isinstance(obj, Ellipse): return True if obj is self: return False return (self.__center != obj.getCenter() or abs(self.__major - obj.getMajorAxis()) > 1e-10 or abs(self.__minor - obj.getMinorAxis()) > 1e-10 or abs(self.__angle - obj.getAngle()) > 1e-10) def getDefaultStyle(cls): if cls.__defstyle is None: _s = style.Style(u'Default Ellipse 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.__major = self.__minor = self.__angle = None super(Ellipse, self).finish() def setStyle(self, s): """Set the Style of the Ellipse. setStyle(s) This method extends GraphicObject::setStyle(). """ _s = s if _s is None: _s = self.getDefaultStyle() super(Ellipse, self).setStyle(_s) def getValues(self): """Return values comprising the Ellipse. getValues() This method extends the GraphicObject::getValues() method. """ _data = super(Ellipse, self).getValues() _data.setValue('type', 'ellipse') _data.setValue('center', self.__center.getID()) _data.setValue('major', self.__major) _data.setValue('minor', self.__minor) _data.setValue('angle', self.__angle) return _data def getCenter(self): """Return the center _Point of the Ellipse. getCenter() """ return self.__center def setCenter(self, cp): """Set the center _Point of the Ellipse. setCenter(cp) The argument must be a _Point or a tuple containing two float values. """ if self.isLocked(): raise RuntimeError, "Setting center not allowed - object locked." if not isinstance(cp, point._Point): raise TypeError, "Invalid Point: " + `cp` _c = self.__center if _c is not cp: _c.disconnect(self) _c.freeUser(self) self.startChange('center_changed') self.__center = cp self.endChange('center_changed') self.sendMessage('center_changed', _c) cp.storeUser(self) cp.connect('moved', self.__movePoint) cp.connect('change_pending', self.__pointChangePending) cp.connect('change_complete', self.__pointChangeComplete) if abs(_c.x - cp.x) > 1e-10 or abs(_c.y - cp.y) > 1e-10: _x, _y = _c.getCoords() self.sendMessage('moved', _x, _y, self.__major, self.__minor, self.__angle) self.modified() center = property(getCenter, setCenter, None, "Ellipse center") def getMajorAxis(self): """Return the major axis value of the Ellipse. getMajorAxis() This method returns a float. """ return self.__major def setMajorAxis(self, val): """Set the major axis of the Ellipse. setMajorAxis(val) Argument 'val' must be a float value greater than 0. """ if self.isLocked(): raise RuntimeError, "Setting major axis not allowed - object locked." _val = util.get_float(val) if not _val > 0.0: raise ValueError, "Invalid major axis value: %g" % _val if _val < self.__minor: raise ValueError, "Major axis must be greater than minor axis." _maj = self.__major if abs(_val - _maj) > 1e-10: self.startChange('major_axis_changed') self.__major = _val self.endChange('major_axis_changed') self.sendMessage('major_axis_changed', _maj) _x, _y = self.__center.getCoords() self.sendMessage('moved', _x, _y, _maj, self.__minor, self.__angle) self.modified() major_axis = property(getMajorAxis, setMajorAxis, None, "Ellipse major axis") def getMinorAxis(self): """Return the minor axis value of the Ellipse. getMinorAxis() This method returns a float. """ return self.__minor def setMinorAxis(self, val): """Set the minor axis of the Ellipse. setMinorAxis(val) Argument 'val' must be a float value greater than 0. """ if self.isModified(): raise RuntimeError, "Setting minor axis not allowed - object locked." _val = util.get_float(val) if not _val > 0.0: raise ValueError, "Invalid minor axis value: %g" % _val if _val > self.__major: raise ValueError, "Minor axis must be less than major axis" _min = self.__minor if abs(_val - _min) > 1e-10: self.startChange('minor_axis_changed') self.__minor = _val self.endChange('minor_axis_changed') self.sendMessage('minor_axis_changed', _min) _x, _y = self.__center.getCoords() self.sendMessage('moved', _x, _y, self.__major, _min, self.__angle) self.modified() minor_axis = property(getMinorAxis, setMinorAxis, None, "Ellipse minor axis") def getAngle(self): """Return the Ellipse major axis angle. getAngle() This method returns a float value. """ return self.__angle def setAngle(self, angle): """Set the Ellipse major axis angle. setAngle(angle) Argument 'angle' should be a float. The value will be adjusted so the angle will be defined from 90.0 to -90.0. """ if self.isModified(): raise RuntimeError, "Setting angle not allowed - object locked." _angle = util.make_angle(angle) _a = self.__angle if abs(_a - _angle) > 1e-10: self.startChange('angle_changed') self.__angle = _angle self.endChange('angle_changed') self.sendMessage('angle_changed', _a) _x, _y = self.__center.getCoords() self.sendMessage('moved', _x, _y, self.__major, self.__minor, _angle) self.modified() angle = property(getAngle, setAngle, None, "Ellipse major axis angle") def move(self, dx, dy): """Move an Ellipse. move(dx, dy) Arguments 'dx' and 'dy' should be floats. """ if self.isLocked() or self.__center.isLocked(): raise RuntimeError, "Moving object 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.__major, self.__minor, self.__angle) def rotate(self, angle): """Rotate an Ellipse rotate(angle) Argument 'angle' should be a float. """ if self.isLocked(): raise RuntimeError, "Rotating object not allowed - object locked." _angle = util.get_float(angle) if abs(_angle) > 1e-10: _cur = self.__angle _new = util.make_angle(_angle + _cur) self.startChange('angle_changed') self.__angle = _new self.endChange('angle_changed') self.sendMessage('angle_changed', _cur) _x, _y = self.__center.getCoords() self.sendMessage('moved', _x, _y, self.__major, self.__minor, _cur) self.modified() def eccentricity(self): """Return the eccecntricity of the Ellipse. eccentricity() This method returns a float value. """ _major = self.__major _minor = self.__minor if abs(_major - _minor) < 1e-10: # circular _e = 0.0 else: _e = math.sqrt(1.0 - ((_minor * _minor)/(_major * _major))) return _e def area(self): """Return the area of the Ellipse. area() This method returns a float value. """ return math.pi * self.__major * self.__minor def circumference(self): """Return the circumference of an ellipse. circumference() This method returns a float. The algorithm below is taken from http://astronomy.swin.edu.au/~pbourke/geometry/ellipsecirc/ Ramanujan, Second Approximation """ _a = self.__major _b = self.__minor _h = math.pow((_a - _b), 2)/math.pow((_a + _b), 2) _3h = 3.0 * _h return math.pi * (_a + _b) * (1.0 + _3h/(10.0 + math.sqrt(4.0 - _3h))) def mapCoords(self, x, y, tol=tolerance.TOL): """Return the nearest _Point on the Ellipse 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 Ellipse. 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() _dist = math.hypot((_x - _cx), (_y - _cy)) _major = self.__major _minor = self.__minor _ep = None if abs(_major - _minor) < 1e-10: # circular _sep = _dist - _major if _sep < _t or abs(_sep - _t) < 1e-10: _angle = math.atan2((_y - _cy),(_x - _cx)) _px = _major * math.cos(_angle) _py = _major * math.sin(_angle) _ep = point._Point((_cx + _px), (_cy + _py)) else: if _dist < _major and _dist > _minor: _ecos = math.cos(self.__angle) _esin = math.sin(self.__angle) # FIXME ... return _ep 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]) if p is not self.__center: raise ValueError, "Unexpected point in movePoint" + `p` self.sendMessage('moved', _x, _y, self.__major, self.__minor, self.__angle) self.modified() # # measure r from focus # # x = c + r*cos(theta) # y = r*sin(theta) # # c = sqrt(a^2 - b^2) # # r = a*(1-e)/(1 + e*cos(theta)) def clone(self): """Make a copy of an Ellipse. clone() This method returns a new Ellipse object """ _cp = self.__center.clone() _st = self.getStyle() _lt = self.getLinetype() _col = self.getColor() _th = self.getThickness() return Ellipse(_cp, self.__major, self.__minor, self.__angle, _st, _lt, _col, _th) def sendsMessage(self, m): if m in Ellipse.__messages: return True return super(Ellipse, self).sendsMessage(m)