Sketcher: Point on Object solver constraint

src/Mod/Sketcher/App/Sketch.cpp

@@ -1887,6 +1887,12 @@ int Sketch::addPointOnObjectConstraint(int geoId1, PointPos pos1, int geoId2)
             GCSsys.addConstraintPointOnHyperbolicArc(p1, a, tag);
             return ConstraintsCounter;
         }
+        else if (Geoms[geoId2].type == ArcOfParabola) {
+            GCS::ArcOfParabola &a = ArcsOfParabola[Geoms[geoId2].index];
+            int tag = ++ConstraintsCounter;
+            GCSsys.addConstraintPointOnParabolicArc(p1, a, tag);
+            return ConstraintsCounter;
+        }
     }
     return -1;
 }

src/Mod/Sketcher/App/planegcs/Constraints.cpp

@@ -1639,6 +1639,105 @@ double ConstraintPointOnHyperbola::grad(double *param)
         return scale * deriv;
 }
 
+// ConstraintPointOnParabola
+ConstraintPointOnParabola::ConstraintPointOnParabola(Point &p, Parabola &e)
+{
+    pvec.push_back(p.x);
+    pvec.push_back(p.y);
+    e.PushOwnParams(pvec);
+    this->parab = e.Copy();
+    pvecChangedFlag = true;
+    origpvec = pvec;
+    rescale();
+}
+
+ConstraintPointOnParabola::ConstraintPointOnParabola(Point &p, ArcOfParabola &e)
+{
+    pvec.push_back(p.x);
+    pvec.push_back(p.y);
+    e.PushOwnParams(pvec);
+    this->parab = e.Copy();
+    pvecChangedFlag = true;
+    origpvec = pvec;
+    rescale();
+}
+
+ConstraintPointOnParabola::~ConstraintPointOnParabola()
+{
+    delete this->parab; this->parab = 0;
+}
+
+void ConstraintPointOnParabola::ReconstructGeomPointers()
+{
+    int i=0;
+    p.x=pvec[i]; i++;
+    p.y=pvec[i]; i++;
+    this->parab->ReconstructOnNewPvec(pvec, i);
+    pvecChangedFlag = false;
+}
+
+ConstraintType ConstraintPointOnParabola::getTypeId()
+{
+    return PointOnParabola;
+}
+
+void ConstraintPointOnParabola::rescale(double coef)
+{
+    scale = coef * 1;
+}
+
+void ConstraintPointOnParabola::errorgrad(double *err, double *grad, double *param)
+{
+    if (pvecChangedFlag) ReconstructGeomPointers();
+
+    DeriVector2 focus(this->parab->focus1, param);
+    DeriVector2 vertex(this->parab->vertex, param);
+
+    DeriVector2 point(this->p, param); //point to be constrained to parabola
+    
+    DeriVector2 focalvect = focus.subtr(vertex);
+    
+    DeriVector2 xdir = focalvect.getNormalized();
+    
+    DeriVector2 point_to_focus = point.subtr(focus);
+
+    double focal, dfocal;
+    
+    focal = focalvect.length(dfocal);
+    
+    double pf, dpf;
+    
+    pf = point_to_focus.length(dpf);
+    
+    double proj, dproj;
+    
+    proj = point_to_focus.scalarProd(xdir, &dproj);
+    
+    if (err) 
+	*err = pf - 2*focal - proj;
+    if (grad)
+	*grad = dpf - 2*dfocal - dproj;
+
+}
+
+double ConstraintPointOnParabola::error()
+{
+    double err;
+    errorgrad(&err,0,0);
+    return scale * err;
+}
+
+double ConstraintPointOnParabola::grad(double *param)
+{
+    //first of all, check that we need to compute anything.
+    if ( findParamInPvec(param) == -1  ) return 0.0;
+    
+    double deriv;
+    errorgrad(0, &deriv, param);
+    
+    return deriv*scale;
+}
+
 // ConstraintAngleViaPoint
 ConstraintAngleViaPoint::ConstraintAngleViaPoint(Curve &acrv1, Curve &acrv2, Point p, double* angle)
 {

src/Mod/Sketcher/App/planegcs/Constraints.h

@@ -66,6 +66,7 @@ namespace GCS
         CurveValue = 20,
         PointOnHyperbola = 21,
         InternalAlignmentPoint2Hyperbola = 22,
+	PointOnParabola = 23
     };
     
     enum InternalAlignmentType {
@@ -512,6 +513,27 @@ namespace GCS
         virtual double grad(double *);
     };
 
+    // PointOnParabola
+    class ConstraintPointOnParabola : public Constraint
+    {
+    private:
+        void errorgrad(double* err, double* grad, double *param); //error and gradient combined. Values are returned through pointers.
+        void ReconstructGeomPointers(); //writes pointers in pvec to the parameters of crv1, crv2 and poa
+        Parabola* parab;
+        Point p;
+    public:
+        ConstraintPointOnParabola(Point &p, Parabola &e);
+        ConstraintPointOnParabola(Point &p, ArcOfParabola &a);
+	~ConstraintPointOnParabola();
+        #ifdef _GCS_EXTRACT_SOLVER_SUBSYSTEM_
+        inline ConstraintPointOnParabola(){}
+        #endif
+        virtual ConstraintType getTypeId();
+        virtual void rescale(double coef=1.);
+        virtual double error();
+        virtual double grad(double *);
+    };
+    
     class ConstraintAngleViaPoint : public Constraint
     {
     private:

src/Mod/Sketcher/App/planegcs/GCS.cpp

@@ -582,6 +582,13 @@ int System::addConstraintPointOnHyperbolicArc(Point &p, ArcOfHyperbola &e, int t
     return addConstraint(constr);   
 }
 
+int System::addConstraintPointOnParabolicArc(Point &p, ArcOfParabola &e, int tagId)
+{
+    Constraint *constr = new ConstraintPointOnParabola(p, e);
+    constr->setTag(tagId);
+    return addConstraint(constr);   
+}
+
 int System::addConstraintArcOfEllipseRules(ArcOfEllipse &a, int tagId)
 {
     addConstraintCurveValue(a.start,a,a.startAngle, tagId);

src/Mod/Sketcher/App/planegcs/GCS.h

@@ -182,6 +182,7 @@ namespace GCS
         int addConstraintPointOnCircle(Point &p, Circle &c, int tagId=0);
         int addConstraintPointOnEllipse(Point &p, Ellipse &e, int tagId=0);
         int addConstraintPointOnHyperbolicArc(Point &p, ArcOfHyperbola &e, int tagId=0);
+	int addConstraintPointOnParabolicArc(Point &p, ArcOfParabola &e, int tagId=0);
         int addConstraintArcOfEllipseRules(ArcOfEllipse &a, int tagId=0);
         int addConstraintCurveValue(Point &p, Curve &a, double *u, int tagId=0);
         int addConstraintArcOfHyperbolaRules(ArcOfHyperbola &a, int tagId=0);