public static void CalculateDirectionLine(TextBox subHeadingText, TextBox directionText, TextBox observePos1PositionText, ref LineModel directionLine, ref TextBox directionLineText, bool isObservePos1DirectionLine = true)
{
if (string.IsNullOrEmpty(directionText.Text) || string.IsNullOrEmpty(subHeadingText.Text))
{
return;
}
double direction, subHeading;
try
{
direction = Convert.ToDouble(directionText.Text);
subHeading = Convert.ToDouble(subHeadingText.Text);
}
catch
{
MessageBox.Show("invalid number: " + directionText.Text + ", " + subHeadingText.Text);
return;
}
direction = DirectionOperation.CalculateSubActualDirection(subHeading, direction);
PointModel observePos = new PointModel(0, 0);
if (isObservePos1DirectionLine && !string.IsNullOrEmpty(observePos1PositionText.Text))
{
observePos = PointModel.Parse(observePos1PositionText.Text);
if (observePos == null)
{
return;
}
}
directionLine = CoordinateSystemOperation.CalculateLineFromPointAndDirection(observePos, direction);
directionLineText.Text = directionLine.ToString();
}
public static void CalculateActualTargetLine(LineModel randomTargetLine, LineModel estimatedDirectionLine, LineModel directionLine1, LineModel directionLine2, LineModel directionLine3, LineModel directionLine4, TextBox observePos1TimeDiffText, ref LineModel actualTargetLine, ref TextBox actualTargetLineText, ref PointModel targetConfirmedPoint, ref DateTime targetConfirmedPointDate, ref TextBox targetSpeedText)
{
if (randomTargetLine == null || estimatedDirectionLine == null || directionLine4 == null)
{
return;
}
targetConfirmedPoint = CoordinateSystemOperation.CalculatePointByTwoLines(estimatedDirectionLine, directionLine4);
targetConfirmedPointDate = DateTime.Now;
actualTargetLine = CoordinateSystemOperation.CalculateLineFromSlopeAndPoint(randomTargetLine.a, targetConfirmedPoint, randomTargetLine.lineDirection);
actualTargetLineText.Text = actualTargetLine.ToString();
if (string.IsNullOrEmpty(observePos1TimeDiffText.Text) || directionLine1 == null || directionLine2 == null || directionLine3 == null)
{
return;
}
double time;
try
{
time = Convert.ToDouble(observePos1TimeDiffText.Text);
}
catch
{
MessageBox.Show("invalid number: " + observePos1TimeDiffText.Text);
return;
}
var intercept1 = CoordinateSystemOperation.CalculatePointByTwoLines(actualTargetLine, directionLine1);
var intercept2 = CoordinateSystemOperation.CalculatePointByTwoLines(actualTargetLine, directionLine2);
var intercept3 = CoordinateSystemOperation.CalculatePointByTwoLines(actualTargetLine, directionLine3);
var length = (CoordinateSystemOperation.CalculateLengthBetweenPoints(intercept1, intercept2) + CoordinateSystemOperation.CalculateLengthBetweenPoints(intercept2, intercept3)) / 2.00;
var speedByMeter = length / time;
var speedByKnot = speedByMeter * 1.94;
targetSpeedText.Text = Math.Round(speedByKnot, 2).ToString();
var actualDirectionLine = CoordinateSystemOperation.CalculateLineFromTwoPoint(intercept1, intercept2);
actualTargetLine.lineDirection = actualDirectionLine.lineDirection;
}
public static void CalculateEstimatedDirectionLine(LineModel directionLine1, LineModel directionLine2, LineModel directionLine3, LineModel randomTargetLine, TextBox observePos1Text, TextBox observePos1TimeDiffText, TextBox observePos2TimeDiffText, ref LineModel estimatedDirectionLine, ref TextBox estimatedDirectionLineText, ref TextBox targetHeadingText)
{
if (directionLine1 == null || directionLine2 == null || directionLine3 == null || randomTargetLine == null)
{
return;
}
double pos2LengthRatio = 1;
if (!string.IsNullOrEmpty(observePos1TimeDiffText.Text) && !string.IsNullOrEmpty(observePos2TimeDiffText.Text))
{
try
{
double pos1TimeDiff = Convert.ToDouble(observePos1TimeDiffText.Text);
double pos2TimeDiff = Convert.ToDouble(observePos2TimeDiffText.Text);
pos2LengthRatio = pos2TimeDiff / pos1TimeDiff;
}
catch
{ }
}
var intercept1 = CoordinateSystemOperation.CalculatePointByTwoLines(directionLine1, randomTargetLine);
var intercept2 = CoordinateSystemOperation.CalculatePointByTwoLines(directionLine2, randomTargetLine);
var intercept3 = CoordinateSystemOperation.CalculatePointByTwoLines(directionLine3, randomTargetLine);
var length1 = CoordinateSystemOperation.CalculateLengthBetweenPoints(intercept1, intercept2);
var length2 = CoordinateSystemOperation.CalculateLengthBetweenPoints(intercept2, intercept3);
var length = (length1 + length2) / 2;
length = length * pos2LengthRatio;
LineDirection direction;
if (intercept2.x > intercept1.x)
{
direction = LineDirection.LEFT_TO_RIGHT;
}
else
{
direction = LineDirection.RIGHT_TO_LEFT;
}
PointModel observePos = new PointModel(0, 0);
if (!string.IsNullOrEmpty(observePos1Text.Text))
{
observePos = PointModel.Parse(observePos1Text.Text);
if (observePos == null)
{
return;
}
}
var estimatedPoint = CoordinateSystemOperation.CalculatePointByLineAndLength(randomTargetLine, intercept3, length, direction);
estimatedDirectionLine = CoordinateSystemOperation.CalculateLineFromTwoPoint(observePos, estimatedPoint);
estimatedDirectionLineText.Text = estimatedDirectionLine.ToString();
var headingLine = CoordinateSystemOperation.CalculateLineFromTwoPoint(intercept1, intercept2);
var heading = CoordinateSystemOperation.CalculateDirectionFromLine(headingLine);
targetHeadingText.Text = Math.Round(heading, 2).ToString();
}
public static void CalculateTargetObservationPos(TextBox targetDirectionText, TextBox subDirectionText, TextBox observationHeightText, TextBox targetHeightText, ref TextBox distanceText, ref TextBox observationDateText, ref TextBox targetPositionText, bool updateObservationDate = true)
{
if (updateObservationDate)
{
observationDateText.Text = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
}
if (string.IsNullOrEmpty(targetHeightText.Text) || string.IsNullOrEmpty(observationHeightText.Text))
{
return;
}
double targetHeight, observationHeight = 0;
try
{
targetHeight = Convert.ToDouble(targetHeightText.Text);
observationHeight = Convert.ToDouble(observationHeightText.Text);
}
catch
{
MessageBox.Show("invalid number: " + targetHeightText.Text + ", " + observationHeightText.Height);
return;
}
var distance = Math.Round(targetHeight / observationHeight * 400.00, 2);
distanceText.Text = distance.ToString();
if (string.IsNullOrEmpty(targetDirectionText.Text) || string.IsNullOrEmpty(subDirectionText.Text))
{
return;
}
double targetDirection = 0, subDirection = 0;
try
{
targetDirection = Convert.ToDouble(targetDirectionText.Text);
subDirection = Convert.ToDouble(subDirectionText.Text);
}
catch
{
MessageBox.Show("invalid number: " + targetDirectionText.Text + ", " + subDirectionText.Text);
}
var actualDirection = DirectionOperation.CalculateSubActualDirection(subDirection, targetDirection);
double xAxisAngle;
int quadrantIndex;
if (actualDirection < 90)
{
xAxisAngle = 90 - actualDirection;
quadrantIndex = 1;
}
else if (actualDirection < 180)
{
xAxisAngle = actualDirection - 90;
quadrantIndex = 2;
}
else if (actualDirection < 270)
{
xAxisAngle = 270 - actualDirection;
quadrantIndex = 3;
}
else
{
xAxisAngle = actualDirection - 270;
quadrantIndex = 4;
}
var cos = MathOperation.Cos(xAxisAngle);
var sin = MathOperation.Sin(xAxisAngle);
var x = cos * distance;
var y = sin * distance;
if (quadrantIndex == 2)
{
y = -1 * y;
}
if (quadrantIndex == 3)
{
y = -1 * y;
x = -1 * x;
}
if (quadrantIndex == 4)
{
x = -1 * x;
}
var point = new PointModel(x, y);
targetPositionText.Text = point.ToString();
}
private void DrawLineByPoint(ref Graphics graphic, Pen pen, PointModel point1, PointModel point2)
{
DrawLineByCoordinate(ref graphic, pen, point1.x, point1.y, point2.x, point2.y);
}
private void PaintNauticalChart()
{
Graphics graphic = this.CreateGraphics();
graphic.Clear(Color.LightGray);
PaintCoordinateSystem(ref graphic);
#region direction distance aiming form
if (!string.IsNullOrEmpty(directionDistanceAimingForm.subHeadingText.Text))
{
try
{
var heading = Convert.ToDouble(directionDistanceAimingForm.subHeadingText.Text);
PaintEntity(ref graphic, ChartEntityType.SUB, 0, 0, heading);
}
catch
{ }
}
if (!string.IsNullOrEmpty(directionDistanceAimingForm.targetPosition1Text.Text))
{
PointModel point = PointModel.Parse(directionDistanceAimingForm.targetPosition1Text.Text);
if (point != null)
{
PaintPosition(ref graphic, point);
}
}
if (!string.IsNullOrEmpty(directionDistanceAimingForm.targetPosition2Text.Text))
{
PointModel point = PointModel.Parse(directionDistanceAimingForm.targetPosition2Text.Text);
if (point != null)
{
PaintPosition(ref graphic, point);
}
}
if (!string.IsNullOrEmpty(directionDistanceAimingForm.targetPosition3Text.Text))
{
PointModel point = PointModel.Parse(directionDistanceAimingForm.targetPosition3Text.Text);
if (point != null)
{
PaintPosition(ref graphic, point);
}
}
if (directionDistanceAimingForm.targetLine != null)
{
PaintTargetLine(ref graphic, directionDistanceAimingForm.targetLine, ChartEntityType.TARGET);
}
if (!string.IsNullOrEmpty(directionDistanceAimingForm.targetEstimatedPositionText.Text) && !string.IsNullOrEmpty(directionDistanceAimingForm.targetHeadingText.Text))
{
var targetPos = PointModel.Parse(directionDistanceAimingForm.targetEstimatedPositionText.Text);
if (targetPos != null)
{
try
{
var targetHeading = Convert.ToDouble(directionDistanceAimingForm.targetHeadingText.Text);
PaintEntity(ref graphic, ChartEntityType.TARGET, targetPos, targetHeading);
}
catch
{ }
}
}
if (directionDistanceAimingForm.targetLine != null && !string.IsNullOrEmpty(directionDistanceAimingForm.subHeadingText.Text) && !string.IsNullOrEmpty(directionDistanceAimingForm.attackDirectionText.Text))
{
try
{
var subHeading = Convert.ToDouble(directionDistanceAimingForm.subHeadingText.Text);
var attackAngle = Convert.ToDouble(directionDistanceAimingForm.attackDirectionText.Text);
PaintAttackLine(ref graphic, directionDistanceAimingForm.targetLine, subHeading, attackAngle);
}
catch
{ }
}
#endregion
#region direction aiming form
if (!string.IsNullOrEmpty(directionAimingForm.subPos1HeadingText.Text))
{
try
{
double heading = Convert.ToDouble(directionAimingForm.subPos1HeadingText.Text);
PaintEntity(ref graphic, ChartEntityType.SUB, new PointModel(0, 0), heading);
}
catch
{ }
}
if (directionAimingForm.directionLine1 != null)
{
Pen pen = new Pen(Color.Black, 2);
DrawLineByLine(ref graphic, pen, directionAimingForm.directionLine1);
pen.Dispose();
}
if (directionAimingForm.directionLine2 != null)
{
Pen pen = new Pen(Color.Black, 2);
DrawLineByLine(ref graphic, pen, directionAimingForm.directionLine2);
pen.Dispose();
}
if (directionAimingForm.directionLine3 != null)
{
Pen pen = new Pen(Color.Black, 2);
DrawLineByLine(ref graphic, pen, directionAimingForm.directionLine3);
pen.Dispose();
}
if (directionAimingForm.directionLine4 != null)
{
Pen pen = new Pen(Color.Black, 2);
DrawLineByLine(ref graphic, pen, directionAimingForm.directionLine4);
pen.Dispose();
}
if (directionAimingForm.targetRandomLine != null)
{
Pen pen = new Pen(Color.Blue, 2);
DrawLineByLine(ref graphic, pen, directionAimingForm.targetRandomLine);
pen.Dispose();
}
if (directionAimingForm.estimatedDirectionLine != null)
{
try
{
Pen pen = new Pen(Color.Blue, 2);
DrawLineByLine(ref graphic, pen, directionAimingForm.estimatedDirectionLine);
pen.Dispose();
}
catch
{ }
}
if (directionAimingForm.targetActualLine != null)
{
try
{
Pen pen = new Pen(Color.Black, 2);
DrawLineByLine(ref graphic, pen, directionAimingForm.targetActualLine);
pen.Dispose();
}
catch
{ }
}
if (!string.IsNullOrEmpty(directionAimingForm.observePoint1PositionText.Text))
{
var observePoint1 = PointModel.Parse(directionAimingForm.observePoint1PositionText.Text);
if (observePoint1 != null)
{
PaintPosition(ref graphic, observePoint1);
}
}
if (directionAimingForm.targetConfirmedPos != null)
{
PaintPosition(ref graphic, directionAimingForm.targetConfirmedPos);
}
if (!string.IsNullOrEmpty(directionAimingForm.targetEstimatedPosText.Text) && !string.IsNullOrEmpty(directionAimingForm.targetHeadingText.Text))
{
var targetPos = PointModel.Parse(directionAimingForm.targetEstimatedPosText.Text);
if (targetPos != null)
{
try
{
var targetHeading = Convert.ToDouble(directionAimingForm.targetHeadingText.Text);
PaintEntity(ref graphic, ChartEntityType.TARGET, targetPos, targetHeading);
}
catch
{ }
}
}
if (directionAimingForm.targetActualLine != null && !string.IsNullOrEmpty(directionAimingForm.subPos1HeadingText.Text) && !string.IsNullOrEmpty(directionAimingForm.attackDirectionText.Text))
{
try
{
var subHeading = Convert.ToDouble(directionAimingForm.subPos1HeadingText.Text);
var attackAngle = Convert.ToDouble(directionAimingForm.attackDirectionText.Text);
PaintAttackLine(ref graphic, directionAimingForm.targetActualLine, subHeading, attackAngle);
}
catch
{ }
}
#endregion
#region test paints
#endregion
graphic.Dispose();
}
private void PaintEntity(ref Graphics graphic, ChartEntityType entityType, PointModel point, double heading)
{
PaintEntity(ref graphic, entityType, point.x, point.y, heading);
}
private void PaintPosition(ref Graphics graphic, PointModel point)
{
PaintPosition(ref graphic, point.x, point.y);
}
public AttackParameterModel(PointModel attackPoint, double AOB)
{
this.attackPoint = attackPoint;
this.AOB = AOB;
}
public static double CalculateLengthBetweenPointAndLine(PointModel point, LineModel line)
{
var result = (line.a * point.x - point.y + line.b) / Math.Sqrt(line.a * line.a + 1);
return(result);
}
public static double CalculateLengthBetweenPoints(PointModel point1, PointModel point2)
{
var result = Math.Sqrt(Math.Pow(point2.x - point1.x, 2) + Math.Pow(point2.y - point1.y, 2));
return(result);
}
