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 static LeastSquareFittedAstrometry FromReflectedObject(object reflObj)
{
var rv = new LeastSquareFittedAstrometry();
rv.m_RA0Deg = StarMap.GetPropValue <double>(reflObj, "m_RA0Deg");
rv.m_DE0Deg = StarMap.GetPropValue <double>(reflObj, "m_DE0Deg");
rv.m_Variance = StarMap.GetPropValue <double>(reflObj, "m_Variance");
rv.m_StdDevRAArcSec = StarMap.GetPropValue <double>(reflObj, "m_StdDevRAArcSec");
rv.m_StdDevDEArcSec = StarMap.GetPropValue <double>(reflObj, "m_StdDevDEArcSec");
object image = StarMap.GetPropValue <object>(reflObj, "m_Image");
rv.m_Image = AstroPlate.FromReflectedObject(image);
object constants = StarMap.GetPropValue <object>(reflObj, "m_SolvedConstants");
if (constants != null)
{
rv.m_SolvedConstants = PlateConstantsFit.FromReflectedObject(constants);
}
return(rv);
}
public static LeastSquareFittedAstrometry FromReflectedObject(object reflObj)
{
var rv = new LeastSquareFittedAstrometry();
rv.m_RA0Deg = StarMap.GetPropValue<double>(reflObj, "m_RA0Deg");
rv.m_DE0Deg = StarMap.GetPropValue<double>(reflObj, "m_DE0Deg");
rv.m_Variance = StarMap.GetPropValue<double>(reflObj, "m_Variance");
rv.m_StdDevRAArcSec = StarMap.GetPropValue<double>(reflObj, "m_StdDevRAArcSec");
rv.m_StdDevDEArcSec = StarMap.GetPropValue<double>(reflObj, "m_StdDevDEArcSec");
object image = StarMap.GetPropValue<object>(reflObj, "m_Image");
rv.m_Image = AstroPlate.FromReflectedObject(image);
object constants = StarMap.GetPropValue<object>(reflObj, "m_SolvedConstants");
if (constants != null)
rv.m_SolvedConstants = PlateConstantsFit.FromReflectedObject(constants);
return rv;
}
public void NextFrame(int frameNo, IAstroImage astroImage, IStarMap starMap, LeastSquareFittedAstrometry astrometricFit)
{
IsTrackedSuccessfully = false;
PSFFit psfFit = null;
if (m_RepeatedIntergationPositions * 4 < m_PastFrameNos.Count)
{
var expectedPos = GetExpectedPosition(frameNo);
if (expectedPos != null)
AstrometryContext.Current.StarMap.GetPSFFit(expectedPos.X, expectedPos.Y, PSFFittingMethod.NonLinearFit, out psfFit);
}
if (psfFit == null)
{
var brightestFeature = starMap.GetFeatureInRadius((int)TrackedObject.LastKnownX, (int)TrackedObject.LastKnownY, CoreAstrometrySettings.Default.PreMeasureSearchCentroidRadius);
if (brightestFeature != null)
{
var center = brightestFeature.GetCenter();
var referenceStarFeatures = astrometricFit.FitInfo.AllStarPairs.Where(x => x.FitInfo.UsedInSolution).ToList();
var refStar = referenceStarFeatures.FirstOrDefault(s => Math.Sqrt((s.x - center.X) * (s.x - center.X) + (s.y - center.Y) * (s.y - center.Y)) < 2);
if (refStar == null)
// The brightest feature is not a reference star, so we assume it is our object
AstrometryContext.Current.StarMap.GetPSFFit(center.X, center.Y, PSFFittingMethod.NonLinearFit, out psfFit);
}
}
if (psfFit == null)
{
ImagePixel centroid = AstrometryContext.Current.StarMap.GetCentroid(
(int)TrackedObject.LastKnownX,
(int)TrackedObject.LastKnownY,
CoreAstrometrySettings.Default.PreMeasureSearchCentroidRadius);
if (centroid != null)
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;
}
if (psfFit != null && psfFit.XCenter > 0 && psfFit.YCenter > 0)
{
m_PastFramePosX.Add(psfFit.XCenter);
m_PastFramePosY.Add(psfFit.YCenter);
m_PastFrameNos.Add(frameNo);
}
}
private LeastSquareFittedAstrometry SolveWithLinearRegression(FitOrder fitOrder, int minNumberOfStars, double maxResidual, bool upgradeIfPossible, out LeastSquareFittedAstrometry firstFit)
{
bool failed = false;
try
{
PlateConstantsFit firstPlateConstantsFit = null;
if (!upgradeIfPossible)
{
PlateConstantsFit bestFit = LinearFitWithExcludingResiduals(fitOrder, minNumberOfStars, maxResidual, out firstPlateConstantsFit);
firstFit = firstPlateConstantsFit != null ? new LeastSquareFittedAstrometry(m_PlateConfig, m_Tangent_RA0, m_Tangent_DE0, firstPlateConstantsFit) : null;
if (bestFit != null)
return new LeastSquareFittedAstrometry(m_PlateConfig, m_Tangent_RA0, m_Tangent_DE0, bestFit);
}
else
{
// less than 11 stars - do a linear fit
// between 12 and 19 - do a quadratic fit
// more than 20 - do a cubic fit
PlateConstantsFit bestFit = null;
int numStars = m_Pairs.Count;
if (m_Pairs.Count >= MIN_STARS_FOR_CUBIC_FIT)
{
bestFit = LinearFitWithExcludingResiduals(FitOrder.Cubic, minNumberOfStars, maxResidual, out firstPlateConstantsFit);
if (bestFit != null)
numStars = bestFit.FitInfo.NumberOfStarsUsedInSolution();
else
numStars = MIN_STARS_FOR_CUBIC_FIT - 1;
}
if (numStars >= MIN_STARS_FOR_QUADRATIC_FIT && numStars < MIN_STARS_FOR_CUBIC_FIT)
{
bestFit = LinearFitWithExcludingResiduals(FitOrder.Quadratic, minNumberOfStars, maxResidual, out firstPlateConstantsFit);
if (bestFit != null)
numStars = bestFit.FitInfo.NumberOfStarsUsedInSolution();
else
numStars = MIN_STARS_FOR_QUADRATIC_FIT - 1;
}
if (numStars < MIN_STARS_FOR_QUADRATIC_FIT)
{
bestFit = LinearFitWithExcludingResiduals(FitOrder.Linear, minNumberOfStars, maxResidual, out firstPlateConstantsFit);
}
firstFit = firstPlateConstantsFit != null ? new LeastSquareFittedAstrometry(m_PlateConfig, m_Tangent_RA0, m_Tangent_DE0, firstPlateConstantsFit) : null;
if (bestFit != null)
return new LeastSquareFittedAstrometry(m_PlateConfig, m_Tangent_RA0, m_Tangent_DE0, bestFit);
}
failed = true;
return null;
}
finally
{
m_IncludedInSolution.Clear();
m_ExcludedForBadResiduals.Clear();
for (int i = 0; i < m_Pairs.Count; i++)
{
#if ASTROMETRY_DEBUG
Trace.Assert(!m_IncludedInSolution.ContainsKey(m_Pairs[i].StarNo));
#endif
m_IncludedInSolution.Add(m_Pairs[i].StarNo, m_Pairs[i].FitInfo.UsedInSolution);
#if ASTROMETRY_DEBUG
Trace.Assert(!m_ExcludedForBadResiduals.ContainsKey(m_Pairs[i].StarNo));
#endif
m_ExcludedForBadResiduals.Add(m_Pairs[i].StarNo, m_Pairs[i].FitInfo.ExcludedForHighResidual);
}
if (failed)
{
if (TangraConfig.Settings.TraceLevels.PlateSolving.TraceInfo())
Trace.WriteLine(string.Format("Solution LeastSquareFit failed. {0} included stars, {1} excluded for high residuals.", m_IncludedInSolution.Count, m_ExcludedForBadResiduals.Count));
}
}
}
public LeastSquareFittedAstrometry SolveWithLinearRegression(IAstrometrySettings settings, out LeastSquareFittedAstrometry firstFit)
{
double maxResidual = m_PlateConfig.GetDistanceInArcSec(
m_PlateConfig.CenterXImage, m_PlateConfig.CenterYImage,
m_PlateConfig.CenterXImage + settings.MaxResidualInPixels, m_PlateConfig.CenterYImage + settings.MaxResidualInPixels);
if (m_Pairs.Count < CorePyramidConfig.Default.MinStarsForImprovementForThreshold)
{
double minResidual = m_PlateConfig.GetDistanceInArcSec(
m_PlateConfig.CenterXImage, m_PlateConfig.CenterYImage,
m_PlateConfig.CenterXImage + CorePyramidConfig.Default.MaxResidualThresholdForImprovementInPixels, m_PlateConfig.CenterYImage);
if (maxResidual < minResidual)
maxResidual = minResidual;
}
if (settings.Method == AstrometricMethod.AutomaticFit)
return SolveWithLinearRegression(FitOrder.Cubic, settings.MinimumNumberOfStars, maxResidual, true, out firstFit);
else if (settings.Method == AstrometricMethod.LinearFit)
return SolveWithLinearRegression(FitOrder.Linear, settings.MinimumNumberOfStars, maxResidual, false, out firstFit);
else if (settings.Method == AstrometricMethod.QuadraticFit)
return SolveWithLinearRegression(FitOrder.Quadratic, settings.MinimumNumberOfStars, maxResidual, false, out firstFit);
else if (settings.Method == AstrometricMethod.CubicFit)
return SolveWithLinearRegression(FitOrder.Cubic, settings.MinimumNumberOfStars, maxResidual, false, out firstFit);
else
throw new NotImplementedException();
}
public LeastSquareFittedAstrometry SolveWithLinearRegression(FitOrder fitOrder, int minNumberOfStars, double maxResidual, out LeastSquareFittedAstrometry firstFit)
{
return SolveWithLinearRegression(fitOrder, minNumberOfStars, maxResidual, false, out firstFit);
}
internal void PresentAstrometricFit(LeastSquareFittedAstrometry fit, StarMagnitudeFit magFit)
{
pnlAstrometry.Visible = true;
pnlObject.Visible = false;
pnlMeasurements.Visible = false;
pnlAstrometry.Top = 0;
pnlAstrometry.Left = 0;
pnlAstrometry.Visible = fit != null;
pnlFitSuccessful.Visible = fit != null;
pnlFitFailed.Visible = !pnlFitSuccessful.Visible;
pnlFitInfo.Visible = fit != null;
if (fit != null)
{
lblStdDevRA.Text = string.Format("{0}\"", fit.StdDevRAArcSec.ToString("0.00"));
lblStdDevDE.Text = string.Format("{0}\"", fit.StdDevDEArcSec.ToString("0.00"));
if (magFit != null)
{
if (double.IsNaN(magFit.Sigma))
lblStdDevMag.Text = "NaN";
else
lblStdDevMag.Text = string.Format("{0} mag", magFit.Sigma.ToString("0.00"));
}
else
lblStdDevMag.Text = "N/A";
double onePixX = fit.GetDistanceInArcSec(fit.Image.CenterXImage, fit.Image.CenterYImage, fit.Image.CenterXImage + 1, fit.Image.CenterYImage);
double onePixY = fit.GetDistanceInArcSec(fit.Image.CenterXImage, fit.Image.CenterYImage, fit.Image.CenterXImage, fit.Image.CenterYImage + 1);
lblPixelSizeX.Text = string.Format("{0}\"", onePixX.ToString("0.0"));
lblPixelSizeY.Text = string.Format("{0}\"", onePixY.ToString("0.0"));
}
}
private LeastSquareFittedAstrometry SolveWithLinearRegression(FitOrder fitOrder, int minNumberOfStars, double maxResidual, bool upgradeIfPossible, out LeastSquareFittedAstrometry firstFit)
{
bool failed = false;
try
{
PlateConstantsFit firstPlateConstantsFit = null;
if (!upgradeIfPossible)
{
PlateConstantsFit bestFit = LinearFitWithExcludingResiduals(fitOrder, minNumberOfStars, maxResidual, out firstPlateConstantsFit);
firstFit = firstPlateConstantsFit != null ? new LeastSquareFittedAstrometry(m_PlateConfig, m_Tangent_RA0, m_Tangent_DE0, firstPlateConstantsFit) : null;
if (bestFit != null)
{
return(new LeastSquareFittedAstrometry(m_PlateConfig, m_Tangent_RA0, m_Tangent_DE0, bestFit));
}
}
else
{
// less than 11 stars - do a linear fit
// between 12 and 19 - do a quadratic fit
// more than 20 - do a cubic fit
PlateConstantsFit bestFit = null;
int numStars = m_Pairs.Count;
if (m_Pairs.Count >= MIN_STARS_FOR_CUBIC_FIT)
{
bestFit = LinearFitWithExcludingResiduals(FitOrder.Cubic, minNumberOfStars, maxResidual, out firstPlateConstantsFit);
if (bestFit != null)
{
numStars = bestFit.FitInfo.NumberOfStarsUsedInSolution();
}
else
{
numStars = MIN_STARS_FOR_CUBIC_FIT - 1;
}
}
if (numStars >= MIN_STARS_FOR_QUADRATIC_FIT && numStars < MIN_STARS_FOR_CUBIC_FIT)
{
bestFit = LinearFitWithExcludingResiduals(FitOrder.Quadratic, minNumberOfStars, maxResidual, out firstPlateConstantsFit);
if (bestFit != null)
{
numStars = bestFit.FitInfo.NumberOfStarsUsedInSolution();
}
else
{
numStars = MIN_STARS_FOR_QUADRATIC_FIT - 1;
}
}
if (numStars < MIN_STARS_FOR_QUADRATIC_FIT)
{
bestFit = LinearFitWithExcludingResiduals(FitOrder.Linear, minNumberOfStars, maxResidual, out firstPlateConstantsFit);
}
firstFit = firstPlateConstantsFit != null ? new LeastSquareFittedAstrometry(m_PlateConfig, m_Tangent_RA0, m_Tangent_DE0, firstPlateConstantsFit) : null;
if (bestFit != null)
{
return(new LeastSquareFittedAstrometry(m_PlateConfig, m_Tangent_RA0, m_Tangent_DE0, bestFit));
}
}
failed = true;
return(null);
}
finally
{
m_IncludedInSolution.Clear();
m_ExcludedForBadResiduals.Clear();
for (int i = 0; i < m_Pairs.Count; i++)
{
#if ASTROMETRY_DEBUG
Trace.Assert(!m_IncludedInSolution.ContainsKey(m_Pairs[i].StarNo));
#endif
m_IncludedInSolution.Add(m_Pairs[i].StarNo, m_Pairs[i].FitInfo.UsedInSolution);
#if ASTROMETRY_DEBUG
Trace.Assert(!m_ExcludedForBadResiduals.ContainsKey(m_Pairs[i].StarNo));
#endif
m_ExcludedForBadResiduals.Add(m_Pairs[i].StarNo, m_Pairs[i].FitInfo.ExcludedForHighResidual);
}
if (failed)
{
if (TangraConfig.Settings.TraceLevels.PlateSolving.TraceInfo())
{
Trace.WriteLine(string.Format("Solution LeastSquareFit failed. {0} included stars, {1} excluded for high residuals.", m_IncludedInSolution.Count, m_ExcludedForBadResiduals.Count));
}
}
}
}
public LeastSquareFittedAstrometry SolveWithLinearRegression(IAstrometrySettings settings, out LeastSquareFittedAstrometry firstFit)
{
double maxResidual = m_PlateConfig.GetDistanceInArcSec(
m_PlateConfig.CenterXImage, m_PlateConfig.CenterYImage,
m_PlateConfig.CenterXImage + settings.MaxResidualInPixels, m_PlateConfig.CenterYImage + settings.MaxResidualInPixels);
if (m_Pairs.Count < CorePyramidConfig.Default.MinStarsForImprovementForThreshold)
{
double minResidual = m_PlateConfig.GetDistanceInArcSec(
m_PlateConfig.CenterXImage, m_PlateConfig.CenterYImage,
m_PlateConfig.CenterXImage + CorePyramidConfig.Default.MaxResidualThresholdForImprovementInPixels, m_PlateConfig.CenterYImage);
if (maxResidual < minResidual)
{
maxResidual = minResidual;
}
}
if (settings.Method == AstrometricMethod.AutomaticFit)
{
return(SolveWithLinearRegression(FitOrder.Cubic, settings.MinimumNumberOfStars, maxResidual, true, out firstFit));
}
else if (settings.Method == AstrometricMethod.LinearFit)
{
return(SolveWithLinearRegression(FitOrder.Linear, settings.MinimumNumberOfStars, maxResidual, false, out firstFit));
}
else if (settings.Method == AstrometricMethod.QuadraticFit)
{
return(SolveWithLinearRegression(FitOrder.Quadratic, settings.MinimumNumberOfStars, maxResidual, false, out firstFit));
}
else if (settings.Method == AstrometricMethod.CubicFit)
{
return(SolveWithLinearRegression(FitOrder.Cubic, settings.MinimumNumberOfStars, maxResidual, false, out firstFit));
}
else
{
throw new NotImplementedException();
}
}
public LeastSquareFittedAstrometry SolveWithLinearRegression(FitOrder fitOrder, int minNumberOfStars, double maxResidual, out LeastSquareFittedAstrometry firstFit)
{
return(SolveWithLinearRegression(fitOrder, minNumberOfStars, maxResidual, false, out firstFit));
}
public AstrometricSolutionImpl(LeastSquareFittedAstrometry astrometry, StarMagnitudeFit photometry, AstrometricState state, FieldSolveContext fieldSolveContext)
{
StarCatalog = fieldSolveContext.StarCatalogueFacade.CatalogNETCode;
UtcTime = fieldSolveContext.UtcTime;
FrameNoOfUtcTime = fieldSolveContext.FrameNoOfUtcTime;
AutoLimitMagnitude = (float)fieldSolveContext.AutoLimitMagnitude;
ResolvedFocalLength = (float)fieldSolveContext.FocalLength;
if (astrometry != null)
{
ResolvedCenterRADeg = (float)astrometry.RA0Deg;
ResolvedCenterDEDeg = (float)astrometry.DE0Deg;
StdDevRAArcSec = (float)astrometry.StdDevRAArcSec;
StdDevDEArcSec = (float)astrometry.StdDevDEArcSec;
}
else
{
ResolvedCenterRADeg = float.NaN;
ResolvedCenterDEDeg = float.NaN;
StdDevRAArcSec = float.NaN;
StdDevDEArcSec = float.NaN;
}
if (state.SelectedObject != null)
{
m_UserObject = new TangraUserObjectImpl();
m_UserObject.RADeg = (float)state.SelectedObject.RADeg;
m_UserObject.DEDeg = (float)state.SelectedObject.DEDeg;
m_UserObject.X = (float)state.SelectedObject.X0;
m_UserObject.Y = (float)state.SelectedObject.Y0;
if (state.IdentifiedObjects != null &&
state.IdentifiedObjects.Count == 1)
{
foreach (IIdentifiedObject idObj in state.IdentifiedObjects)
{
if (AngleUtility.Elongation(idObj.RAHours * 15.0, idObj.DEDeg, state.SelectedObject.RADeg, state.SelectedObject.DEDeg) * 3600 < 120)
{
m_UserObject.ResolvedName = idObj.ObjectName;
break;
}
}
}
}
m_MeasurementsImpl = new List<TangraAstrometricMeasurementImpl>();
if (state.Measurements != null)
{
foreach (var mea in state.Measurements)
{
m_MeasurementsImpl.Add(new TangraAstrometricMeasurementImpl()
{
DEDeg = mea.DEDeg,
RADeg = mea.RADeg,
FrameNo = mea.FrameNo,
SolutionUncertaintyRACosDEArcSec = mea.SolutionUncertaintyRACosDEArcSec,
SolutionUncertaintyDEArcSec = mea.SolutionUncertaintyDEArcSec,
FWHMArcSec = mea.FWHMArcSec,
Detection = mea.Detection,
SNR = mea.SNR,
UncorrectedTimeStamp = mea.OCRedTimeStamp ?? mea.CalculatedTimeStamp,
Mag = mea.Mag
});
}
}
m_MatchedStarImpl = new List<TangraMatchedStarImpl>();
if (astrometry != null)
{
foreach (PlateConstStarPair pair in astrometry.FitInfo.AllStarPairs)
{
if (pair.FitInfo.UsedInSolution)
{
var star = new TangraMatchedStarImpl()
{
X = (float)pair.x,
Y = (float)pair.y,
RADeg = (float)pair.RADeg,
DEDeg = (float)pair.DEDeg,
StarNo = pair.StarNo,
ExcludedForHighResidual = pair.FitInfo.ExcludedForHighResidual,
ResidualRAArcSec = (float)pair.FitInfo.ResidualRAArcSec,
ResidualDEArcSec = (float)pair.FitInfo.ResidualDEArcSec,
DetectionCertainty = (float)pair.DetectionCertainty,
PSFAmplitude = (int)pair.Intensity,
IsSaturated = pair.IsSaturated,
Mag = (float)pair.Mag
};
TangraCatalogStarImpl catStar = null;
IStar catalogStar = fieldSolveContext.CatalogueStars.Find(s => s.StarNo == pair.StarNo);
if (catalogStar != null)
{
if (catalogStar is UCAC4Entry)
catStar = new TangraAPASSStar();
else
catStar = new TangraCatalogStarImpl();
catStar.StarNo = catalogStar.StarNo;
catStar.MagR = (float)catalogStar.MagR;
catStar.MagV = (float)catalogStar.MagV;
catStar.MagB = (float)catalogStar.MagB;
catStar.Mag = (float)catalogStar.Mag;
if (catalogStar is UCAC3Entry)
{
UCAC3Entry ucac3Star = (UCAC3Entry)catalogStar;
catStar.MagJ = (float)(ucac3Star.jmag * 0.001);
catStar.MagK = (float)(ucac3Star.kmag * 0.001);
catStar.RAJ2000Deg = (float)ucac3Star.RACat;
catStar.DEJ2000Deg = (float)ucac3Star.DECat;
}
else if (catalogStar is UCAC2Entry)
{
UCAC2Entry ucac2Star = (UCAC2Entry)catalogStar;
catStar.MagJ = (float)(ucac2Star._2m_J * 0.001);
catStar.MagK = (float)(ucac2Star._2m_Ks * 0.001);
catStar.RAJ2000Deg = (float)ucac2Star.RACat;
catStar.DEJ2000Deg = (float)ucac2Star.DECat;
}
else if (catalogStar is NOMADEntry)
{
NOMADEntry nomadStar = (NOMADEntry)catalogStar;
catStar.MagJ = (float)(nomadStar.m_J * 0.001);
catStar.MagK = (float)(nomadStar.m_K * 0.001);
catStar.RAJ2000Deg = (float)nomadStar.RACat;
catStar.DEJ2000Deg = (float)nomadStar.DECat;
}
else if (catalogStar is UCAC4Entry)
{
UCAC4Entry ucac4Star = (UCAC4Entry)catalogStar;
catStar.MagJ = (float)(ucac4Star.MagJ);
catStar.MagK = (float)(ucac4Star.MagK);
catStar.RAJ2000Deg = (float)ucac4Star.RACat;
catStar.DEJ2000Deg = (float)ucac4Star.DECat;
((TangraAPASSStar)catStar).B = (float)ucac4Star.MagB;
((TangraAPASSStar)catStar).V = (float)ucac4Star.MagV;
((TangraAPASSStar)catStar).g = (float)ucac4Star.Mag_g;
((TangraAPASSStar)catStar).r = (float)ucac4Star.Mag_r;
((TangraAPASSStar)catStar).i = (float)ucac4Star.Mag_i;
((TangraAPASSStar)catStar).e_B = ucac4Star.apase_B * 0.001f;
((TangraAPASSStar)catStar).e_V = ucac4Star.apase_V * 0.001f;
((TangraAPASSStar)catStar).e_g = ucac4Star.apase_g * 0.001f;
((TangraAPASSStar)catStar).e_r = ucac4Star.apase_r * 0.001f;
((TangraAPASSStar)catStar).e_i = ucac4Star.apase_i * 0.001f;
}
}
star.CatalogStar = catStar;
if (photometry != null)
{
IStar photometryStar = photometry.StarNumbers.FirstOrDefault(s => s.StarNo == pair.StarNo);
if (photometryStar != null)
{
int idx = photometry.StarNumbers.IndexOf(photometryStar);
star.Intensity = (float)photometry.Intencities[idx];
star.IsSaturated = photometry.SaturatedFlags[idx];
star.MeaSignalMethod = ConvertSignalMethod(photometry.MeaSignalMethod);
star.MeaBackgroundMethod = ConvertBackgroundMethod(photometry.MeaBackgroundMethod);
star.MeaSingleApertureSize = photometry.MeaSingleAperture;
star.MeaBackgroundPixelCount = photometry.MeaBackgroundPixelCount;
star.MeaSaturationLevel = photometry.MeaSaturationLevel;
}
}
m_MatchedStarImpl.Add(star);
}
}
}
}
// TODO: Use the imeplementation in the MainForm instead
private void DrawHighResFeature(ImagePixel pixel, PlateConstStarPair selectedPair, LeastSquareFittedAstrometry astrometry)
{
int x0 = pixel.X;
int y0 = pixel.Y;
if (x0 < 15) x0 = 15; if (y0 < 15) y0 = 15;
if (x0 > AstrometryContext.Current.FullFrame.Width - 15) x0 = AstrometryContext.Current.FullFrame.Width - 15;
if (y0 > AstrometryContext.Current.FullFrame.Height - 15) y0 = AstrometryContext.Current.FullFrame.Height - 15;
int bytes;
int bytesPerPixel;
int selIdx;
Bitmap featureBitmap = new Bitmap(31 * 8, 31 * 8, PixelFormat.Format24bppRgb);
m_VideoController.UpdateZoomedImage(featureBitmap, pixel);
BitmapData zoomedData = featureBitmap.LockBits(new Rectangle(0, 0, 31 * 8, 31 * 8), ImageLockMode.ReadWrite, featureBitmap.PixelFormat);
try
{
bytes = zoomedData.Stride * featureBitmap.Height;
byte[] zoomedValues = new byte[bytes];
Marshal.Copy(zoomedData.Scan0, zoomedValues, 0, bytes);
bytesPerPixel = AstrometryContext.Current.BytesPerPixel;
byte saturatedR = TangraConfig.Settings.Color.Saturation.R;
byte saturatedG = TangraConfig.Settings.Color.Saturation.G;
byte saturatedB = TangraConfig.Settings.Color.Saturation.B;
selIdx = 0;
for (int y = 0; y < 31; y++)
for (int x = 0; x < 31; x++)
{
for (int i = 0; i < 8; i++)
for (int j = 0; j < 8; j++)
{
int zoomedX = 8 * x + i;
int zoomedY = 8 * y + j;
int zoomedIdx = zoomedData.Stride * zoomedY + zoomedX * bytesPerPixel;
if (zoomedValues[zoomedIdx] > TangraConfig.Settings.Photometry.Saturation.Saturation8Bit)
{
// Saturation detected
zoomedValues[zoomedIdx] = saturatedR;
zoomedValues[zoomedIdx + 1] = saturatedG;
zoomedValues[zoomedIdx + 2] = saturatedB;
}
}
selIdx++;
}
Marshal.Copy(zoomedValues, 0, zoomedData.Scan0, bytes);
}
finally
{
featureBitmap.UnlockBits(zoomedData);
}
Pen starPen = catalogStarPen;
double xFitUnscaled = pixel.XDouble;
double yFitUnscaled = pixel.YDouble;
if (selectedPair != null && selectedPair.FitInfo.UsedInSolution)
{
starPen = referenceStarPen;
astrometry.GetImageCoordsFromRADE(selectedPair.RADeg, selectedPair.DEDeg, out xFitUnscaled, out yFitUnscaled);
}
else if (selectedPair != null && selectedPair.FitInfo.ExcludedForHighResidual)
{
starPen = rejectedStarPen;
astrometry.GetImageCoordsFromRADE(selectedPair.RADeg, selectedPair.DEDeg, out xFitUnscaled, out yFitUnscaled);
}
else
{
starPen = unrecognizedStarPen;
}
double xFit = (8 * (xFitUnscaled - x0 + 16)) - 4;
double yFit = (8 * (yFitUnscaled - y0 + 16)) - 4;
}
