public TrackedObject(byte targetNo, TrackedObjectConfig originalObject)
: base(targetNo, originalObject)
{
ThisFrameX = originalObject.ApertureStartingX;
ThisFrameY = originalObject.ApertureStartingY;
ThisFrameCertainty = originalObject.Gaussian != null ? (float)originalObject.Gaussian.Certainty : 0;
}
public TrackedObject(byte targetNo, TrackedObjectConfig originalObject)
: base(targetNo, originalObject)
{
ThisFrameX = originalObject.ApertureStartingX;
ThisFrameY = originalObject.ApertureStartingY;
ThisFrameCertainty = originalObject.Gaussian != null ? (float)originalObject.Gaussian.Certainty : 0;
}
internal static TrackedObjectConfig Load(BinaryReader reader)
{
TrackedObjectConfig instance = new TrackedObjectConfig();
byte version = reader.ReadByte();
if (version > 0)
{
instance.TrackingType = (TrackingType)reader.ReadInt32();
instance.MeasureThisObject = reader.ReadBoolean();
instance.ApertureInPixels = reader.ReadSingle();
instance.PsfFitMatrixSize = reader.ReadInt32();
instance.ApertureStartingX = reader.ReadSingle();
instance.ApertureStartingY = reader.ReadSingle();
instance.OriginalFieldCenterX = reader.ReadInt32();
instance.OriginalFieldCenterY = reader.ReadInt32();
bool hasGaussian = reader.ReadBoolean();
if (hasGaussian)
{
instance.Gaussian = PSFFit.Load(reader);
}
instance.PositionTolerance = reader.ReadSingle();
instance.IsWeakSignalObject = reader.ReadBoolean();
instance.ApertureMatrixX0 = reader.ReadSingle();
instance.ApertureMatrixY0 = reader.ReadSingle();
instance.ApertureDX = reader.ReadSingle();
instance.ApertureDY = reader.ReadSingle();
instance.AutoStarsInArea = new List <PSFFit>();
int autoStarsInArea = reader.ReadInt32();
for (int i = 0; i < autoStarsInArea; i++)
{
instance.AutoStarsInArea.Add(PSFFit.Load(reader));
}
if (version > 1)
{
instance.RefinedFWHM = reader.ReadSingle();
if (version > 2)
{
instance.IsFixedAperture = reader.ReadBoolean();
if (version > 3)
{
instance.GroupId = reader.ReadInt32();
}
}
}
}
return(instance);
}
public TrackedObjectBase(byte targetNo, TrackedObjectConfig originalObject)
{
TargetNo = targetNo;
OriginalObject = originalObject;
ApertureArea = Math.PI * originalObject.ApertureInPixels * originalObject.ApertureInPixels;
IsOccultedStar = OriginalObject.TrackingType == TrackingType.OccultedStar;
PsfGroupId = OriginalObject.GroupId;
PsfFitMatrixSize = OriginalObject.PsfFitMatrixSize;
}
internal NativeSimplifiedTracker(int width, int height, List<TrackedObjectConfig> measuringStars, bool isFullDisappearance)
{
NativeTracking.ConfigureNativeTracker();
var dataRange = PSFFittingDataRange.DataRange8Bit;
switch (LightCurveReductionContext.Instance.BitPix)
{
case 8:
dataRange = PSFFittingDataRange.DataRange8Bit;
break;
case 12:
dataRange = PSFFittingDataRange.DataRange12Bit;
break;
case 14:
dataRange = PSFFittingDataRange.DataRange14Bit;
break;
case 16:
dataRange = PSFFittingDataRange.DataRange16Bit;
break;
default:
dataRange = PSFFittingDataRange.DataRange16Bit;
break;
}
NativeTracking.InitNewTracker(
width,
height,
measuringStars.Count,
LightCurveReductionContext.Instance.FullDisappearance,
dataRange,
(ushort)LightCurveReductionContext.Instance.MaxPixelValue);
for (int i = 0; i < measuringStars.Count; i++)
{
TrackedObjectConfig obj = measuringStars[i];
NativeTracking.ConfigureTrackedObject(i, obj);
var nativeObj = new NativeTrackedObject(i, LightCurveReductionContext.Instance.BitPix, obj, isFullDisappearance);
m_NativeTrackedObject.Add(nativeObj);
m_TrackedObjects.Add(nativeObj);
}
m_OccultedStarConfig = measuringStars.Single(x => x.TrackingType == TrackingType.OccultedStar);
}
internal NativeSimplifiedTracker(int width, int height, List <TrackedObjectConfig> measuringStars, bool isFullDisappearance)
{
NativeTracking.ConfigureNativeTracker();
var dataRange = PSFFittingDataRange.DataRange8Bit;
switch (LightCurveReductionContext.Instance.BitPix)
{
case 8:
dataRange = PSFFittingDataRange.DataRange8Bit;
break;
case 12:
dataRange = PSFFittingDataRange.DataRange12Bit;
break;
case 14:
dataRange = PSFFittingDataRange.DataRange14Bit;
break;
case 16:
dataRange = PSFFittingDataRange.DataRange16Bit;
break;
default:
dataRange = PSFFittingDataRange.DataRange16Bit;
break;
}
NativeTracking.InitNewTracker(
width,
height,
measuringStars.Count,
LightCurveReductionContext.Instance.FullDisappearance,
dataRange,
(ushort)LightCurveReductionContext.Instance.MaxPixelValue);
for (int i = 0; i < measuringStars.Count; i++)
{
TrackedObjectConfig obj = measuringStars[i];
NativeTracking.ConfigureTrackedObject(i, obj);
var nativeObj = new NativeTrackedObject(i, LightCurveReductionContext.Instance.BitPix, obj, isFullDisappearance);
m_NativeTrackedObject.Add(nativeObj);
m_TrackedObjects.Add(nativeObj);
}
m_OccultedStarConfig = measuringStars.Single(x => x.TrackingType == TrackingType.OccultedStar);
}
public MeasurmentGroup(float fwhm, TrackedObjectConfig firstObjectInGroup, int targetNo)
{
m_FWHM = fwhm;
AddObjectInGroup(firstObjectInGroup, targetNo);
}
public void ObjectSelected(TrackedObjectConfig selectedObject, bool shift, bool ctrl)
{
m_CurrentStateObject.ObjectSelected(selectedObject, shift, ctrl, -1);
}
public TrackedObjectBase(byte targetNo, TrackedObjectConfig originalObject)
{
TargetNo = targetNo;
OriginalObject = originalObject;
ApertureArea = Math.PI * originalObject.ApertureInPixels * originalObject.ApertureInPixels;
IsOccultedStar = OriginalObject.TrackingType == TrackingType.OccultedStar;
PsfGroupId = OriginalObject.GroupId;
PsfFitMatrixSize = OriginalObject.PsfFitMatrixSize;
}
internal frmAddOrEditSingleTarget(int objectId, TrackedObjectConfig selectedObject, LCStateMachine state, VideoController videoController)
{
InitializeComponent();
m_VideoController = videoController;
m_AutocenteredApertureAvailable = true;
Text = "Edit Object";
btnAdd.Text = "Save";
btnDontAdd.Text = "Cancel";
btnDelete.Visible = true;
m_IsEdit = true;
m_ObjectId = objectId;
m_State = state;
m_AstroImage = m_State.VideoOperation.m_StackedAstroImage;
ObjectToAdd = selectedObject;
if (selectedObject.TrackingType != TrackingType.ComparisonStar)
nudFitMatrixSize.SetNUDValue(selectedObject.PsfFitMatrixSize);
m_Center = new ImagePixel(
selectedObject.OriginalFieldCenterX,
selectedObject.OriginalFieldCenterY);
if (ObjectToAdd.PositionTolerance > 0)
nudPositionTolerance.SetNUDValue((decimal)ObjectToAdd.PositionTolerance);
Initialize();
if (!selectedObject.IsWeakSignalObject && !selectedObject.IsFixedAperture)
{
int matrixSize = selectedObject.PsfFitMatrixSize;
GetFitInMatrix(selectedObject.Gaussian, ref matrixSize, selectedObject.ApertureInPixels);
selectedObject.PsfFitMatrixSize = matrixSize;
}
else
{
m_ProcessingPixels = m_AstroImage.GetMeasurableAreaPixels(m_Center);
m_DisplayPixels = m_AstroImage.GetMeasurableAreaDisplayBitmapPixels(m_Center);
m_FWHM = 6;
m_Gaussian = null;
m_X0 = selectedObject.ApertureMatrixX0;
m_Y0 = selectedObject.ApertureMatrixY0;
dx = selectedObject.ApertureDX;
dy = selectedObject.ApertureDY;
PlotSingleTargetPixels();
nudAperture1.SetNUDValue((decimal) Math.Round(ObjectToAdd.ApertureInPixels, 2));
}
SetHeightAndType();
if (selectedObject.TrackingType == TrackingType.GuidingStar)
SelectedObjectType = TrackingType.GuidingStar;
else if (selectedObject.TrackingType == TrackingType.OccultedStar)
SelectedObjectType = TrackingType.OccultedStar;
}
public TrackedObjectLight(byte targetNo, TrackedObjectConfig originalObject)
: base(targetNo, originalObject)
{
Center = new ImagePixel(originalObject.OriginalFieldCenterX, originalObject.OriginalFieldCenterY);
}
internal frmAddOrEditMutualEventsTarget(int objectId, TrackedObjectConfig selectedObject, LCStateMachine state, VideoController videoController)
{
InitializeComponent();
m_VideoController = videoController;
Text = "Edit 'Mutual Event' Target";
btnAdd.Text = "Save";
btnDontAdd.Text = "Cancel";
btnDelete.Visible = true;
m_IsEdit = true;
m_ObjectId = objectId;
m_State = state;
m_AstroImage = m_VideoController.GetCurrentAstroImage(false);
ObjectToAdd = selectedObject;
float? commonAperture = m_State.MeasuringApertures.Count > 0
? m_State.MeasuringApertures[0] :
(float?)null;
m_Aperture = commonAperture;
m_Aperture1 = commonAperture;
m_Aperture2 = commonAperture;
m_Center = new ImagePixel(selectedObject.ApertureStartingX, selectedObject.ApertureStartingY);
m_OriginalCenter = new ImagePixel(selectedObject.ApertureStartingX, selectedObject.ApertureStartingY);
if (selectedObject.ProcessInPsfGroup)
{
m_GroupId = selectedObject.GroupId;
List<TrackedObjectConfig> otherGroupedObjects = state.m_MeasuringStars.Where(x => m_GroupId >= 0 && x.GroupId == m_GroupId && x != selectedObject).ToList();
if (otherGroupedObjects.Count == 1)
{
ObjectToAdd2 = otherGroupedObjects[0];
m_ObjectId2 = state.m_MeasuringStars.IndexOf(ObjectToAdd2);
}
}
else
{
ObjectToAdd2 = null;
m_GroupId = objectId;
// If we are to use a second object, it should have the next available Id
m_ObjectId2 = state.m_MeasuringStars.Count;
}
m_EditingOccultedStar = selectedObject.IsOcultedStar();
Initialise();
}
internal static TrackedObjectConfig Load(BinaryReader reader)
{
TrackedObjectConfig instance = new TrackedObjectConfig();
byte version = reader.ReadByte();
if (version > 0)
{
instance.TrackingType = (TrackingType)reader.ReadInt32();
instance.MeasureThisObject = reader.ReadBoolean();
instance.ApertureInPixels = reader.ReadSingle();
instance.PsfFitMatrixSize = reader.ReadInt32();
instance.ApertureStartingX = reader.ReadSingle();
instance.ApertureStartingY = reader.ReadSingle();
instance.OriginalFieldCenterX = reader.ReadInt32();
instance.OriginalFieldCenterY = reader.ReadInt32();
bool hasGaussian = reader.ReadBoolean();
if (hasGaussian)
instance.Gaussian = PSFFit.Load(reader);
instance.PositionTolerance = reader.ReadSingle();
instance.IsWeakSignalObject = reader.ReadBoolean();
instance.ApertureMatrixX0 = reader.ReadSingle();
instance.ApertureMatrixY0 = reader.ReadSingle();
instance.ApertureDX = reader.ReadSingle();
instance.ApertureDY = reader.ReadSingle();
instance.AutoStarsInArea = new List<PSFFit>();
int autoStarsInArea = reader.ReadInt32();
for (int i = 0; i < autoStarsInArea; i++)
{
instance.AutoStarsInArea.Add(PSFFit.Load(reader));
}
if (version > 1)
{
instance.RefinedFWHM = reader.ReadSingle();
if (version > 2)
{
instance.IsFixedAperture = reader.ReadBoolean();
if (version > 3)
{
instance.GroupId = reader.ReadInt32();
}
}
}
}
return instance;
}
internal static void ConfigureTrackedObject(int objectId, TrackedObjectConfig obj)
{
TrackerConfigureObject(
objectId,
obj.IsFixedAperture,
obj.TrackingType == TrackingType.OccultedStar,
obj.ApertureStartingX,
obj.ApertureStartingY,
obj.ApertureInPixels);
}
public virtual void ObjectSelected(TrackedObjectConfig selectedObject, bool shift, bool ctrl, int selectedStarId)
{
}
public void AddObjectInGroup(TrackedObjectConfig objectToAdd, int targetNo)
{
if (m_ObjectIds.IndexOf(targetNo) == -1)
{
m_ObjectsInGroup.Add(objectToAdd);
m_ObjectIds.Add(targetNo);
}
}
public bool IsCloseEnoughToBelongToTheGroup(TrackedObjectConfig objectToCheck)
{
foreach (TrackedObjectConfig existingObject in m_ObjectsInGroup)
{
double distance =
ImagePixel.ComputeDistance(existingObject.ApertureStartingX, objectToCheck.ApertureStartingX,
existingObject.ApertureStartingY, objectToCheck.ApertureStartingY);
if (distance < m_FWHM * TangraConfig.Settings.Special.MinDistanceForPhotometricGroupingInFWHM)
{
return true;
}
}
return false;
}
private void CopyDoubleObjectsToAdd()
{
// Add the first star (with bigger amplitude)
ObjectToAdd = new TrackedObjectConfig();
ObjectToAdd.ApertureInPixels = (float)nudAperture1.Value;
ObjectToAdd.MeasureThisObject = true; /* We measure all objects (comparison or occulted), unless specified otherwise by the user */
ObjectToAdd.ApertureMatrixX0 = m_X1;
ObjectToAdd.ApertureMatrixY0 = m_Y1;
ObjectToAdd.ApertureDX = 0;
ObjectToAdd.ApertureDY = 0;
ObjectToAdd.AutoStarsInArea.Clear();
ObjectToAdd.OriginalFieldCenterX = m_Center.X;
ObjectToAdd.OriginalFieldCenterY = m_Center.Y;
ObjectToAdd.IsWeakSignalObject = false;
ObjectToAdd.Gaussian = m_DoubleGaussian.GetGaussian1();
ObjectToAdd.ApertureStartingX = m_X1Center;
ObjectToAdd.ApertureStartingY = m_Y1Center;
ObjectToAdd.GroupId = m_GroupId;
if (rbOcculted.Checked && rbOccElc1.Checked)
{
ObjectToAdd.TrackingType = TrackingType.OccultedStar;
ObjectToAdd.PositionTolerance = 2;
if (ObjectToAdd.Gaussian != null)
// Correction for really large stars
ObjectToAdd.PositionTolerance += (float)(ObjectToAdd.Gaussian.FWHM / 2);
ObjectToAdd.PsfFitMatrixSize = TangraConfig.Settings.Special.DefaultOccultedStarPsfFitMatrixSize;
}
else
{
ObjectToAdd.TrackingType = TrackingType.GuidingStar;
ObjectToAdd.PsfFitMatrixSize = (int)TangraConfig.Settings.Special.DefaultComparisonStarPsfFitMatrixSize;
ObjectToAdd.IsWeakSignalObject = false; // Must have a fit for a guiding star
}
// Add the second star (with bigger amplitude)
ObjectToAdd2 = new TrackedObjectConfig();
ObjectToAdd2.ApertureInPixels = (float)nudAperture1.Value;
ObjectToAdd2.MeasureThisObject = true; /* We measure all objects (comparison or occulted), unless specified otherwise by the user */
ObjectToAdd2.ApertureMatrixX0 = m_X2;
ObjectToAdd2.ApertureMatrixY0 = m_Y2;
ObjectToAdd2.ApertureDX = 0;
ObjectToAdd2.ApertureDY = 0;
ObjectToAdd2.AutoStarsInArea.Clear();
ObjectToAdd2.OriginalFieldCenterX = m_Center.X;
ObjectToAdd2.OriginalFieldCenterY = m_Center.Y;
ObjectToAdd2.GroupId = m_GroupId;
ObjectToAdd2.IsWeakSignalObject = false;
ObjectToAdd2.Gaussian = m_DoubleGaussian.GetGaussian2();
ObjectToAdd2.ApertureStartingX = m_X2Center;
ObjectToAdd2.ApertureStartingY = m_Y2Center;
if (rbOcculted.Checked && rbOccElc2.Checked)
{
ObjectToAdd2.TrackingType = TrackingType.OccultedStar;
ObjectToAdd2.PositionTolerance = 2;
if (ObjectToAdd.Gaussian != null)
// Correction for really large stars
ObjectToAdd2.PositionTolerance += (float)(ObjectToAdd.Gaussian.FWHM / 2);
ObjectToAdd2.PsfFitMatrixSize = TangraConfig.Settings.Special.DefaultOccultedStarPsfFitMatrixSize;
}
else
{
ObjectToAdd2.TrackingType = TrackingType.GuidingStar;
ObjectToAdd2.PsfFitMatrixSize = (int)TangraConfig.Settings.Special.DefaultComparisonStarPsfFitMatrixSize;
ObjectToAdd2.IsWeakSignalObject = false; // Must have a fit for a guiding star
}
}
internal void StartMeasurements()
{
MeasurementAreaWing = m_SpectroscopyController.SpectraReductionContext.MeasurementAreaWing;
BackgroundAreaWing = m_SpectroscopyController.SpectraReductionContext.BackgroundAreaWing;
BackgroundAreaGap = m_SpectroscopyController.SpectraReductionContext.BackgroundAreaGap;
PixelValueCoefficient = m_SpectroscopyController.SpectraReductionContext.PixelValueCoefficient;
var starToTrack = new TrackedObjectConfig()
{
ApertureInPixels = (float)(SelectedStarFWHM * 2),
MeasureThisObject = false,
ApertureDX = 0,
ApertureDY = 0,
Gaussian = m_SelectedStarGaussian,
ApertureStartingX = (float)m_SelectedStarGaussian.XCenter,
ApertureStartingY = (float)m_SelectedStarGaussian.YCenter,
TrackingType = TrackingType.OccultedStar,
IsWeakSignalObject = false
};
m_Tracker = new SpectroscopyStarTracker(starToTrack);
m_OperationState = SpectroscopyState.RunningMeasurements;
m_AllFramesSpectra.Clear();
m_ControlPanel.MeasurementsStarted();
m_FirstMeasuredFrame = null;
m_CancelMeasurementsRequested = false;
m_FramePlayer.Start(FramePlaySpeed.Fastest, null, 1);
}
private void CopyObjectToAdd()
{
ObjectToAdd = new TrackedObjectConfig();
ObjectToAdd.ApertureInPixels = (float)nudAperture1.Value;
ObjectToAdd.MeasureThisObject = true; /* We measure all objects (comparison or occulted), unless specified otherwise by the user */
ObjectToAdd.ApertureMatrixX0 = m_X0;
ObjectToAdd.ApertureMatrixY0 = m_Y0;
ObjectToAdd.ApertureDX = 0;
ObjectToAdd.ApertureDY = 0;
ObjectToAdd.AutoStarsInArea.Clear();
ObjectToAdd.OriginalFieldCenterX = m_Center.X;
ObjectToAdd.OriginalFieldCenterY = m_Center.Y;
ObjectToAdd.IsWeakSignalObject = false;
ObjectToAdd.Gaussian = m_Gaussian;
ObjectToAdd.ApertureStartingX = m_X0Center;
ObjectToAdd.ApertureStartingY = m_Y0Center;
ObjectToAdd.GroupId = -1;
if (rbOcculted.Checked)
{
ObjectToAdd.TrackingType = TrackingType.OccultedStar;
ObjectToAdd.PositionTolerance = 2;
if (ObjectToAdd.Gaussian != null)
// Correction for really large stars
ObjectToAdd.PositionTolerance += (float)(ObjectToAdd.Gaussian.FWHM / 2);
ObjectToAdd.PsfFitMatrixSize = TangraConfig.Settings.Special.DefaultOccultedStarPsfFitMatrixSize;
}
else
{
ObjectToAdd.TrackingType = TrackingType.GuidingStar;
ObjectToAdd.PsfFitMatrixSize = (int)TangraConfig.Settings.Special.DefaultComparisonStarPsfFitMatrixSize;
ObjectToAdd.IsWeakSignalObject = false; // Must have a fit for a guiding star
}
ObjectToAdd2 = null;
}
internal frmAddOrEditSingleTarget(int objectId, ImagePixel center, PSFFit gaussian, LCStateMachine state, VideoController videoController)
{
InitializeComponent();
m_VideoController = videoController;
m_AutocenteredApertureAvailable = true;
Text = "Add Object";
btnAdd.Text = "Add";
btnDontAdd.Text = "Don't Add";
btnDelete.Visible = false;
m_IsEdit = false;
nudFitMatrixSize.Value = 11;
nudFitMatrixSize.Maximum = 15;
m_ObjectId = objectId;
m_State = state;
m_AstroImage = m_State.VideoOperation.m_StackedAstroImage;
ObjectToAdd = new TrackedObjectConfig();
m_Center = new ImagePixel(center);
Initialize();
if (rbOccultedStar.Enabled)
SelectedObjectType = TrackingType.OccultedStar;
else
SelectedObjectType = TrackingType.GuidingStar;
// Apply filtering to the processing pixels according to the configured default filter value
int matirxSize = (int)nudFitMatrixSize.Value;
GetFitInMatrix(gaussian, ref matirxSize);
nudFitMatrixSize.Maximum = matirxSize;
if (SelectedObjectType != TrackingType.OccultedStar)
SetHeightAndType();
}
public TrackedObjectLight(byte targetNo, TrackedObjectConfig originalObject)
: base(targetNo, originalObject)
{
Center = new ImagePixel(originalObject.OriginalFieldCenterX, originalObject.OriginalFieldCenterY);
}
internal bool IsLocateFirstObject(TrackedObjectConfig objectConfig)
{
if (objectConfig.TrackingType == TrackingType.GuidingStar)
// A pure guiding star
return true;
if (objectConfig.TrackingType == TrackingType.OccultedStar &&
LightCurveReductionContext.Instance.LightCurveReductionType == LightCurveReductionType.MutualEvent &&
!LightCurveReductionContext.Instance.FullDisappearance)
{
// Occulted star in Mutual events (which is not fully disappearing) will be bright enough for guiding
return true;
}
if (objectConfig.TrackingType == TrackingType.OccultedStar &&
objectConfig.AutoStarsInArea.Count == 1 &&
!objectConfig.IsWeakSignalObject &&
!LightCurveReductionContext.Instance.FullDisappearance)
{
// Occulted star, which is the only bright in the area and doesn't have a manually placed aperture
// and is not a full or almost full disappearance
return true;
}
return false;
}
public SpectroscopyStarTracker(TrackedObjectConfig starConfig)
{
TrackedStar = new TrackedObject(0, starConfig);
TrackedStar.LastKnownGoodPosition = new ImagePixel(starConfig.ApertureStartingX, starConfig.ApertureStartingY);
}
public override void ObjectSelected(TrackedObjectConfig selectedObject, bool shift, bool ctrl, int selectedStarId)
{
if (ctrl)
{
// Delete
int starIdx = -1;
for (int i = 0; i < Context.MeasuringStars.Count; i++)
{
TrackedObjectConfig obj = Context.MeasuringStars[i];
if (obj.AsImagePixel == selectedObject.AsImagePixel)
{
starIdx = i;
break;
}
}
if (starIdx > -1)
{
Context.MeasuringStars.RemoveAt(starIdx);
Context.MeasuringApertures.RemoveAt(starIdx);
Context.PsfFitMatrixSizes.RemoveAt(starIdx);
if (Context.MeasuringStars.Count < 4)
Context.VideoOperation.MaxStarsReached(false);
}
}
else if (shift)
{
Trace.Assert(false, "Overwriting is not implemented");
//// Overwrite
//if (MeasuringStars.Count > 0)
//{
// MeasuringStars.RemoveAt(MeasuringStars.Count - 1);
// MeasuringApertures.RemoveAt(MeasuringStars.Count - 1);
// MeasuringStars.Add(star);
// MeasuringApertures.Add(ApertureSize(gaussian));
//}
}
else
{
// Add/Update
int idx = selectedStarId < 0 ? Context.MeasuringStars.IndexOf(selectedObject) : selectedStarId;
if (idx > -1)
{
if (idx >= 0 && idx < Context.MeasuringStars.Count)
{
Context.MeasuringStars[idx] = selectedObject;
Context.MeasuringApertures[idx] = selectedObject.ApertureInPixels;
Context.PsfFitMatrixSizes[idx] = selectedObject.PsfFitMatrixSize;
Context.VideoOperation.SelectedTargetChanged(idx);
}
return;
}
if (Context.MeasuringStars.FindAll(obj => obj.MeasureThisObject).Count >= 4) return;
Context.MeasuringStars.Add(selectedObject);
Context.MeasuringApertures.Add(selectedObject.ApertureInPixels);
Context.PsfFitMatrixSizes.Add(selectedObject.PsfFitMatrixSize);
if (Context.MeasuringStars.Count >= 4)
Context.VideoOperation.MaxStarsReached(true);
}
Context.m_SelectedMeasuringStar = Context.MeasuringStars.Count - 1;
Context.VideoOperation.SelectedTargetChanged(Context.m_SelectedMeasuringStar);
// Make all the aperture the same size as the current one
for (int i = 0; i < Context.MeasuringStars.Count; i++)
{
TrackedObjectConfig obj = Context.MeasuringStars[i];
obj.ApertureInPixels = selectedObject.ApertureInPixels;
Context.m_MeasuringApertures[i] = selectedObject.ApertureInPixels;
}
}
public void ObjectEdited(int selectedStarId, TrackedObjectConfig selectedObject)
{
m_CurrentStateObject.ObjectSelected(selectedObject, false, false, selectedStarId);
}
