import java.util.*;

class Point {
  public float X;
  public float Y;
  public Point(float x, float y) {
    this.X = x;
    this.Y = y;
  }

  public float getDistance(Point p) {
    return sqrt((float)((p.X-X)*(p.X-X)+(p.Y-Y)*(p.Y-Y)));
  }
}

class Edge {
  public Point Start,End;
  public Edge(Point start, Point end) {
    this.Start = start;
    this.End = end;
  }

  public boolean isEqualTo(Edge e) {
    return (Start.getDistance(e.Start)<epsilon && End.getDistance(e.End)<epsilon)
               || (Start.getDistance(e.End)<epsilon && End.getDistance(e.Start)<epsilon);
  }
}

class Triangle {
  public Edge[] edges;
  public Triangle(Point a, Point b, Point c) {
    edges = new Edge[3];
    edges[0] = new Edge(a, b);
    edges[1] = new Edge(b,c);
    edges[2] = new Edge(a,c);
  }

  public boolean hasCommonVertices(Triangle t) {
    for(Edge e1:t.edges) {
     for(Edge e2:edges) {
       if(e1.Start.getDistance(e2.Start)<epsilon || e1.End.getDistance(e2.End)<epsilon ||
             e1.Start.getDistance(e2.End)<epsilon || e1.End.getDistance(e2.Start)<epsilon)
         return true;
     }
    }
    return false;
  }

  public Point getCircumcircleCenter() {
    Point a = edges[0].Start;
    Point b = edges[0].End;
    Point c = edges[1].End;
    float d = 2.0 * (a.X * (b.Y - c.Y) + b.X * (c.Y - a.Y) + c.X * (a.Y - b.Y));
    float ux = ((a.X * a.X + a.Y * a.Y) * (b.Y - c.Y) + (b.X * b.X + b.Y * b.Y) * (c.Y - a.Y) + (c.X * c.X + c.Y * c.Y) * (a.Y - b.Y)) / d;
    float uy = ((a.X * a.X + a.Y * a.Y) * (c.X - b.X) + (b.X * b.X + b.Y * b.Y) * (a.X - c.X) + (c.X * c.X + c.Y * c.Y) * (b.X - a.X)) / d;
    return new Point(ux, uy);
  }

  public float getRadius() {
    return this.getCircumcircleCenter().getDistance(edges[0].Start);
  }
}

void correctTriangulation(Point p) {
  if(triangles.size() < 1) return;
  List<Triangle> incorrectTriangles = new ArrayList<Triangle>();
  for(Triangle t:triangles) {
    float radius = t.getRadius();
    float distance = t.getCircumcircleCenter().getDistance(p);
    if(distance<radius) {
      incorrectTriangles.add(t);
    }
  }
  for(Triangle t:incorrectTriangles) {
    triangles.remove(t);
  }
  List<Edge> hull = new ArrayList<Edge>();
  boolean contains;
  for(Triangle t:incorrectTriangles) {
    for(Edge e:t.edges) {
      contains = false;
      for(Edge hullEdge:hull) {
        if(hullEdge.isEqualTo(e)) {
          contains = true;
          hull.remove(e);
          hull.remove(hullEdge);
          break;
        }
      }
      if(!contains) {
        hull.add(e);
      }
    }
  }
  for(Edge e:hull) {
    triangles.add(new Triangle(e.Start, e.End, p));
  }
}

void drawTriangles() {
  for(Triangle t:triangles) {
    if(!t.hasCommonVertices(bigOne)) {
      for(Edge e:t.edges) {
        line(e.Start.X, e.Start.Y, e.End.X, e.End.Y);
      }
    }
  }
}

boolean wasReleased = true;
float epsilon = 0.000001;
Triangle bigOne = new Triangle(new Point(10000, 0), new Point(-10000, 10000), new Point(-10000, -10000));
List<Triangle> triangles = new ArrayList<Triangle>();
List<Point> points = new ArrayList<Point>();

void setup() {
  size(640, 360);
  noSmooth();
  fill(126);
  background(102);
  triangles.add(bigOne);
}

void draw() {
  if (mousePressed && wasReleased) {
    background(102);
    wasReleased = false;
    Point p = new Point(mouseX, mouseY);
    points.add(p);
    correctTriangulation(p);
    stroke(255);
  }
  for(Point p1:points) {
    point((int)p1.X, (int)p1.Y);
  }
  drawTriangles();
}

void mouseReleased() {
  wasReleased = true;
}