| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| using System; |
| using System.Drawing; |
| |
| namespace Diagram { |
| public static class Geometry { |
| public static readonly float precision = 1e-5f; |
| |
| public static readonly float[][] splineMatrix = new float[][] { |
| new float[] { 2f, -2f, 1f, 1f }, |
| new float[] { -3f, 3f, -2f, -1f }, |
| new float[] { 0f, 0f, 1f, 0f }, |
| new float[] { 1f, 0f, 0f, 0f } }; |
| |
| |
| public static int comparePointsAtLine(PointF a0, PointF a1, PointF base0, PointF base1) { |
| if (base0.X < base1.X && a0.X < a1.X) return -1; |
| if (base0.X < base1.X && a1.X < a0.X) return 1; |
| if (base1.X < base0.X && a0.X < a1.X) return 1; |
| if (base1.X < base0.X && a1.X < a0.X) return -1; |
| if (base0.Y < base1.Y && a0.Y < a1.Y) return -1; |
| if (base0.Y < base1.Y && a1.Y < a0.Y) return 1; |
| if (base1.Y < base0.Y && a0.Y < a1.Y) return 1; |
| if (base1.Y < base0.Y && a1.Y < a0.Y) return -1; |
| return 0; |
| } |
| |
| public static bool findIntersection(PointF a0, PointF a1, PointF b0, PointF b1, out PointF c) { |
| c = new PointF(0f, 0f); |
| PointF da = new PointF(a1.X - a0.X, a1.Y - a0.Y); |
| PointF db = new PointF(b1.X - b0.X, b1.Y - b0.Y); |
| |
| float divider = da.X*db.Y - db.X*da.Y; |
| if (Math.Abs(divider) < precision) return false; |
| float numeratorX = da.X*(b1.Y*b0.X - b0.Y*b1.X) |
| - db.X*(a1.Y*a0.X - a0.Y*a1.X); |
| float numeratorY = db.Y*(a1.X*a0.Y - a0.X*a1.Y) |
| - da.Y*(b1.X*b0.Y - b0.X*b1.Y); |
| PointF p = new PointF(numeratorX/divider, numeratorY/divider); |
| if ( comparePointsAtLine(p, a0, a0, a1) < 0 |
| || comparePointsAtLine(p, a1, a0, a1) > 0 |
| || comparePointsAtLine(p, b0, b0, b1) < 0 |
| || comparePointsAtLine(p, b1, b0, b1) > 0 ) |
| return false; |
| |
| c = p; |
| return true; |
| } |
| |
| public static float lineLength(PointF p0, PointF p1) { |
| return (float)Math.Sqrt( |
| (p1.X-p0.X)*(p1.X-p0.X) |
| + (p1.Y-p0.Y)*(p1.Y-p0.Y) ); |
| } |
| |
| public static PointF pointAtLine(PointF p0, PointF p1, int index = 0, int count = 1, float padding = 0f) { |
| float l = lineLength(p0, p1); |
| float px = l > precision ? (p1.X - p0.X)*padding/l : 0f; |
| float py = l > precision ? (p1.Y - p0.Y)*padding/l : 0f; |
| return new PointF( |
| (index+1)*(p1.X - p0.X - 2*px)/(count + 1) + p0.X + px, |
| (index+1)*(p1.Y - p0.Y - 2*py)/(count + 1) + p0.Y + py); |
| } |
| |
| public static PointF splineTangent(float s, PointF p0, PointF p1, PointF t0, PointF t1) { |
| float h1 = 3f*splineMatrix[0][0]*s*s + 2f*splineMatrix[1][0]*s + splineMatrix[2][0]; |
| float h2 = 3f*splineMatrix[0][1]*s*s + 2f*splineMatrix[1][1]*s + splineMatrix[2][1]; |
| float h3 = 3f*splineMatrix[0][2]*s*s + 2f*splineMatrix[1][2]*s + splineMatrix[2][2]; |
| float h4 = 3f*splineMatrix[0][3]*s*s + 2f*splineMatrix[1][3]*s + splineMatrix[2][3]; |
| return new PointF( |
| p0.X*h1 + p1.X*h2 + t0.X*h3 + t1.X*h4, |
| p0.Y*h1 + p1.Y*h2 + t0.Y*h3 + t1.Y*h4); |
| } |
| |
| public static PointF splinePoint(float s, PointF p0, PointF p1, PointF t0, PointF t1) { |
| float h1 = splineMatrix[0][0]*s*s*s + splineMatrix[1][0]*s*s + splineMatrix[2][0]*s + splineMatrix[3][0]; |
| float h2 = splineMatrix[0][1]*s*s*s + splineMatrix[1][1]*s*s + splineMatrix[2][1]*s + splineMatrix[3][1]; |
| float h3 = splineMatrix[0][2]*s*s*s + splineMatrix[1][2]*s*s + splineMatrix[2][2]*s + splineMatrix[3][2]; |
| float h4 = splineMatrix[0][3]*s*s*s + splineMatrix[1][3]*s*s + splineMatrix[2][3]*s + splineMatrix[3][3]; |
| return new PointF( |
| p0.X*h1 + p1.X*h2 + t0.X*h3 + t1.X*h4, |
| p0.Y*h1 + p1.Y*h2 + t0.Y*h3 + t1.Y*h4 ); |
| } |
| } |
| } |
| |