private static IShape BuildCurrentShape(ShapeMode mode, RealPoint startPoint, RealPoint endPoint)
{
IShape output = null;
switch (mode)
{
case ShapeMode.Rectangle:
output = new PolygonRectangle(startPoint, endPoint.X - startPoint.X, endPoint.Y - startPoint.Y);
break;
case ShapeMode.Circle:
output = new Circle(new Segment(startPoint, endPoint).Barycenter, startPoint.Distance(endPoint) / 2);
break;
case ShapeMode.CircleFromCenter:
output = new Circle(startPoint, startPoint.Distance(endPoint));
break;
case ShapeMode.Segment:
output = new Segment(startPoint, endPoint);
break;
case ShapeMode.Line:
output = new Line(startPoint, endPoint);
break;
}
return(output);
}
public static double Distance(Line line, RealPoint point)
{
// Pour calculer la distance, on calcule la droite perpendiculaire passant par ce point
// Puis on calcule l'intersection de la droite et de sa perpendiculaire
// On obtient la projection orthogonale du point, qui est le point de la droite le plus proche du point donné
// On retourne la distance entre ces deux points
return(point.Distance(line.GetProjection(point)));
}
public static double Distance(Segment segment, RealPoint point)
{
// Le raisonnement est le même que pour la droite cf Droite.Distance
Line perpendicular = segment.GetPerpendicular(point);
List <RealPoint> cross = segment.GetCrossingPoints(perpendicular);
double distance;
// Seule différence : on teste si l'intersection appartient bien au segment, sinon on retourne la distance avec l'extrémité la plus proche
if (cross.Count > 0 && segment.Contains(cross[0]))
{
distance = point.Distance(cross[0]);
}
else
{
double distanceDebut = point.Distance(segment.StartPoint);
double distanceFin = point.Distance(segment.EndPoint);
distance = Math.Min(distanceDebut, distanceFin);
}
return(distance);
}
public override List <int>[] DiagnosticLine(int distance, SensAR sens)
{
List <int>[] output = new List <int> [2];
output[0] = new List <int>();
output[1] = new List <int>();
RealPoint startPos = new RealPoint(Position.Coordinates);
MoveForward(distance, false);
while ((Position.Coordinates.X != _destination.Coordinates.X ||
Position.Coordinates.Y != _destination.Coordinates.Y) && !Execution.Shutdown)
{
double dist = startPos.Distance(Position.Coordinates);
output[0].Add((int)(dist * 1000));
output[1].Add((int)(dist * 1000));
Thread.Sleep(1);
}
return(output);
}
private void GenerateRandomBuoys()
{
Circle zone = new Circle(new RealPoint(1500, 0), 500);
List <Circle> randoms = new List <Circle>();
Random r = new Random();
for (int i = 0; i < 6; i++)
{
RealPoint random = new RealPoint(r.Next(1000, 1500) + (i < 3 ? 0 : 500), r.Next(36, 500 - 36));
Circle c = new Circle(random, 36);
if (zone.Contains(c) && !randoms.Exists(o => random.Distance(o) < 36 + 2))
{
_buoys.Add(new Buoy(random, Color.White, i % 2 == 0 ? Buoy.Green : Buoy.Red, true));
randoms.Add(c);
}
else
{
i -= 1;
}
}
}
public static double Distance(Line line1, Line line2)
{
double distance;
if (!line1.IsParallel(line2))
{
// Si les droites se croisent la distance est de 0
distance = 0;
}
else
{
// Sinon elles sont parrallèles donc on trace une perdendiculaire et une mesure la distance entre les croisements avec les 2 droites
Line perpendicular = line1.GetPerpendicular(new RealPoint(0, 0));
RealPoint p1 = line1.GetCrossingPoints(perpendicular)[0];
RealPoint p2 = line2.GetCrossingPoints(perpendicular)[0];
distance = p1.Distance(p2);
}
return(distance);
}
public static bool Contains(Circle containingCircle, RealPoint containedPoint)
{
// Pour contenir un point, celui si se trouve à une distance inférieure au rayon du centre
return(containedPoint.Distance(containingCircle.Center) <= containingCircle.Radius);
}
public static double Distance(Circle circle, RealPoint point)
{
// C'est la distance entre le centre du cercle et le point moins le rayon du cercle
return(Math.Max(0, point.Distance(circle.Center) - circle.Radius));
}
public static double Distance(RealPoint point, Polygon polygon)
{
if (polygon is PolygonRectangle)
{
// Plus rapide que la méthode des polygones
RealPoint topLeft = polygon.Sides[0].StartPoint;
RealPoint topRight = polygon.Sides[1].StartPoint;
RealPoint bottomRight = polygon.Sides[2].StartPoint;
RealPoint bottomLeft = polygon.Sides[3].StartPoint;
double distance;
if (point.X < topLeft.X)
{
if (point.Y < topLeft.Y)
{
distance = point.Distance(topLeft);
}
else if (point.Y > bottomRight.Y)
{
distance = point.Distance(bottomLeft);
}
else
{
distance = topLeft.X - point.X;
}
}
else if (point.X > bottomRight.X)
{
if (point.Y < topLeft.Y)
{
distance = point.Distance(topRight);
}
else if (point.Y > bottomRight.Y)
{
distance = point.Distance(bottomRight);
}
else
{
distance = point.X - topRight.X;
}
}
else
{
if (point.Y < topLeft.Y)
{
distance = topLeft.Y - point.Y;
}
else if (point.Y > bottomRight.Y)
{
distance = point.Y - bottomLeft.Y;
}
else
{
distance = 0;
}
}
return(distance);
}
// Distance jusqu'au segment le plus proche
double minDistance = double.MaxValue;
foreach (Segment s in polygon.Sides)
{
minDistance = Math.Min(s.Distance(point), minDistance);
}
return(minDistance);
}
private void pictureBoxTable_MouseMove(object sender, MouseEventArgs e)
{
semMove.WaitOne();
Dessinateur.PositionCurseur = pictureBoxTable.PointToClient(MousePosition);
if (pSelected != -1)
{
pointsPolaires[pSelected] = Dessinateur.Scale.ScreenToRealPosition(e.Location);
trajectoirePolaire = BezierCurve.GetPoints(pointsPolaires, (int)(numNbPoints.Value));//((int)pointsPolaires[0].Distance(pointsPolaires[pointsPolaires.Count - 1])) / 50);
Dessinateur.TrajectoirePolaire = trajectoirePolaire;
Dessinateur.PointsPolaire = pointsPolaires;
}
if (boxSourisObstacle.Checked)
{
if ((DateTime.Now - dateCapture).TotalMilliseconds > 50)
{
dateCapture = DateTime.Now;
Point p = Dessinateur.Scale.ScreenToRealPosition(pictureBoxTable.PointToClient(MousePosition));
List <RealPoint> positions = new List <RealPoint>();
positions.Add(Dessinateur.Scale.ScreenToRealPosition(pictureBoxTable.PointToClient(MousePosition)));
GameBoard.SetOpponents(positions);
//SuiviBalise.MajPositions(positions, Plateau.Enchainement == null || Plateau.Enchainement.DebutMatch == null);
}
}
else
{
RealPoint posOnTable = Dessinateur.Scale.ScreenToRealPosition(pictureBoxTable.PointToClient(MousePosition));
lblX.Text = posOnTable.X.ToString("0");
lblY.Text = posOnTable.Y.ToString("0");
bool hoverElement = false;
foreach (GameElement element in GameBoard.Elements)
{
if (posOnTable.Distance(element.Position) < element.HoverRadius)
{
element.IsHover = true;
hoverElement = true;
}
else
{
element.IsHover = false;
}
}
if (hoverElement)
{
this.Cursor = Cursors.Hand;
}
else
{
this.Cursor = Cursors.Arrow;
}
//System.Threading.Tasks.Task.Factory.StartNew(() => ChercheTraj(new Position(Robots.GrosRobot.Position)));
}
semMove.Release();
}
