This post is written as a set of Literate Commits. The goal of this style is to show you how this program came together from beginning to end. Each commit in the project is represented by a section of the article. Click each section’s header to see the commit on Github, or check out the repository and follow along.
Project Setup
The goal of today’s
kata
is to implement a function called pointInPoly. pointInPoly is
called with a polygon represented as a series of points as the first
argument, and a single point at the second argument. Each point is
represented as a set of [x, y] coordinates, where both x and y are
numbers. pointInPoly should return true if the point is within the
defined polygon, and false if it is not.
The kata description points out several assumptions we can make about the inputs: 1) The polygon will be a valid simple polygon. That is, it will have at least three points, none of its edges will cross each other, and exactly two edges will meet at each vertex. 2) In the tests, the point will never fall exactly on an edge of the polygon.
And lastly, although the description never explicitly says so, we’re assuming that the points in the polygon are given in order; each point shares an edge with the next.
This initial commit sets up our initial project.
.babelrc
+{ + "presets": ["es2015"] +}
.gitignore
+node_modules/
package.json
+{ + "main": "index.js", + "scripts": { + "test": "mocha ./test --compilers js:babel-register" + }, + "dependencies": { + "babel-preset-es2015": "^6.9.0", + "babel-register": "^6.9.0", + "chai": "^3.5.0", + "lodash": "^4.12.0", + "mocha": "^2.4.5" + } +}
test/index.js
+import { expect } from "chai"; + +describe("index", function() { + + it("works", function() { + expect(2+2).to.equal(4); + }); + +});
The Simplest Test
The first thing we do when we’re solving a problem like this is to write
a test. Because we’re implementing a function given to us, we already
know what our final interface will look like (pointInPoly), so we can
immediately write a test for it.
Our first test asserts that a point at the origin ([0, 0]) is within a
simple triangle with points at [-1, -1], [1, -1], and [0, 1].
After writing this test, our test suite complains that pointInPoly is
not defined. This is quickly fixed by importing pointInPoly into
our test file and then exporting it from index.js.
After exporting the empty pointInPoly function, the test suite shouts
that it expected undefined to be true. To bring us back to green we
change our new pointInPoly function to return true.
index.js
+export function pointInPoly(poly, point) { + return true; +}
test/index.js
import { expect } from "chai"; +import { pointInPoly } from "../"; -describe("index", function() { +describe("pointInPoly", function() { - it("works", function() { - expect(2+2).to.equal(4); + it("detects a point in a triangle", function() { + let poly = [[-1, -1], [1, -1], [0, 1]]; + expect(pointInPoly(poly, [0, 0])).to.be.true; });
Fleshing Out a Strategy
We knew that our initial pointInPoly solution was incomplete.
Returning true for all cases obviously wasn’t going to work.
But what do we do instead? How do we even begin to tackle this
problem?
Thankfully, from my days of video game programming I know that a simple test for checking if a point lies within a polygon is to send a ray outward from that point. If the ray intersects with the lines of the polygon an odd number of times, the point lies within the polygon. Otherwise, it’s outside.
Since we’re in a green state, we can do a little refactoring and implement a high level version of this solution. We want to count the number of intersections between our imaginary ray and our polygon:
let intersections = countIntersections(poly, point);
And then return true if that count is odd, or false if it’s even:
return !!(intersections % 2);
After making these changes, our test suite complains that
countIntersections does not exist, so let’s quickly define it and have
it return 1 to bring us back to green.
index.js
+function countIntersections(poly, point) { + return 1; +} + export function pointInPoly(poly, point) { - return true; + let intersections = countIntersections(poly, point); + return !!(intersections % 2); }
Rethinking Our Interfaces
After some soul-searching, I decided I wasn’t happy with where we were
going with our previous solution. countIntersections was really an
“internal method”. Outside of the context of our point-in-polygon
problem, a function called countIntersections that takes in a poly
and a point really just doesn’t make any sense.
Because it was an internal method, I was hesitant to write tests for it.
These tests would be too closely coupled with our implementation, and
would make refactoring difficult. Additionally, countIntersections
would most likely call other methods would be even more contextually
dependant and awkward to test.
We needed a cleaner solution.
After reconsidering the problem, it’s clear that we’re dealing with a
few really solid abstractions. The most apparent is a polygon. If we
implement a generic polygon, we’d be able to cleanly specify what we
want from our pointInPoly method:
function pointInPoly(poly, point) {
return polygon(poly).surrounds(point);
}
Additionally, by breaking polygon out into a new abstraction, we can
freely build and test its interface to our heart’s content.
With this in mind, we wrote a new set of tests that describe polygon.
The first tests looks nearly identical to our pointInPoly tests and
checks if a polygon surrounds a point.
Our dummy implementation of polygon.surrounds simply returns true.
polygon.js
+export function polygon(_points) { + + let surrounds = (point) => true; + + return { + surrounds + }; +}
test/polygon.js
+import { expect } from "chai"; +import { polygon } from "../polygon"; + +describe("polygon", function() { + + it("checks if a polygon surrounds a point", function() { + let poly = polygon([[-1, -1], [1, -1], [0, 1]]); + expect(poly.surrounds([0, 0])).to.be.true; + }); + +});
Restating Point-in-Polygon
Now that we’ve defined our polygon, we can restate our
implementation of surrounds. We want to translate our polygon so
that the point we’ve been given can be treated as the origin. Next
we want to count the number of intersections that an arbitrary ray
([0, 1]) makes with the newly translated polygon:
let intersections = translate([-x, -y]).intersections([0, 1]);
Lastly we want to return true from surrounds if intersections is
odd:
return !!(intersections % 2);
After making these changes, our test suite complains about translate
and intersections not being defined.
The fastest way to get us back to green is to have translate return a
new polygon, and have intersections return 1.
polygon.js
... - let surrounds = (point) => true; + let surrounds = ([x, y]) => { + let intersections = translate([-x, -y]).intersections([0, 1]); + return !!(intersections % 2); + }; + + let translate = ([x, y]) => { + return polygon(_points); + }; + + let intersections = (ray) => 1; return { - surrounds + surrounds, + translate, + intersections };
Translate Base Case
Now we can start testing the component pieces of our surrounds
function.
First up, let’s write a test for translate. A straight-forward base
case for translate asserts that calling translate on an empty
polygon ([[]]) should return an empty polygon.
After writing this test, I realized that I needed a function to return
the points from a polygon. Thus, points was born.
let points = () => _points;
Suprisingly, our naive solution also works for all calls to translate
where x and y are zero.
polygon.js
... + let points = () => _points; + return { ... translate, - intersections + intersections, + points };
test/polygon.js
... + it("translates a polygon", function() { + expect(polygon([]).translate([0, 0]).points()).to.deep.equal([]); + }); + });
Finishing Translate
Adding a more complicated test of translate shows that we need a
better solution. Thankfully, it isn’t a huge leap to come up with the
final form of the function.
The translate function returns a new polygon where every point in
the polygon has been incremented by the provided x and y values.
polygon.js
... let translate = ([x, y]) => { - return polygon(_points); + return polygon(_points.map(p => [p[0] + x, p[1] + y])); };
test/polygon.js
... expect(polygon([]).translate([0, 0]).points()).to.deep.equal([]); + expect(polygon([ + [0, 0], [5, -5] + ]).translate([1, 1]).points()).to.deep.equal([ + [1, 1], [6, -4] + ]); });
Line Abstraction
Now we turn out attention to the intersections function. This still
seems like a daunting piece of functionality, and we should break it
down into simpler pieces, if possible.
If we’re not afraid of making use of another abstraction (line), a
simple implementation of intersections could be written like this:
return lines().filter(line => line.intersects(ray)).length;
In plain english, this reads as “return the number of lines in this polygon that intersect the given ray”.
This is a nice solution. To make it a reality, let’s create a new set
of tests for our new line abstraction and a dummy implementation of
line and line.intersects.
line.js
+export function line(a, b) { + + let intersects = (ray) => true; + + return { + intersects + }; +}
test/line.js
+import { expect } from "chai"; +import { line } from "../line"; + +describe("line", function() { + + it("checks if the line intersects a ray", function() { + expect(line([0, 1], [1, 0]).intersects([1, 1])).to.be.true; + }); + +});
Finishing Line
Adding another test against line.intersects shows that we need a
better solution.
Determining if a line intersects with a ray is a well-documented problem. I used this blog post as a guide for implementing my solution. Be sure to check it out for details on the math being used here.
line.js
... - let intersects = (ray) => true; + function cross(v1, v2) { + return (v1[0] * v2[1]) - (v1[1]*v2[0]); + } + + function dot(v1, v2) { + return v1[0] * v2[0] + v1[1] + v2[1]; + } + + let intersects = (ray) => { + let v1 = [-a[0], -a[1]]; + let v2 = [b[0] - a[0], b[1] - a[1]]; + let v3 = [-ray[1], ray[0]]; + + let t1 = cross(v2, v1) / (dot(v2, v3)); + let t2 = (dot(v1, v3)) / (dot(v2, v3)); + + return t1 >= 0 && (t2 >= 0 && t2 <= 1); + };
test/line.js
... expect(line([0, 1], [1, 0]).intersects([1, 1])).to.be.true; + expect(line([0, 1], [1, 0]).intersects([-1, -1])).to.be.false; });
Finishing Intersections
Now that line and line.intersects exist, we can implement our
polygon.intersections method.
As usual, we start by adding a test for intersections, and then
we make our test suite happy by importing line, and creating the
polygon.lines function.
polygon.js
+import { line } from "./line"; + export function polygon(_points) { ... - let intersections = (ray) => 1; + let intersections = (ray) => { + return lines().filter(line => line.intersects(ray)).length; + }; ... + let lines = () => { + return [line([-1, 1], [1, 1])]; + } + return { ... intersections, - points + points, + lines };
test/polygon.js
... + it("counts intersections with a ray", function() { + let poly = polygon([[-1, -1], [1, -1], [0, 1]]); + expect(polygon([ + [-1, -1], [1, -1], [0, 1] + ]).intersections([0, 1])).to.equal(1); + }); + });
Constructing Lines
Finally, all we need to do to complete our solution is to build our
polygon.lines function. This function should transform the set of
_points that were used to define our polygon into a set of line
objects.
We implement a test for polygon.lines and use it to drive the
creation of our solution. Don’t forget that the last point in the
polygon must connect back to the first!
line.js
... + let points = () => [a, b]; + return { - intersects + intersects, + points };
polygon.js
... let lines = () => { - return [line([-1, 1], [1, 1])]; + if ((!_points) || !_points.length) { + return []; + } + + let last = _points[0]; + let pairs = _points.slice(1).map((point) => { + let segment = line(last, point); + last = point; + return segment; + }); + pairs.push(line(_points[_points.length - 1], _points[0])); + + return pairs; }
test/polygon.js
... + it("creates lines for a polygon", function() { + let lines = polygon([ + [-1, -1], [1, -1], [0, 1] + ]).lines(); + expect(lines.map((line) => line.points())).to.deep.equal([ + [[-1, -1], [1, -1]], + [[1, -1], [0, 1]], + [[0, 1], [-1, -1]] + ]); + }); + });
Pull it all Together
Now that all of our building blocks are finalized, we can come back to
our original pointInPoly method and rewrite it exactly how we had
imagined:
return polygon(poly).surrounds(point);
After making this change, our test suite is still green. Everything is working as expected.
index.js
-function countIntersections(poly, point) { - return 1; -} +import { polygon } from "./polygon"; export function pointInPoly(poly, point) { - let intersections = countIntersections(poly, point); - return !!(intersections % 2); + return polygon(poly).surrounds(point); }
Final Test & Bug Fix
At this point, our solution should be finished. However, when we feed in the tests provided by the kata, we notice a failure.
After digging into what’s happening, we notice that the system was
claiming that a line, line([4, -6], [4, 4]), was intersecting with a
ray, [0, 1]. Clearly, this is incorrect.
To find out what was causing this, we write a new test against the
line.intersects function:
expect(line([4, -6], [4, 4]).intersects([0, 1])).to.be.false;
As expected, this test fails.
After some poking, prodding, and comparing against reference equations,
we notice a typo in the dot function. After fixing the dot production
calculation, our entire test suite shifts back to a passing state.
Success!
line.js
... function dot(v1, v2) { - return v1[0] * v2[0] + v1[1] + v2[1]; + return v1[0] * v2[0] + v1[1] * v2[1]; }
test/index.js
... + it("detects a point in a square", function() { + var poly = [ + [-5, -5], [5, -5], + [5, 5], [-5, 5] + ]; + + expect(pointInPoly(poly, [-6, 0])).to.be.false; + expect(pointInPoly(poly, [1, 1])).to.be.true; + }); + });
test/line.js
... expect(line([0, 1], [1, 0]).intersects([-1, -1])).to.be.false; + expect(line([4, -6], [4, 4]).intersects([0, 1])).to.be.false; });
Wrap-up
When you compare our solution with other submitted solutions, you’ll notice that ours is longer. Our solution probably took much longer to write as well. However, our solution was a fantastic exercise in deliberate practice.
By consciously focusing on writing robust and maintainable code, we had a few introspective moments about our process and our technique.
The first major insight that we had came when we realized we were going down a bad road with the countIntersections method. By creating additional abstractions, we ended up with more testable, maintainable and re-usable code.
At the very end of the process we found a bug in the solution. Thanks to our test suite we were able to almost immediately find the source of the bug and fix it.
Be sure to check out the full project, complete with detail commit messages on GitHub.