## 2007-11-06

### Plane Geometry in Java (III)

See also Part I and Part II.

Now that we have vectors and points, I can show how a line on the plane can be implemented:

```final class Line {
public final Pt p;
public final Vec v;

public Line(Pt p, Vec v) {
if (p == null || v == null)
throw new IllegalArgumentException("Arguments cannot be null");
this.p = p;
this.v = v;
}

public boolean equals(Object o) {
if (o == null || !(o instanceof Line)) return false;
else if (this == o) return true;
final Line that = (Line) o;
return this.p.equals(that.p) && this.v.equals(that.v);
}

public int hashCode() {
return 127 * p.hashCode() + v.hashCode();
}

public String toString() {
return String.format("%s-->%s", p, v);
}
```

A difference with previous value classes is that we must make sure that a `Line` is properly constructed with actual values; other than that, the implementation is unsurprising. A basic property of a line is its slope:

```  public double slope()            { return v.arg(); }
```

Given two lines, we might want to know whether they are parallel or perpendicular:

```  private static final double EPSILON = 1e-11;

public boolean isPerpendicular(Line l) {
return Math.abs(v.dot(l.v)) < EPSILON;
}

public boolean isParallel(Line l) {
return isPerpendicular(l.perp(l.p));
}
```

This is necessarily an approximation, since it involves a subtraction. In any case, the angle between two lines is the angle between its respective direction vectors:

```  public double angle(Line l)      { return v.angle(l.v); }
```

Our first construction on lines gives the perpendicular through a given point:

```  public Line perp(Pt q)           { return new Line(q, v.perp()); }
```

In particular, the median between to points is the perpendicular to the line comprising both and passing through their midpoint:

```  public static Line median(Pt p, Pt q) {
return p.through(q).perp(p.mid(q));
}
```

Note how the definition formalizes the English description. The second, fundamental construction is the intersection point between two lines:

```  public Pt meet(Line l) {
final Vec u = l.v.perp();
return p.at(v.scale(u.dot(p.to(l.p)) / u.dot(v)));
}
```

This is a direct translation of Property 20. If the lines are parallel, `u.dot(v)` is zero and the division gives the point at infinity. Another usual construction is to find the foot of a point on a given line; that is, the nearest point to it on the line:

```  public Pt foot(Pt q) {
final Vec u = v.unit();
return p.at(u.scale(u.dot(p.to(q))));
}
```

To test whether two segments (that is, the subset of the line comprised between the base point and its translate by the direction vector) intersect, check if the quadrilateral formed by said points is convex or not:

```  public boolean meets(Line l) {
final Vec u = l.v.perp();
final Vec w = p.to(l.p);
final double r = u.dot(w);
final double s = v.perp().dot(w);
final double t = u.dot(v);
return 0 <= r && r <= t && 0 <= s && s <= t;
}
```

Sometimes is useful to specify a line in implicit form, as ax + by + c = 0. This constructor does so:

```  public static Line implicit(double a, double b, double c) {
final Pt p = b != 0 ? new Pt(0, c / b) : new Pt(c / a, 0);
final Vec v = b > 0 ? new Vec(b, -a) : new Vec(-b, a);
return new Line(p, v);
}
```

Conversely, the implicit coefficients of a line can be retrieved with:

```  public double[] coeffs() {
final Vec u = v.perp();
return new double[] { u.i, u.j, -u.dot(p.to(Pt.ORIGIN)) };
}
}
```

Now we have everything in place to program simple Plane Geometry constructions. For instance, we can check that the altitudes of a triangle meet at a point. First, it is convenient to have a way to produce triangles that checks for us that we passed sensible values:

```public class Geom {
static Pt[] triangle(double a, double b, double c) {
double t;
if (a < b) { t = a; a = b; b = t; }
if (b < c) { t = b; b = c; c = t; }
if (a < b) { t = a; a = b; b = t; }
// Now a >= b >= c
if (a >= b + c)
throw new IllegalArgumentException("Unsatisfied triangle inequality");
```

Our triangle will have the origin as its first vertex, its second vertex on the positive x-axis, and the third on the first quadrant. To find the latter, a simple system of equations involving the Pythagorean Theorem suffices:

```    final double x = 0.5 * (a * a + (b + c) * (b - c))/a;
final double y = Math.sqrt(b * b - x * x);
return new Pt[] { Pt.ORIGIN, new Pt(a, 0), new Pt(x, y) };
}
```

Since we have to find the three altitudes, another utility function will save repetition. This one-liner reads exactly as a mathematical description:

```  static Line altitude(Pt a, Pt b, Pt c) {
return a.through(b).foot(c).through(c);
}
```

(albeit backwards!) Maybe this justifies writing a `Tri` class? Finally, the test:

```  public static void main(String[] args) {
final Pt[] tri = triangle(3, 6, 8);
final Line u = altitude(tri[0], tri[1], tri[2]);
final Line v = altitude(tri[1], tri[2], tri[0]);
final Line w = altitude(tri[2], tri[0], tri[1]);
final Pt r = u.meet(v);
final Pt s = v.meet(w);
System.out.printf("r = %s, s = %s\nDistance between points: %f\n", r, s, r.dist(s));
}
```

The result shows, as expected, the coincidence of both points of intersection:

```r = (5.68750 , 6.88204), s = (5.68750 , 6.88204)
Distance between points: 0.000000
```