#include "solvespace.h"

const hConstraint ConstraintBase::NO_CONSTRAINT = { 0 };

bool ConstraintBase::HasLabel(void) {

}

Expr *ConstraintBase::VectorsParallel(int eq, ExprVector a, ExprVector b) {

ExprVector r = a.Cross(b);

// Hairy ball theorem screws me here. There's no clean solution that I

// know, so let's pivot on the initial numerical guess. Our caller

// has ensured that if one of our input vectors is already known (e.g.

// it's from a previous group), then that one's in a; so that one's

// not going to move, and we should pivot on that one.

double mx = fabs((a.x)->Eval());

double my = fabs((a.y)->Eval());

double mz = fabs((a.z)->Eval());

// The basis vector in which the vectors have the LEAST energy is the

// one that we should look at most (e.g. if both vectors lie in the xy

// plane, then the z component of the cross product is most important).

// So find the strongest component of a and b, and that's the component

// of the cross product to ignore.

Expr *e0, *e1;

if(mx > my && mx > mz) {

e0 = r.y; e1 = r.z;

} else if(my > mz) {

e0 = r.z; e1 = r.x;

} else {

e0 = r.x; e1 = r.y;

}

if(eq == 0) return e0;

if(eq == 1) return e1;

oops();

}

Expr *ConstraintBase::PointLineDistance(hEntity wrkpl, hEntity hpt, hEntity hln)

{

EntityBase *ln = SK.GetEntity(hln);

EntityBase *a = SK.GetEntity(ln->point[0]);

EntityBase *b = SK.GetEntity(ln->point[1]);

EntityBase *p = SK.GetEntity(hpt);

if(wrkpl.v == EntityBase::FREE_IN_3D.v) {

ExprVector ep = p->PointGetExprs();

ExprVector ea = a->PointGetExprs();

ExprVector eb = b->PointGetExprs();

ExprVector eab = ea.Minus(eb);

Expr *m = eab.Magnitude();

return ((eab.Cross(ea.Minus(ep))).Magnitude())->Div(m);

} else {

Expr *ua, *va, *ub, *vb;

a->PointGetExprsInWorkplane(wrkpl, &ua, &va);

b->PointGetExprsInWorkplane(wrkpl, &ub, &vb);

Expr *du = ua->Minus(ub);

Expr *dv = va->Minus(vb);

Expr *u, *v;

p->PointGetExprsInWorkplane(wrkpl, &u, &v);

Expr *m = ((du->Square())->Plus(dv->Square()))->Sqrt();

Expr *proj = (dv->Times(ua->Minus(u)))->Minus(

(du->Times(va->Minus(v))));

return proj->Div(m);

}

}

Expr *ConstraintBase::PointPlaneDistance(ExprVector p, hEntity hpl) {

ExprVector n;

Expr *d;

SK.GetEntity(hpl)->WorkplaneGetPlaneExprs(&n, &d);

return (p.Dot(n))->Minus(d);

}

Expr *ConstraintBase::Distance(hEntity wrkpl, hEntity hpa, hEntity hpb) {

EntityBase *pa = SK.GetEntity(hpa);

EntityBase *pb = SK.GetEntity(hpb);

if(!(pa->IsPoint() && pb->IsPoint())) oops();

if(wrkpl.v == EntityBase::FREE_IN_3D.v) {

// This is true distance

ExprVector ea, eb, eab;

ea = pa->PointGetExprs();

eb = pb->PointGetExprs();

eab = ea.Minus(eb);

return eab.Magnitude();

} else {

// This is projected distance, in the given workplane.

Expr *au, *av, *bu, *bv;

pa->PointGetExprsInWorkplane(wrkpl, &au, &av);

pb->PointGetExprsInWorkplane(wrkpl, &bu, &bv);

Expr *du = au->Minus(bu);

Expr *dv = av->Minus(bv);

return ((du->Square())->Plus(dv->Square()))->Sqrt();

}

}

Expr *ConstraintBase::DirectionCosine(hEntity wrkpl,

ExprVector ae, ExprVector be)

{

if(wrkpl.v == EntityBase::FREE_IN_3D.v) {

Expr *mags = (ae.Magnitude())->Times(be.Magnitude());

return (ae.Dot(be))->Div(mags);

} else {

EntityBase *w = SK.GetEntity(wrkpl);

ExprVector u = w->Normal()->NormalExprsU();

ExprVector v = w->Normal()->NormalExprsV();

Expr *ua = u.Dot(ae);

Expr *va = v.Dot(ae);

Expr *ub = u.Dot(be);

Expr *vb = v.Dot(be);

Expr *maga = (ua->Square()->Plus(va->Square()))->Sqrt();

Expr *magb = (ub->Square()->Plus(vb->Square()))->Sqrt();

Expr *dot = (ua->Times(ub))->Plus(va->Times(vb));

return dot->Div(maga->Times(magb));

}

}

ExprVector ConstraintBase::PointInThreeSpace(hEntity workplane,

}

void ConstraintBase::ModifyToSatisfy(void) {

}

void ConstraintBase::AddEq(IdList<Equation,hEquation> *l, Expr *expr, int index)

}

void ConstraintBase::Generate(IdList<Equation,hEquation> *l) {

}

void ConstraintBase::GenerateReal(IdList<Equation,hEquation> *l) {

}