private void CompleteActivation()
{
m_VideoController.SetPictureBoxCursor(CustomCursors.PanCursor);
m_FieldSolveContext = AstrometryContext.Current.FieldSolveContext;
m_Image = m_AstrometryController.GetCurrentAstroPlate();
m_Image.EffectiveFocalLength = m_FieldSolveContext.FocalLength;
m_RADegCenter = m_FieldSolveContext.RADeg;
m_DEDegCenter = m_FieldSolveContext.DEDeg;
StarCatalogueFacade facade = new StarCatalogueFacade(TangraConfig.Settings.StarCatalogue);
m_CatalogueStars = facade.GetStarsInRegion(
m_FieldSolveContext.RADeg, m_FieldSolveContext.DEDeg,
2.5 * m_Image.GetMaxFOVInArcSec() / 3600.0, m_FieldSolveContext.LimitMagn, (float)m_FieldSolveContext.Epoch);
m_Eta = GetUserCameraConfigParam("rotation", 0.0);
m_FLength = m_FieldSolveContext.FocalLength;
m_Aspect = GetUserCameraConfigParam("aspect", 1.0);
m_LimitMag = (int)Math.Round(m_FieldSolveContext.LimitMagn);
m_ShowLabels = GetUserCameraConfigParam("labels", 0) == 1;
m_Grid = GetUserCameraConfigParam("grid", 0) == 1;
m_ShowMagnitudes = GetUserCameraConfigParam("magnitudes", 0) == 1;
UpdateControls();
InitStarMap();
m_SolvedPlate = new DirectTransRotAstrometry(m_Image, m_FieldSolveContext.RADeg, m_FieldSolveContext.DEDeg, m_Eta, m_Aspect);
m_CalibrationContext = new CalibrationContext();
m_CalibrationContext.StarMap = AstrometryContext.Current.StarMap;
m_CalibrationContext.PreliminaryFit = m_SolvedPlate;
m_FieldSolveContext.CatalogueStars = m_CatalogueStars;
m_CalibrationContext.FieldSolveContext = m_FieldSolveContext;
m_CalibrationContext.PlateConfig = m_Image;
TangraConfig.AstrometrySettings calibrationSettings = TangraConfig.Settings.Astrometry.Clone();
calibrationSettings.MaxResidualInPixels = CorePyramidConfig.Default.CalibrationMaxResidualInPixels;
calibrationSettings.PyramidDistanceToleranceInPixels = CorePyramidConfig.Default.CalibrationPyramidDistanceToleranceInPixels;
calibrationSettings.MinimumNumberOfStars = CorePyramidConfig.Default.CalibrationNumberOfStars;
m_PlateCalibrator = new PlateCalibration(m_CalibrationContext, calibrationSettings, m_AstrometryController);
UpdateToolControlDisplay();
m_PlatesolveController.SetupControls();
m_SolveState = -1;
DrawCatalogStarsFit();
m_State = FittingsState.Activated;
}
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 byte[] Serialize()
{
BinaryFormatter fmt = new BinaryFormatter();
using (MemoryStream memStr = new MemoryStream())
{
fmt.Serialize(memStr, SERIALIZATION_VERSION);
fmt.Serialize(memStr, PlateConfig);
StarMap sMap = StarMap as StarMap;
fmt.Serialize(memStr, sMap);
fmt.Serialize(memStr, FitExcludeArea.Top);
fmt.Serialize(memStr, FitExcludeArea.Left);
fmt.Serialize(memStr, FitExcludeArea.Width);
fmt.Serialize(memStr, FitExcludeArea.Height);
fmt.Serialize(memStr, FieldSolveContext);
DirectTransRotAstrometry trRot = PreliminaryFit as DirectTransRotAstrometry;
fmt.Serialize(memStr, trRot != null);
if (trRot != null)
{
fmt.Serialize(memStr, trRot);
}
fmt.Serialize(memStr, FirstAstrometricFit != null);
if (FirstAstrometricFit != null)
{
fmt.Serialize(memStr, FirstAstrometricFit);
}
fmt.Serialize(memStr, SecondAstrometricFit != null);
if (SecondAstrometricFit != null)
{
fmt.Serialize(memStr, SecondAstrometricFit);
}
fmt.Serialize(memStr, DistanceBasedFit != null);
if (DistanceBasedFit != null)
{
fmt.Serialize(memStr, DistanceBasedFit);
}
fmt.Serialize(memStr, ImprovedDistanceBasedFit != null);
if (ImprovedDistanceBasedFit != null)
{
fmt.Serialize(memStr, ImprovedDistanceBasedFit);
}
FocalLengthFit flf = null;
if (ConstantsSolver != null)
{
flf = ConstantsSolver.ComputeFocalLengthFit();
}
fmt.Serialize(memStr, flf != null);
if (flf != null)
{
fmt.Serialize(memStr, flf);
}
memStr.Flush();
return(memStr.ToArray());
}
}
public static CalibrationContext Deserialize(byte[] data)
{
CalibrationContext ctx = new CalibrationContext();
BinaryFormatter fmt = new BinaryFormatter();
using (MemoryStream memStr = new MemoryStream(data))
using (StreamReader rdr = new StreamReader(memStr))
{
int version = (int)fmt.Deserialize(memStr);
if (version > 0)
{
object obj = fmt.Deserialize(memStr);
try
{
ctx.PlateConfig = (AstroPlate)obj;
}
catch (Exception)
{
ctx.PlateConfig = AstroPlate.FromReflectedObject(obj);
}
obj = fmt.Deserialize(memStr);
try
{
ctx.StarMap = (StarMap)obj;
}
catch (Exception)
{
ctx.StarMap = Tangra.Model.Astro.StarMap.FromReflectedObject(obj);
}
int top = (int)fmt.Deserialize(memStr);
int left = (int)fmt.Deserialize(memStr);
int width = (int)fmt.Deserialize(memStr);
int height = (int)fmt.Deserialize(memStr);
ctx.FitExcludeArea = new Rectangle(top, left, width, height);
obj = fmt.Deserialize(memStr);
try
{
ctx.FieldSolveContext = (FieldSolveContext)obj;
}
catch (Exception)
{
ctx.FieldSolveContext = FieldSolveContext.FromReflectedObject(obj);
}
if (version > 1)
{
bool noNull = (bool)fmt.Deserialize(memStr);
if (noNull)
{
obj = fmt.Deserialize(memStr);
try
{
ctx.PreliminaryFit = (DirectTransRotAstrometry)obj;
}
catch (Exception)
{
ctx.PreliminaryFit = DirectTransRotAstrometry.FromReflectedObject(obj);
}
}
noNull = (bool)fmt.Deserialize(memStr);
if (noNull)
{
obj = fmt.Deserialize(memStr);
try
{
ctx.FirstAstrometricFit = (LeastSquareFittedAstrometry)obj;
}
catch (Exception)
{
ctx.FirstAstrometricFit = LeastSquareFittedAstrometry.FromReflectedObject(obj);
}
}
noNull = (bool)fmt.Deserialize(memStr);
if (noNull)
{
obj = fmt.Deserialize(memStr);
try
{
ctx.SecondAstrometricFit = (LeastSquareFittedAstrometry)obj;
}
catch (Exception)
{
ctx.SecondAstrometricFit = LeastSquareFittedAstrometry.FromReflectedObject(obj);
}
}
noNull = (bool)fmt.Deserialize(memStr);
if (noNull)
{
obj = fmt.Deserialize(memStr);
try
{
ctx.DistanceBasedFit = (LeastSquareFittedAstrometry)obj;
}
catch (Exception)
{
ctx.DistanceBasedFit = LeastSquareFittedAstrometry.FromReflectedObject(obj);
}
}
noNull = (bool)fmt.Deserialize(memStr);
if (noNull)
{
obj = fmt.Deserialize(memStr);
try
{
ctx.ImprovedDistanceBasedFit = (LeastSquareFittedAstrometry)obj;
}
catch (Exception)
{
ctx.ImprovedDistanceBasedFit = LeastSquareFittedAstrometry.FromReflectedObject(obj);
}
}
if (version > 2)
{
FocalLengthFit flf = null;
noNull = (bool)fmt.Deserialize(memStr);
if (noNull)
{
obj = fmt.Deserialize(memStr);
try
{
flf = (FocalLengthFit)obj;
}
catch (Exception)
{
flf = FocalLengthFit.FromReflectedObject(obj);
}
}
ctx.ConstantsSolver = new PlateConstantsSolver(ctx.PlateConfig);
ctx.ConstantsSolver.SetFocalLengthFit(flf);
}
}
else
{
ctx.PreliminaryFit = (DirectTransRotAstrometry)fmt.Deserialize(memStr);
}
}
}
return(ctx);
}
public void RegisterPreliminaryThreeStarFit(DirectTransRotAstrometry solution)
{
PreliminaryFit = solution;
}
public void RegisterPreliminaryThreeStarFit(DirectTransRotAstrometry solution)
{
PreliminaryFit = solution;
}
