#
# 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)