private Bitmap AddWarpEffect(ref Bitmap image)
{
// build warp map
int width = image.Width;
int height = image.Height;
IntPoint[,] warpMap = new IntPoint[height, width];
int size = 8;
int maxOffset = -size + 1;
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
int dx = (x / size) * size - x;
int dy = (y / size) * size - y;
if (dx + dy <= maxOffset)
{
dx = (x / size + 1) * size - 1 - x;
}
warpMap[y, x] = new IntPoint(dx, dy);
}
}
// create filter
ImageWarp filter = new ImageWarp(warpMap);
// apply the filter
Bitmap newImage = filter.Apply(image);
return newImage;
}
/// <summary>
/// Get bounding rectangle of the specified list of points.
/// </summary>
///
/// <param name="cloud">Collection of points to get bounding rectangle for.</param>
/// <param name="minXY">Point comprised of smallest X and Y coordinates.</param>
/// <param name="maxXY">Point comprised of biggest X and Y coordinates.</param>
///
public static void GetBoundingRectangle( IEnumerable<IntPoint> cloud, out IntPoint minXY, out IntPoint maxXY )
{
int minX = int.MaxValue;
int maxX = int.MinValue;
int minY = int.MaxValue;
int maxY = int.MinValue;
foreach ( IntPoint pt in cloud )
{
int x = pt.X;
int y = pt.Y;
// check X coordinate
if ( x < minX )
minX = x;
if ( x > maxX )
maxX = x;
// check Y coordinate
if ( y < minY )
minY = y;
if ( y > maxY )
maxY = y;
}
if ( minX > maxX ) // if no point appeared to set either minX or maxX
throw new ArgumentException( "List of points can not be empty." );
minXY = new IntPoint( minX, minY );
maxXY = new IntPoint( maxX, maxY );
}
public void RoundTest( double x, double y, int expectedX, int expectedY )
{
DoublePoint dPoint = new DoublePoint( x, y );
IntPoint iPoint = new IntPoint( expectedX, expectedY );
Assert.AreEqual( iPoint, dPoint.Round( ) );
}
/// <summary>
/// Shift cloud by adding specified value to all points in the collection.
/// </summary>
///
/// <param name="cloud">Collection of points to shift their coordinates.</param>
/// <param name="shift">Point to shift by.</param>
///
public static void Shift( IList<IntPoint> cloud, IntPoint shift )
{
for ( int i = 0, n = cloud.Count; i < n; i++ )
{
cloud[i] = cloud[i] + shift;
}
}
public void RoundTest( float x, float y, int expectedX, int expectedY )
{
Point point = new Point( x, y );
IntPoint iPoint = new IntPoint( expectedX, expectedY );
Assert.AreEqual( iPoint, point.Round( ) );
}
private void initTracking(Image <Bgr, byte> frame)
{
initializeKalman(roi.Center());
//get hue channel from search area
var hsvImg = frame.Convert <Hsv, byte>(); //<<parallel operation>>
//user constraints...
Image <Gray, byte> mask = hsvImg.InRange(new Hsv(0, 0, minV), new Hsv(0, 0, maxV), Byte.MaxValue, 2);
originalObjHist.Calculate(hsvImg.GetSubRect(roi).SplitChannels(0, 1), false, mask.GetSubRect(roi));
originalObjHist.Scale((float)1 / roi.Area());
//originalObjHist.Normalize(Byte.MaxValue);
var backgroundArea = roi.Inflate(1.5, 1.5, frame.Size);
var backgroundMask = mask.GetSubRect(backgroundArea).Clone();
backgroundMask.GetSubRect(new Rectangle(Point.Subtract(roi.Location, backgroundArea.Location), roi.Size)).SetValue(0);
backgroundHist.Calculate(hsvImg.GetSubRect(backgroundArea).SplitChannels(0, 1), false, mask.GetSubRect(backgroundArea));
backgroundHist.Scale((float)1 / (backgroundArea.Area() - roi.Area()));
//backgroundHist.Normalize(Byte.MaxValue);
//how good originalObjHist and objHist match (suppresses possible selected background)
ratioHist = originalObjHist.CreateRatioHistogram(backgroundHist, Byte.MaxValue, 3);
searchArea = roi;
roi = Rectangle.Empty;
}
/// <summary>
/// Calculate Euclidean distance between two points.
/// </summary>
///
/// <param name="anotherPoint">Point to calculate distance to.</param>
///
/// <returns>Returns Euclidean distance between this point and
/// <paramref name="anotherPoint"/> points.</returns>
///
public float DistanceTo( IntPoint anotherPoint )
{
int dx = X - anotherPoint.X;
int dy = Y - anotherPoint.Y;
return (float) System.Math.Sqrt( dx * dx + dy * dy );
}
public static void GridInPlace(Bitmap img, uint rows, uint cols, Color colour)
{
//Lock image for read write so we can alter it
BitmapData imgData = img.LockBits(new Rectangle(0, 0, img.Width, img.Height),
ImageLockMode.ReadWrite, img.PixelFormat);
//Draw lines at regular intervals along the image both vertically & horizontally
//TODO: Fix bug where sometimes draws a line at the end, other times doesn't (because of double precision)
double colWidth = img.Width / (double)cols;
for (double i = colWidth; i < img.Width; i += colWidth)
{
IntPoint p1 = new IntPoint((int)i, 0);
IntPoint p2 = new IntPoint((int)i, img.Height);
Drawing.Line(imgData, p1, p2, colour);
}
double rowHeight = img.Height / (double)rows;
for (double i = rowHeight; i < img.Height; i += rowHeight)
{
IntPoint p1 = new IntPoint(0, (int)i);
IntPoint p2 = new IntPoint(img.Width, (int)i);
Drawing.Line(imgData, p1, p2, colour);
}
img.UnlockBits(imgData);
}
/// <summary>
/// Calculate Euclidean distance between two points.
/// </summary>
///
/// <param name="anotherPoint">Point to calculate distance to.</param>
///
/// <returns>Returns Euclidean distance between this point and
/// <paramref name="anotherPoint"/> points.</returns>
///
public double DistanceTo( IntPoint anotherPoint )
{
int dx = X - anotherPoint.X;
int dy = Y - anotherPoint.Y;
return System.Math.Sqrt( dx * dx + dy * dy );
}
public void InequalityOperatorTest( int x1, int y1, int x2, int y2, bool areNotEqual )
{
IntPoint point1 = new IntPoint( x1, y1 );
IntPoint point2 = new IntPoint( x2, y2 );
Assert.AreEqual( point1 != point2, areNotEqual );
}
private void initTracking(Bgr <byte>[,] frame)
{
initializeKalman(roi.Center());
//get hue channel from search area
var hsvImg = frame.ToHsv();
//user constraints...
Gray <byte>[,] mask = hsvImg.InRange(new Hsv <byte>(0, 0, (byte)minV), new Hsv <byte>(0, 0, (byte)maxV), Byte.MaxValue, 2);
originalObjHist.Calculate(hsvImg.SplitChannels <Hsv <byte>, byte>(roi, 0, 1), false, mask, roi.Location);
originalObjHist.Scale((float)1 / roi.Area());
//originalObjHist.Normalize(Byte.MaxValue);
var backgroundArea = roi.Inflate(1.5, 1.5, frame.Size());
var backgroundMask = mask.Clone(backgroundArea);
backgroundMask.SetValue <Gray <byte> >(0, new Rectangle(Point.Subtract(roi.Location, backgroundArea.Location), roi.Size));
backgroundHist.Calculate(hsvImg.SplitChannels <Hsv <byte>, byte>(backgroundArea, 0, 1), false, mask, backgroundArea.Location);
backgroundHist.Scale((float)1 / (backgroundArea.Area() - roi.Area()));
//backgroundHist.Normalize(Byte.MaxValue);
//how good originalObjHist and objHist match (suppresses possible selected background)
ratioHist = originalObjHist.CreateRatioHistogram(backgroundHist, Byte.MaxValue, 3);
searchArea = roi;
roi = Rectangle.Empty;
}
/// <summary>
/// Negates point coordinates.
/// </summary>
/// <param name="point">The point to negate.</param>
/// <returns>Point with negated coordinates.</returns>
public static Point Negate(this Point point)
{
return(new Point
{
X = -point.X,
Y = -point.Y
});
}
/// <summary>
/// Clamps point coordinate according to the specified size (0,0, size.Width, size.Height).
/// </summary>
/// <param name="point">The point to clamp.</param>
/// <param name="size">The valid region.</param>
/// <returns>Clamped point.</returns>
public static Point Clamp(this Point point, Size size)
{
return(new Point
{
X = System.Math.Min(System.Math.Max(0, point.X), size.Width),
Y = System.Math.Min(System.Math.Max(0, point.Y), size.Height)
});
}
public void Add(IntPoint point)
{
if (Points.Count != 0)
{
Length += point.DistanceTo(Points.Last());
}
Points.Add(point);
}
/// <summary>
/// Clamps point coordinate according to the specified size (rect.X, rect.Y, rect.Right, rect.Bottom).
/// </summary>
/// <param name="point">The point to clamp.</param>
/// <param name="rect">The valid region.</param>
/// <returns>Clamped point.</returns>
public static Point Clamp(this Point point, Rectangle rect)
{
return(new Point
{
X = System.Math.Min(System.Math.Max(rect.X, point.X), rect.Right),
Y = System.Math.Min(System.Math.Max(rect.Y, point.Y), rect.Bottom)
});
}
public void TestEuclideanDistance1()
{
//Basic test
IntPoint a = new IntPoint(1, 1);
IntPoint b = new IntPoint(2, 2);
double distance = Geometry.EuclideanDistance(a, b);
Assert.AreEqual(Math.Sqrt(2), distance);
}
public void TestEuclideanDistance5()
{
//0 distance / points equal
IntPoint a = new IntPoint(0, 0);
IntPoint b = new IntPoint(0, 0);
double distance = Geometry.EuclideanDistance(a, b);
Assert.AreEqual(0, distance);
}
public void TestEuclideanDistance4()
{
//Negative coordinates
IntPoint a = new IntPoint(-1, -1);
IntPoint b = new IntPoint(-2, -2);
double distance = Geometry.EuclideanDistance(a, b);
Assert.AreEqual(Math.Sqrt(2), distance);
}
public void TestEuclideanDistance3()
{
//Non-unit lengths test
IntPoint a = new IntPoint(324, 12);
IntPoint b = new IntPoint(12, 123);
double distance = Geometry.EuclideanDistance(a, b);
Assert.AreEqual(3 * Math.Sqrt(12185), distance);
}
public void TestEuclideanDistance2()
{
//Parameter order doesn't matter
IntPoint a = new IntPoint(2, 2);
IntPoint b = new IntPoint(1, 1);
double distance = Geometry.EuclideanDistance(a, b);
Assert.AreEqual(Math.Sqrt(2), distance);
}
public static double AreaQuadrilateral(IntPoint[] points)
{
if(!IsQuadrilateral(points))
{
throw new InvalidShapeException("Expected Quadrilateral");
}
return Area(points[0], points[1], points[2], points[3]);
}
public void GetAngleBetweenVectorsTest( int sx, int sy, int ex1, int ey1, int ex2, int ey2, float expectedAngle )
{
IntPoint startPoint = new IntPoint( sx, sy );
IntPoint vector1end = new IntPoint( ex1, ey1 );
IntPoint vector2end = new IntPoint( ex2, ey2 );
float angle = GeometryTools.GetAngleBetweenVectors( startPoint, vector1end, vector2end );
Assert.AreApproximatelyEqual<float, float>( expectedAngle, angle, 0.00001f );
}
public void dessinePoint(IntPoint point, UnmanagedImage img,int nbPixel,Color col)
{
for (int i = point.X - nbPixel / 2; i < point.X + nbPixel / 2 + 1; i++)
{
for (int j = point.Y - nbPixel / 2; j < point.Y + nbPixel / 2 + 1; j++)
{
img.SetPixel(i, j, col);
}
}
}
public void GetAngleBetweenLinesTest( int sx1, int sy1, int ex1, int ey1, int sx2, int sy2, int ex2, int ey2, float expectedAngle )
{
IntPoint line1start = new IntPoint( sx1, sy1 );
IntPoint line1end = new IntPoint( ex1, ey1 );
IntPoint line2start = new IntPoint( sx2, sy2 );
IntPoint line2end = new IntPoint( ex2, ey2 );
float angle = GeometryTools.GetAngleBetweenLines( line1start, line1end, line2start, line2end );
Assert.AreApproximatelyEqual<float, float>( expectedAngle, angle, 0.00001f );
}
private Suit suit; //Suit of card
#endregion Fields
#region Constructors
//Constructor
public Card(Bitmap cardImg, IntPoint[] cornerIntPoints)
{
this.image = cardImg;
//Convert AForge.IntPoint Array to System.Drawing.Point Array
int total = cornerIntPoints.Length;
corners = new Point[total];
for(int i = 0 ; i < total ; i++)
{
this.corners[i].X = cornerIntPoints[i].X;
this.corners[i].Y = cornerIntPoints[i].Y;
}
}
//calculating rotation angle (form the law of cosines)
public int calculateRotateAngle(List<IntPoint> blobCorners, List<IntPoint> frameCorners)
{
IntPoint center = new IntPoint(frameCorners[2].X/2, frameCorners[2].Y/2);
float a = Math.Abs(blobCorners[1].DistanceTo(frameCorners[1]));
float b = Math.Abs(blobCorners[1].DistanceTo(center));
float c = Math.Abs(frameCorners[1].DistanceTo(center));
float cosAlpha = (-1)*(a * a - b * b - c * c) / (2 * b * c);
int angle = (int)Math.Acos(cosAlpha);
// if (blobCorners[0].Y > blobCorners[1].Y) angle = angle * (-1);
return angle;
}
private Suit suit; //Suit of card
#endregion Fields
#region Constructors
//Constructor
public Card(Bitmap cardImg, IntPoint[] cornerIntPoints)
{
//This has nothing to do with the rest of the framework, so it can be refactored
this.image = cardImg;
//Convert AForge.IntPoint Array to System.Drawing.Point Array
int total = cornerIntPoints.Length;
corners = new AForge.Point[total];
for (int i = 0; i < total; i++)
{
this.corners[i].X = cornerIntPoints[i].X;
this.corners[i].Y = cornerIntPoints[i].Y;
}
}
void CamProc_NewTargetPosition(IntPoint Center, System.Drawing.Bitmap image)
{
IntPtr hBitMap = image.GetHbitmap();
BitmapSource bmaps = Imaging.CreateBitmapSourceFromHBitmap(hBitMap, IntPtr.Zero, Int32Rect.Empty, BitmapSizeOptions.FromEmptyOptions());
bmaps.Freeze();
Dispatcher.Invoke((Action)(() =>
{
if (Center.X > 0)
{
try
{
prova.Content = String.Format(" Codigo: {0}", Center.X);
item.Content = String.Format(" Nº Itens: {0}", Center.Y);
TextReader respostas = new StreamReader(@"" + Center.X + ".txt");
string R_1 = respostas.ReadLine();
string R_2 = respostas.ReadLine();
string R_3 = respostas.ReadLine();
string R_4 = respostas.ReadLine();
string R_5 = respostas.ReadLine();
string R_6 = respostas.ReadLine();
string R_7 = respostas.ReadLine();
string R_8 = respostas.ReadLine();
string R_9 = respostas.ReadLine();
string R_0 = respostas.ReadLine();
item1.Content = String.Format(" Item 01: {0}", R_1);
item2.Content = String.Format(" Item 02: {0}", R_2);
item3.Content = String.Format(" Item 03: {0}", R_3);
item4.Content = String.Format(" Item 04: {0}", R_4);
item5.Content = String.Format(" Item 05: {0}", R_5);
item6.Content = String.Format(" Item 06: {0}", R_6);
item7.Content = String.Format(" Item 07: {0}", R_7);
item8.Content = String.Format(" Item 08: {0}", R_8);
item9.Content = String.Format(" Item 09: {0}", R_9);
item10.Content = String.Format(" Item 10: {0}", R_0);
string resps = R_1 + ";" + R_2 + ";" + R_3 + ";" + R_4 + ";" + R_5 + ";" + R_6 + ";" + R_7 + ";" + R_8 + ";" + R_9 + ";" + R_0;
refer.Content = String.Format("todas: {0}", resps);
conexao((int)Center.X, resps);
respostas.Close();
}
catch { }
}
pictureBoxMain.Source = bmaps;
}), DispatcherPriority.Render, null);
DeleteObject(hBitMap);
}
private void pictureBox_MouseMove(object sender, MouseEventArgs e)
{
if (e.Button != MouseButtons.Left)
{
return;
}
Point ptSecond = e.Location.ToPt();
roi = new Rectangle
{
X = System.Math.Min(ptFirst.X, ptSecond.X),
Y = System.Math.Min(ptFirst.Y, ptSecond.Y),
Width = System.Math.Abs(ptFirst.X - ptSecond.X),
Height = System.Math.Abs(ptFirst.Y - ptSecond.Y)
};
}
//Draws a solution onto a Bitmap, using a specified Segmentation to split the image into characters.
// Draws each line from the centre of each segmentation cell
public static void SolutionInPlace(Bitmap img, Segmentation segmentation, Solution solution, Color colour)
{
//Validation: Check that the image dimensions & segmentation dimensions match
if (img.Width != segmentation.Width || img.Height != segmentation.Height)
{
throw new ArgumentException("Bitmap dimensions do not match Segmentation dimensions");
}
//Work out the centre point for each character
IntPoint[,] charCentres = new IntPoint[segmentation.NumCols, segmentation.NumRows];
for(int i = 0; i < segmentation.NumCols; i++)
{
int colStart = (i == 0) ? 0 : segmentation.Cols[i - 1];
int colEnd = (i == segmentation.NumCols - 1) ? segmentation.Width : segmentation.Cols[i];
int colCentre = (int)Math.Round((((double)colEnd - colStart) / 2) + colStart);
for(int j = 0; j < segmentation.NumRows; j++)
{
int rowStart = (j == 0) ? 0 : segmentation.Rows[j - 1];
int rowEnd = (j == segmentation.NumRows - 1) ? segmentation.Height : segmentation.Rows[j];
int rowCentre = (int)Math.Round(rowStart + (((double)rowEnd - rowStart) / 2));
charCentres[i, j] = new IntPoint(colCentre, rowCentre);
}
}
//Lock the image for write so we can alter it
BitmapData imgData = img.LockBits(new Rectangle(0, 0, img.Width, img.Height),
ImageLockMode.WriteOnly, img.PixelFormat);
//Draw on the word positions
foreach (WordPosition position in solution.Values)
{
IntPoint startPoint = charCentres[position.StartCol, position.StartRow];
IntPoint endPoint = charCentres[position.EndCol, position.EndRow];
Drawing.Line(imgData, startPoint, endPoint, colour);
}
img.UnlockBits(imgData);
}
//Calculates the area of an arbitrary polygon using the Shoelace algorithm http://en.wikipedia.org/wiki/Shoelace_formula
public static double Area(IntPoint[] points)
{
//There must be at least 3 points in any shape with an area
if(points.Length < 3)
{
throw new InvalidShapeException("A shape requires at least 3 points in order to have an Area");
}
//Order the points before computing the area (since the algorithm requires them to be ordered)
IntPoint[] clockwisePoints = SortPointsClockwise(points);
ulong sumA = 0;
ulong sumB = 0;
for(int i = 0; i < clockwisePoints.Length - 1; i++)
{
sumA += (ulong)(clockwisePoints[i].X * clockwisePoints[i + 1].Y);
sumB += (ulong)(clockwisePoints[i + 1].X * clockwisePoints[i].Y);
}
sumA += (ulong)(clockwisePoints[clockwisePoints.Length - 1].X * clockwisePoints[0].Y);
sumB += (ulong)(clockwisePoints[0].X * clockwisePoints[clockwisePoints.Length - 1].Y);
//Because the points are ordered clockwise, sumB will always be greater than sumA so for half their difference we don't need to check for neg
return (double)(sumB - sumA) / 2;
}
public static System.Drawing.Point ToGDIPoint(this AForge.IntPoint point)
{
return(new System.Drawing.Point(point.X, point.Y));
}
/// <summary>
/// Find the furthest point from the specified line.
/// </summary>
///
/// <param name="cloud">Collection of points to search furthest points in.</param>
/// <param name="linePoint1">First point forming the line.</param>
/// <param name="linePoint2">Second point forming the line.</param>
/// <param name="distance">Distance between the furthest found point and the given line.</param>
///
/// <returns>Returns a point, which is the furthest away from the
/// specified line.</returns>
///
/// <remarks><para>The method finds the furthest point from the specified line.
/// Unlike the <see cref="GetFurthestPointsFromLine( IEnumerable{IntPoint}, IntPoint, IntPoint, out IntPoint, out float, out IntPoint, out float )"/>
/// method, this method find only one point, which is the furthest away from the line
/// regardless of side from the line.</para></remarks>
///
public static IntPoint GetFurthestPointFromLine( IEnumerable<IntPoint> cloud, IntPoint linePoint1, IntPoint linePoint2, out float distance )
{
IntPoint furthestPoint = linePoint1;
distance = 0;
if ( linePoint2.X != linePoint1.X )
{
// line's equation y(x) = k * x + b
float k = (float) ( linePoint2.Y - linePoint1.Y ) / ( linePoint2.X - linePoint1.X );
float b = linePoint1.Y - k * linePoint1.X;
float div = (float) System.Math.Sqrt( k * k + 1 );
float pointDistance = 0;
foreach ( IntPoint point in cloud )
{
pointDistance = System.Math.Abs( ( k * point.X + b - point.Y ) / div );
if ( pointDistance > distance )
{
distance = pointDistance;
furthestPoint = point;
}
}
}
else
{
int lineX = linePoint1.X;
float pointDistance = 0;
foreach ( IntPoint point in cloud )
{
distance = System.Math.Abs( lineX - point.X );
if ( pointDistance > distance )
{
distance = pointDistance;
furthestPoint = point;
}
}
}
return furthestPoint;
}
/// <summary>
/// Find the furthest point from the specified line.
/// </summary>
///
/// <param name="cloud">Collection of points to search furthest point in.</param>
/// <param name="linePoint1">First point forming the line.</param>
/// <param name="linePoint2">Second point forming the line.</param>
///
/// <returns>Returns a point, which is the furthest away from the
/// specified line.</returns>
///
/// <remarks><para>The method finds the furthest point from the specified line.
/// Unlike the <see cref="GetFurthestPointsFromLine( IEnumerable{IntPoint}, IntPoint, IntPoint, out IntPoint, out IntPoint )"/>
/// method, this method find only one point, which is the furthest away from the line
/// regardless of side from the line.</para></remarks>
///
public static IntPoint GetFurthestPointFromLine( IEnumerable<IntPoint> cloud, IntPoint linePoint1, IntPoint linePoint2 )
{
float d;
return GetFurthestPointFromLine( cloud, linePoint1, linePoint2, out d );
}
/// <summary>
/// Find two furthest points from the specified line.
/// </summary>
///
/// <param name="cloud">Collection of points to search furthest points in.</param>
/// <param name="linePoint1">First point forming the line.</param>
/// <param name="linePoint2">Second point forming the line.</param>
/// <param name="furthestPoint1">First found furthest point.</param>
/// <param name="distance1">Distance between the first found point and the given line.</param>
/// <param name="furthestPoint2">Second found furthest point (which is on the
/// opposite side from the line compared to the <paramref name="furthestPoint1"/>);</param>
/// <param name="distance2">Distance between the second found point and the given line.</param>
///
/// <remarks><para>The method finds two furthest points from the specified line,
/// where one point is on one side from the line and the second point is on
/// another side from the line.</para></remarks>
///
public static void GetFurthestPointsFromLine( IEnumerable<IntPoint> cloud, IntPoint linePoint1, IntPoint linePoint2,
out IntPoint furthestPoint1, out float distance1, out IntPoint furthestPoint2, out float distance2 )
{
furthestPoint1 = linePoint1;
distance1 = 0;
furthestPoint2 = linePoint2;
distance2 = 0;
if ( linePoint2.X != linePoint1.X )
{
// line's equation y(x) = k * x + b
float k = (float) ( linePoint2.Y - linePoint1.Y ) / ( linePoint2.X - linePoint1.X );
float b = linePoint1.Y - k * linePoint1.X;
float div = (float) System.Math.Sqrt( k * k + 1 );
float distance = 0;
foreach ( IntPoint point in cloud )
{
distance = ( k * point.X + b - point.Y ) / div;
if ( distance > distance1 )
{
distance1 = distance;
furthestPoint1 = point;
}
if ( distance < distance2 )
{
distance2 = distance;
furthestPoint2 = point;
}
}
}
else
{
int lineX = linePoint1.X;
float distance = 0;
foreach ( IntPoint point in cloud )
{
distance = lineX - point.X;
if ( distance > distance1 )
{
distance1 = distance;
furthestPoint1 = point;
}
if ( distance < distance2 )
{
distance2 = distance;
furthestPoint2 = point;
}
}
}
distance2 = -distance2;
}
/// <summary>
/// Find two furthest points from the specified line.
/// </summary>
///
/// <param name="cloud">Collection of points to search furthest points in.</param>
/// <param name="linePoint1">First point forming the line.</param>
/// <param name="linePoint2">Second point forming the line.</param>
/// <param name="furthestPoint1">First found furthest point.</param>
/// <param name="furthestPoint2">Second found furthest point (which is on the
/// opposite side from the line compared to the <paramref name="furthestPoint1"/>);</param>
///
/// <remarks><para>The method finds two furthest points from the specified line,
/// where one point is on one side from the line and the second point is on
/// another side from the line.</para></remarks>
///
public static void GetFurthestPointsFromLine( IEnumerable<IntPoint> cloud, IntPoint linePoint1, IntPoint linePoint2,
out IntPoint furthestPoint1, out IntPoint furthestPoint2 )
{
float d1, d2;
GetFurthestPointsFromLine( cloud, linePoint1, linePoint2,
out furthestPoint1, out d1, out furthestPoint2, out d2 );
}
/// <summary>
/// Find furthest point from the specified point.
/// </summary>
///
/// <param name="cloud">Collection of points to search furthest point in.</param>
/// <param name="referencePoint">The point to search furthest point from.</param>
///
/// <returns>Returns a point, which is the furthest away from the <paramref name="referencePoint"/>.</returns>
///
public static IntPoint GetFurthestPoint( IEnumerable<IntPoint> cloud, IntPoint referencePoint )
{
IntPoint furthestPoint = referencePoint;
float maxDistance = -1;
int rx = referencePoint.X;
int ry = referencePoint.Y;
foreach ( IntPoint point in cloud )
{
int dx = rx - point.X;
int dy = ry - point.Y;
// we are not calculating square root for finding "real" distance,
// since it is really not important for finding furthest point
float distance = dx * dx + dy * dy;
if ( distance > maxDistance )
{
maxDistance = distance;
furthestPoint = point;
}
}
return furthestPoint;
}
private void pictureBox_MouseDown(object sender, MouseEventArgs e)
{
ptFirst = e.Location.ToPt();
isROISelected = false;
}
