solvespace/drawconstraint.cpp

#include "solvespace.h"

bool Constraint::HasLabel(void) {
    switch(type) {
        case PT_LINE_DISTANCE:
        case PT_PLANE_DISTANCE:
        case PT_PT_DISTANCE:
        case DIAMETER:
            return true;

        default:
            return false;
    }
}

void Constraint::LineDrawOrGetDistance(Vector a, Vector b) {
    if(dogd.drawing) {
        glBegin(GL_LINE_STRIP);
            glxVertex3v(a);
            glxVertex3v(b);
        glEnd();
    } else {
        Point2d ap = SS.GW.ProjectPoint(a);
        Point2d bp = SS.GW.ProjectPoint(b);

        double d = dogd.mp.DistanceToLine(ap, bp.Minus(ap), true);
        dogd.dmin = min(dogd.dmin, d);
    }
}

double Constraint::EllipticalInterpolation(double rx, double ry, double theta) {
    double ex = rx*cos(theta);
    double ey = ry*sin(theta);
    double v = sqrt(ex*ex + ey*ey);

    return v;
}

void Constraint::DoLabel(Vector ref, Vector *labelPos, Vector gr, Vector gu) {
    char *s = exprA->Print();
    if(labelPos) {
        // labelPos is from the top left corner (for the text box used to
        // edit things), but ref is from the center.
        *labelPos = ref.Minus(gr.WithMagnitude(glxStrWidth(s)/2)).Minus(
                             gu.WithMagnitude(glxStrHeight()/2));
    }

    if(dogd.drawing) {
        glPushMatrix();
            glxTranslatev(ref);
            glxOntoWorkplane(gr, gu);
            glxWriteTextRefCenter(s);
        glPopMatrix();
    } else {
        Point2d o = SS.GW.ProjectPoint(ref);
        dogd.dmin = min(dogd.dmin, o.DistanceTo(dogd.mp) - 10);
    }
}

void Constraint::DoProjectedPoint(Vector *r) {
    Vector p = r->ProjectInto(workplane);
    glLineStipple(4, 0x5555);
    glEnable(GL_LINE_STIPPLE);
    LineDrawOrGetDistance(p, *r);
    glDisable(GL_LINE_STIPPLE);
    *r = p;
}

void Constraint::DrawOrGetDistance(Vector *labelPos) {
    if(!SS.GW.showConstraints) return;
    Group *g = SS.GetGroup(group);
    // If the group is hidden, then the constraints are hidden and not
    // able to be selected.
    if(!(g->visible)) return;
    // And likewise if the group is not the active group.
    if(g->h.v != SS.GW.activeGroup.v) return;

    // Unit vectors that describe our current view of the scene. One pixel
    // long, not one actual unit.
    Vector gr = SS.GW.projRight.ScaledBy(1/SS.GW.scale);
    Vector gu = SS.GW.projUp.ScaledBy(1/SS.GW.scale);
    Vector gn = (gr.Cross(gu)).WithMagnitude(1/SS.GW.scale);

    glxColor3d(1, 0.2, 1);
    switch(type) {
        case PT_PT_DISTANCE: {
            Vector ap = SS.GetEntity(ptA)->PointGetNum();
            Vector bp = SS.GetEntity(ptB)->PointGetNum();

            if(workplane.v != Entity::FREE_IN_3D.v) {
                DoProjectedPoint(&ap);
                DoProjectedPoint(&bp);
            }

            Vector ref = ((ap.Plus(bp)).ScaledBy(0.5)).Plus(disp.offset);

            Vector ab   = ap.Minus(bp);
            Vector ar   = ap.Minus(ref);
            // Normal to a plan containing the line and the label origin.
            Vector n    = ab.Cross(ar);
            Vector out  = ab.Cross(n).WithMagnitude(1);
            out = out.ScaledBy(-out.Dot(ar));

            LineDrawOrGetDistance(ap, ap.Plus(out));
            LineDrawOrGetDistance(bp, bp.Plus(out));

            DoLabel(ref, labelPos, gr, gu);
            break;
        }

        case PT_PLANE_DISTANCE: {
            Vector pt = SS.GetEntity(ptA)->PointGetNum();
            Entity *plane = SS.GetEntity(entityA);
            Vector n = plane->Normal()->NormalN();
            Vector p = plane->WorkplaneGetOffset();
            double d = (p.Minus(pt)).Dot(n);

            Vector closest = pt.Plus(n.WithMagnitude(d));
            LineDrawOrGetDistance(pt, closest);

            Vector ref = ((closest.Plus(pt)).ScaledBy(0.5)).Plus(disp.offset);
            DoLabel(ref, labelPos, gr, gu);
            break;
        }

        case PT_LINE_DISTANCE: {
            Vector pt = SS.GetEntity(ptA)->PointGetNum();
            Entity *line = SS.GetEntity(entityA);
            Vector lA = SS.GetEntity(line->point[0])->PointGetNum();
            Vector lB = SS.GetEntity(line->point[1])->PointGetNum();

            if(workplane.v != Entity::FREE_IN_3D.v) {
                lA = lA.ProjectInto(workplane);
                lB = lB.ProjectInto(workplane);
                DoProjectedPoint(&pt);
            }

            Vector lAB = (lA.Minus(lB)).WithMagnitude(1);
            Vector closest;
            // lA, lB, and pt define a plane; the min distance is in
            // that plane, so calculate its normal
            Vector pn = (pt.Minus(lA)).Cross(lAB);
            // The minimum distance line is in that plane, perpendicular
            // to the line
            Vector n = pn.Cross(lAB);

            // Calculate the actual distance
            double d = (lAB.Cross(lA.Minus(pt))).Magnitude();
            closest = pt.Plus(n.WithMagnitude(d));
            
            LineDrawOrGetDistance(pt, closest);
            Vector ref = ((closest.Plus(pt)).ScaledBy(0.5)).Plus(disp.offset);
            DoLabel(ref, labelPos, gr, gu);
            break;
        }

        case DIAMETER: {
            Entity *circle = SS.GetEntity(entityA);
            Vector center = SS.GetEntity(circle->point[0])->PointGetNum();
            double r = SS.GetEntity(circle->distance)->DistanceGetNum();
            Vector ref = center.Plus(disp.offset);

            double theta = atan2(disp.offset.Dot(gu), disp.offset.Dot(gr));
            double adj = EllipticalInterpolation(
                glxStrWidth(exprA->Print())/2, glxStrHeight()/2, theta);

            Vector mark = ref.Minus(center);
            mark = mark.WithMagnitude(mark.Magnitude()-r);
            LineDrawOrGetDistance(ref.Minus(mark.WithMagnitude(adj)),
                                  ref.Minus(mark));

            DoLabel(ref, labelPos, gr, gu);
            break;
        }

        case POINTS_COINCIDENT: {
            if(!dogd.drawing) {
                for(int i = 0; i < 2; i++) {
                    Vector p = SS.GetEntity(i == 0 ? ptA : ptB)-> PointGetNum();
                    Point2d pp = SS.GW.ProjectPoint(p);
                    // The point is selected within a radius of 7, from the
                    // same center; so if the point is visible, then this
                    // constraint cannot be selected. But that's okay.
                    dogd.dmin = min(dogd.dmin, pp.DistanceTo(dogd.mp) - 3);
                }
                break;
            }

            for(int a = 0; a < 2; a++) {
                Vector r = SS.GW.projRight.ScaledBy((a+1)/SS.GW.scale);
                Vector d = SS.GW.projUp.ScaledBy((2-a)/SS.GW.scale);
                for(int i = 0; i < 2; i++) {
                    Vector p = SS.GetEntity(i == 0 ? ptA : ptB)-> PointGetNum();
                    glxColor3d(0.4, 0, 0.4);
                    glBegin(GL_QUADS);
                        glxVertex3v(p.Plus (r).Plus (d));
                        glxVertex3v(p.Plus (r).Minus(d));
                        glxVertex3v(p.Minus(r).Minus(d));
                        glxVertex3v(p.Minus(r).Plus (d));
                    glEnd();
                }

            }
            break;
        }

        case PT_ON_CIRCLE:
        case PT_ON_LINE:
        case PT_IN_PLANE: {
            double s = 7/SS.GW.scale;
            Vector p = SS.GetEntity(ptA)->PointGetNum();
            Vector r = gr.WithMagnitude(s);
            Vector d = gu.WithMagnitude(s);
            LineDrawOrGetDistance(p.Plus (r).Plus (d), p.Plus (r).Minus(d));
            LineDrawOrGetDistance(p.Plus (r).Minus(d), p.Minus(r).Minus(d));
            LineDrawOrGetDistance(p.Minus(r).Minus(d), p.Minus(r).Plus (d));
            LineDrawOrGetDistance(p.Minus(r).Plus (d), p.Plus (r).Plus (d));
            break;
        }

        case EQUAL_LENGTH_LINES: {
            for(int i = 0; i < 2; i++) {
                Entity *e = SS.GetEntity(i == 0 ? entityA : entityB);
                Vector a = SS.GetEntity(e->point[0])->PointGetNum();
                Vector b = SS.GetEntity(e->point[1])->PointGetNum();
                Vector m = (a.ScaledBy(1.0/3)).Plus(b.ScaledBy(2.0/3));
                Vector ab = a.Minus(b);
                Vector n = (gn.Cross(ab)).WithMagnitude(10/SS.GW.scale);
                
                LineDrawOrGetDistance(m.Minus(n), m.Plus(n));
            }
            break;
        }

        case SYMMETRIC: {
            Vector a = SS.GetEntity(ptA)->PointGetNum();
            Vector b = SS.GetEntity(ptB)->PointGetNum();
            Vector n = SS.GetEntity(entityA)->Normal()->NormalN();
            for(int i = 0; i < 2; i++) {
                Vector tail = (i == 0) ? a : b;
                Vector d = (i == 0) ? b : a;
                d = d.Minus(tail);
                // Project the direction in which the arrow is drawn normal
                // to the symmetry plane; for projected symmetry constraints,
                // they might not be in the same direction, even when the
                // constraint is fully solved.
                d = n.ScaledBy(d.Dot(n));
                d = d.WithMagnitude(20/SS.GW.scale);
                Vector tip = tail.Plus(d);

                LineDrawOrGetDistance(tail, tip);
                d = d.WithMagnitude(9/SS.GW.scale);
                LineDrawOrGetDistance(tip, tip.Minus(d.RotatedAbout(gn,  0.6)));
                LineDrawOrGetDistance(tip, tip.Minus(d.RotatedAbout(gn, -0.6)));
            }
            break;
        }

        case AT_MIDPOINT:
        case HORIZONTAL:
        case VERTICAL:
            if(entityA.v) {
                Vector r, u, n;
                if(workplane.v == Entity::FREE_IN_3D.v) {
                    r = gr; u = gu; n = gn;
                } else {
                    r = SS.GetEntity(workplane)->Normal()->NormalU();
                    u = SS.GetEntity(workplane)->Normal()->NormalV();
                    n = r.Cross(u);
                }
                // For "at midpoint", this branch is always taken.
                Entity *e = SS.GetEntity(entityA);
                Vector a = SS.GetEntity(e->point[0])->PointGetNum();
                Vector b = SS.GetEntity(e->point[1])->PointGetNum();
                Vector m = (a.ScaledBy(0.5)).Plus(b.ScaledBy(0.5));
                Vector offset = (a.Minus(b)).Cross(n);
                offset = offset.WithMagnitude(13/SS.GW.scale);
                // Draw midpoint constraint on other side of line, so that
                // a line can be midpoint and horizontal at same time.
                if(type == AT_MIDPOINT) offset = offset.ScaledBy(-1);

                if(dogd.drawing) {
                    glPushMatrix();
                        glxTranslatev(m.Plus(offset));
                        glxOntoWorkplane(r, u);
                        glxWriteTextRefCenter(
                            (type == HORIZONTAL)  ? "H" : (
                            (type == VERTICAL)    ? "V" : (
                            (type == AT_MIDPOINT) ? "M" : NULL)));
                    glPopMatrix();
                } else {
                    Point2d ref = SS.GW.ProjectPoint(m.Plus(offset));
                    dogd.dmin = min(dogd.dmin, ref.DistanceTo(dogd.mp)-10);
                }
            } else {
                Vector a = SS.GetEntity(ptA)->PointGetNum();
                Vector b = SS.GetEntity(ptB)->PointGetNum();

                Entity *w = SS.GetEntity(SS.GetEntity(ptA)->workplane);
                Vector cu = w->Normal()->NormalU();
                Vector cv = w->Normal()->NormalV();
                Vector cn = w->Normal()->NormalN();

                int i;
                for(i = 0; i < 2; i++) {
                    Vector o = (i == 0) ? a : b;
                    Vector oo = (i == 0) ? a.Minus(b) : b.Minus(a);
                    Vector d = (type == HORIZONTAL) ? cu : cv;
                    if(oo.Dot(d) < 0) d = d.ScaledBy(-1);

                    Vector dp = cn.Cross(d);
                    d = d.WithMagnitude(14/SS.GW.scale);
                    Vector c = o.Minus(d);
                    LineDrawOrGetDistance(o, c);
                    d = d.WithMagnitude(3/SS.GW.scale);
                    dp = dp.WithMagnitude(2/SS.GW.scale);
                    if(dogd.drawing) {
                        glBegin(GL_QUADS);
                            glxVertex3v((c.Plus(d)).Plus(dp));
                            glxVertex3v((c.Minus(d)).Plus(dp));
                            glxVertex3v((c.Minus(d)).Minus(dp));
                            glxVertex3v((c.Plus(d)).Minus(dp));
                        glEnd();
                    } else {
                        Point2d ref = SS.GW.ProjectPoint(c);
                        dogd.dmin = min(dogd.dmin, ref.DistanceTo(dogd.mp)-6);
                    }
                }
            }
            break;

        default: oops();
    }
}

void Constraint::Draw(void) {
    dogd.drawing = true;
    DrawOrGetDistance(NULL);
}

double Constraint::GetDistance(Point2d mp) {
    dogd.drawing = false;
    dogd.mp = mp;
    dogd.dmin = 1e12;

    DrawOrGetDistance(NULL);
    
    return dogd.dmin;
}

Vector Constraint::GetLabelPos(void) {
    dogd.drawing = false;
    dogd.mp.x = 0; dogd.mp.y = 0;
    dogd.dmin = 1e12;

    Vector p;
    DrawOrGetDistance(&p);
    return p;
}