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); }