// a point
class Point  {
  float x=0, y=0, z=0;
  int pcolor=255;
  int[] rgb = new int[3];
  boolean isRGB;
  String txtID="txt";
  int focus=PLAN;
  
  Line on_line_1, on_line_2;
  Line on_lineZ_1, on_lineZ_2;
  Point[] children;
  
  // *** constructors ***
  Point()  {}
  Point(float xc)  {
    x = xc;
  }
  Point(float xc, float yc)  {
    x = xc;
    y = yc;
  }
  Point(float xc, float yc, String id)  {
    x = xc;
    y = yc;
    txtID = id;
  }
  Point( float xc, float yc, float zc )  {
    x = xc;
    y = yc;
    z = zc;
  }
  Point( float xc, float yc, float zc, String id )  {
    x = xc;
    y = yc;
    z = zc;
    txtID = id;
  }
  // *** accessors ***
  public void X(float xc)  {  
    x = xc;
    NotifyChildren();
  }
  public void Y(float yc)  {  
    y = yc;
    NotifyChildren();
  }
  public void Z(float zc)  {  
    z = zc;
    NotifyChildren();
  }
  public void setColor(int c)  {
    isRGB = false;
    pcolor = c;
  }
  public void setColor(int r, int g, int b)  {
    isRGB = true;
    rgb[0] = r;
    rgb[1] = g;
    rgb[2] = b;
  }
  // *** methods ***
  public void drawPoint()  {
    if (isRGB)  {
      fill(rgb[0], rgb[1], rgb[2]);
    } else  {  fill(pcolor);  }
    noStroke();
    rect(x, y, 4, 4);
    rect(x, z, 4, 4);
  }
  
  public void onLines(Line l1, Line l2)  {
    on_line_1 = l1;
    on_line_2 = l2;
  }
  public void onLinesZ(Line l1, Line l2)  {
    on_lineZ_1 = l1;
    on_lineZ_2 = l2;
  }
  
  // event handlers
  void NotifyChildren()  {
    if (children.length == 0)  {return;}
    for (int i=0; i<children.length; i++)  {
      children[i].updatePosition();
    }
  }
  void updatePosition()  {
    X(on_line_1.getIntersect(on_line_2));
    Y(on_line_1.getY(x));
    Z(on_line_1.getZ(x));
  }
  void reposition(float mX, float mY)  {
    // construct perpendicular line between new point and dependent line 1
    // in order to measure distance between the two 
    on_line_1.getSlopeY(); // get the slope of the line in plan
    float yint = mY - (-1/on_line_1.slope_y * mX); // get Y intercept of new line [perp to dependent line]
    Point mP = new Point(mX, mY); // new position of the point
    Line mL = new Line(mP, new Point(0,yint)); // new line between new point and old line
    Point line1_p = new Point(on_line_1.getIntersect(mL), on_line_1.getY(x)); // new point at intersection of dependent line and perp line
    
    // do the same for dependent line 2
    on_line_2.getSlopeY(); // get the Y intercept of line 2
    yint = mY - (-1/on_line_2.slope_y*mX);
    Line mL2 = new Line(mP, new Point(0,yint));
    Point line2_p = new Point (on_line_2.getIntersect(mL2), on_line_2.getY(x));
    
    // figure out which dep line the new point is closer to and reposition accordingly
    if (mP.getDist(line1_p) < mP.getDist(line2_p))  { // closer to depndent line 1
      X(line1_p.x);
      Y(line1_p.y);
      repoLine(on_line_2, line1_p); //reposition the other dependent line according to adjusted point position
    } else  {
      X(line2_p.x);
      Y(line2_p.y);
      repoLine(on_line_1, line2_p); // closer to dependent line 2
    }
  }
  
  // take base points in elevation view and slide them on X axis ONLY, reposition dependent points accordingly
  // NB: unclear if this is preferable to having points adjust on Y axis so dependent points are affected
  // as little as possible
  void slideX(float mX)  {
    Point mP = new Point(mX, y);
    repoLine(on_line_1, mP);
    repoLine(on_line_2, mP);
  }
  
  void repositionZ(float mX, float mZ)  {
    // construct perpendicular line between new point and dependent line 1
    // in order to measure distance between the two 
    on_lineZ_1.getSlopeZ(); // get the slope of the dependent line in plan
    float yint = mZ - (-1/on_lineZ_1.slope_z * mX); // get Y intercept of new line [perp to dependent line]
    Point mP = new Point(mX,0, mZ); // new position of the point
    Line mL = new Line(mP, new Point(0,0,yint), ELEVATION); // new line between new point and old line
    Point line1_p = new Point(on_lineZ_1.getIntersectZ(mL), 0, on_lineZ_1.getZ(x)); // new point at intersection of dependent line and perp line
    
    // do the same for dependent line 2
    on_lineZ_2.getSlopeZ(); // get the Y intercept of line 2
    yint = mZ - (-1/on_lineZ_2.slope_z*mX);
    Line mL2 = new Line(mP, new Point(0,0,yint), ELEVATION);
    Point line2_p = new Point (on_lineZ_2.getIntersectZ(mL2), 0, on_lineZ_2.getZ(x));
    
    // figure out which dep line the new point is closer to and reposition accordingly
    if (mP.getDistZ(line1_p) < mP.getDistZ(line2_p))  { // closer to depndent line 1
      X(line1_p.x);
      Z(line1_p.z);
      repoLineZ(on_lineZ_2, line1_p); //reposition the other dependent line according to adjusted point position
    } else  { // closer to dependent line 2
      X(line2_p.x);
      Z(line2_p.z);
      repoLineZ(on_lineZ_1, line2_p); 
    }
  }
  
  void repoLine(Line l, Point newP)  {
    // figure out which line the point lands on that you're not dealing with
    Line nL = (l == l.end.on_line_1) ? l.end.on_line_2 : l.end.on_line_1;
    // make a temporary new regulating line
    Line newL = new Line(l.start, newP);
    // reposition existing line to where new line and the not-line intersect
    l.end.X(newL.getIntersect(nL));
    l.end.Y(nL.getY(l.end.x));
  }
  
  void repoLineZ(Line l, Point newP)  {
    // figure out which line the point lands on that you're not dealing with
    Line nL = (l == l.end.on_lineZ_1) ? l.end.on_lineZ_2 : l.end.on_lineZ_1;
    // make a temporary new regulating line
    Line newL = new Line(l.start, newP, ELEVATION);
    // reposition existing line to where new line and the not-line intersect
    l.end.X(newL.getIntersectZ(nL));
    l.end.Z(nL.getZ(l.end.x));
  }
  
  float getDist(Point p)  {
    return dist( x, y, p.x, p.y);
  }
  float getDistZ(Point p)  {
    return dist(x,z, p.x, p.z);
  }
  
  void initChildren(Point p1)  {
    children = new Point[1];
    children[0] = p1;
  }
  void initChildren(Point p1, Point p2)  {
    children = new Point[2];
    children[0] = p1;
    children[1] = p2;
  }
  void rotateAbout(Point o, float theta)  {
    float a = x - o.x;
    float b = y - o.y;
    float c = dist(x, y, o.x, o.y);
    float alph = atan(b / a);
    float beta = alph + theta ;
    //String pr = alph + ", " + beta;
    //println(pr);
    
    if (alph*beta < 0)  { // check the quadrant
      beta+=PI;
    }
    
    x = o.x + (cos(beta) * c);
    y = o.y + (sin(beta) * c);
  }
}

// a base line point -- a point that lives on the baselines
class BLinePoint extends Point {

  BLinePoint( int xc, Line l_1, Line l_2, String id )  {
    x = xc;
    on_line_1 = l_1;
    on_line_2 = l_2;
    z = on_line_1.getY(x);
    y = on_line_2.getY(x);
    txtID = id;
  }    
  
  public void X(float xc)  {
    x = xc;
    z = on_line_1.getY(x);
    y = on_line_2.getY(x);
    NotifyChildren();
  }
  
  public void drawPoint()  {
    if (isRGB)  {
      fill(rgb[0], rgb[1], rgb[2]);
    } else  {  fill(pcolor);  }
    noStroke();
    rect(x, z, 4,4);
    rect(x, y, 4,4);
  }
  
  void updatePosition()  {
    Z(on_line_1.getY(x));
    Y(on_line_2.getY(x));
  }
    
}

// a line, construct with two endpoints
class Line {
  Point start, end;
  int lcolor=255;
  int[] rgb;
  float slope_y, slope_z, slope_normal;
  float y_int, z_int;
  boolean isRGB;
  int plane = PLAN;
  
  // *** constructors ***
  Line(Point s, Point e)  {
    start = s;
    end = e;
  }
  Line(Point s, Point e, int pl)  {
    start = s;
    end = e;
    plane = pl;
  }
  
  // *** accessors ***
  public void setStart(Point s)  {
    start = s;
  }
  public void setEnd(Point e)  {
    end = e;
  }
  public void setColor(int c)  {
    isRGB = false;
    lcolor = c;
  }
  public void setColor(int a, int b, int c)  {
    isRGB = true;
    rgb = new int[3];
    rgb[0] = a;
    rgb[1] = b;
    rgb[2] = c;
  }
  
  // *** methods ***  
  // draw this line
  public void drawLine()  {
    if (isRGB) { stroke(rgb[0],rgb[1],rgb[2]); }
    else  { stroke(lcolor); }
    noFill();
    if (plane == PLAN)  {
      line(start.x, start.y, end.x, end.y);
    }
    else   {
      line(start.x, start.z, end.x, end.z);
    }
  }
  public float getX(float y)  {
    float s = (end.y-start.y)/(end.x-start.x);
    float y_i = start.y - s*start.x;
    return (y - y_i)/s;
  }
  // get y coordinate given x coordinate
  public float getY(float x)  {
    getSlopeY();
    getYInt();
    return (slope_y*x) + y_int;
  }
  public float getZ(float x)  {
    getSlopeZ();
    getZInt();
    return (slope_z*x) + z_int;
  }
  // find x coordinate of intersection with another line
  public float getIntersect(Line l)  {
    getSlopeY();
    l.getSlopeY();
    getYInt();
    l.getYInt();
    return (l.y_int - y_int)/(slope_y - l.slope_y);
  }
  public float getIntersectZ(Line l)  {
    getSlopeZ();
    l.getSlopeZ();
    getZInt();
    l.getZInt();
    return (l.z_int - z_int)/(slope_z - l.slope_z);
  }
  
  void getSlopeY()  {
    // avoid Divide by Zero situations
    if (end.x == start.x)  {
      slope_y = 0;
      slope_normal = 0;
    }  else  {
      slope_y = (end.y-start.y)/(end.x-start.x);
      slope_normal = -1/slope_y;
    }
  }
  void getYInt()  {
    y_int = start.y - (slope_y*start.x);
  }
  void getSlopeZ()  {
    slope_z = (end.z-start.z)/(end.x-start.x);
  }
  void getZInt()  {
    z_int = start.z - (slope_z*start.x);
  }
  
  // functions to unfold the shape
  Point unfoldPt(Point p, Point pivot)  {
    // first rotate down to elevation baseline
    float d = p.getDistZ(pivot);
    Point p_pri = new Point(pivot.x+d, p.y, 0);
    
    // next construct line perp to axis through pivot
    getSlopeY();
    float y_i = p.y - (-1/slope_y)*p.x;
    Line perp = new Line(p, new Point(0,y_i));
    perp.start = new Point(width, perp.getY(width));
    //perp.setColor(50);
    //perp.drawLine();
  
    // now find intersect of arc with center at pivot and through p_pri and line perp
    d = pivot.getDist(p_pri); // radius
    perp.getSlopeY();
    perp.getYInt();
    float x_1 = (-(2*perp.slope_y*(perp.y_int - pivot.y) - 2*pivot.x) +
        sqrt( sq(2*perp.slope_y*(perp.y_int - pivot.y) - 2*pivot.x) - 
            4*(sq(perp.slope_y) + 1) * (sq(pivot.x) + sq(perp.y_int - pivot.y) - d*d) )) /
        (2 * sq(perp.slope_y) + 2);
    float x_2 = (-(2*perp.slope_y*(perp.y_int - pivot.y) - 2*pivot.x) -
        sqrt( sq(2*perp.slope_y*(perp.y_int - pivot.y) - 2*pivot.x) - 
            4*(sq(perp.slope_y) + 1) * (sq(pivot.x) + sq(perp.y_int - pivot.y) - d*d) )) /
        (2 * sq(perp.slope_y) + 2);
  
    Point temp_1 = new Point(x_1, perp.getY(x_1), 0);
    Point temp_2 = new Point(x_2, perp.getY(x_2), 0);
  
    return ( (centroid.getDist(temp_1) > centroid.getDist(temp_2)) ? temp_1 : temp_2 );
  }
  
  // mirror point across line
  void mirror(Point p)  {
    getSlopeY();
    float y_i = p.y - (-1/slope_y) * p.x;
    Line perp = new Line(p, new Point(0,y_i));
    
    Point mpoint = new Point(getIntersect(perp), getY(getIntersect(perp)));
    p.x = p.x + 2 * (mpoint.x - p.x);
    p.y = p.y + 2 * (mpoint.y - p.y);
  }
}

// regulating lines
class RLine extends Line  {
  boolean isRGB = false;
  int lcolor = 125;
  
  RLine(Point s, Point e)  {
    super(s, e);
    setColor(125);
  }
  RLine(Point s, Point e, int pl)  {
    super(s, e, pl);
    setColor(125);
  }    
}

// a horizontal line
class HLine extends Line  {
  float height;
  HLine(float ypos)  {
    super(new Point(0.0, ypos), new Point(width, ypos));
    height = ypos;
  }
}

// baseline == has moveable endpoints
class BLine extends Line  {
  
  BLine(Point s, Point e)  {
    super(s, e);
    s.setColor(0,155,0);
    e.setColor(0,155,0);
  }
  
  public void drawLine()  {
    if (isRGB) { stroke(rgb[0],rgb[1],rgb[2]); }
    else  { stroke(lcolor); }
    noFill();
    line(start.x, start.y, end.x, end.y);
    start.drawPoint();
    end.drawPoint();
  }
  
  Point unfoldPt(Point p, Point pivot)  {
    // first rotate down to elevation baseline
    float d = p.getDistZ(pivot);
    Point p_pri = new Point(pivot.x+d, p.y, 0);
    
    // next construct line perp to axis through pivot
    getSlopeY();
    float y_i = p.y - (-1/slope_y)*p.x;
    Line perp = new Line(p, new Point(0,y_i));
    perp.start = new Point(width, perp.getY(width));
    //perp.setColor(50);
    //perp.drawLine();
  
    // now find intersect of arc with center at pivot and through p_pri and line perp
    d = pivot.getDist(p_pri); // radius
    perp.getSlopeY();
    perp.getYInt();
    float x_1 = (-(2*perp.slope_y*(perp.y_int - pivot.y) - 2*pivot.x) +
        sqrt( sq(2*perp.slope_y*(perp.y_int - pivot.y) - 2*pivot.x) - 
            4*(sq(perp.slope_y) + 1) * (sq(pivot.x) + sq(perp.y_int - pivot.y) - d*d) )) /
        (2 * sq(perp.slope_y) + 2);
    float x_2 = (-(2*perp.slope_y*(perp.y_int - pivot.y) - 2*pivot.x) -
        sqrt( sq(2*perp.slope_y*(perp.y_int - pivot.y) - 2*pivot.x) - 
            4*(sq(perp.slope_y) + 1) * (sq(pivot.x) + sq(perp.y_int - pivot.y) - d*d) )) /
        (2 * sq(perp.slope_y) + 2);
  
    Point temp_1 = new Point(x_1, perp.getY(x_1), 0);
    Point temp_2 = new Point(x_2, perp.getY(x_2), 0);
  
    return ( (p_pri.getDist(temp_1) < p_pri.getDist(temp_2)) ? temp_1 : temp_2 );
  }
}