public bool Equals(LineSegment l)
{
if (this.isEqual(l))
if (lowerBound.Equals(l.lowerBound) && upperBound.Equals(l.upperBound))
return true;
return false;
}
public Bitmap2D scaleBitmap2DToRestrictedLineSegment(Bitmap2D bitmap2DToScale, LineSegment lineSegment, Point one, Point two)
{
//Given a line segment, that has already been restricted to the region rectangle given the 2 points one, and two
//scale / padd the image given the fact that the original line might have partially been out of the bounds of the rectangle.
return null;
}
public void getArrayIndiciesMarkedByLineTest()
{
//Horizontal line
LineSegment line = new LineSegment(new Point(.5, .5), new Point(5.5, .5));
long arrayspacesizex = 10;
long arrayspacesizey = 10;
List<Point> expected = new List<Point>();
expected.Add(new Point(0, 0));
expected.Add(new Point(1, 0));
expected.Add(new Point(2, 0));
expected.Add(new Point(3, 0));
expected.Add(new Point(4, 0));
expected.Add(new Point(5, 0));
List<Point> actual;
actual = ArraySpaceUtilities.getArrayIndiciesMarkedByLine(line, arrayspacesizex, arrayspacesizey);
Assert.AreEqual(expected.Count, actual.Count);
Point[] expectedArray = expected.ToArray();
Point[] actualArray = actual.ToArray();
for (int i = 0; i < expectedArray.Length; i++)
{
Assert.AreEqual(true, actualArray[i].Equals(expectedArray[i]));
}
//Vertical line
line = new LineSegment(new Point(2.5, 1.5), new Point(2.5, 4.5));
expected.Clear();
expected.Add(new Point(2, 1));
expected.Add(new Point(2, 2));
expected.Add(new Point(2, 3));
expected.Add(new Point(2, 4));
expected.Reverse();
actual.Clear();
actual = ArraySpaceUtilities.getArrayIndiciesMarkedByLine(line, arrayspacesizex, arrayspacesizey);
Assert.AreEqual(expected.Count, actual.Count);
expectedArray = expected.ToArray();
actualArray = actual.ToArray();
for (int i = 0; i < expectedArray.Length; i++)
{
Assert.AreEqual(true, actualArray[i].Equals(expectedArray[i]));
}
//diagonal line
line = new LineSegment(new Point(0.5, 0.5), new Point(5.5, 2.5));
expected.Clear();
expected.Add(new Point(0, 0));
expected.Add(new Point(1, 0));
expected.Add(new Point(1, 1));
expected.Add(new Point(2, 1));
expected.Add(new Point(3, 1));
expected.Add(new Point(4, 1));
expected.Add(new Point(4, 2));
expected.Add(new Point(5, 2));
actual.Clear();
actual = ArraySpaceUtilities.getArrayIndiciesMarkedByLine(line, arrayspacesizex, arrayspacesizey);
Assert.AreEqual(expected.Count, actual.Count);
expectedArray = expected.ToArray();
actualArray = actual.ToArray();
for (int i = 0; i < expectedArray.Length; i++)
{
Assert.AreEqual(true, actualArray[i].Equals(expectedArray[i]));
}
}
public void restrictLineToArraySpaceTest()
{
Point one = new Point(1, 1);
Point two = new Point(4, 4); ;
long arrayspacesizex = 10;
long arrayspacesizey = 10;
LineSegment expected = new LineSegment(one, two);
LineSegment actual;
actual = ArraySpaceUtilities.restrictLineToArraySpace(one, two, arrayspacesizex, arrayspacesizey);
Assert.AreEqual(expected.lowerBound.x, actual.lowerBound.x);
Assert.AreEqual(expected.lowerBound.y, actual.lowerBound.y);
Assert.AreEqual(expected.upperBound.x, actual.upperBound.x);
Assert.AreEqual(expected.upperBound.y, actual.upperBound.y);
one = new Point(4, 5);
two = new Point(9, 9);
expected = new LineSegment(one, two);
actual = ArraySpaceUtilities.restrictLineToArraySpace(one, two, arrayspacesizex, arrayspacesizey);
Assert.AreEqual(expected.lowerBound.x, actual.lowerBound.x);
Assert.AreEqual(expected.lowerBound.y, actual.lowerBound.y);
Assert.AreEqual(expected.upperBound.x, actual.upperBound.x);
Assert.AreEqual(expected.upperBound.y, actual.upperBound.y);
one = new Point(-2, 5);
two = new Point(5, 5);
expected = new LineSegment(new Point(0, 5), new Point(5, 5));
actual = ArraySpaceUtilities.restrictLineToArraySpace(one, two, arrayspacesizex, arrayspacesizey);
Assert.AreEqual(expected.lowerBound.x, actual.lowerBound.x);
Assert.AreEqual(expected.lowerBound.y, actual.lowerBound.y);
Assert.AreEqual(expected.upperBound.x, actual.upperBound.x);
Assert.AreEqual(expected.upperBound.y, actual.upperBound.y);
one = new Point(15, 5);
two = new Point(5, 5);
expected = new LineSegment(new Point(10, 5), new Point(5, 5));
actual = ArraySpaceUtilities.restrictLineToArraySpace(one, two, arrayspacesizex, arrayspacesizey);
Assert.AreEqual(expected.lowerBound.x, actual.lowerBound.x);
Assert.AreEqual(expected.lowerBound.y, actual.lowerBound.y);
Assert.AreEqual(expected.upperBound.x, actual.upperBound.x);
Assert.AreEqual(expected.upperBound.y, actual.upperBound.y);
}
public void createPixelGrid(byte[] rawData, int sizex, int sizey, SeismicUtilities.Point offsetpoint, int pixelPaddingX, int pixelPaddingY, double rotation)
{
long memoryoffset = 0;
//Turn all pixels white
while (memoryoffset < sizex * sizey * pixelFormat.BitsPerPixel / 8)
{
//deal with one pixel at a time
rawData[memoryoffset++] = (byte)255;
rawData[memoryoffset++] = (byte)255;
rawData[memoryoffset++] = (byte)255;
rawData[memoryoffset++] = (byte)255;
}
//Draw horizontal border lines
int x = 0, y = 0;
for (int i = 0; i < sizex; i++)
{
x = i;
y = 0;
memoryoffset = (y * sizex + x) * pixelFormat.BitsPerPixel / 8;
rawData[memoryoffset++] = (byte)0;
rawData[memoryoffset++] = (byte)0;
rawData[memoryoffset++] = (byte)0;
rawData[memoryoffset++] = (byte)255;
y = sizey - 1;
memoryoffset = (y * sizex + x) * pixelFormat.BitsPerPixel / 8;
rawData[memoryoffset++] = (byte)0;
rawData[memoryoffset++] = (byte)0;
rawData[memoryoffset++] = (byte)0;
rawData[memoryoffset++] = (byte)255;
}
//Draw vertical border lines
for (int i = 0; i < sizey; i++)
{
x = 0;
y = i;
memoryoffset = (y * sizex + x) * pixelFormat.BitsPerPixel / 8;
rawData[memoryoffset++] = (byte)0;
rawData[memoryoffset++] = (byte)0;
rawData[memoryoffset++] = (byte)0;
rawData[memoryoffset++] = (byte)255;
x = sizex - 1;
memoryoffset = (y * sizex + x) * pixelFormat.BitsPerPixel / 8;
rawData[memoryoffset++] = (byte)0;
rawData[memoryoffset++] = (byte)0;
rawData[memoryoffset++] = (byte)0;
rawData[memoryoffset++] = (byte)255;
}
SeismicUtilities.Point bottomLeft = offsetpoint;
SeismicUtilities.Point bottomRight = new SeismicUtilities.Point(offsetpoint.x + arraySpaceImageWidth - 2 * imagePixelPaddingX, offsetpoint.y);
SeismicUtilities.Point topLeft = new SeismicUtilities.Point(offsetpoint.x, offsetpoint.y + arraySpaceImageHeight - 2 * imagePixelPaddingY);
SeismicUtilities.Point topRight = new SeismicUtilities.Point(offsetpoint.x + arraySpaceImageWidth - 2 * imagePixelPaddingX, offsetpoint.y + arraySpaceImageHeight - 2 * imagePixelPaddingY);
SeismicUtilities.Point rotatedTopLeft = topLeft.rotatePointAboutPoint(rotation, offsetpoint);
SeismicUtilities.Point rotatedTopRight = topRight.rotatePointAboutPoint(rotation, offsetpoint);
SeismicUtilities.Point rotatedBottomRight = bottomRight.rotatePointAboutPoint(rotation, offsetpoint);
//Left rectangle line
SeismicUtilities.LineSegment line = new SeismicUtilities.LineSegment(new SeismicUtilities.Point(rotatedTopLeft.x, arraySpaceImageHeight - rotatedTopLeft.y), new SeismicUtilities.Point(offsetpoint.x, arraySpaceImageHeight - offsetpoint.y));
List<SeismicUtilities.Point> points = ArraySpaceUtilities.getArrayIndiciesMarkedByLine(line, sizex, sizey);
drawPoints(points, sizex, sizey, rawData);
//Bottom rect line
line = new SeismicUtilities.LineSegment(new SeismicUtilities.Point(offsetpoint.x, arraySpaceImageHeight - offsetpoint.y), new SeismicUtilities.Point(rotatedBottomRight.x, arraySpaceImageHeight - rotatedBottomRight.y));
points = ArraySpaceUtilities.getArrayIndiciesMarkedByLine(line, sizex, sizey);
drawPoints(points, sizex, sizey, rawData);
//Right rect line
line = new SeismicUtilities.LineSegment(new SeismicUtilities.Point(rotatedBottomRight.x, arraySpaceImageHeight - rotatedBottomRight.y), new SeismicUtilities.Point(rotatedTopRight.x, arraySpaceImageHeight - rotatedTopRight.y));
points = ArraySpaceUtilities.getArrayIndiciesMarkedByLine(line, sizex, sizey);
drawPoints(points, sizex, sizey, rawData);
//top rect line
line = new SeismicUtilities.LineSegment(new SeismicUtilities.Point(rotatedTopRight.x, arraySpaceImageHeight - rotatedTopRight.y), new SeismicUtilities.Point(rotatedTopLeft.x, arraySpaceImageHeight - rotatedTopLeft.y));
points = ArraySpaceUtilities.getArrayIndiciesMarkedByLine(line, sizex, sizey);
drawPoints(points, sizex, sizey, rawData);
////Draw horizontal array space lines
//for (int i = 0; i < sizex - 2 * pixelPaddingX; i++)
// {
// x = i;
// y = pixelPaddingY;
// memoryoffset = (y * sizex + x + pixelPaddingX) * pixelFormat.BitsPerPixel / 8;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)255;
// y = sizey - 1 - pixelPaddingY;
// memoryoffset = (y * sizex + x + pixelPaddingX) * pixelFormat.BitsPerPixel / 8;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)255;
// }
//Draw vertical array space lines
//for (int i = 0; i < sizey - 2 * pixelPaddingY; i++)
//{
// x = pixelPaddingX;
// y = i + pixelPaddingY;
// memoryoffset = (y * sizex + x) * pixelFormat.BitsPerPixel / 8;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)255;
// x = sizex - 1 - pixelPaddingX;
// memoryoffset = (y * sizex + x) * pixelFormat.BitsPerPixel / 8;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)255;
//}
#region
//for (int i = 1; i < numxregions; i++)
//{
// for (int j = 0; j < sizey; j++)
// {
// x = i * sizex / numxregions;
// y = j;
// memoryoffset = (y * sizex + x) * pixelFormat.BitsPerPixel / 8;
// //if (i == 1)
// //{
// // rawData[memoryoffset++] = (byte)0;
// // rawData[memoryoffset++] = (byte)255;
// // rawData[memoryoffset++] = (byte)0;
// // rawData[memoryoffset++] = (byte)255;
// //}
// //else
// //{
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)255;
// //}
// }
//}
//for (int i = 1; i < numyregions; i++)
//{
// for (int j = 0; j < sizex; j++)
// {
// x = j;
// y = i * sizey / numyregions;
// memoryoffset = (y * sizex + x )* pixelFormat.BitsPerPixel / 8;
// //if (i == 1)
// //{
// // rawData[memoryoffset++] = (byte)0;
// // rawData[memoryoffset++] = (byte)255;
// // rawData[memoryoffset++] = (byte)0;
// // rawData[memoryoffset++] = (byte)255;
// //}
// //else
// //{
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)0;
// rawData[memoryoffset++] = (byte)255;
// //}
// }
//}
#endregion
}
public static List<Point> getArrayIndiciesMarkedByLine(LineSegment line, long arrayspacesizex, long arrayspacesizey)
{
//columnList = new List<PixelColumn>();
List<Point> coordinateList = new List<Point>();
double regionone, regiontwo, regionmax, regionmin;
regionone = line.lowerBound.x;
regiontwo = (int)regionone + 1;
//Console.Out.WriteLine("Starting Regions: " + regionone + ", " + regiontwo);
bool positiveSlope = false;
if (line.slope > 0)
{
positiveSlope = true;
}
else
{
positiveSlope = false;
}
if ((int)regionone == (int)regiontwo)
{
//Near verticle line
regionmax = line.getMaxOnRegion(regionone, regiontwo);
regionmin = line.getMinOnRegion(regionone, regiontwo);
if (regionmax == Double.PositiveInfinity || (int)regionmax == arrayspacesizey)
{
regionmax = arrayspacesizey - 1;
}
if ((int)regionone == arrayspacesizex)
{
regionone = arrayspacesizex - 1;
}
addAllVerticalPointsToList(ref coordinateList, (int)regionmin, (int)regionmax, (int)regionone, positiveSlope);
}
else
{
while (regiontwo < line.upperBound.x)
{
//Using this region, add all points to the list
regionmax = line.getMaxOnRegion(regionone, regiontwo);
regionmin = line.getMinOnRegion(regionone, regiontwo);
if (regionmax == Double.PositiveInfinity || (int)regionmax == arrayspacesizey)
{
regionmax = arrayspacesizey - 1;
}
//Console.Out.WriteLine("region: " + regionone + ", " + regiontwo + " Max: " + regionmax + ", Min: " + regionmin);
//addAllVerticalColumnsToList(ref columnList, (int)regionmin, (int)regionmax, (int)regionone);
addAllVerticalPointsToList(ref coordinateList, (int)regionmin, (int)regionmax, (int)regionone, positiveSlope);
regionone = regiontwo;
regiontwo++;
}
//Add last region manually
regiontwo = line.upperBound.x;
regionmax = line.getMaxOnRegion(regionone, regiontwo);
regionmin = line.getMinOnRegion(regionone, regiontwo);
if (regionmax == Double.PositiveInfinity || (int)regionmax == arrayspacesizey)
{
regionmax = arrayspacesizey - 1;
}
if ((int)regionone == arrayspacesizex)
{
regionone = arrayspacesizex - 1;
}
//Console.Out.WriteLine("last region: " + regionone + ", " + regiontwo + " Max: " + regionmax + ", Min: " + regionmin);
//addAllVerticalColumnsToList(ref columnList, (int)regionmin, (int)regionmax, (int)regionone);
addAllVerticalPointsToList(ref coordinateList, (int)regionmin, (int)regionmax, (int)regionone, positiveSlope);
}
//Reverse the list if the points go in the opposite direction, ie if the ipad is flipped 180 degrees,
//the two points used to find the line will be reversed, thus here we are moving left to right vs right to left
//if (one.x > two.x)
//{
// coordinateList.Reverse();
//}
return coordinateList;
}
public static LineSegment restrictLineToArraySpace(Point one, Point two, long arrayspacesizex, long arrayspacesizey)
{
//These points are in relative array space, but can be outside of the array bounds (ie could be larger then the number of array regions, or negative.)
//Given two points creates a line, then creates a line segment that is within the array space, along this line
bool pointOneIsExterior = false, pointTwoIsExterior = false;
if (one.x < 0 || one.x >= arrayspacesizex || one.y < 0 || one.y >= arrayspacesizey)
{
pointOneIsExterior = true;
}
if (two.x < 0 || two.x >= arrayspacesizex || two.y < 0 || two.y >= arrayspacesizey)
{
pointTwoIsExterior = true;
}
//Common case in which both points are interior to the domain
if (!pointOneIsExterior && !pointTwoIsExterior)
{
return new LineSegment(one, two);
}
//At least 1 pointis exterior, we need to create a line and restrict part of it to the domain
LineSegment givenLineSegment = new LineSegment(one, two);
//Create 4 lines to represent to bounds of this rectangle to test intersections against
LineSegment left = new LineSegment(new Point(0, 0), new Point(0, arrayspacesizey));
LineSegment right = new LineSegment(new Point(arrayspacesizex, 0), new Point(arrayspacesizex, arrayspacesizey));
LineSegment bottom = new LineSegment(new Point(0, 0), new Point(arrayspacesizex, 0));
LineSegment top = new LineSegment(new Point(0, arrayspacesizey), new Point(arrayspacesizex, arrayspacesizey));
Point intersectionPoint = new Point(0, 0), intersectionPointOne = new Point(0, 0), intersectionPointTwo = new Point(0, 0);
bool intersectionPointOneFound = false;
bool infiniteIntersections = false;
//we need to see if a line segment exists
if (pointOneIsExterior && pointTwoIsExterior)
{
//both points are exterior, check if there is an overlap of the line segment and the bounding box
//If there exists a line segment, it will be made with a line that intersects two of the lines of the bounding rectangle
if (givenLineSegment.intersectsLineSegment(left, ref intersectionPoint, ref infiniteIntersections))
{
intersectionPointOne = intersectionPoint;
intersectionPointOneFound = true;
}
if (givenLineSegment.intersectsLineSegment(right, ref intersectionPoint, ref infiniteIntersections))
{
if (intersectionPointOneFound)
{
//The intersection point is on the end of array space, such that when evaluating it. it will be outside of the array
//(ex x = 40, array size = 40, but only elements 0-39 are valid)
//Thus reduce the size slightly such that when casted to int it will round down to the last element,
//but be suffeciently high when evaluated as to give all the necessary boxes
//intersectionPoint.x -= reduceConstant;
intersectionPointTwo = intersectionPoint;
return new LineSegment(intersectionPointOne, intersectionPointTwo);
}
else
{
//The intersection point is on the end of array space, such that when evaluating it. it will be outside of the array
//(ex x = 40, array size = 40, but only elements 0-39 are valid)
//Thus reduce the size slightly such that when casted to int it will round down to the last element,
//but be suffeciently high when evaluated as to give all the necessary boxes
//intersectionPoint.x -= reduceConstant;
intersectionPointOne = intersectionPoint;
intersectionPointOneFound = true;
}
}
if (givenLineSegment.intersectsLineSegment(bottom, ref intersectionPoint, ref infiniteIntersections))
{
if (intersectionPointOneFound)
{
intersectionPointTwo = intersectionPoint;
return new LineSegment(intersectionPointOne, intersectionPointTwo);
}
else
{
intersectionPointOne = intersectionPoint;
intersectionPointOneFound = true;
}
}
if (givenLineSegment.intersectsLineSegment(top, ref intersectionPoint, ref infiniteIntersections))
{
if (intersectionPointOneFound)
{
//The intersection point is on the end of array space, such that when evaluating it. it will be outside of the array
//(ex x = 40, array size = 40, but only elements 0-39 are valid)
//Thus reduce the size slightly such that when casted to int it will round down to the last element,
//but be suffeciently high when evaluated as to give all the necessary boxes
//intersectionPoint.y -= reduceConstant;
intersectionPointTwo = intersectionPoint;
return new LineSegment(intersectionPointOne, intersectionPointTwo);
}
else
{
//The intersection point is on the end of array space, such that when evaluating it. it will be outside of the array
//(ex x = 40, array size = 40, but only elements 0-39 are valid)
//Thus reduce the size slightly such that when casted to int it will round down to the last element,
//but be suffeciently high when evaluated as to give all the necessary boxes
//intersectionPoint.y -= reduceConstant;
intersectionPointOne = intersectionPoint;
intersectionPointOneFound = true;
}
}
//Only other option is no intersections took place
if (!intersectionPointOneFound)
{
//No intersection found
return null;
}
else
{
//One intersection found?? not possible?
}
}
else if (pointOneIsExterior)
{
//only point one is exterior, there must be exactly one intersection point with the bounding rect, use this intersection point + point 2 for a line segment
if (givenLineSegment.intersectsLineSegment(left, ref intersectionPoint, ref infiniteIntersections))
{
return new LineSegment(intersectionPoint, two);
}
else if (givenLineSegment.intersectsLineSegment(right, ref intersectionPoint, ref infiniteIntersections))
{
//The intersection point is on the end of array space, such that when evaluating it. it will be outside of the array
//(ex x = 40, array size = 40, but only elements 0-39 are valid)
//Thus reduce the size slightly such that when casted to int it will round down to the last element,
//but be suffeciently high when evaluated as to give all the necessary boxes
//intersectionPoint.x -= reduceConstant;
return new LineSegment(intersectionPoint, two);
}
else if (givenLineSegment.intersectsLineSegment(bottom, ref intersectionPoint, ref infiniteIntersections))
{
return new LineSegment(intersectionPoint, two);
}
else if (givenLineSegment.intersectsLineSegment(top, ref intersectionPoint, ref infiniteIntersections))
{
//The intersection point is on the end of array space, such that when evaluating it. it will be outside of the array
//(ex x = 40, array size = 40, but only elements 0-39 are valid)
//Thus reduce the size slightly such that when casted to int it will round down to the last element,
//but be suffeciently high when evaluated as to give all the necessary boxes
//intersectionPoint.y -= reduceConstant;
return new LineSegment(intersectionPoint, two);
}
else
{
//Cant happen, but still need to do the last check to get the intersection point
}
}
else
{
//Onlypoint two is exterior, there must be actaly one intersection point with the bounding rect, use this intersection point + point one for linesegment
if (givenLineSegment.intersectsLineSegment(left, ref intersectionPoint, ref infiniteIntersections))
{
return new LineSegment(intersectionPoint, one);
}
else if (givenLineSegment.intersectsLineSegment(right, ref intersectionPoint, ref infiniteIntersections))
{
//The intersection point is on the end of array space, such that when evaluating it. it will be outside of the array
//(ex x = 40, array size = 40, but only elements 0-39 are valid)
//Thus reduce the size slightly such that when casted to int it will round down to the last element,
//but be suffeciently high when evaluated as to give all the necessary boxes
//intersectionPoint.x -= reduceConstant;
return new LineSegment(intersectionPoint, one);
}
else if (givenLineSegment.intersectsLineSegment(bottom, ref intersectionPoint, ref infiniteIntersections))
{
return new LineSegment(intersectionPoint, one);
}
else if (givenLineSegment.intersectsLineSegment(top, ref intersectionPoint, ref infiniteIntersections))
{
//The intersection point is on the end of array space, such that when evaluating it. it will be outside of the array
//(ex x = 40, array size = 40, but only elements 0-39 are valid)
//Thus reduce the size slightly such that when casted to int it will round down to the last element,
//but be suffeciently high when evaluated as to give all the necessary boxes
//intersectionPoint.y -= reduceConstant;
return new LineSegment(intersectionPoint, one);
}
else
{
//Cant happen, but still need to do the last check/functioncall to get the intersection point
}
}
return null;
}
public void LineSegmentConstructorTest()
{
Point one = new Point(0, 0);
Point two = new Point(1, 1);
LineSegment target = new LineSegment(one, two);
Assert.AreEqual(target.lowerBound.x, one.x);
Assert.AreEqual(target.lowerBound.y, one.y);
Assert.AreEqual(target.upperBound.x, two.x);
Assert.AreEqual(target.upperBound.y, two.y);
double expectedSlope = 1.0;
double expectedYIntercept = 0.0;
Assert.AreEqual(expectedSlope, target.slope);
Assert.AreEqual(expectedYIntercept, target.yintercept);
//Test reversing of which point comes first
one = new Point(5, 5);
target = new LineSegment(one, two);
Assert.AreEqual(target.lowerBound.x, two.x);
Assert.AreEqual(target.lowerBound.y, two.y);
Assert.AreEqual(target.upperBound.x, one.x);
Assert.AreEqual(target.upperBound.y, one.y);
Assert.AreEqual(expectedSlope, target.slope);
Assert.AreEqual(expectedYIntercept, target.yintercept);
//vertical points
one = new Point(0, 0);
two = new Point(0, 5);
target = new LineSegment(one, two);
Assert.AreEqual(true, target.isInfiniteSlope);
Assert.AreEqual(target.lowerBound.x, one.x);
Assert.AreEqual(target.lowerBound.y, one.y);
Assert.AreEqual(target.upperBound.x, two.x);
Assert.AreEqual(target.upperBound.y, two.y);
one = new Point(0, 0);
two = new Point(0, 5);
target = new LineSegment(two, one);
Assert.AreEqual(true, target.isInfiniteSlope);
Assert.AreEqual(target.lowerBound.x, one.x);
Assert.AreEqual(target.lowerBound.y, one.y);
Assert.AreEqual(target.upperBound.x, two.x);
Assert.AreEqual(target.upperBound.y, two.y);
}
public void getMaxOnRegionTest()
{
Point one = new Point(0, 0);
Point two = new Point(1, 1);
LineSegment target = new LineSegment(one, two);
double regionx1 = .5;
double regionx2 = .75;
double expected = .75;
Assert.AreEqual(expected, target.getMaxOnRegion(regionx1, regionx2));
Assert.AreEqual(expected, target.getMaxOnRegion(regionx2, regionx1));
regionx1 = .25;
regionx2 = 1.0;
expected = 1.0;
Assert.AreEqual(expected, target.getMaxOnRegion(regionx1, regionx2));
Assert.AreEqual(expected, target.getMaxOnRegion(regionx2, regionx1));
//Test when max is outside the region, and restricted
regionx2 = 1.5;
regionx1 = .25;
expected = 1.0;
Assert.AreEqual(expected, target.getMaxOnRegion(regionx1, regionx2));
Assert.AreEqual(expected, target.getMaxOnRegion(regionx2, regionx1));
one = new Point(0, 1);
two = new Point(1, 0);
target = new LineSegment(one, two);
regionx1 = -.5;
regionx2 = .2;
expected = 1.0;
Assert.AreEqual(expected, target.getMaxOnRegion(regionx1, regionx2));
Assert.AreEqual(expected, target.getMaxOnRegion(regionx2, regionx1));
regionx1 = .5;
regionx2 = .2;
expected = .8;
Assert.AreEqual(expected, target.getMaxOnRegion(regionx1, regionx2));
Assert.AreEqual(expected, target.getMaxOnRegion(regionx2, regionx1));
regionx1 = -.5;
regionx2 = 1.2;
expected = 1.0;
Assert.AreEqual(expected, target.getMaxOnRegion(regionx1, regionx2));
Assert.AreEqual(expected, target.getMaxOnRegion(regionx2, regionx1));
regionx1 = .5;
regionx2 = 1.2;
expected = .5;
Assert.AreEqual(expected, target.getMaxOnRegion(regionx1, regionx2));
Assert.AreEqual(expected, target.getMaxOnRegion(regionx2, regionx1));
//region outside
one = new Point(0, 1);
two = new Point(1, 0);
target = new LineSegment(one, two);
regionx1 = -.5;
regionx2 = -.2;
expected = Double.NaN;
Assert.AreEqual(expected, target.getMaxOnRegion(regionx1, regionx2));
Assert.AreEqual(expected, target.getMaxOnRegion(regionx2, regionx1));
regionx1 = 1.5;
regionx2 = 3.2;
expected = Double.NaN;
Assert.AreEqual(expected, target.getMaxOnRegion(regionx1, regionx2));
Assert.AreEqual(expected, target.getMaxOnRegion(regionx2, regionx1));
//Test vertical line segment, outside less than
one = new Point(1, 1);
two = new Point(1, 0);
target = new LineSegment(one, two);
regionx1 = -.5;
regionx2 = .2;
expected = Double.NaN;
Assert.AreEqual(expected, target.getMaxOnRegion(regionx1, regionx2));
Assert.AreEqual(expected, target.getMaxOnRegion(regionx2, regionx1));
//outside greater than
regionx1 = 1.5;
regionx2 = 6.62;
expected = Double.NaN;
Assert.AreEqual(expected, target.getMaxOnRegion(regionx1, regionx2));
Assert.AreEqual(expected, target.getMaxOnRegion(regionx2, regionx1));
//Region contained
regionx1 = -.5;
regionx2 = 1.2;
expected = 1.0;
Assert.AreEqual(expected, target.getMaxOnRegion(regionx1, regionx2));
Assert.AreEqual(expected, target.getMaxOnRegion(regionx2, regionx1));
//region equal
regionx1 = 1.0;
regionx2 = 1.0;
expected = 1.0;
Assert.AreEqual(expected, target.getMaxOnRegion(regionx1, regionx2));
Assert.AreEqual(expected, target.getMaxOnRegion(regionx2, regionx1));
regionx1 = 1.5;
regionx2 = 1.0;
expected = 1.0;
Assert.AreEqual(expected, target.getMaxOnRegion(regionx1, regionx2));
Assert.AreEqual(expected, target.getMaxOnRegion(regionx2, regionx1));
}
public void intersectsLineSegmentTest()
{
//Normal line segment intersection
Point one = new Point(0, 0);
Point two = new Point(1, 1);
Point one2 = new Point(0, 1);
Point two2 = new Point(1, 0);
LineSegment target = new LineSegment(one, two);
LineSegment target2 = new LineSegment(one2, two2);
Point intersectionpoint = null;
Point intersectionpointExpected = new Point(.5, .5);
bool infiniteIntersections = false, expectedInfiniteIntersections = false;
bool intersectionExpected = true;
bool linesActualIntersection;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting at both end points
one = new Point(-1, -1);
two = new Point(0, 0);
one2 = new Point(0, 0);
two2 = new Point(2, 1);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0, 0);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting at one end point
one = new Point(-1, 1);
two = new Point(1, -1);
one2 = new Point(1, 1);
two2 = new Point(0, 0);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0, 0);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting line to horizontal
one = new Point(0, 0);
two = new Point(1, 1);
one2 = new Point(-10, 0.5);
two2 = new Point(10, 0.5);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0.5, 0.5);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting line to horizontal end point
one = new Point(0, 0);
two = new Point(1, 1);
one2 = new Point(.5, 0.5);
two2 = new Point(10, 0.5);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0.5, 0.5);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting line end point to horizontal
one = new Point(0, 0);
two = new Point(1, 1);
one2 = new Point(-10, 0);
two2 = new Point(10, 0);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0, 0.0);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting line end point to horizontal end point
one = new Point(0, 0);
two = new Point(1, 1);
one2 = new Point(0, 0);
two2 = new Point(10, 0);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0, 0);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting vertical segment to line end point
one = new Point(0, 0);
two = new Point(0, 1);
one2 = new Point(1, 1.5);
two2 = new Point(0, 0.5);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0, 0.5);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting vertical segment to line
one = new Point(0, 0);
two = new Point(0, 1);
one2 = new Point(-1, 0);
two2 = new Point(1, 1);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0, 0.5);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting vertical segment end point to line
one = new Point(0.0, 0.0);
two = new Point(0.0, 1.0);
one2 = new Point(-1.0, -.5);
two2 = new Point(1.0, 0.5);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0, 0.0);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting vertical segment end to line end
one = new Point(0, 0);
two = new Point(1, 1);
one2 = new Point(1, 1);
two2 = new Point(1, 3);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(1.0, 1.0);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting vertical segment to horizontal
one = new Point(0, 0);
two = new Point(0, 1);
one2 = new Point(1, .6);
two2 = new Point(-1, .6);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0, 0.6);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting vertical segment to horizontal end
one = new Point(0, 0);
two = new Point(0, 1);
one2 = new Point(1, .6);
two2 = new Point(0, .6);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0, 0.6);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting vertical segment end to horizontal
one = new Point(0, 0);
two = new Point(0, 1);
one2 = new Point(1, 1);
two2 = new Point(-1, 1);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0, 1);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting vertical segment end to horizontal end
one = new Point(0, 0);
two = new Point(0, 1);
one2 = new Point(1, 1);
two2 = new Point(0, 1);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0, 1);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting vertical segment to vertical segment
one = new Point(0, 0);
two = new Point(0, 1);
one2 = new Point(0, 0);
two2 = new Point(0, -6);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0, 0.0);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
//Connecting horizontal segment to horizontal segment
one = new Point(0, 5);
two = new Point(3, 5);
one2 = new Point(-1, 5);
two2 = new Point(0, 5);
target = new LineSegment(one, two);
target2 = new LineSegment(one2, two2);
expectedInfiniteIntersections = false;
intersectionpointExpected = new Point(0, 5.0);
intersectionExpected = true;
linesActualIntersection = target.intersectsLineSegment(target2, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
linesActualIntersection = target2.intersectsLineSegment(target, ref intersectionpoint, ref infiniteIntersections);
Assert.AreEqual(intersectionpointExpected.x, intersectionpoint.x);
Assert.AreEqual(intersectionpointExpected.y, intersectionpoint.y);
Assert.AreEqual(intersectionExpected, linesActualIntersection);
Assert.AreEqual(expectedInfiniteIntersections, infiniteIntersections);
}
public void inDomainTest()
{
Point one = new Point(0, 0);
Point two = new Point(1, 1);
LineSegment target = new LineSegment(one, two);
double xval = .5;
bool expected = true;
Assert.AreEqual(expected, target.inDomain(xval));
xval = 0;
Assert.AreEqual(expected, target.inDomain(xval));
xval = 1;
Assert.AreEqual(expected, target.inDomain(xval));
expected = false;
xval = -5;
Assert.AreEqual(expected, target.inDomain(xval));
xval = 2;
Assert.AreEqual(expected, target.inDomain(xval));
one = new Point(-5, 12);
two = new Point(12, 188);
target = new LineSegment(one, two);
xval = -100;
Assert.AreEqual(expected, target.inDomain(xval));
xval = 56;
Assert.AreEqual(expected, target.inDomain(xval));
expected = true;
xval = 8;
Assert.AreEqual(expected, target.inDomain(xval));
xval = -2;
Assert.AreEqual(expected, target.inDomain(xval));
}
public void inDomainAndRangeTest()
{
Point one = new Point(0, 0);
Point two = new Point(1, 1);
LineSegment target = new LineSegment(one, two);
Point intersectionPoint = new Point(.5, .5);
bool expected = true;
Assert.AreEqual(expected, target.inDomainAndRange(intersectionPoint));
intersectionPoint = new Point(1.5, .5);
expected = false;
Assert.AreEqual(expected, target.inDomainAndRange(intersectionPoint));
one = new Point(0, 0);
two = new Point(0, 5);
target = new LineSegment(one, two);
expected = false;
intersectionPoint = new Point(1, 4);
Assert.AreEqual(expected, target.inDomainAndRange(intersectionPoint));
//Here the point 0,10 is in the domain, but not the range.
expected = false;
intersectionPoint = new Point(0, 10);
Assert.AreEqual(expected, target.inDomainAndRange(intersectionPoint));
//Point is on the line segment, ie within range and domain of a vertical line
expected = true;
intersectionPoint = new Point(0, 4);
Assert.AreEqual(expected, target.inDomainAndRange(intersectionPoint));
}
public bool intersectsLineSegment(LineSegment L, ref Point intersectionpoint, ref bool infiniteIntersections)
{
Point possibleIntersectionPoint = this.intersectsLine(L, ref infiniteIntersections);
if (infiniteIntersections)
{
//possibly Intersects at infinitely many points due to it being a line, but restricting it to a segment, changes things!
//Find lowest bound:
LineSegment theLowerSegment, theHigherSegment;
if (this.isInfiniteSlope)
{
//Use y values to check, not x!
if (this.lowerBound.y < L.lowerBound.y)
{
theHigherSegment = L;
theLowerSegment = this;
}
else
{
theHigherSegment = this;
theLowerSegment = L;
}
//See how much overlap there is on the 2 bounds
if (theLowerSegment.upperBound.y < theHigherSegment.lowerBound.y)
{
//Non overlapping
infiniteIntersections = false;
intersectionpoint = null;
return false;
}
else if (theLowerSegment.upperBound.y == theHigherSegment.lowerBound.y)
{
//Intersect at only one point
intersectionpoint = theLowerSegment.upperBound;
infiniteIntersections = false;
return true;
}
else
{
//Overlap of bounds
infiniteIntersections = true;
intersectionpoint = null;
return false;
}
}
if (this.lowerBound.x < L.lowerBound.x)
{
theHigherSegment = L;
theLowerSegment = this;
}
else
{
theHigherSegment = this;
theLowerSegment = L;
}
//See how much overlap there is on the 2 bounds
if (theLowerSegment.upperBound.x < theHigherSegment.lowerBound.x)
{
//Non overlapping
infiniteIntersections = false;
intersectionpoint = null;
return false;
}
else if (theLowerSegment.upperBound.x == theHigherSegment.lowerBound.x)
{
//Intersect at only one point
intersectionpoint = theLowerSegment.upperBound;
infiniteIntersections = false;
return true;
}
else
{
//Overlap of bounds
infiniteIntersections = true;
intersectionpoint = null;
return false;
}
}
if (possibleIntersectionPoint == null)
{
//Line doesnt interesect
intersectionpoint = null;
return false;
}
if (inDomainAndRange(possibleIntersectionPoint) && L.inDomainAndRange(possibleIntersectionPoint))
{
intersectionpoint = possibleIntersectionPoint;
return true;
}
//The line intersects but is not within the domain of both lines
return false;
}