Sketcher New Feature: Ellipse support

- Ellipse introduction button via (center,majaxis extreme, a point in edge), ellipse is always CCW so that Z axis goes in the positive direction of the sketch
- Backwards compatibility with files of previous versions of ellipse not defining a phi angle
- Art by Jim (all the icons you see and the XPMs shown on creation of an ellipse)
- Element Widget support for ellipses
- Box selection for ellipses
- Point on Ellipse constraint based on the gardener's method based on Ulrich's function proposal (radcan simplified, i.e. with simplify_radical sage function)
- Tangent: Ellipse to Line based on DeepSOIC's geometric formulation (radcan simplified)

Sketcher New Feature: Internal Alignment Constraint
- The element to which internal alignment is applied has to be selected last.
- All other elements are added in the order of priority, taking into account existing elements
- Art by Jim (beautiful icons).

Sketcher New Feature: Tool to show/hide/restore the internal geometry of an element
- New functionality for show/hide internal geometry:
  toggles between hiding all unused internal geometry elements and showing all internal geometry.
  The restore function is implicit to the showing all internal geometry

Sketcher New Feature: Arc of Ellipse support
- Part::Geometry + Python implementation
- ArcOfEllipse creation method
- Art by Jim (all the icons you see and the XPMs shown on creation of arc of ellipse elements)
- Sketcher Element widget for ArcOfEllipse.

Bug fix: Select elements associated to constraints works now for foci internal alignment constraints

src/Mod/Part/App/AppPart.cpp

@@ -66,6 +66,7 @@
 #include "EllipsePy.h"
 #include "ArcPy.h"
 #include "ArcOfCirclePy.h"
+#include "ArcOfEllipsePy.h"
 #include "BezierCurvePy.h"
 #include "BSplineCurvePy.h"
 #include "HyperbolaPy.h"
@@ -172,6 +173,7 @@ void PartExport initPart()
     Base::Interpreter().addType(&Part::ParabolaPy           ::Type,partModule,"Parabola");
     Base::Interpreter().addType(&Part::ArcPy                ::Type,partModule,"Arc");
     Base::Interpreter().addType(&Part::ArcOfCirclePy        ::Type,partModule,"ArcOfCircle");
+    Base::Interpreter().addType(&Part::ArcOfEllipsePy       ::Type,partModule,"ArcOfEllipse");
     Base::Interpreter().addType(&Part::BezierCurvePy        ::Type,partModule,"BezierCurve");
     Base::Interpreter().addType(&Part::BSplineCurvePy       ::Type,partModule,"BSplineCurve");
     Base::Interpreter().addType(&Part::OffsetCurvePy        ::Type,partModule,"OffsetCurve");
@@ -261,6 +263,7 @@ void PartExport initPart()
     Part::GeomBSplineCurve        ::init();
     Part::GeomCircle              ::init();
     Part::GeomArcOfCircle         ::init();
+    Part::GeomArcOfEllipse        ::init();
     Part::GeomEllipse             ::init();
     Part::GeomHyperbola           ::init();
     Part::GeomParabola            ::init();

src/Mod/Part/App/ArcOfEllipsePy.xml

@@ -0,0 +1,54 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<GenerateModel xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="generateMetaModel_Module.xsd">
+  <PythonExport 
+      Father="GeometryCurvePy" 
+      Name="ArcOfEllipsePy" 
+      Twin="GeomArcOfEllipse" 
+      TwinPointer="GeomArcOfEllipse" 
+      Include="Mod/Part/App/Geometry.h" 
+      Namespace="Part" 
+      FatherInclude="Mod/Part/App/GeometryCurvePy.h" 
+      FatherNamespace="Part"
+      Constructor="true">
+    <Documentation>
+      <Author Licence="LGPL" Name="Abdullah Tahiri" EMail="abdullah.tahiri.yo[at]gmail.com" />
+      <UserDocu>Describes a portion of an ellipse</UserDocu>
+    </Documentation>
+    <Attribute Name="MajorRadius" ReadOnly="false">
+      <Documentation>
+        <UserDocu>The major radius of the ellipse.</UserDocu>
+      </Documentation>
+      <Parameter Name="MajorRadius" Type="Float"/>
+    </Attribute>      
+    <Attribute Name="MinorRadius" ReadOnly="false">
+      <Documentation>
+        <UserDocu>The minor radius of the ellipse.</UserDocu>
+      </Documentation>
+      <Parameter Name="MinorRadius" Type="Float"/>
+    </Attribute>
+    <Attribute Name="AngleXU" ReadOnly="false">
+      <Documentation>
+        <UserDocu>The angle between the X axis and the major axis of the ellipse.</UserDocu>
+      </Documentation>
+      <Parameter Name="AngleXU" Type="Float"/>
+    </Attribute> 
+    <Attribute Name="Center" ReadOnly="false">
+      <Documentation>
+        <UserDocu>Center of the ellipse.</UserDocu>
+      </Documentation>
+      <Parameter Name="Center" Type="Object"/>
+    </Attribute>
+    <Attribute Name="Axis" ReadOnly="false">
+      <Documentation>
+        <UserDocu>The axis direction of the ellipse</UserDocu>
+      </Documentation>
+      <Parameter Name="Axis" Type="Object"/>
+    </Attribute>
+    <Attribute Name="Ellipse" ReadOnly="true">
+      <Documentation>
+        <UserDocu>The internal ellipse representation</UserDocu>
+      </Documentation>
+      <Parameter Name="Ellipse" Type="Object"/>
+    </Attribute>
+  </PythonExport>
+</GenerateModel>

src/Mod/Part/App/ArcOfEllipsePyImp.cpp

@@ -0,0 +1,233 @@
+/***************************************************************************
+ *   Copyright (c) 2014 Abdullah Tahiri <abdullah.tahiri.yo@gmail.com      *
+ *                                                                         *
+ *   This file is part of the FreeCAD CAx development system.              *
+ *                                                                         *
+ *   This library is free software; you can redistribute it and/or         *
+ *   modify it under the terms of the GNU Library General Public           *
+ *   License as published by the Free Software Foundation; either          *
+ *   version 2 of the License, or (at your option) any later version.      *
+ *                                                                         *
+ *   This library  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 Library General Public License for more details.                  *
+ *                                                                         *
+ *   You should have received a copy of the GNU Library General Public     *
+ *   License along with this library; see the file COPYING.LIB. If not,    *
+ *   write to the Free Software Foundation, Inc., 59 Temple Place,         *
+ *   Suite 330, Boston, MA  02111-1307, USA                                *
+ *                                                                         *
+ ***************************************************************************/
+
+
+#include "PreCompiled.h"
+#ifndef _PreComp_
+# include <gp_Elips.hxx>
+# include <Geom_Ellipse.hxx>
+# include <GC_MakeArcOfEllipse.hxx>
+# include <GC_MakeEllipse.hxx>
+# include <Geom_TrimmedCurve.hxx>
+#endif
+
+#include "Mod/Part/App/Geometry.h"
+#include "ArcOfEllipsePy.h"
+#include "ArcOfEllipsePy.cpp"
+#include "EllipsePy.h"
+#include "OCCError.h"
+
+#include <Base/GeometryPyCXX.h>
+#include <Base/VectorPy.h>
+
+using namespace Part;
+
+extern const char* gce_ErrorStatusText(gce_ErrorType et);
+
+// returns a string which represents the object e.g. when printed in python
+std::string ArcOfEllipsePy::representation(void) const
+{
+    Handle_Geom_TrimmedCurve trim = Handle_Geom_TrimmedCurve::DownCast
+        (getGeomArcOfEllipsePtr()->handle());
+    Handle_Geom_Ellipse ellipse = Handle_Geom_Ellipse::DownCast(trim->BasisCurve());
+
+    gp_Ax1 axis = ellipse->Axis();
+    gp_Dir dir = axis.Direction();
+    gp_Pnt loc = axis.Location();
+    Standard_Real fMajRad = ellipse->MajorRadius();
+    Standard_Real fMinRad = ellipse->MinorRadius();
+    Standard_Real u1 = trim->FirstParameter();
+    Standard_Real u2 = trim->LastParameter();
+
+    gp_Dir normal = ellipse->Axis().Direction();
+    gp_Dir xdir = ellipse->XAxis().Direction();
+
+    gp_Ax2 xdirref(loc, normal); // this is a reference XY for the ellipse
+
+    Standard_Real fAngleXU = -xdir.AngleWithRef(xdirref.XDirection(),normal);
+
+
+    std::stringstream str;
+    str << "ArcOfEllipse (";
+    str << "MajorRadius : " << fMajRad << ", "; 
+    str << "MinorRadius : " << fMinRad << ", ";
+    str << "AngleXU : " << fAngleXU << ", ";
+    str << "Position : (" << loc.X() << ", "<< loc.Y() << ", "<< loc.Z() << "), "; 
+    str << "Direction : (" << dir.X() << ", "<< dir.Y() << ", "<< dir.Z() << "), "; 
+    str << "Parameter : (" << u1 << ", " << u2 << ")"; 
+    str << ")";
+
+    return str.str();
+}
+
+PyObject *ArcOfEllipsePy::PyMake(struct _typeobject *, PyObject *, PyObject *)  // Python wrapper
+{
+    // create a new instance of ArcOfEllipsePy and the Twin object 
+    return new ArcOfEllipsePy(new GeomArcOfEllipse);
+}
+
+// constructor method
+int ArcOfEllipsePy::PyInit(PyObject* args, PyObject* kwds)
+{
+    PyObject* o;
+    double u1, u2;
+    PyObject *sense=Py_True;
+    if (PyArg_ParseTuple(args, "O!dd|O!", &(Part::EllipsePy::Type), &o, &u1, &u2, &PyBool_Type, &sense)) {
+        try {
+            Handle_Geom_Ellipse ellipse = Handle_Geom_Ellipse::DownCast
+                (static_cast<EllipsePy*>(o)->getGeomEllipsePtr()->handle());
+            GC_MakeArcOfEllipse arc(ellipse->Elips(), u1, u2, PyObject_IsTrue(sense) ? Standard_True : Standard_False);
+            if (!arc.IsDone()) {
+                PyErr_SetString(PartExceptionOCCError, gce_ErrorStatusText(arc.Status()));
+                return -1;
+            }
+
+            getGeomArcOfEllipsePtr()->setHandle(arc.Value());
+            return 0;
+        }
+        catch (Standard_Failure) {
+            Handle_Standard_Failure e = Standard_Failure::Caught();
+            PyErr_SetString(PartExceptionOCCError, e->GetMessageString());
+            return -1;
+        }
+        catch (...) {
+            PyErr_SetString(PartExceptionOCCError, "creation of arc failed");
+            return -1;
+        }
+    }
+
+    // All checks failed
+    PyErr_SetString(PyExc_TypeError,
+        "ArcOfEllipse constructor expects an ellipse curve and a parameter range");
+    return -1;
+}
+
+Py::Float ArcOfEllipsePy::getMajorRadius(void) const
+{
+    return Py::Float(getGeomArcOfEllipsePtr()->getMajorRadius()); 
+}
+
+void  ArcOfEllipsePy::setMajorRadius(Py::Float arg)
+{
+    getGeomArcOfEllipsePtr()->setMajorRadius((double)arg);
+}
+
+Py::Float ArcOfEllipsePy::getMinorRadius(void) const
+{
+    return Py::Float(getGeomArcOfEllipsePtr()->getMinorRadius()); 
+}
+
+void  ArcOfEllipsePy::setMinorRadius(Py::Float arg)
+{
+    getGeomArcOfEllipsePtr()->setMinorRadius((double)arg);
+}
+
+Py::Float ArcOfEllipsePy::getAngleXU(void) const
+{
+    return Py::Float(getGeomArcOfEllipsePtr()->getAngleXU()); 
+}
+
+void ArcOfEllipsePy::setAngleXU(Py::Float arg)
+{
+    getGeomArcOfEllipsePtr()->setAngleXU((double)arg);
+}
+
+Py::Object ArcOfEllipsePy::getCenter(void) const
+{
+    return Py::Vector(getGeomArcOfEllipsePtr()->getCenter());
+}
+
+void  ArcOfEllipsePy::setCenter(Py::Object arg)
+{
+    PyObject* p = arg.ptr();
+    if (PyObject_TypeCheck(p, &(Base::VectorPy::Type))) {
+        Base::Vector3d loc = static_cast<Base::VectorPy*>(p)->value();
+        getGeomArcOfEllipsePtr()->setCenter(loc);
+    }
+    else if (PyObject_TypeCheck(p, &PyTuple_Type)) {
+        Base::Vector3d loc = Base::getVectorFromTuple<double>(p);
+        getGeomArcOfEllipsePtr()->setCenter(loc);
+    }
+    else {
+        std::string error = std::string("type must be 'Vector', not ");
+        error += p->ob_type->tp_name;
+        throw Py::TypeError(error);
+    }
+}
+
+Py::Object ArcOfEllipsePy::getAxis(void) const
+{
+    Handle_Geom_TrimmedCurve trim = Handle_Geom_TrimmedCurve::DownCast
+        (getGeomArcOfEllipsePtr()->handle());
+    Handle_Geom_Ellipse ellipse = Handle_Geom_Ellipse::DownCast(trim->BasisCurve());
+    gp_Ax1 axis = ellipse->Axis();
+    gp_Dir dir = axis.Direction();
+    return Py::Vector(Base::Vector3d(dir.X(), dir.Y(), dir.Z()));
+}
+
+void  ArcOfEllipsePy::setAxis(Py::Object arg)
+{
+    PyObject* p = arg.ptr();
+    Base::Vector3d val;
+    if (PyObject_TypeCheck(p, &(Base::VectorPy::Type))) {
+        val = static_cast<Base::VectorPy*>(p)->value();
+    }
+    else if (PyTuple_Check(p)) {
+        val = Base::getVectorFromTuple<double>(p);
+    }
+    else {
+        std::string error = std::string("type must be 'Vector', not ");
+        error += p->ob_type->tp_name;
+        throw Py::TypeError(error);
+    }
+
+    Handle_Geom_TrimmedCurve trim = Handle_Geom_TrimmedCurve::DownCast
+        (getGeomArcOfEllipsePtr()->handle());
+    Handle_Geom_Ellipse ellipse = Handle_Geom_Ellipse::DownCast(trim->BasisCurve());
+    try {
+        gp_Ax1 axis;
+        axis.SetLocation(ellipse->Location());
+        axis.SetDirection(gp_Dir(val.x, val.y, val.z));
+        ellipse->SetAxis(axis);
+    }
+    catch (Standard_Failure) {
+        throw Py::Exception("cannot set axis");
+    }
+}
+
+Py::Object ArcOfEllipsePy::getEllipse(void) const
+{
+    Handle_Geom_TrimmedCurve trim = Handle_Geom_TrimmedCurve::DownCast
+        (getGeomArcOfEllipsePtr()->handle());
+    Handle_Geom_Ellipse ellipse = Handle_Geom_Ellipse::DownCast(trim->BasisCurve());
+    return Py::Object(new EllipsePy(new GeomEllipse(ellipse)), true);
+}
+
+PyObject *ArcOfEllipsePy::getCustomAttributes(const char* attr) const
+{
+    return 0;
+}
+
+int ArcOfEllipsePy::setCustomAttributes(const char* attr, PyObject *obj)
+{
+    return 0; 
+}

src/Mod/Part/App/ArcPy.xml

@@ -21,5 +21,12 @@
     const Geom_Circle & value(void) const {return *getGeom_CirclePtr();}
 	</ClassDeclarations>
 	-->
+	<!--
+	<ClassDeclarations>public:
+      ArcPy(const Geom_Ellipse &amp; circ, PyTypeObject *T = &amp;Type)
+      :PyObjectBase(new Geom_Ellipse(circ),T){}
+    const Geom_Ellipse &amp; value(void) const {return *getGeom_EllipsePtr();}
+	</ClassDeclarations>
+	-->
   </PythonExport>
 </GenerateModel>

src/Mod/Part/App/CMakeLists.txt

@@ -40,6 +40,7 @@ endif(FREETYPE_FOUND)
 generate_from_xml(ArcPy)
 generate_from_xml(ArcOfCirclePy)
 generate_from_xml(CirclePy)
+generate_from_xml(ArcOfEllipsePy)
 generate_from_xml(EllipsePy)
 generate_from_xml(HyperbolaPy)
 generate_from_xml(ParabolaPy)
@@ -148,6 +149,8 @@ SET(Python_SRCS
     ArcOfCirclePyImp.cpp
     CirclePy.xml
     CirclePyImp.cpp
+    ArcOfEllipsePy.xml
+    ArcOfEllipsePyImp.cpp
     EllipsePy.xml
     EllipsePyImp.cpp
     HyperbolaPy.xml

src/Mod/Part/App/EllipsePy.xml

@@ -46,6 +46,12 @@
 			</Documentation>
 			<Parameter Name="MinorRadius" Type="Float"/>
 		</Attribute>
+		<Attribute Name="AngleXU" ReadOnly="false">
+		  <Documentation>
+		    <UserDocu>The angle between the X axis and the major axis of the ellipse.</UserDocu>
+		  </Documentation>
+		  <Parameter Name="AngleXU" Type="Float"/>
+		</Attribute>		
 		<Attribute Name="Eccentricity" ReadOnly="true">
 			<Documentation>
 				<UserDocu>The eccentricity of the ellipse.</UserDocu>

src/Mod/Part/App/EllipsePyImp.cpp

@@ -151,6 +151,38 @@ void EllipsePy::setMinorRadius(Py::Float arg)
     ellipse->SetMinorRadius((double)arg);
 }
 
+Py::Float EllipsePy::getAngleXU(void) const
+{
+    Handle_Geom_Ellipse ellipse = Handle_Geom_Ellipse::DownCast(getGeomEllipsePtr()->handle());
+
+    gp_Pnt center = ellipse->Axis().Location();
+    gp_Dir normal = ellipse->Axis().Direction();
+    gp_Dir xdir = ellipse->XAxis().Direction();
+
+    gp_Ax2 xdirref(center, normal); // this is a reference system, might be CCW or CW depending on the creation method
+
+    return Py::Float(-xdir.AngleWithRef(xdirref.XDirection(),normal));
+
+}
+
+void EllipsePy::setAngleXU(Py::Float arg)
+{
+    Handle_Geom_Ellipse ellipse = Handle_Geom_Ellipse::DownCast(getGeomEllipsePtr()->handle());
+
+
+    gp_Pnt center = ellipse->Axis().Location();
+    gp_Dir normal = ellipse->Axis().Direction();
+
+    gp_Ax1 normaxis(center, normal);
+
+    gp_Ax2 xdirref(center, normal);
+
+    xdirref.Rotate(normaxis,arg);
+
+    ellipse->SetPosition(xdirref);
+
+}
+
 Py::Float EllipsePy::getEccentricity(void) const
 {
     Handle_Geom_Ellipse ellipse = Handle_Geom_Ellipse::DownCast(getGeomEllipsePtr()->handle());