projects/doodle: doodle/tk/geometry.d comparison

comparison doodle/tk/geometry.d @ 41:f2e4e1d29b98

Bah

author	daveb
date	Tue, 01 Jun 2010 17:21:01 +0930
parents	1f97022e5c6d
children	1b4c9ba58673

comparison

equal deleted inserted replaced

-:1f97022e5c6d
+:f2e4e1d29b98
 private {
 import std.stdio;
 import std.math;
 import doodle.tk.misc;
+import doodle.core.logging;
 }
 // In doodle x and y increase right/east and up/north respectively.
 // TODO explain the strategy for ensuring numerical stability
 static this() {
 DEFAULT = Point(0.0, 0.0);
 }
 this(in double x, in double y) {
+assert(!isnan(x));
+assert(!isnan(y));
 _x = x;
 _y = y;
 }
 Point opAdd(in Vector v) const {
 static this() {
 DEFAULT = Vector(0.0, 0.0);
 }
 this(in double x, in double y) {
+assert(!isnan(x));
+assert(!isnan(y));
 _x = x;
 _y = y;
 }
 Vector opAdd(in Vector v) const {
 Vector opNeg() const {
 return Vector(-_x, -_y);
 }
 Vector opMul_r(in double d) const {
+assert(!isnan(d));
 return Vector(d * _x, d * _y);
 }
 Vector opDiv(in double d) const {
+assert(!isnan(d));
 return Vector(_x / d, _y / d);
 }
 double length() const {
 return sqrt(_x * _x + _y * _y);
 Vector size() const { return _size; }
 Point max_corner() const { return _position + _size; }
-bool valid() const { return _size.x > 0.0 & _size.y > 0.0; }
+bool valid() const { return _size.x > 0.0 && _size.y > 0.0; }
 bool invalid() const { return !valid(); }
 double area() const { return _size.x * _size.y; }
 Rectangle reposition(in Rectangle r, in Point new_position) {
 return Rectangle(new_position, r.size);
 }
+Rectangle resize(in Rectangle r, in Vector new_size) {
+return Rectangle(r.position, new_size);
+}
 // Operations about the bottom left corner
 Rectangle expand(in Rectangle r, in Vector expand_amount) {
 return Rectangle(r.position, r.size + expand_amount);
 }
 // Operations about the centre
 Rectangle feather(in Rectangle r, double amount) {
 assert(amount >= 0.0);
+assert(!isnan(amount));
 return Rectangle(Point(r.position.x - amount, r.position.y - amount),
 Vector(r.size.x + 2.0 * amount, r.size.y + 2.0 * amount));
 }
-Rectangle resize(in Rectangle r, in Vector new_size) {
-return Rectangle(r.position, new_size);
-}
 private {
-// This is a commmon building block for intersection of lines and segments
+// This function computes the intersection of two lines.
-// Two lines "a" and "b" are defined by two points each .
+// The lines are defined by a start point and an end point, however they
-// "ua" and "ub" define the intersection as a fraction along
+// notionally extend infinitely in each direction.
-// the two respective line segments (FIXME this comment sucks)
+// The out parameters specify the fraction along the line-segment at which
+// intersection occurred.
+//
+// This is a commmon building block for computing intersection between lines, segments,
+// rectangles, etc.
+//
+// The function returns false if the lines are parallel or nearly so.
+//
 // Influenced by http://ozviz.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/
 bool compute_intersection(in Point pa1, in Point pa2, out double ua,
 in Point pb1, in Point pb2, out double ub) {
 double den = (pb2.y - pb1.y) * (pa2.x - pa1.x) - (pb2.x - pb1.x) * (pa2.y - pa1.y);
 if (abs(den) < 1e-9) {          // TODO consolidate constants used for numerical stability
 // Lines are parallel or nearly so
-writefln("Warning, parallel lines!");
+warning("Warning, parallel lines!");
 return false;
 }
 else {
 // It will be safe to divide by den
 double num_a = (pb2.x - pb1.x) * (pa1.y - pb1.y) - (pb2.y - pb1.y) * (pa1.x - pb1.x);
 ub = num_b / den;
 return true;
 }
 }
+/+
+double compute_angle(in Point p1, in Point p2) {
+}
++/
 }
 //
 // A line (notionally infinitely extending in both directions) in 2D space.
 // Internally represented by:

Mercurial > projects > doodle

comparison doodle/tk/geometry.d @ 41:f2e4e1d29b98