private void ComputeVelocities(TrajectoryKinematics kinematics, CalibrationHelper calibrationHelper)
{
if (kinematics.Length <= 2)
{
PadVelocities(kinematics);
return;
}
for (int i = 1; i < kinematics.Length - 1; i++)
{
PointF a = kinematics.Coordinates(i - 1);
PointF b = kinematics.Coordinates(i + 1);
float t = calibrationHelper.GetTime(2);
kinematics.Speed[i] = (double)calibrationHelper.ConvertSpeed(GetSpeed(a, b, t, Component.Magnitude));
kinematics.HorizontalVelocity[i] = (double)calibrationHelper.ConvertSpeed(GetSpeed(a, b, t, Component.Horizontal));
kinematics.VerticalVelocity[i] = (double)calibrationHelper.ConvertSpeed(GetSpeed(a, b, t, Component.Vertical));
}
PadVelocities(kinematics);
double constantVelocitySpan = 40;
MovingAverage filter = new MovingAverage();
kinematics.Speed = filter.FilterSamples(kinematics.Speed, calibrationHelper.CaptureFramesPerSecond, constantVelocitySpan, 1);
kinematics.HorizontalVelocity = filter.FilterSamples(kinematics.HorizontalVelocity, calibrationHelper.CaptureFramesPerSecond, constantVelocitySpan, 1);
kinematics.VerticalVelocity = filter.FilterSamples(kinematics.VerticalVelocity, calibrationHelper.CaptureFramesPerSecond, constantVelocitySpan, 1);
}
private void ComputeAngularAccelerations(TrajectoryKinematics kinematics, CalibrationHelper calibrationHelper)
{
if (kinematics.Length <= 4)
{
PadAngularAccelerations(kinematics);
return;
}
for (int i = 2; i < kinematics.Length - 2; i++)
{
double d1 = GetDisplacementAngle(kinematics, i - 1, i - 2);
double d2 = GetDisplacementAngle(kinematics, i, i - 1);
double d3 = GetDisplacementAngle(kinematics, i + 1, i);
double d4 = GetDisplacementAngle(kinematics, i + 2, i + 1);
float t02 = calibrationHelper.GetTime(2);
float t24 = calibrationHelper.GetTime(2);
float t13 = calibrationHelper.GetTime(2);
float v1 = (float)((d1 + d2) / t02);
float v2 = (float)((d3 + d4) / t24);
float a = (float)((v2 - v1) / t13);
kinematics.AngularAcceleration[i] = calibrationHelper.ConvertAngularAcceleration(a);
}
PadAngularAccelerations(kinematics);
}
private void ComputeAcceleration(TimeSeriesCollection tsc, CalibrationHelper calibrationHelper)
{
if (tsc.Length <= 2)
{
PadAccelerations(tsc);
return;
}
for (int i = 1; i < tsc.Length - 1; i++)
{
float v1 = velocities[i - 1];
float v2 = velocities[i + 1];
float t = calibrationHelper.GetTime(2);
float alpha = (v2 - v1) / t;
tsc[Kinematics.AngularAcceleration][i] = (double)calibrationHelper.ConvertAngularAcceleration(alpha);
float at = radii[i] * alpha;
tsc[Kinematics.TangentialAcceleration][i] = (double)calibrationHelper.ConvertAcceleration(at);
float ac = radii[i] * velocities[i] * velocities[i];
tsc[Kinematics.CentripetalAcceleration][i] = (double)calibrationHelper.ConvertAcceleration(ac);
float a = (float)Math.Sqrt(at * at + ac * ac);
tsc[Kinematics.ResultantLinearAcceleration][i] = (double)calibrationHelper.ConvertAcceleration(a);
}
PadAccelerations(tsc);
}
public void UpdateOrigin()
{
if (CalibrationHelper != null)
{
points["0"] = CalibrationHelper.GetImagePoint(PointF.Empty);
}
}
private static void AlignPointPerpendicular(GenericPosture posture, CalibrationHelper calibrationHelper, GenericPosturePerpendicularAlign impact)
{
// The point is moved so that it stays on a perpendicular segment relatively to another segment.
if (impact == null)
{
return;
}
PointF pivot = posture.PointList[impact.Origin];
PointF leg1 = posture.PointList[impact.Leg1];
PointF pointToMove = posture.PointList[impact.PointToMove];
if (pivot == leg1)
{
return;
}
PointF pivotPlane = calibrationHelper.GetPoint(pivot);
PointF leg1Plane = calibrationHelper.GetPoint(leg1);
PointF pointPlane = calibrationHelper.GetPoint(pointToMove);
PointF resultPlane = GeometryHelper.GetPointAtAngle(pivotPlane, leg1Plane, pointPlane, 90);
PointF result = calibrationHelper.GetImagePoint(resultPlane);
posture.PointList[impact.PointToMove] = result;
}
private void DrawPositions(SolidBrush brushFill, Color baseBrushFillColor, int alphaBackground, double opacity, Graphics canvas, IImageToViewportTransformer transformer, List <Point> points)
{
foreach (GenericPosturePosition position in genericPosture.Positions)
{
if (!IsActive(position.OptionGroup))
{
continue;
}
PointF untransformedP = position.Point >= 0 ? genericPosture.PointList[position.Point] : GetUntransformedComputedPoint(position.Point);
string label = CalibrationHelper.GetPointText(untransformedP, true, true, infosFading.ReferenceTimestamp);
if (!string.IsNullOrEmpty(position.Symbol))
{
label = string.Format("{0} = {1}", position.Symbol, label);
}
PointF p = position.Point >= 0 ? points[position.Point] : GetComputedPoint(position.Point, transformer);
brushFill.Color = position.Color == Color.Transparent ? baseBrushFillColor : Color.FromArgb(alphaBackground, position.Color);
DrawPointText(p, label, canvas, opacity, transformer, brushFill);
}
brushFill.Color = baseBrushFillColor;
}
public override void MoveDrawing(float dx, float dy, Keys modifierKeys, bool zooming)
{
if (zooming)
{
return;
}
if (CalibrationHelper == null)
{
return;
}
if ((modifierKeys & Keys.Alt) == Keys.Alt)
{
// Change the number of divisions.
styleHelper.GridDivisions = styleHelper.GridDivisions + (int)((dx - dy) / 4);
styleHelper.GridDivisions = Math.Min(Math.Max(styleHelper.GridDivisions, minimumSubdivisions), maximumSubdivisions);
}
else
{
if (!styleHelper.Perspective)
{
quadImage.Translate(dx, dy);
CalibrationHelper.CalibrationByPlane_Update(Id, quadImage);
}
}
SignalAllTrackablePointsMoved();
}
private void DrawDistances(SolidBrush brushFill, Color baseBrushFillColor, int alphaBackground, double opacity, Graphics canvas, IImageToViewportTransformer transformer, List <Point> points)
{
foreach (GenericPostureDistance distance in genericPosture.Distances)
{
if (!IsActive(distance.OptionGroup))
{
continue;
}
PointF untransformedA = distance.Point1 >= 0 ? genericPosture.PointList[distance.Point1] : GetUntransformedComputedPoint(distance.Point1);
PointF untransformedB = distance.Point2 >= 0 ? genericPosture.PointList[distance.Point2] : GetUntransformedComputedPoint(distance.Point2);
string label = CalibrationHelper.GetLengthText(untransformedA, untransformedB, true, true);
if (!string.IsNullOrEmpty(distance.Symbol))
{
label = string.Format("{0} = {1}", distance.Symbol, label);
}
PointF a = distance.Point1 >= 0 ? points[distance.Point1] : GetComputedPoint(distance.Point1, transformer);
PointF b = distance.Point2 >= 0 ? points[distance.Point2] : GetComputedPoint(distance.Point2, transformer);
brushFill.Color = distance.Color == Color.Transparent ? baseBrushFillColor : Color.FromArgb(alphaBackground, distance.Color);
DrawDistanceText(a, b, label, canvas, opacity, transformer, brushFill);
}
brushFill.Color = baseBrushFillColor;
}
private static void ProcessPointImpacts(GenericPosture posture, CalibrationHelper calibrationHelper, int handle, PointF old)
{
foreach (GenericPostureAbstractImpact impact in posture.Handles[handle].Impacts)
{
ProcessPointImpact(posture, calibrationHelper, impact, handle, old);
}
}
public FormCalibrateDistortion(Bitmap currentImage, List <List <PointF> > points, CalibrationHelper calibrationHelper)
{
this.currentImage = currentImage;
this.calibrationHelper = calibrationHelper;
if (calibrationHelper.DistortionHelper == null || !calibrationHelper.DistortionHelper.Initialized)
{
distorter.Initialize(DistortionParameters.Default, calibrationHelper.ImageSize);
bmpUndistorted = currentImage;
}
else
{
distorter.Initialize(calibrationHelper.DistortionHelper.Parameters, calibrationHelper.ImageSize);
}
calibrator = new CameraCalibrator(points, calibrationHelper.ImageSize);
InitializeComponent();
LocalizeForm();
mnuOpen.Click += (s, e) => Open();
mnuSave.Click += (s, e) => Save();
mnuImportAgisoft.Click += (s, e) => ImportAgisoft();
mnuDefault.Click += (s, e) => RestoreDefaults();
mnuQuit.Click += (s, e) => Close();
if (currentImage == null)
{
tabPages.TabPages.Remove(tabImage);
}
btnCalibrate.Enabled = calibrator.Valid;
Populate();
}
public static void MoveHandle(GenericPosture posture, CalibrationHelper calibrationHelper, int handle, PointF point, Keys modifiers)
{
try
{
// Update the point(s) attached to the handle based on the constraints.
// Update all other points that may have been impacted.
switch (posture.Handles[handle].Type)
{
case HandleType.Point:
MovePointHandle(posture, calibrationHelper, handle, point, modifiers);
break;
case HandleType.Segment:
MoveSegmentHandle(posture, calibrationHelper, handle, point);
break;
case HandleType.Ellipse:
case HandleType.Circle:
MoveCircleHandle(posture, handle, point);
break;
}
}
catch (Exception e)
{
log.DebugFormat("Error while moving handle");
log.DebugFormat(e.ToString());
}
}
private string GetExtraDataText(long currentTimestamp)
{
if (trackExtraData == TrackExtraData.None)
{
return("");
}
string displayText = "###";
switch (trackExtraData)
{
case TrackExtraData.Name:
displayText = name;
break;
case TrackExtraData.TotalDistance:
PointF o = CalibrationHelper.GetOrigin();
displayText = CalibrationHelper.GetLengthText(o, points["0"], true, true);
break;
case TrackExtraData.Position:
default:
displayText = CalibrationHelper.GetPointText(points["0"], true, true, currentTimestamp);
break;
}
return(displayText);
}
private void LocalizeForm()
{
this.Text = " " + ScreenManagerLang.dlgConfigureMeasure_Title;
btnCancel.Text = ScreenManagerLang.Generic_Cancel;
btnOK.Text = ScreenManagerLang.Generic_Apply;
grpConfig.Text = ScreenManagerLang.Generic_Configuration;
lblRealSize.Text = ScreenManagerLang.dlgConfigureMeasure_lblRealSize.Replace("\\n", "\n");
// Combo Units (MUST be filled in the order of the enum)
cbUnit.Items.Add(ScreenManagerLang.LengthUnit_Centimeters + " (" + CalibrationHelper.GetLengthAbbreviationFromUnit(LengthUnits.Centimeters) + ")");
cbUnit.Items.Add(ScreenManagerLang.LengthUnit_Meters + " (" + CalibrationHelper.GetLengthAbbreviationFromUnit(LengthUnits.Meters) + ")");
cbUnit.Items.Add(ScreenManagerLang.LengthUnit_Inches + " (" + CalibrationHelper.GetLengthAbbreviationFromUnit(LengthUnits.Inches) + ")");
cbUnit.Items.Add(ScreenManagerLang.LengthUnit_Feet + " (" + CalibrationHelper.GetLengthAbbreviationFromUnit(LengthUnits.Feet) + ")");
cbUnit.Items.Add(ScreenManagerLang.LengthUnit_Yards + " (" + CalibrationHelper.GetLengthAbbreviationFromUnit(LengthUnits.Yards) + ")");
// Update with current values.
if (m_Metadata.CalibrationHelper.CurrentLengthUnit == LengthUnits.Pixels)
{
// Default to 50 cm if no unit selected yet.
tbMeasure.Text = "50";
cbUnit.SelectedIndex = (int)LengthUnits.Centimeters;
}
else
{
tbMeasure.Text = String.Format("{0:0.00}", m_fCurrentLengthReal);
cbUnit.SelectedIndex = (int)m_Metadata.CalibrationHelper.CurrentLengthUnit;
}
}
public override int HitTest(PointF point, long currentTimestamp, DistortionHelper distorter, IImageToViewportTransformer transformer, bool zooming)
{
// Convention: miss = -1, object = 0, handle = n.
if (!Visible)
{
return(-1);
}
int result = -1;
if (HitTester.HitTest(points["0"], point, transformer))
{
return(1);
}
if (showGrid || showGraduations || showAxis)
{
CoordinateSystemGrid grid = CalibrationHelper.GetCoordinateSystemGrid();
if (grid.HorizontalAxis != null && IsPointOnRectifiedLine(point, grid.HorizontalAxis.Start, grid.HorizontalAxis.End, distorter, transformer))
{
result = 2;
}
else if (grid.VerticalAxis != null && IsPointOnRectifiedLine(point, grid.VerticalAxis.Start, grid.VerticalAxis.End, distorter, transformer))
{
result = 3;
}
}
return(result);
}
private static void MovePointHandleByRotationSteps(GenericPosture posture, CalibrationHelper calibrationHelper, int handle, PointF point, GenericPostureConstraintRotationSteps constraint)
{
if (constraint == null)
{
return;
}
PointF parent = posture.PointList[constraint.Origin];
PointF leg1 = posture.PointList[constraint.Leg1];
if (parent == leg1 || constraint.Step == 0)
{
return;
}
PointF candidate = point;
if (constraint.KeepDistance)
{
PointF leg2 = posture.PointList[posture.Handles[handle].Reference];
float distance = GeometryHelper.GetDistance(parent, leg2);
candidate = GeometryHelper.GetPointAtDistance(parent, point, distance);
}
int constraintAngleSubdivisions = 360 / constraint.Step;
posture.PointList[posture.Handles[handle].Reference] = GeometryHelper.GetPointAtClosestRotationStep(parent, leg1, candidate, constraintAngleSubdivisions);
}
private static void ExportImage(CalibrationHelper calibrationHelper, CoordinateSystemGrid grid)
{
//Bitmap bitmap = new Bitmap((int)(calibrationHelper.ImageSize.Width + 100), (int)(calibrationHelper.ImageSize.Height + 100), PixelFormat.Format24bppRgb);
Bitmap bitmap = new Bitmap((int)(calibrationHelper.ImageSize.Width), (int)(calibrationHelper.ImageSize.Height), PixelFormat.Format24bppRgb);
Graphics g = Graphics.FromImage(bitmap);
g.FillRectangle(Brushes.White, 0, 0, bitmap.Width, bitmap.Height);
if (grid.VerticalAxis != null)
{
g.DrawLine(Pens.Blue, grid.VerticalAxis.Start, grid.VerticalAxis.End);
}
if (grid.HorizontalAxis != null)
{
g.DrawLine(Pens.Blue, grid.HorizontalAxis.Start, grid.HorizontalAxis.End);
}
foreach (GridLine line in grid.GridLines)
{
g.DrawLine(Pens.Red, line.Start, line.End);
}
string filename = GetRandomString(10);
bitmap.Save(Path.Combine(@"C:\Users\Joan\Videos\Kinovea\Video Testing\Projective\infinite plane\rnd", string.Format("{0}.png", filename)));
}
public void Update(PointF o, PointF a, PointF b, int radius, Color color, CalibrationHelper calibration, IImageToViewportTransformer transformer)
{
if (o == a || o == b)
{
return;
}
Origin = o;
Angle = ComputeAngle(o, a, b, false);
Color = color;
if (calibration == null)
{
CalibratedAngle = Angle;
}
else if (calibration.CalibratorType == CalibratorType.Plane)
{
PointF calibratedO = calibration.GetPoint(o);
PointF calibratedA = calibration.GetPoint(a);
PointF calibratedB = calibration.GetPoint(b);
CalibratedAngle = ComputeAngle(calibratedO, calibratedA, calibratedB, true);
}
else if (calibration.CalibratorType == CalibratorType.Line)
{
// Note that direction of Y-axis is not the same that the one used for the uncalibrated space.
PointF calibratedO = calibration.GetPoint(o);
PointF calibratedA = calibration.GetPoint(a);
PointF calibratedB = calibration.GetPoint(b);
CalibratedAngle = ComputeAngle(calibratedO, calibratedA, calibratedB, true);
}
ComputeBoundingBox(o, a, b, (float)radius);
ComputeTextPosition(Angle, transformer);
ComputeHitRegion(BoundingBox, Angle);
}
public FormCalibrateDistortion(Bitmap currentImage, List <List <PointF> > points, CalibrationHelper calibrationHelper)
{
this.bmpCurrentImage = currentImage;
this.calibrationHelper = calibrationHelper;
if (calibrationHelper.DistortionHelper == null || !calibrationHelper.DistortionHelper.Initialized)
{
distortionParameters = new DistortionParameters(calibrationHelper.ImageSize);
}
else
{
distortionParameters = calibrationHelper.DistortionHelper.Parameters;
}
distorter.Initialize(distortionParameters, calibrationHelper.ImageSize);
calibrator = new CameraCalibrator(points, calibrationHelper.ImageSize);
InitializeComponent();
LocalizeForm();
SetupStyle();
PopulateStyleElements();
mnuOpen.Click += (s, e) => Open();
mnuSave.Click += (s, e) => Save();
mnuImportAgisoft.Click += (s, e) => ImportAgisoft();
mnuDefault.Click += (s, e) => RestoreDefaults();
mnuQuit.Click += (s, e) => Close();
btnCalibrate.Enabled = calibrator.Valid;
AfterImport();
PopulatePhysicalParameters();
PopulateValues();
UpdateDistortionGrid();
}
private string GetExtraDataText()
{
if (trackExtraData == TrackExtraData.None)
{
return("");
}
string displayText = "###";
switch (trackExtraData)
{
case TrackExtraData.Name:
displayText = name;
break;
case TrackExtraData.TotalDistance:
default:
PointF a = new PointF(points["a"].X, points["a"].Y);
PointF b = new PointF(points["b"].X, points["b"].Y);
displayText = CalibrationHelper.GetLengthText(a, b, true, true);
break;
}
return(displayText);
}
public override void MoveHandle(PointF point, int handleNumber, Keys modifiers)
{
int handle = handleNumber - 1;
quadImage[handle] = point;
if (inPerspective)
{
planeIsConvex = quadImage.IsConvex;
}
else
{
if ((modifiers & Keys.Shift) == Keys.Shift)
{
quadImage.MakeSquare(handle);
}
else
{
quadImage.MakeRectangle(handle);
}
}
SignalTrackablePointMoved(handle);
CalibrationHelper.CalibrationByPlane_Update(quadImage);
}
public override void Draw(Graphics canvas, DistortionHelper distorter, IImageToViewportTransformer transformer, bool selected, long currentTimestamp)
{
double opacityFactor = infosFading.GetOpacityFactor(currentTimestamp);
if (tracking)
{
opacityFactor = 1.0;
}
if (opacityFactor <= 0)
{
return;
}
int iAlpha = (int)(opacityFactor * 255);
Point c = transformer.Transform(points["0"]);
using (Pen p = styleHelper.GetPen(iAlpha))
using (SolidBrush b = styleHelper.GetBrush((int)(opacityFactor * defaultBackgroundAlpha)))
{
canvas.DrawLine(p, c.X - defaultRadius, c.Y, c.X + defaultRadius, c.Y);
canvas.DrawLine(p, c.X, c.Y - defaultRadius, c.X, c.Y + defaultRadius);
canvas.FillEllipse(b, c.Box(defaultRadius + 1));
}
if (ShowMeasurableInfo)
{
labelCoordinates.SetText(CalibrationHelper.GetPointText(new PointF(points["0"].X, points["0"].Y), true, true, infosFading.ReferenceTimestamp));
labelCoordinates.Draw(canvas, transformer, opacityFactor);
}
}
public FormCalibrateLine(CalibrationHelper calibrationHelper, DrawingLine line)
{
this.calibrationHelper = calibrationHelper;
this.line = line;
InitializeComponent();
LocalizeForm();
InitializeValues();
}
private static void MovePointHandle(GenericPosture posture, CalibrationHelper calibrationHelper, int handle, PointF point, Keys modifiers)
{
// Constraints. (position of the point managed by this handle).
GenericPostureAbstractConstraint constraint = posture.Handles[handle].Constraint;
PointF old = posture.PointList[posture.Handles[handle].Reference];
PrepareImpacts(posture, handle);
if (constraint == null ||
(!string.IsNullOrEmpty(constraint.OptionGroup) && !posture.OptionGroups[constraint.OptionGroup]))
{
MovePointHandleFreely(posture, handle, point);
}
else
{
switch (constraint.Type)
{
case ConstraintType.None:
MovePointHandleFreely(posture, handle, point);
break;
case ConstraintType.LineSlide:
MovePointHandleAlongLine(posture, handle, point, constraint as GenericPostureConstraintLineSlide);
break;
case ConstraintType.VerticalSlide:
MovePointHandleAlongVertical(posture, calibrationHelper, handle, point);
break;
case ConstraintType.HorizontalSlide:
MovePointHandleAlongHorizontal(posture, handle, point);
break;
case ConstraintType.DistanceToPoint:
MovePointHandleAtDistance(posture, handle, point, constraint as GenericPostureConstraintDistanceToPoint, modifiers);
break;
case ConstraintType.RotationSteps:
MovePointHandleByRotationSteps(posture, calibrationHelper, handle, point, constraint as GenericPostureConstraintRotationSteps);
break;
case ConstraintType.PerpendicularSlide:
MovePointHandleAlongPerpendicular(posture, calibrationHelper, handle, point, constraint as GenericPostureConstraintPerpendicularSlide);
break;
case ConstraintType.ParallelSlide:
MovePointHandleAlongParallel(posture, calibrationHelper, handle, point, constraint as GenericPostureConstraintParallelSlide);
break;
case ConstraintType.LockedInPlace:
break;
}
}
ProcessPointImpacts(posture, calibrationHelper, handle, old);
}
public void SetTrackablePointValue(string name, PointF value)
{
if (!points.ContainsKey(name))
{
throw new ArgumentException("This point is not bound.");
}
points[name] = value;
CalibrationHelper.SetOrigin(value);
}
public FormCalibratePlane(CalibrationHelper calibrationHelper, DrawingPlane drawingPlane)
{
this.calibrationHelper = calibrationHelper;
this.drawingPlane = drawingPlane;
this.quadrilateral = drawingPlane.QuadImage;
InitializeComponent();
LocalizeForm();
InitializeValues();
}
public void SetTrackablePointValue(string name, PointF value)
{
int p = int.Parse(name);
quadImage[p] = new PointF(value.X, value.Y);
projectiveMapping.Update(quadPlane, quadImage);
CalibrationHelper.CalibrationByPlane_Update(quadImage);
planeIsConvex = quadImage.IsConvex;
}
private static void MovePointHandleAlongVertical(GenericPosture posture, CalibrationHelper calibrationHelper, int handle, PointF point)
{
/*PointF source = calibrationHelper.GetPoint(posture.Points[posture.Handles[handle].Reference]);
* PointF target = calibrationHelper.GetPoint(point.ToPointF());
*
* PointF result = new PointF(source.X, target.Y);
* PointF resultImage = calibrationHelper.GetImagePoint(result);
*
* posture.Points[posture.Handles[handle].Reference] = resultImage;*/
posture.Points[posture.Handles[handle].Reference] = new PointF(posture.Points[posture.Handles[handle].Reference].X, point.Y);
}
private void ComputeFilteredCoordinates(TrajectoryKinematics kinematics, CalibrationHelper calibrationHelper)
{
double framerate = calibrationHelper.CaptureFramesPerSecond;
ButterworthFilter filter = new ButterworthFilter();
int bestCutoffIndex;
kinematics.FilterResultXs = filter.FilterSamples(kinematics.RawXs, framerate, 100, out bestCutoffIndex);
kinematics.XCutoffIndex = bestCutoffIndex;
kinematics.FilterResultYs = filter.FilterSamples(kinematics.RawYs, framerate, 100, out bestCutoffIndex);
kinematics.YCutoffIndex = bestCutoffIndex;
}
public static CoordinateSystemGrid Find(CalibrationHelper calibrationHelper)
{
switch (calibrationHelper.CalibratorType)
{
case CalibratorType.Line:
return(FindForLineCalibration(calibrationHelper));
case CalibratorType.Plane:
return(FindForPlaneCalibration(calibrationHelper));
}
return(null);
}
public void SetTrackablePointValue(string name, PointF value)
{
if (!points.ContainsKey(name))
{
throw new ArgumentException("This point is not bound.");
}
points[name] = value;
if (CalibrationHelper != null)
{
CalibrationHelper.CalibrationByLine_Update(Id, points["a"], points["b"]);
}
}
