protected virtual void IdentifyStar(StarMapFeature feature, IStar star)
{
if (m_SolvedPlate != null)
{
ImagePixel featureCenter = feature.GetCenter();
if (m_PreviousStar == null ||
m_PreviousStar.StarNo == star.StarNo)
{
// Translation only
double x, y;
m_SolvedPlate.GetImageCoordsFromRADE(star.RADeg, star.DEDeg, out x, out y);
double newCenterX = m_Image.FullFrame.Width / 2 - featureCenter.X + x;
double newCenterY = m_Image.FullFrame.Height / 2 - featureCenter.Y + y;
m_SolvedPlate.GetRADEFromImageCoords(newCenterX, newCenterY, out m_RADegCenter, out m_DEDegCenter);
m_PreviousFeature = feature;
m_PreviousStar = star;
}
else
{
// TODO: Rotate and streach until the feature fits
}
ReinitializePlateConstants();
DrawCatalogStarsFit();
// TODO: For now we only support 1 star centering
m_PreviousStar = null;
m_PreviousStar = null;
}
}
public ImagePixel GetPSFFit(int x, int y, int fitMatrixSize, PSFFittingMethod method, out PSFFit psfFit)
{
psfFit = new PSFFit(x, y);
psfFit.FittingMethod = method;
int dimention = 2 * (fitMatrixSize / 2) + 1;
uint[,] data = new uint[dimention, dimention];
int halfWidth = dimention / 2;
#if ASTROMETRY_DEBUG
Trace.Assert(2 * halfWidth + 1 == dimention);
#endif
PixelAreaOperation2(x, y, halfWidth,
delegate(int x1, int y1, uint z)
{
data[x1 - x + halfWidth, y1 - y + halfWidth] = z;
});
psfFit.Fit(data);
if (psfFit.IsSolved)
{
ImagePixel psfPixel = new ImagePixel((int)Math.Min(m_Pixelmap.MaxSignalValue, (uint)Math.Round(psfFit.IMax)), psfFit.XCenter, psfFit.YCenter);
psfPixel.SignalNoise = psfFit.Certainty;
return(psfPixel);
}
return(null);
}
private bool HasObjectsWithAutoAperutreCloserThan8PixelsApart()
{
for (int i = 0; i < m_StateMachine.MeasuringStars.Count; i++)
{
for (int j = i + 1; j < m_StateMachine.MeasuringStars.Count; j++)
{
TrackedObjectConfig obj1 = m_StateMachine.MeasuringStars[i];
TrackedObjectConfig obj2 = m_StateMachine.MeasuringStars[j];
if (obj1.IsFixedAperture || obj2.IsFixedAperture)
{
continue;
}
double dist = ImagePixel.ComputeDistance(
obj1.ApertureStartingX, obj2.ApertureStartingX,
obj1.ApertureStartingY, obj2.ApertureStartingY);
double minDist = 8 + (obj1.ApertureInPixels + obj2.ApertureInPixels) / 2;
if (dist <= minDist && !obj1.ProcessInPsfGroup && !obj2.ProcessInPsfGroup)
{
return(true);
}
}
}
return(false);
}
private void ProcessSingleUnitSet(
List <LCMeasurement> units,
bool useLowPass,
bool useLowPassDiff,
MeasurementsHelper measurer)
{
for (int i = 0; i < units.Count; i++)
{
LCMeasurement reading = units[i];
IImagePixel[] groupCenters = new IImagePixel[0];
float[] aperturesInGroup = new float[0];
TrackedObjectConfig objConfig = Footer.TrackedObjects[reading.TargetNo];
List <TrackedObjectConfig> gropedObjects = Footer.TrackedObjects.Where(x => objConfig.GroupId >= 0 && x.GroupId == objConfig.GroupId).ToList();
if (gropedObjects.Count > 1)
{
groupCenters = new IImagePixel[gropedObjects.Count];
aperturesInGroup = new float[gropedObjects.Count];
for (int j = 0; j < gropedObjects.Count; j++)
{
LCMeasurement mea = units[Footer.TrackedObjects.IndexOf(gropedObjects[j])];
groupCenters[j] = new ImagePixel(mea.X0, mea.Y0);
aperturesInGroup[j] = gropedObjects[j].ApertureInPixels;
}
}
units[i] = ProcessSingleUnit(
reading, useLowPass, useLowPassDiff,
Context.ReProcessFitAreas[i], Context.ReProcessApertures[i], Header.FixedApertureFlags[i],
measurer, groupCenters, aperturesInGroup);
}
}
public PlateConstStarPair AddStar(ImagePixel plateStar, IStar celestialPyramidStarEntry, StarMapFeature feature)
{
double detectionCertainty = plateStar.SignalNoise;
PlateConstStarPair starPair =
AddStar(
plateStar.XDouble,
celestialPyramidStarEntry.RADeg,
plateStar.YDouble,
celestialPyramidStarEntry.DEDeg,
celestialPyramidStarEntry.Mag,
plateStar.Brightness,
detectionCertainty,
plateStar.IsSaturated);
#if ASTROMETRY_DEBUG
Trace.Assert(m_Pairs.Find((pair) => pair.StarNo == celestialPyramidStarEntry.StarNo) == null);
#endif
starPair.StarNo = celestialPyramidStarEntry.StarNo;
starPair.FeatureId = feature != null ? feature.FeatureId : -1;
starPair.RADeg = celestialPyramidStarEntry.RADeg;
starPair.DEDeg = celestialPyramidStarEntry.DEDeg;
return(starPair);
}
public static void DrawOverlay(Graphics g, int topNumCandidates, bool showPeakPixels)
{
if (s_CandidateScores != null)
{
s_TopCandidatesToTake = topNumCandidates;
var hotPixelsList = s_Candidates.Take(topNumCandidates);
if (m_ShowHotPixelPositions)
{
foreach (ImagePixel pixel in hotPixelsList)
{
g.DrawEllipse(Pens.Yellow, pixel.X - 5, pixel.Y - 5, 10, 10);
}
}
if (showPeakPixels && topNumCandidates < s_Candidates.Count())
{
for (int i = topNumCandidates; i < s_Candidates.Length; i++)
{
ImagePixel pixel = s_Candidates[i];
g.DrawLine(Pens.Pink, pixel.X - 5, pixel.Y, pixel.X + 5, pixel.Y);
g.DrawLine(Pens.Pink, pixel.X, pixel.Y - 5, pixel.X, pixel.Y + 5);
g.DrawString(s_CandidateScores[i].ToString("0.00"), s_Font, Brushes.Pink, pixel.X + 1, pixel.Y - 10);
}
}
}
}
public void Fit(uint[,] pixels, float starX0, float starY0, float startMinDistance)
{
m_Star1Center = new ImagePixel(-1, starX0, starY0);
m_Star1MinDistance = startMinDistance;
m_Star2Center = null;
Fit(pixels);
}
private bool TryAutoLocateDoubleObject(out ImagePixel newCenter)
{
var pixelsFlatList = new List <Tuple <int, int, uint> >();
for (int x = 0; x < 35; x++)
{
for (int y = 0; y < 35; y++)
{
uint pixel = m_ProcessingPixels[x, y];
pixelsFlatList.Add(new Tuple <int, int, uint>(x, y, pixel));
}
}
// Sort by brghtness (brigher at the top)
pixelsFlatList.Sort((x, y) => y.Item3.CompareTo(x.Item3));
Tuple <int, int, uint> brightProbe1 = pixelsFlatList[0];
Tuple <int, int, uint> brightProbe2 = pixelsFlatList[1];
Tuple <int, int, uint> secondPeakProbe1 = null;
Tuple <int, int, uint> secondPeakProbe2 = null;
for (int i = 0; i < pixelsFlatList.Count; i++)
{
if (secondPeakProbe1 == null &&
ImagePixel.ComputeDistance(brightProbe1.Item1, pixelsFlatList[i].Item1, brightProbe1.Item2, pixelsFlatList[i].Item2) > 3)
{
secondPeakProbe1 = pixelsFlatList[i];
}
if (secondPeakProbe2 == null &&
ImagePixel.ComputeDistance(brightProbe2.Item1, pixelsFlatList[i].Item1, brightProbe2.Item2, pixelsFlatList[i].Item2) > 3)
{
secondPeakProbe2 = pixelsFlatList[i];
}
if (secondPeakProbe1 != null && secondPeakProbe2 != null)
{
break;
}
}
if (secondPeakProbe1 != null &&
IsGoodDoubleObjectFit(brightProbe1, secondPeakProbe1))
{
newCenter = new ImagePixel((int)Math.Max(brightProbe1.Item3, secondPeakProbe1.Item3), (brightProbe1.Item1 + secondPeakProbe1.Item1) / 2.0, (brightProbe1.Item2 + secondPeakProbe1.Item2) / 2.0);
return(true);
}
if (secondPeakProbe2 != null &&
IsGoodDoubleObjectFit(brightProbe2, secondPeakProbe2))
{
newCenter = new ImagePixel((int)Math.Max(brightProbe2.Item3, secondPeakProbe2.Item3), (brightProbe2.Item1 + secondPeakProbe2.Item1) / 2.0, (brightProbe2.Item2 + secondPeakProbe2.Item2) / 2.0);
return(true);
}
newCenter = null;
return(false);
}
private void EnsureComputedRefinedData()
{
if (!float.IsNaN(m_MinLocateSignal))
{
m_LocateObjects.Clear();
for (int i = 0; i < TrackedObjects.Count; i++)
{
if (
(!(TrackedObjects[i] as TrackedObject).IsOccultedStar || !LightCurveReductionContext.Instance.FullDisappearance) &&
!TrackedObjects[i].IsOffScreen &&
!float.IsNaN((TrackedObjects[i] as TrackedObject).LastFrameX)
)
{
// Don't include targets offscreen, or targets that were not found during the last tracking (could have been off screen)
m_LocateObjects.Add((TrackedObjects[i] as TrackedObject).TargetNo);
}
}
return;
}
m_MinLocateSignal = TrackedObjects.Cast <TrackedObject>().Min(o => o.RefinedOrLastSignalLevel == 0 ? 255f : o.RefinedOrLastSignalLevel);
// Locate all peak pixels with signal higher than (minSignal + medianNoise) / 2
m_MinLocateSignal = (m_MedianValue + m_MinLocateSignal) / 2f;
double minDistance = double.MaxValue;
for (int i = 0; i < TrackedObjects.Count; i++)
{
if ((!(TrackedObjects[i] as TrackedObject).IsOccultedStar && !TrackedObjects[i].IsOffScreen) ||
!LightCurveReductionContext.Instance.FullDisappearance)
{
m_LocateObjects.Add((TrackedObjects[i] as TrackedObject).TargetNo);
}
for (int j = 0; j < TrackedObjects.Count; j++)
{
if (i == j)
{
continue;
}
double dist = ImagePixel.ComputeDistance(
TrackedObjects[i].OriginalObject.ApertureStartingX,
TrackedObjects[j].OriginalObject.ApertureStartingX,
TrackedObjects[i].OriginalObject.ApertureStartingY,
TrackedObjects[j].OriginalObject.ApertureStartingY);
if (minDistance > dist)
{
minDistance = dist;
}
}
}
m_MinLocateDistance = minDistance / 2.0;
}
public ObjectClickEventArgs(ImagePixel pixel, PSFFit gausian, Point location, bool shiftHeld, bool ctrlHeld, MouseEventArgs mouseEventArgs)
{
ClickLocation = location;
Pixel = pixel;
Gausian = gausian;
Shift = shiftHeld;
Control = ctrlHeld;
MouseEventArgs = mouseEventArgs;
}
public override void MouseClick(ObjectClickEventArgs e)
{
if (m_State == FittingsState.Configuring)
{
m_OSDExcluderTool.MouseClick(e);
}
if (m_State == FittingsState.Solved)
{
IStarMap starMap = AstrometryContext.Current.StarMap;
if (starMap != null)
{
int x, y;
StarMapFeature feature = starMap.GetFeatureInRadius(e.Pixel.X, e.Pixel.Y, 5);
if (feature != null)
{
x = feature.GetCenter().X;
y = feature.GetCenter().Y;
}
else
{
x = e.Pixel.X;
y = e.Pixel.Y;
}
int searchArea = Control.ModifierKeys == Keys.Shift ? 5 : 10;
PSFFit psfFit;
ImagePixel pixelCent = starMap.GetPSFFit(x, y, searchArea, out psfFit);
if (pixelCent != null && pixelCent != ImagePixel.Unspecified)
{
PlateConstStarPair selectedPair = null;
LeastSquareFittedAstrometry astrometry = FittedAstrometryFromUserSelectedFitGrade();
if (astrometry != null)
{
foreach (PlateConstStarPair pair in astrometry.FitInfo.AllStarPairs)
{
if (Math.Abs(pair.x - pixelCent.X) < 2 &&
Math.Abs(pair.y - pixelCent.Y) < 2)
{
selectedPair = pair;
break;
}
}
}
DrawHighResFeature(pixelCent, selectedPair, astrometry);
}
else
{
ClearZoomImage();
}
}
}
}
internal void LoadFromNativeData(NativeTrackedObjectInfo trackingInfo, NativePsfFitInfo psfInfo, double[] residuals)
{
Center = new ImagePixel(trackingInfo.CenterX, trackingInfo.CenterY);
LastKnownGoodPosition = new ImagePixel(trackingInfo.LastGoodPositionX, trackingInfo.LastGoodPositionY);
LastKnownGoodPsfCertainty = trackingInfo.LastGoodPsfCertainty;
IsLocated = trackingInfo.IsLocated == 1;
IsOffScreen = trackingInfo.IsOffScreen == 1;
m_TrackingFlags = TranslateTrackingFlags((NativeTrackerNotMeasuredReasons)trackingInfo.TrackingFlags);
m_NativePsfFit.LoadFromNativePsfFitInfo(psfInfo, residuals);
}
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 bool IdentifyBrightObject(PSFFit fit1, PSFFit fit2, float minStarCertainty, out TrackedObjectLight obj1, out TrackedObjectLight obj2, out IImagePixel center1, out IImagePixel center2)
{
double brightness1 = (fit1.Certainty > minStarCertainty ? fit1.Brightness : 1);
double brightness2 = (fit2.Certainty > minStarCertainty ? fit2.Brightness : 1);
double bDiff = Math.Abs(brightness1 - brightness2);
double bRatio = bDiff / Math.Max(brightness1, brightness2);
if (bRatio > 0.5)
{
bool fit1Brighter = brightness1 > brightness2;
bool oldFit1Brighter = LastCenterObject1.Brightness > LastCenterObject2.Brightness;
double oldDeltaXBrightFaint = oldFit1Brighter ? LastCenterObject1.XDouble - LastCenterObject2.XDouble : LastCenterObject2.XDouble - LastCenterObject1.XDouble;
double oldDeltaYBrightFaint = oldFit1Brighter ? LastCenterObject1.YDouble - LastCenterObject2.YDouble : LastCenterObject2.YDouble - LastCenterObject1.YDouble;
if (!(fit1Brighter ^ oldFit1Brighter))
{
// 1 == 1; 2 == 2
if (fit1Brighter)
{
center1 = new ImagePixel((int)brightness1, fit1.XCenter, fit1.YCenter);
center2 = new ImagePixel((int)brightness2, fit1.XCenter - oldDeltaXBrightFaint, fit1.YCenter - oldDeltaYBrightFaint);
return(Match1122(out obj1, out obj2));
}
else
{
center1 = new ImagePixel((int)brightness2, fit2.XCenter, fit2.YCenter);
center2 = new ImagePixel((int)brightness1, fit2.XCenter - oldDeltaXBrightFaint, fit2.YCenter - oldDeltaYBrightFaint);
return(Match1122(out obj1, out obj2));
}
}
else
{
// 1 == 2; 2 == 1
if (fit1Brighter)
{
center2 = new ImagePixel((int)brightness1, fit1.XCenter, fit1.YCenter);
center1 = new ImagePixel((int)brightness2, fit1.XCenter - oldDeltaXBrightFaint, fit1.YCenter - oldDeltaYBrightFaint);
return(Match1212(out obj1, out obj2));
}
else
{
center2 = new ImagePixel((int)brightness2, fit2.XCenter, fit2.YCenter);
center1 = new ImagePixel((int)brightness1, fit2.XCenter - oldDeltaXBrightFaint, fit2.YCenter - oldDeltaYBrightFaint);
return(Match1212(out obj1, out obj2));
}
}
}
center1 = null;
center2 = null;
return(NoMatch(out obj1, out obj2));
}
public void SetTrackedObjectMatch(PSFFit psfFitMatched)
{
PSFFit = psfFitMatched;
Center = new ImagePixel((int)psfFitMatched.IMax, psfFitMatched.XCenter, psfFitMatched.YCenter);
IsLocated = true;
NotMeasuredReasons = NotMeasuredReasons.TrackedSuccessfully;
if (PSFFit != null && PSFFit.IsSolved)
{
LastKnownGoodPosition = new ImagePixel(Center.Brightness, Center.XDouble, Center.YDouble);
LastKnownGoodPsfCertainty = PSFFit.Certainty;
}
}
public void Test1()
{
var matrix = new CCDMatrix(8.6, 8.3, 752, 582);
var astroPlate = new AstroPlate(matrix, 720, 576, 8);
var userStars = new Dictionary <ImagePixel, IStar>();
var star1 = new TestStar(2890001240, 18.528885242458674, -32.262447583319769, 11.033);
var pixel1 = new ImagePixel(72.0519465443632, 240.48754416283302);
userStars.Add(pixel1, star1);
var star2 = new TestStar(2890001234, 18.353495385568369, -32.296976944037546, 12.294);
var pixel2 = new ImagePixel(421.79863331879409, 329.57539665223919);
userStars.Add(pixel2, star2);
var star3 = new TestStar(2890001229, 18.284537781225755, -32.213242615932892, 10.882);
var pixel3 = new ImagePixel(559.51676838260289, 114.86160161500557);
userStars.Add(pixel3, star3);
var plateSolve = DirectTransRotAstrometry.SolveByThreeStars(astroPlate, userStars, 2);
Assert.IsNotNull(plateSolve);
Assert.AreEqual(1.2836, plateSolve.Aspect, 0.0001);
Assert.AreEqual(-32.2808, plateSolve.DE0Deg, 0.0001);
Assert.AreEqual(18.3845, plateSolve.RA0Deg, 0.0001);
Assert.AreEqual(179.9401, plateSolve.EtaDeg, 0.0001);
Assert.AreEqual(0.00, plateSolve.Residual, 0.01);
var newAstro = new ThreeStarAstrometry(astroPlate, userStars, 2);
Assert.IsTrue(newAstro.Success);
Assert.AreEqual(-32.2808, newAstro.DE0Deg, 0.0001);
Assert.AreEqual(18.3845, newAstro.RA0Deg, 0.0001);
double ra, de;
newAstro.GetRADEFromImageCoords(72.0519465443632, 240.48754416283302, out ra, out de);
Assert.AreEqual(18.5288852, ra, 0.0000001);
Assert.AreEqual(-32.2624475, de, 0.0000001);
double x, y;
newAstro.GetImageCoordsFromRADE(18.528885242458674, -32.262447583319769, out x, out y);
Assert.AreEqual(72.0519, x, 0.0001);
Assert.AreEqual(240.4875, y, 0.0001);
}
public override void MouseClick(ObjectClickEventArgs e)
{
if (m_OperationState == SpectroscopyState.ChoosingStar && e.Gausian != null && e.Gausian.IsSolved && e.Gausian.Certainty > 0.2)
{
float bestAngle = m_SpectroscopyController.LocateSpectraAngle(e.Gausian);
if (float.IsNaN(bestAngle))
{
SelectedStar = new ImagePixel(e.Gausian.XCenter, e.Gausian.YCenter);
SelectedStarFWHM = e.Gausian.FWHM;
m_SelectedStarGaussian = e.Gausian;
MeasurementAreaWing = (int)(2 * Math.Ceiling(SelectedStarFWHM));
BackgroundAreaWing = MeasurementAreaWing;
BackgroundAreaGap = 5;
SelectedAnglePoint = Point.Empty;
m_ControlPanel.ClearSpectra();
m_OperationState = SpectroscopyState.ChoosingAngleManually;
}
else
{
SelectedStar = new ImagePixel(e.Gausian.XCenter, e.Gausian.YCenter);
SelectedStarFWHM = e.Gausian.FWHM;
m_SelectedStarGaussian = e.Gausian;
MeasurementAreaWing = (int)(2 * Math.Ceiling(SelectedStarFWHM));
BackgroundAreaWing = MeasurementAreaWing;
BackgroundAreaGap = 5;
SetBestAngle(bestAngle);
}
m_VideoController.RedrawCurrentFrame(false, true);
}
else if (m_OperationState == SpectroscopyState.ChoosingAngleManually && SelectedStar != null)
{
double atanAgnle = 180 * Math.Atan((SelectedStar.YDouble - e.Pixel.YDouble) / (e.Pixel.XDouble - SelectedStar.XDouble)) / Math.PI;
if (atanAgnle < 0)
{
atanAgnle = 360 + atanAgnle;
}
int roughAngle = (int)atanAgnle;
float bestAngle = m_SpectroscopyController.LocateSpectraAngle(e.Gausian, roughAngle);
if (!float.IsNaN(bestAngle))
{
SetBestAngle(bestAngle);
m_VideoController.RedrawCurrentFrame(false, true);
}
}
}
private void ApplyPSFExclusionRulesToFeatures()
{
try
{
List <int> rejectedFeatureIds = new List <int>();
foreach (StarMapFeature feature in m_Features)
{
ImagePixel center = feature.GetCenter();
PSFFit fit;
if (center != null)
{
GetPSFFit(center.X, center.Y, PSFFittingMethod.NonLinearAsymetricFit, out fit);
bool isGoodPsf =
fit.Certainty >= m_MinFeatureCertainty &&
fit.FWHM >= m_MinFeatureFWHM &&
fit.FWHM <= m_MaxFeatureFWHM &&
fit.ElongationPercentage < m_MaxPSFElongationPercentage;
#if ASTROMETRY_DEBUG
Trace.WriteLine(string.Format("{0} Feature: ({1}, {2}) Certainty = {3:0.00} FWHM = {4:0.0} Elongation = {5:0}%",
isGoodPsf ? "Accepted" : "Rejected", center.X, center.Y, fit.Certainty, fit.FWHM, fit.ElongationPercentage));
#endif
if (!isGoodPsf)
{
rejectedFeatureIds.Add(feature.FeatureId);
}
}
}
if (rejectedFeatureIds.Count > 0)
{
m_Features.RemoveAll(f => rejectedFeatureIds.Contains(f.FeatureId));
m_Features.Sort((a, b) => a.FeatureId.CompareTo(b.FeatureId));
for (int i = 0; i < m_Features.Count; i++)
{
m_Features[i].FixFeatureIdAfterSetExcusion(i);
}
}
}
catch (Exception ex)
{
Trace.WriteLine(ex);
}
}
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();
}
}
private bool IncludePixel(int x, int y)
{
if (m_Star1Center != null &&
ImagePixel.ComputeDistance(m_Star1Center.XDouble, x, m_Star1Center.YDouble, y) <= m_Star1MinDistance)
{
return(false);
}
if (m_Star2Center != null &&
ImagePixel.ComputeDistance(m_Star2Center.XDouble, x, m_Star2Center.YDouble, y) <= m_Star2MinDistance)
{
return(false);
}
return(true);
}
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);
}
public PyramidEntry(int i, int j, int k, ImagePixel iPixel, ImagePixel jPixel, ImagePixel kPixel, ulong iStarNo, ulong jStarNo, ulong kStarNo)
{
Xi = iPixel.XDouble;
Yi = iPixel.YDouble;
Xj = jPixel.XDouble;
Yj = jPixel.YDouble;
Xk = kPixel.XDouble;
Yk = kPixel.YDouble;
SNi = iStarNo;
SNj = jStarNo;
SNk = kStarNo;
this.i = i;
this.j = j;
this.k = k;
}
public void NextFrame(int frameNo, IAstroImage astroImage, IStarMap starMap, LeastSquareFittedAstrometry astrometricFit)
{
IsTrackedSuccessfully = false;
ImagePixel centroid = AstrometryContext.Current.StarMap.GetCentroid(
(int)TrackedObject.LastKnownX,
(int)TrackedObject.LastKnownY,
CoreAstrometrySettings.Default.PreMeasureSearchCentroidRadius);
if (centroid != null)
{
PSFFit psfFit;
AstrometryContext.Current.StarMap.GetPSFFit(
centroid.X, centroid.Y, PSFFittingMethod.NonLinearFit, out psfFit);
if (psfFit != null)
{
double ra, de;
astrometricFit.GetRADEFromImageCoords(psfFit.XCenter, psfFit.YCenter, out ra, out de);
double maxPosDiffArcSec =
astrometricFit.GetDistanceInArcSec(astrometricFit.Image.CenterXImage, astrometricFit.Image.CenterYImage,
astrometricFit.Image.CenterXImage + CoreAstrometrySettings.Default.PreMeasureSearchCentroidRadius, astrometricFit.Image.CenterYImage);
if (!double.IsNaN(TrackedObject.RAHours))
{
double posDif = 3600 * AngleUtility.Elongation(15 * TrackedObject.RAHours, TrackedObject.DEDeg, ra, de);
if (posDif > maxPosDiffArcSec)
{
// NOTE: Not a valid measurement
Trace.WriteLine(string.Format("The target position is too far from the last measured position", posDif));
return;
}
}
TrackedObject.RAHours = ra / 15.0;
TrackedObject.DEDeg = de;
TrackedObject.LastKnownX = psfFit.XCenter;
TrackedObject.LastKnownY = psfFit.YCenter;
TrackedObject.PSFFit = psfFit;
IsTrackedSuccessfully = true;
}
}
}
public double GetIntencity(ImagePixel center, out bool isSaturated)
{
isSaturated = false;
uint[,] data = m_CurrentAstroImage.GetMeasurableAreaPixels(center.X, center.Y, 17);
PSFFit fit = new PSFFit(center.X, center.Y);
fit.Fit(data, PSF_FIT_AREA_SIZE);
if (!fit.IsSolved)
{
return(double.NaN);
}
int areaSize = m_Filter == TangraConfig.PreProcessingFilter.NoFilter ? 17 : 19;
int centerX = (int)Math.Round(center.XDouble);
int centerY = (int)Math.Round(center.YDouble);
data = m_CurrentAstroImage.GetMeasurableAreaPixels(centerX, centerY, areaSize);
uint[,] backgroundPixels = m_CurrentAstroImage.GetMeasurableAreaPixels(centerX, centerY, 35);
m_Measurer.MeasureObject(
center,
data,
backgroundPixels,
m_CurrentAstroImage.Pixelmap.BitPixCamera,
m_Filter,
m_PhotometryReductionMethod,
m_PsfQuadrature,
m_PsfFittingMethod,
m_MeasurementAperture ?? (float)Aperture(fit.FWHM),
fit.FWHM,
(float)m_EmpericalFWHM,
new FakeIMeasuredObject(fit),
null, null,
false);
isSaturated = m_Measurer.HasSaturatedPixels;
return(m_Measurer.TotalReading - m_Measurer.TotalBackground);
}
private bool IsGoodDoubleObjectFit(Tuple <int, int, uint> object1, Tuple <int, int, uint> object2)
{
var doubleFit = new DoublePSFFit(100, 100);
if (TangraConfig.Settings.Photometry.PsfFittingMethod == TangraConfig.PsfFittingMethod.LinearFitOfAveragedModel)
{
doubleFit.FittingMethod = PSFFittingMethod.LinearFitOfAveragedModel;
}
doubleFit.Fit(m_ProcessingPixels, object1.Item1, object1.Item2, object2.Item1, object2.Item2);
if (doubleFit.IsSolved &&
Math.Abs(doubleFit.FWHM1 - doubleFit.FWHM2) < Math.Max(1, Math.Min(doubleFit.FWHM1, doubleFit.FWHM2) * 0.25) &&
doubleFit.IAmplitude1 > 0 && doubleFit.IAmplitude2 > 0)
{
double imaxRatio = doubleFit.IAmplitude1 / doubleFit.IAmplitude2;
if (imaxRatio > 1)
{
imaxRatio = 1 / imaxRatio;
}
if (imaxRatio >= 0.25)
{
// We require at least 1:4 ratio in the maximums for the auto-detection to accept that it has found correctly two objects
double distance = ImagePixel.ComputeDistance(object1.Item1, object2.Item1, object1.Item2, object2.Item2);
if (distance > doubleFit.FWHM1 && distance > doubleFit.FWHM2)
{
// We also require at least a FWHM distance between centers for automatic detection
m_X1Start = object1.Item1;
m_Y1Start = object1.Item2;
m_X2Start = object2.Item1;
m_Y2Start = object2.Item2;
return(true);
}
}
return(false);
}
return(false);
}
public void Fit(uint[,] pixels, PSFFit star1, PSFFit star2)
{
int dataMatrixSize = pixels.GetLength(0);
int offset = (dataMatrixSize - star1.MatrixSize) / 2;
m_Star1Center = new ImagePixel(star1.Brightness, star1.X0_Matrix + offset, star1.Y0_Matrix + offset);
m_Star1MinDistance = star1.FWHM * 2.0;
if (star2 != null)
{
offset = (dataMatrixSize - star2.MatrixSize) / 2;
m_Star2Center = new ImagePixel(star2.Brightness, star2.X0_Matrix + offset, star2.Y0_Matrix + offset);
m_Star2MinDistance = star2.FWHM * 2.0;
}
else
{
m_Star2Center = null;
}
Fit(pixels);
}
public void Test2_NearSouthPole()
{
var matrix = new CCDMatrix(8.6, 8.3, 752, 582);
var astroPlate = new AstroPlate(matrix, 720, 576, 16);
var userStars = new Dictionary <ImagePixel, IStar>();
var star1 = new TestStar(670000669, 14.040622402203727, -76.691539882008868, 13.389);
var pixel1 = new ImagePixel(111.28789147012657, 170.18336583345945);
userStars.Add(pixel1, star1);
var star2 = new TestStar(680000642, 13.3447869927272, -76.594950217617452, 9.932);
var pixel2 = new ImagePixel(575.00594900921817, 446.45890095859744);
userStars.Add(pixel2, star2);
var star3 = new TestStar(670000641, 13.550035599758042, -76.722167259223085, 13.842);
var pixel3 = new ImagePixel(425.86138030460097, 63.057739094752051);
userStars.Add(pixel3, star3);
var newAstro = new ThreeStarAstrometry(astroPlate, userStars, 2);
Assert.IsTrue(newAstro.Success);
Assert.AreEqual(-76.6498, newAstro.DE0Deg, 0.0001);
Assert.AreEqual(13.6644, newAstro.RA0Deg, 0.0001);
double ra, de;
newAstro.GetRADEFromImageCoords(111.28789147012657, 170.18336583345945, out ra, out de);
Assert.AreEqual(14.0406224, ra, 0.0000001);
Assert.AreEqual(-76.6915398, de, 0.0000001);
double x, y;
newAstro.GetImageCoordsFromRADE(14.040622402203727, -76.691539882008868, out x, out y);
Assert.AreEqual(111.2879, x, 0.0001);
Assert.AreEqual(170.1833, y, 0.0001);
}
private void TrackSingleStar(int frameNo, IAstroImage astroImage)
{
TrackedStar.NewFrame();
float expectedX;
float expectedY;
GetExpectedXY(out expectedX, out expectedY);
uint[,] pixels = astroImage.GetPixelsArea((int)expectedX, (int)expectedY, FIT_AREA);
// There is only one object in the area, just do a wide fit followed by a fit with the selected matrix size
PSFFit gaussian = new PSFFit((int)expectedX, (int)expectedY);
gaussian.Fit(pixels, FIT_AREA);
IImagePixel firstCenter = new ImagePixel((int)gaussian.XCenter, (int)gaussian.YCenter);
pixels = astroImage.GetPixelsArea(firstCenter.X, firstCenter.Y, FIT_AREA);
gaussian = new PSFFit(firstCenter.X, firstCenter.Y);
gaussian.Fit(pixels, TrackedStar.PsfFitMatrixSize);
if (gaussian.IsSolved)
{
TrackedStar.PSFFit = gaussian;
TrackedStar.ThisFrameX = (float)gaussian.XCenter;
TrackedStar.ThisFrameY = (float)gaussian.YCenter;
TrackedStar.ThisSignalLevel = (float)(gaussian.IMax - gaussian.I0);
TrackedStar.ThisFrameCertainty = (float)gaussian.Certainty;
TrackedStar.SetIsLocated(true, NotMeasuredReasons.TrackedSuccessfully);
}
else
{
TrackedStar.ThisFrameX = expectedX;
TrackedStar.ThisFrameY = expectedY;
TrackedStar.ThisFrameCertainty = (float)gaussian.Certainty;
Trace.WriteLine(string.Format("Frame {0}: Cannot confirm target {1} [SingleStar]. Cannot solve second PSF", m_FrameNo, TrackedStar.TargetNo));
TrackedStar.SetIsLocated(false, NotMeasuredReasons.PSFFittingFailed);
}
}
public override void DoManualFrameCorrection(int targetId, int deltaX, int deltaY)
{
int firstFrameId = m_PreviousPositionFrameIds[0];
float expectedX = (float)m_LinearFitX.ComputeY(m_FrameNo - firstFrameId);
float expectedY = (float)m_LinearFitY.ComputeY(m_FrameNo - firstFrameId);
m_PreviousPositions.Clear();
m_PreviousPositionFrameIds.Clear();
ImagePixel newCenter = new ImagePixel(expectedX + deltaX, expectedY + deltaY);
m_PreviousPositions.Add(newCenter);
m_PreviousPositionFrameIds.Add(m_FrameNo);
m_PreviousPositions.Add(newCenter);
m_PreviousPositionFrameIds.Add(m_FrameNo - 1);
m_PreviousPositions.Add(newCenter);
m_PreviousPositionFrameIds.Add(m_FrameNo - 2);
DoLinearFit();
}
public static Dictionary <ImagePixel, double> LocateHotPixels(AstroImage image, uint[,] model, uint modelMedian)
{
var rv = new Dictionary <ImagePixel, double>();
if (s_NumSamplesCombined > 0)
{
int width = image.Pixelmap.Width;
int height = image.Pixelmap.Height;
uint abv = model[3, 3] - modelMedian;
uint minPeakLevel = (uint)(modelMedian + PEAK_PIXEL_LEVEL_REQUIRED * abv);
EnumeratePeakPixels(image.Pixelmap.GetPixelsCopy(), width, height, minPeakLevel, Rectangle.Empty,
(x, y, z) =>
{
if (x >= 3 && x < width - 3 && y >= 3 && y < height - 3)
{
var newPix = new ImagePixel((int)z, x, y);
if (!rv.Keys.ToArray().Any(p => p.DistanceTo(newPix) < 5))
{
rv.Add(newPix, long.MinValue);
}
}
});
foreach (ImagePixel center in rv.Keys.ToArray())
{
uint[,] testArea = image.GetPixelsArea(center.X, center.Y, 7);
var score = ScoreArea(testArea);
rv[center] = score.Item1;
}
var positions = rv.Keys.ToArray();
var scores = rv.Values.ToArray();
Array.Sort(scores, positions);
s_Candidates = positions;
s_CandidateScores = scores;
}
return(rv);
}
