internal MarshalByRefLightCurveDataProvider(ILightCurveDataProvider localProvider)
        {
            m_DelegatedLocalProvider = localProvider;

            FileName = localProvider.FileName;
            NumberOfMeasuredComparisonObjects = localProvider.NumberOfMeasuredComparisonObjects;
            CameraCorrectionsHaveBeenApplied = localProvider.CameraCorrectionsHaveBeenApplied;
            HasEmbeddedTimeStamps = localProvider.HasEmbeddedTimeStamps;
            VideoCameraName = localProvider.VideoCameraName;
            VideoSystem = localProvider.VideoSystem;
            NumberIntegratedFrames = localProvider.NumberIntegratedFrames;
            MinFrameNumber = localProvider.MinFrameNumber;
            MaxFrameNumber = localProvider.MaxFrameNumber;
            m_TangraDrawingSettings = localProvider.GetTangraDrawingSettings();

            CurrentlySelectedFrameNumber = localProvider.CurrentlySelectedFrameNumber;
            HasReliableTimeBase = localProvider.HasReliableTimeBase;
            m_TargetMeasurements = localProvider.GetTargetMeasurements();
            if (NumberOfMeasuredComparisonObjects > 0)
                m_Comp1Measurements = localProvider.GetComparisonObjectMeasurements(0);
            if (NumberOfMeasuredComparisonObjects > 1)
                m_Comp2Measurements = localProvider.GetComparisonObjectMeasurements(1);
            if (NumberOfMeasuredComparisonObjects > 2)
                m_Comp3Measurements = localProvider.GetComparisonObjectMeasurements(2);
            localProvider.GetIntegrationRateAndFirstFrame(out m_IntegrationRate, out m_FirstIntegratingFrame);
        }
        internal MarshalByRefLightCurveDataProvider(ILightCurveDataProvider localProvider)
        {
            m_DelegatedLocalProvider = localProvider;

            FileName = localProvider.FileName;
            NumberOfMeasuredComparisonObjects = localProvider.NumberOfMeasuredComparisonObjects;
            CameraCorrectionsHaveBeenApplied  = localProvider.CameraCorrectionsHaveBeenApplied;
            HasEmbeddedTimeStamps             = localProvider.HasEmbeddedTimeStamps;
            VideoCameraName         = localProvider.VideoCameraName;
            VideoSystem             = localProvider.VideoSystem;
            NumberIntegratedFrames  = localProvider.NumberIntegratedFrames;
            MinFrameNumber          = localProvider.MinFrameNumber;
            MaxFrameNumber          = localProvider.MaxFrameNumber;
            m_TangraDrawingSettings = localProvider.GetTangraDrawingSettings();

            CurrentlySelectedFrameNumber = localProvider.CurrentlySelectedFrameNumber;
            HasReliableTimeBase          = localProvider.HasReliableTimeBase;
            m_TargetMeasurements         = localProvider.GetTargetMeasurements();
            if (NumberOfMeasuredComparisonObjects > 0)
            {
                m_Comp1Measurements = localProvider.GetComparisonObjectMeasurements(0);
            }
            if (NumberOfMeasuredComparisonObjects > 1)
            {
                m_Comp2Measurements = localProvider.GetComparisonObjectMeasurements(1);
            }
            if (NumberOfMeasuredComparisonObjects > 2)
            {
                m_Comp3Measurements = localProvider.GetComparisonObjectMeasurements(2);
            }
            localProvider.GetIntegrationRateAndFirstFrame(out m_IntegrationRate, out m_FirstIntegratingFrame);
        }
Esempio n. 3
0
 public void OnLightCurveSelectedFrameChanged()
 {
     if (m_AOTAFormVisible)
     {
         ILightCurveDataProvider dataProvider = m_TangraHost.GetLightCurveDataProvider();
         int currFrameId = dataProvider.CurrentlySelectedFrameNumber;
         m_OccultWrapper.NotifyAOTAOfCurrentFrameChanged(currFrameId);
     }
 }
Esempio n. 4
0
        public void OnAOTAFormClosing()
        {
            if (m_AOTAFormVisible)
            {
                ILightCurveDataProvider dataProvider = m_TangraHost.GetLightCurveDataProvider();

                AotaReturnValue result = m_OccultWrapper.GetAOTAResult();

                string directory = Path.GetDirectoryName(dataProvider.FileName);
                if (directory != null)
                {
                    if (!Directory.Exists(directory))
                    {
                        Directory.CreateDirectory(directory);
                    }

                    var debugFileName = Path.ChangeExtension(dataProvider.FileName, ".aota.xml");
                    TrySaveReport(debugFileName, result);
                }

                if (result != null &&
                    result.AreResultsAvailable)
                {
                    dataProvider.SetTimeExtractionEngine(result.AOTAVersion);

                    if (result.IsMiss)
                    {
                        dataProvider.SetNoOccultationEvents();
                    }
                    else
                    {
                        for (int i = 0; i < 5; i++)
                        {
                            if (!result.EventResults[i].IsNonEvent)
                            {
                                dataProvider.SetFoundOccultationEvent(
                                    i,
                                    result.EventResults[i].D_Frame,
                                    result.EventResults[i].R_Frame,
                                    result.EventResults[i].D_FrameUncertMinus,
                                    result.EventResults[i].D_FrameUncertPlus,
                                    result.EventResults[i].R_FrameUncertMinus,
                                    result.EventResults[i].R_FrameUncertPlus,
                                    result.EventResults[i].D_UTC,
                                    result.EventResults[i].R_UTC,
                                    result.CameraResult.CameraDelaysKnownToAOTA,
                                    result.CameraResult.FramesIntegrated);
                            }
                        }
                    }
                }

                m_AOTAFormVisible = false;

                dataProvider.FinishedLightCurveEventTimeExtraction();
            }
        }
Esempio n. 5
0
        public void Execute()
        {
            if (m_AOTAFormVisible)
            {
                ShowErrorMessage("AOTA is already running.");
                return;
            }

            ILightCurveDataProvider dataProvider = m_TangraHost.GetLightCurveDataProvider();

            if (!Directory.Exists(m_Settings.OccultLocation))
            {
                string locationFromOW = OccultWatcherHelper.GetConfiguredOccultLocation();
                if (Directory.Exists(locationFromOW))
                {
                    m_Settings.OccultLocation = locationFromOW;
                    m_Settings.Save();
                }
                else
                {
                    m_Addin.Configure();
                }
            }

            string errorMessage = m_OccultWrapper.HasSupportedVersionOfOccult(m_Settings.OccultLocation);

            if (errorMessage != null)
            {
                ShowErrorMessage(errorMessage);
                m_Addin.Configure();
            }

            if (dataProvider != null)
            {
                errorMessage = m_OccultWrapper.HasSupportedVersionOfOccult(m_Settings.OccultLocation);
                if (errorMessage == null)
                {
                    if (m_OccultWrapper.RunAOTA(dataProvider, m_TangraHost.ParentWindow))
                    {
                        m_AOTAFormVisible = true;
                    }
                }
                else
                {
                    ShowErrorMessage(errorMessage);
                }
            }
        }
Esempio n. 6
0
 internal void SetLightCurveDataProvider(ILightCurveDataProvider provider)
 {
     m_lcDataProvider = provider;
 }
Esempio n. 7
0
        private void frmResults_Load(object sender, EventArgs e)
        {
            ILightCurveDataProvider dataProvider = TangraHost.GetLightCurveDataProvider();

            if (dataProvider != null)
            {
                ITangraDrawingSettings settings = dataProvider.GetTangraDrawingSettings();

                Color targetColor = settings.Target1Color;
                if (TargetId == 0)
                {
                    targetColor = settings.Target1Color;
                }
                else if (TargetId == 1)
                {
                    targetColor = settings.Target2Color;
                }
                else if (TargetId == 2)
                {
                    targetColor = settings.Target3Color;
                }
                else if (TargetId == 3)
                {
                    targetColor = settings.Target4Color;
                }

                m_TargetBrush = new SolidBrush(targetColor);
            }
            else
            {
                m_TargetBrush = Brushes.DeepSkyBlue;
            }

            if (Results.Success)
            {
                tbxErrorMessage.Visible = false;
                picGraph.Visible        = true;
            }
            else
            {
                tbxErrorMessage.Text    = Results.ErrorMessage;
                tbxErrorMessage.Visible = true;
                picGraph.Visible        = false;
            }

            // 1E-6 days is a precision of 0.08 sec - good enough for our purposes
            tbxT0JD.Text             = Results.Time_Of_Minimum_JD.ToString("0.000000");
            tbxT0UT.Text             = AstroUtilities.JDToDateTimeUtc(Results.Time_Of_Minimum_JD).ToString("dd MMM yyyy, HH:mm:ss.fff");
            tbxT0Uncertainty.Text    = Results.Time_Of_Minimum_Uncertainty.ToString("0.000000");
            tbxT0.Text               = Results.T0.ToString("0.000000");
            tbxTotalObs.Text         = Results.NumberObservations.ToString();
            tbxIncludedObs.Text      = Results.IncludedObservations.ToString() + "%";
            tbxUncertaintyInSec.Text = (Results.Time_Of_Minimum_Uncertainty * 86400.0).ToString("0.0");

            PlotKweeVanWoerden();


            if (PolyResults != null)
            {
                tbxT0JD_CF.Text = PolyResults.Time_Of_Minimum_JD.ToString("0.000000");
                tbxT0UT_CF.Text = AstroUtilities.JDToDateTimeUtc(PolyResults.Time_Of_Minimum_JD).ToString("dd MMM yyyy, HH:mm:ss.fff");

                nudM0.Value = (decimal)PolyResults.M0;
                nudC.Value  = (decimal)PolyResults.C;
                nudD.Value  = (decimal)PolyResults.D;
                nudG.Value  = (decimal)PolyResults.G;

                PlotPolyFit();
            }
        }
Esempio n. 8
0
            internal static bool RunAOTA(ILightCurveDataProvider dataProvider, IWin32Window parentWindow, IAOTAClientCallbacks clientCallbacks)
            {
                try
                {
                    if (m_AotaInstance == null)
                        m_AotaInstance = Activator.CreateInstance(TYPE_AOTA_ExternalAccess) as Occult.SDK.IAOTAExternalAccess;

                    ShieldedCall(() => m_AotaInstance.InitialiseAOTA(dataProvider.FileName, clientCallbacks));

                    ISingleMeasurement[] measurements = dataProvider.GetTargetMeasurements();

                    bool hasReliableTimeBase = dataProvider.HasReliableTimeBase;

                    float[] data = measurements.Select(x => x.Measurement).ToArray();
                    float[] frameIds = measurements.Select(x => (float)x.CurrFrameNo).ToArray();

                    float[] dataBg = measurements.Select(x => x.Background).ToArray();
                    ShieldedCall(() => m_AotaInstance.Set_TargetData_BackgroundAlreadySubtracted(data, dataBg));

                    ShieldedCall(() => m_AotaInstance.Set_FrameID(frameIds));

                    DateTime[] timestamps = measurements.Select(x => x.Timestamp).ToArray();

                    hasReliableTimeBase = hasReliableTimeBase &&
                        timestamps[0].Date != DateTime.MinValue &&
                        timestamps[measurements.Length - 1].Date != DateTime.MinValue &&
                        timestamps[0].Date.Ticks < timestamps[measurements.Length - 1].Ticks;

                    double[] secondsFromUTMidnight;
                    long startFrameStartDayTicks;

                    bool cameraCorrectionsHaveBeenApplied = dataProvider.CameraCorrectionsHaveBeenApplied && dataProvider.HasEmbeddedTimeStamps;

                    startFrameStartDayTicks = hasReliableTimeBase ? timestamps[0].Date.Ticks : timestamps.FirstOrDefault(x => x != DateTime.MinValue).Date.Ticks;
                    secondsFromUTMidnight = new double[timestamps.Length];
                    for (int i = 0; i < timestamps.Length; i++)
                    {
                        if (!measurements[i].IsCorrectedForInstrumentalDelay && cameraCorrectionsHaveBeenApplied)
                            // Individual frames for which instrumental delays hasn't been applied even that instrumental delay is applied for the file, are marked as blank
                            secondsFromUTMidnight[i] = 0;
                        else if (timestamps[i] != DateTime.MinValue)
                            secondsFromUTMidnight[i] = Math.Truncate(new TimeSpan(timestamps[i].Ticks - startFrameStartDayTicks).TotalSeconds * 10000) / 10000.0;
                        else
                            secondsFromUTMidnight[i] = 0;
                    }

                    ShieldedCall(() => m_AotaInstance.Set_TimeBase(secondsFromUTMidnight, cameraCorrectionsHaveBeenApplied));

                    if (cameraCorrectionsHaveBeenApplied)
                    {
                        string cameraName = dataProvider.VideoCameraName;
                        if (!string.IsNullOrEmpty(cameraName))
                            ShieldedCall(() => m_AotaInstance.Set_VideoCamera(cameraName));
                    }

                    // Now go and set any comparison stars
                    for (int i = 0; i < dataProvider.NumberOfMeasuredComparisonObjects; i++)
                    {
                        ISingleMeasurement[] compMeasurements = dataProvider.GetComparisonObjectMeasurements(i);

                        if (compMeasurements != null)
                        {
                            float[] compData = compMeasurements.Select(x => x.Measurement).ToArray();

                            if (i == 0)
                                ShieldedCall(() => m_AotaInstance.Set_Comp1Data(compData));
                            else if (i == 1)
                                ShieldedCall(() => m_AotaInstance.Set_Comp2Data(compData));
                            else if (i == 2)
                                ShieldedCall(() => m_AotaInstance.Set_Comp3Data(compData));
                        }
                    }

                     ShieldedCall(() => m_AotaInstance.Camera = new Occult.SDK.Camera()
                        {
                            CameraType = dataProvider.VideoCameraName,
                            VideoSystem = dataProvider.VideoSystem,
                            FramesIntegrated = dataProvider.NumberIntegratedFrames
                        });

                    int firstFrameIndex = 0;// (int)frameIds[0];
                    int framesInIntegration = 1;

                    ShieldedCall(() => m_AotaInstance.RunAOTA(null, firstFrameIndex, framesInIntegration, false));

                    return true;
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(ex.ToString());
                    MessageBox.Show(ex is TargetInvocationException ? ex.InnerException.Message : ex.Message, "AOTA Add-in Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }

                return false;
            }
Esempio n. 9
0
 internal void SetLightCurveDataProvider(ILightCurveDataProvider provider)
 {
     m_lcDataProvider = provider;
 }
Esempio n. 10
0
        private void ExecuteWithRealData()
        {
            ILightCurveDataProvider dataProvider = m_TangraHost.GetLightCurveDataProvider();

            if (dataProvider != null)
            {
                if (dataProvider.NumberOfMeasuredComparisonObjects == 0)
                {
                    ShowErrorMessage("At least one comparison object is required to determine the target eclipsing binary minimum.");
                    return;
                }

                ISingleMeasurement[] measurements = dataProvider.GetTargetMeasurements();

                bool hasReliableTimeBase = dataProvider.HasReliableTimeBase;

                double[] frameIds = measurements.Select(x => (double)x.CurrFrameNo).ToArray();
                double[] dataWithBg;
                double[] dataBg;

                var frm = new frmConfigureRun();
                frm.DataProvider = dataProvider;
                frm.NumStars     = dataProvider.NumberOfMeasuredComparisonObjects + 1;
                frm.FromFrameNo  = dataProvider.MinFrameNumber;
                frm.ToFrameNo    = dataProvider.MaxFrameNumber;
                frm.TargetData   = dataProvider.GetTargetMeasurements();
                if (frm.ShowDialog(m_TangraHost.ParentWindow) == DialogResult.Cancel)
                {
                    return;
                }

                bool useCurveFitting    = frm.RunCurveFitting;
                bool useFineGrainedBins = frm.UseFineGrainedBins;

                if (frm.VariableStarIndex == 0)
                {
                    dataWithBg = measurements.Select(x => x.IsSuccessful ? (double)(x.Measurement + x.Background) : double.NaN).ToArray();
                    dataBg     = measurements.Select(x => x.IsSuccessful ? (double)x.Background : double.NaN).ToArray();
                }
                else
                {
                    ISingleMeasurement[] altMeasurements = dataProvider.GetComparisonObjectMeasurements(frm.VariableStarIndex - 1);

                    dataWithBg = altMeasurements.Select(x => x.IsSuccessful ? (double)(x.Measurement + x.Background) : double.NaN).ToArray();
                    dataBg     = altMeasurements.Select(x => x.IsSuccessful ? (double)x.Background : double.NaN).ToArray();
                }

                List <DateTime> timestamps = measurements.Select(x => x.Timestamp).ToList();

                hasReliableTimeBase = hasReliableTimeBase &&
                                      timestamps[0].Date != DateTime.MinValue &&
                                      timestamps[measurements.Length - 1].Date != DateTime.MinValue &&
                                      timestamps[0].Date.Ticks < timestamps[measurements.Length - 1].Ticks;

                int numAvailableTimestamps = timestamps.Count(x => x != DateTime.MinValue && x != DateTime.MaxValue);
                if (numAvailableTimestamps < 2)
                {
                    MessageBox.Show(
                        m_TangraHost.ParentWindow,
                        "This light curve does not seem to have timestamps saved and cannot be processed.",
                        "Eclipsing Binaries Addin for Tangra",
                        MessageBoxButtons.OK,
                        MessageBoxIcon.Error);
                    return;
                }

                if (!hasReliableTimeBase)
                {
                    if (MessageBox.Show(
                            m_TangraHost.ParentWindow,
                            "This light curve may not have a reliable time base. Do you want to continue?",
                            "Eclipsing Binaries Addin for Tangra",
                            MessageBoxButtons.YesNo,
                            MessageBoxIcon.Warning) == DialogResult.No)
                    {
                        return;
                    }
                }

                // Fill in missing timestamps when times are entered manually
                if (!dataProvider.HasEmbeddedTimeStamps)
                {
                    int idx = 0;
                    for (; idx < timestamps.Count / 2 && timestamps[idx] == DateTime.MinValue; idx++)
                    {
                        ;
                    }
                    int      firstTimeStampIndex = idx;
                    DateTime firstTimeStamp      = timestamps[idx];

                    idx = timestamps.Count - 1;
                    for (; idx > timestamps.Count / 2 && timestamps[idx] == DateTime.MinValue; idx--)
                    {
                        ;
                    }
                    int      lastTimeStampIndex = idx;
                    DateTime lastTimeStamp      = timestamps[idx];

                    long ticksPerFrame = (lastTimeStamp.Ticks - firstTimeStamp.Ticks) / (lastTimeStampIndex - firstTimeStampIndex);
                    for (int i = 0; i < timestamps.Count; i++)
                    {
                        timestamps[i] = firstTimeStamp.AddTicks(ticksPerFrame * (i - firstTimeStampIndex));
                    }
                }

                double[] secondsFromUTMidnight   = new double[timestamps.Count];
                long     startFrameStartDayTicks = timestamps[0].Date.Ticks;

                for (int i = 0; i < timestamps.Count; i++)
                {
                    if (timestamps[i] != DateTime.MinValue)
                    {
                        secondsFromUTMidnight[i] = Math.Truncate(new TimeSpan(timestamps[i].Ticks - startFrameStartDayTicks).TotalSeconds * 10000) / 10000.0;
                    }
                    else
                    {
                        secondsFromUTMidnight[i] = 0;
                    }
                }

                // Now go and get the comparison star data
                if (dataProvider.NumberOfMeasuredComparisonObjects > 0)
                {
                    ISingleMeasurement[] compMeasurements = frm.ComparisonStarIndex == 0 ? dataProvider.GetTargetMeasurements() : dataProvider.GetComparisonObjectMeasurements(frm.ComparisonStarIndex - 1);

                    if (compMeasurements != null)
                    {
                        double[] compDataWithBg;
                        double[] compBg;

                        if (frm.UseNormalisation)
                        {
                            compDataWithBg = compMeasurements.Select(x => x.IsSuccessful ? (double)(x.Measurement + x.Background) : double.NaN).ToArray();
                            compBg         = compMeasurements.Select(x => x.IsSuccessful ? (double)x.Background : double.NaN).ToArray();
                        }
                        else
                        {
                            double compDataWithBgAverage = compMeasurements.Average(x => x.IsSuccessful ? x.Measurement + x.Background : double.NaN);
                            double compBgAverage         = compMeasurements.Average(x => x.IsSuccessful ? x.Background : double.NaN);
                            compDataWithBg = compMeasurements.Select(x => compDataWithBgAverage).ToArray();
                            compBg         = compMeasurements.Select(x => compBgAverage).ToArray();
                        }

                        double jdAtUtcMidnight = DateUtcToJulian(new DateTime(startFrameStartDayTicks));


                        KweeVanWoerdenResult result;
                        PolynomialFitResult  polyResult;

                        var times             = new List <double>();
                        var dataWithBgLst     = new List <double>();
                        var dataBgLst         = new List <double>();
                        var compDataWithBgLst = new List <double>();
                        var compBgLst         = new List <double>();

                        if (frm.IncludeDataFrom > 0 || frm.IncludeDataTo < dataWithBg.Length - 1)
                        {
                            double[] timesAlt          = new double[frm.IncludeDataTo - frm.IncludeDataFrom];
                            double[] dataWithBgAlt     = new double[frm.IncludeDataTo - frm.IncludeDataFrom];
                            double[] dataBgAlt         = new double[frm.IncludeDataTo - frm.IncludeDataFrom];
                            double[] compDataWithBgAlt = new double[frm.IncludeDataTo - frm.IncludeDataFrom];
                            double[] compBgAlt         = new double[frm.IncludeDataTo - frm.IncludeDataFrom];
                            for (int i = frm.IncludeDataFrom; i < frm.IncludeDataTo; i++)
                            {
                                timesAlt[i - frm.IncludeDataFrom]          = secondsFromUTMidnight[i];
                                dataWithBgAlt[i - frm.IncludeDataFrom]     = dataWithBg[i];
                                dataBgAlt[i - frm.IncludeDataFrom]         = dataBg[i];
                                compDataWithBgAlt[i - frm.IncludeDataFrom] = compDataWithBg[i];
                                compBgAlt[i - frm.IncludeDataFrom]         = compBg[i];
                            }

                            times.AddRange(timesAlt);
                            dataWithBgLst.AddRange(dataWithBgAlt);
                            dataBgLst.AddRange(dataBgAlt);
                            compDataWithBgLst.AddRange(compDataWithBgAlt);
                            compBgLst.AddRange(compBgAlt);

                            RemoveInvalidMeasurements(times, dataWithBgLst, dataBgLst, compDataWithBgLst, compBgLst);
                        }
                        else
                        {
                            times.AddRange(secondsFromUTMidnight);
                            dataWithBgLst.AddRange(dataWithBg);
                            dataBgLst.AddRange(dataBg);
                            compDataWithBgLst.AddRange(compDataWithBg);
                            compBgLst.AddRange(compBg);

                            RemoveInvalidMeasurements(times, dataWithBgLst, dataBgLst, compDataWithBgLst, compBgLst);
                        }


                        result     = Kwee_van_Woerden(times.Count, jdAtUtcMidnight, times.ToArray(), dataWithBgLst.ToArray(), dataBgLst.ToArray(), compDataWithBgLst.ToArray(), compBgLst.ToArray(), useFineGrainedBins);
                        polyResult = useCurveFitting
                                                        ? PolynomialFit(times.Count, jdAtUtcMidnight, times.ToArray(), dataWithBgLst.ToArray(), dataBgLst.ToArray(), compDataWithBgLst.ToArray(), compBgLst.ToArray(), (int)result.Start_Light_Curve_Obs_Index, (int)result.Stop_Light_Curve_Obs_Index, result.Time_Of_Minimum)
                                                        : null;

                        PresentResults(frm.VariableStarIndex, result, polyResult);
                    }
                }
            }
        }
Esempio n. 11
0
 internal void SetLightCurveDataProvider(ILightCurveDataProvider provider)
 {
     m_LocalLightCurveDataProvider     = provider;
     m_DelegatedLightCurveDataProvider = null;
 }
Esempio n. 12
0
            internal static bool RunAOTA(ILightCurveDataProvider dataProvider, IWin32Window parentWindow, IAOTAClientCallbacks clientCallbacks)
            {
                try
                {
                    if (m_AotaInstance == null)
                    {
                        m_AotaInstance = Activator.CreateInstance(TYPE_AOTA_ExternalAccess) as Occult.SDK.IAOTAExternalAccess;
                    }

                    ShieldedCall(() => m_AotaInstance.InitialiseAOTA(dataProvider.FileName, clientCallbacks));

                    ISingleMeasurement[] measurements = dataProvider.GetTargetMeasurements();

                    bool hasReliableTimeBase = dataProvider.HasReliableTimeBase;

                    float[] data     = measurements.Select(x => x.Measurement).ToArray();
                    float[] frameIds = measurements.Select(x => (float)x.CurrFrameNo).ToArray();

                    float[] dataBg = measurements.Select(x => x.Background).ToArray();
                    ShieldedCall(() => m_AotaInstance.Set_TargetData_BackgroundAlreadySubtracted(data, dataBg));

                    ShieldedCall(() => m_AotaInstance.Set_FrameID(frameIds));

                    DateTime[] timestamps = measurements.Select(x => x.Timestamp).ToArray();

                    hasReliableTimeBase = hasReliableTimeBase &&
                                          timestamps[0].Date != DateTime.MinValue &&
                                          timestamps[measurements.Length - 1].Date != DateTime.MinValue &&
                                          timestamps[0].Date.Ticks < timestamps[measurements.Length - 1].Ticks;

                    double[] secondsFromUTMidnight;
                    long     startFrameStartDayTicks;

                    bool cameraCorrectionsHaveBeenApplied = dataProvider.CameraCorrectionsHaveBeenApplied && dataProvider.HasEmbeddedTimeStamps;

                    startFrameStartDayTicks = hasReliableTimeBase ? timestamps[0].Date.Ticks : timestamps.FirstOrDefault(x => x != DateTime.MinValue).Date.Ticks;
                    secondsFromUTMidnight   = new double[timestamps.Length];
                    for (int i = 0; i < timestamps.Length; i++)
                    {
                        if (!measurements[i].IsCorrectedForInstrumentalDelay && cameraCorrectionsHaveBeenApplied)
                        {
                            // Individual frames for which instrumental delays hasn't been applied even that instrumental delay is applied for the file, are marked as blank
                            secondsFromUTMidnight[i] = 0;
                        }
                        else if (timestamps[i] != DateTime.MinValue)
                        {
                            secondsFromUTMidnight[i] = Math.Truncate(new TimeSpan(timestamps[i].Ticks - startFrameStartDayTicks).TotalSeconds * 10000) / 10000.0;
                        }
                        else
                        {
                            secondsFromUTMidnight[i] = 0;
                        }
                    }

                    ShieldedCall(() => m_AotaInstance.Set_TimeBase(secondsFromUTMidnight, cameraCorrectionsHaveBeenApplied));

                    if (cameraCorrectionsHaveBeenApplied)
                    {
                        string cameraName = dataProvider.VideoCameraName;
                        if (!string.IsNullOrEmpty(cameraName))
                        {
                            ShieldedCall(() => m_AotaInstance.Set_VideoCamera(cameraName));
                        }
                    }
                    else
                    {
                        MessageBox.Show(parentWindow, "The times to be given to AOTA are not corrected for instrumental delays.\r\n\r\nThis means that you are expected to select the video camera and frame reate from the 'Camera corrections' section in tab '6. Camera corrections & final times' and apply the instrumental delays in AOTA.", "Tangra", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }

                    // Now go and set any comparison stars
                    for (int i = 0; i < dataProvider.NumberOfMeasuredComparisonObjects; i++)
                    {
                        ISingleMeasurement[] compMeasurements = dataProvider.GetComparisonObjectMeasurements(i);

                        if (compMeasurements != null)
                        {
                            float[] compData = compMeasurements.Select(x => x.Measurement).ToArray();

                            if (i == 0)
                            {
                                ShieldedCall(() => m_AotaInstance.Set_Comp1Data(compData));
                            }
                            else if (i == 1)
                            {
                                ShieldedCall(() => m_AotaInstance.Set_Comp2Data(compData));
                            }
                            else if (i == 2)
                            {
                                ShieldedCall(() => m_AotaInstance.Set_Comp3Data(compData));
                            }
                        }
                    }

                    ShieldedCall(() => m_AotaInstance.Camera = new Occult.SDK.Camera()
                    {
                        CameraType       = dataProvider.VideoCameraName,
                        VideoSystem      = dataProvider.VideoSystem,
                        FramesIntegrated = dataProvider.NumberIntegratedFrames
                    });

                    int firstFrameIndex     = 0;// (int)frameIds[0];
                    int framesInIntegration = 1;

                    ShieldedCall(() => m_AotaInstance.RunAOTA(null, firstFrameIndex, framesInIntegration, false));

                    return(true);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(ex.ToString());
                    MessageBox.Show(ex is TargetInvocationException ? ex.InnerException.Message : ex.Message, "AOTA Add-in Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }

                return(false);
            }
Esempio n. 13
0
            internal static AotaReturnValue RunAOTA(ILightCurveDataProvider dataProvider, IWin32Window parentWindow)
            {
                try
                {
                    if (m_AotaInstance == null)
                    {
                        m_AotaInstance = Activator.CreateInstance(TYPE_AOTA_ExternalAccess);
                    }

                    AOTA_InitialiseAOTA.Invoke(m_AotaInstance, new object[] { dataProvider.FileName });

                    ISingleMeasurement[] measurements = dataProvider.GetTargetMeasurements();

                    bool hasReliableTimeBase = dataProvider.HasReliableTimeBase;

                    float[] data     = measurements.Select(x => x.Measurement).ToArray();
                    float[] frameIds = measurements.Select(x => (float)x.CurrFrameNo).ToArray();

                    if (AOTA_Set_TargetData_BackgroundAlreadySubtracted != null)
                    {
                        float[] dataBg = measurements.Select(x => x.Background).ToArray();
                        AOTA_Set_TargetData_BackgroundAlreadySubtracted.Invoke(m_AotaInstance, new object[] { data, dataBg });
                    }
                    else
                    {
                        AOTA_Set_TargetData.Invoke(m_AotaInstance, new object[] { data });
                    }

                    AOTA_Set_FrameID.Invoke(m_AotaInstance, new object[] { frameIds });

                    DateTime[] timestamps = measurements.Select(x => x.Timestamp).ToArray();

                    hasReliableTimeBase = hasReliableTimeBase &&
                                          timestamps[0].Date != DateTime.MinValue &&
                                          timestamps[measurements.Length - 1].Date != DateTime.MinValue &&
                                          timestamps[0].Date.Ticks < timestamps[measurements.Length - 1].Ticks;

                    double[] secondsFromUTMidnight;
                    long     startFrameStartDayTicks;

                    if (hasReliableTimeBase)
                    {
                        startFrameStartDayTicks = timestamps[0].Date.Ticks;
                        secondsFromUTMidnight   = timestamps.Select(x => (Math.Truncate(new TimeSpan(x.Ticks - startFrameStartDayTicks).TotalSeconds * 10000) / 10000.0)).ToArray();
                    }
                    else
                    {
                        startFrameStartDayTicks = timestamps.FirstOrDefault(x => x != DateTime.MinValue).Date.Ticks;
                        secondsFromUTMidnight   = new double[timestamps.Length];
                        for (int i = 0; i < timestamps.Length; i++)
                        {
                            if (timestamps[i] != DateTime.MinValue)
                            {
                                secondsFromUTMidnight[i] = Math.Truncate(new TimeSpan(timestamps[i].Ticks - startFrameStartDayTicks).TotalSeconds * 10000) / 10000.0;
                            }
                            else
                            {
                                secondsFromUTMidnight[i] = 0;
                            }
                        }
                    }

                    bool cameraCorrectionsHaveBeenApplied = dataProvider.CameraCorrectionsHaveBeenApplied && dataProvider.HasEmbeddedTimeStamps;

                    if (AOTA_Set_TimeBaseEx != null)
                    {
                        AOTA_Set_TimeBaseEx.Invoke(m_AotaInstance, new object[] { secondsFromUTMidnight, cameraCorrectionsHaveBeenApplied });
                    }
                    else if (AOTA_Set_TimeBase != null)
                    {
                        AOTA_Set_TimeBase.Invoke(m_AotaInstance, new object[] { secondsFromUTMidnight });
                    }

                    if (cameraCorrectionsHaveBeenApplied)
                    {
                        string cameraName = dataProvider.VideoCameraName;
                        if (!string.IsNullOrEmpty(cameraName))
                        {
                            AOTA_Set_VideoCamera.Invoke(m_AotaInstance, new object[] { cameraName });
                        }
                    }

                    // Now go and set any comparison stars
                    for (int i = 0; i < dataProvider.NumberOfMeasuredComparisonObjects; i++)
                    {
                        ISingleMeasurement[] compMeasurements = dataProvider.GetComparisonObjectMeasurements(i);

                        if (compMeasurements != null)
                        {
                            float[] compData = compMeasurements.Select(x => x.Measurement).ToArray();

                            if (i == 0)
                            {
                                AOTA_Set_Comp1Data.Invoke(m_AotaInstance, new object[] { compData });
                            }
                            else if (i == 1)
                            {
                                AOTA_Set_Comp2Data.Invoke(m_AotaInstance, new object[] { compData });
                            }
                            else if (i == 2)
                            {
                                AOTA_Set_Comp3Data.Invoke(m_AotaInstance, new object[] { compData });
                            }
                        }
                    }

                    int firstFrameIndex     = 0;// (int)frameIds[0];
                    int framesInIntegration = 1;

                    AOTA_RunAOTAEx2.Invoke(m_AotaInstance, new object[] { null /*parentWindow*/, firstFrameIndex, framesInIntegration });

                    AotaReturnValue result = ReadAOTAResult();
                    result.IsMiss = (bool)AOTA_IsMiss.GetValue(m_AotaInstance, new object[] { });
                    result.AreResultsAvailable = (bool)AOTA_ResultsAreAvailable.GetValue(m_AotaInstance, new object[] { });
                    result.AOTAVersion         = (string)AOTA_Version.GetValue(m_AotaInstance, new object[] { });

                    return(result);
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(ex.ToString());
                    MessageBox.Show(ex is TargetInvocationException ? ex.InnerException.Message : ex.Message, "AOTA Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }

                return(null);
            }
Esempio n. 14
0
 internal void SetLightCurveDataProvider(ILightCurveDataProvider provider)
 {
     m_LocalLightCurveDataProvider = provider;
     m_DelegatedLightCurveDataProvider = null;
 }
Esempio n. 15
0
            internal static AotaReturnValue RunAOTA(ILightCurveDataProvider dataProvider, IWin32Window parentWindow)
            {
                try
                {
                    if (m_AotaInstance == null)
                        m_AotaInstance = Activator.CreateInstance(TYPE_AOTA_ExternalAccess);

                    AOTA_InitialiseAOTA.Invoke(m_AotaInstance, new object[] { dataProvider.FileName });

                    ISingleMeasurement[] measurements = dataProvider.GetTargetMeasurements();

                    bool hasReliableTimeBase = dataProvider.HasReliableTimeBase;

                    float[] data = measurements.Select(x => x.Measurement).ToArray();
                    float[] frameIds = measurements.Select(x => (float)x.CurrFrameNo).ToArray();

                    if (AOTA_Set_TargetData_BackgroundAlreadySubtracted != null)
                    {
                        float[] dataBg = measurements.Select(x => x.Background).ToArray();
                        AOTA_Set_TargetData_BackgroundAlreadySubtracted.Invoke(m_AotaInstance, new object[] { data, dataBg });
                    }
                    else
                        AOTA_Set_TargetData.Invoke(m_AotaInstance, new object[] { data });

                    AOTA_Set_FrameID.Invoke(m_AotaInstance, new object[] { frameIds });

                    DateTime[] timestamps = measurements.Select(x => x.Timestamp).ToArray();

                    hasReliableTimeBase = hasReliableTimeBase &&
                        timestamps[0].Date != DateTime.MinValue &&
                        timestamps[measurements.Length - 1].Date != DateTime.MinValue &&
                        timestamps[0].Date.Ticks < timestamps[measurements.Length - 1].Ticks;

                    double[] secondsFromUTMidnight;
                    long startFrameStartDayTicks;

                    if (hasReliableTimeBase)
                    {
                        startFrameStartDayTicks = timestamps[0].Date.Ticks;
                        secondsFromUTMidnight = timestamps.Select(x => (Math.Truncate(new TimeSpan(x.Ticks - startFrameStartDayTicks).TotalSeconds * 10000) / 10000.0)).ToArray();
                    }
                    else
                    {
                        startFrameStartDayTicks = timestamps.FirstOrDefault(x => x != DateTime.MinValue).Date.Ticks;
                        secondsFromUTMidnight = new double[timestamps.Length];
                        for (int i = 0; i < timestamps.Length; i++)
                        {
                            if (timestamps[i] != DateTime.MinValue)
                                secondsFromUTMidnight[i] = Math.Truncate(new TimeSpan(timestamps[i].Ticks - startFrameStartDayTicks).TotalSeconds * 10000) / 10000.0;
                            else
                                secondsFromUTMidnight[i] = 0;
                        }
                    }

                    bool cameraCorrectionsHaveBeenApplied = dataProvider.CameraCorrectionsHaveBeenApplied && dataProvider.HasEmbeddedTimeStamps;

                    if (AOTA_Set_TimeBaseEx != null)
                        AOTA_Set_TimeBaseEx.Invoke(m_AotaInstance, new object[] { secondsFromUTMidnight, cameraCorrectionsHaveBeenApplied });
                    else if (AOTA_Set_TimeBase != null)
                        AOTA_Set_TimeBase.Invoke(m_AotaInstance, new object[] { secondsFromUTMidnight });

                    if (cameraCorrectionsHaveBeenApplied)
                    {
                        string cameraName = dataProvider.VideoCameraName;
                        if (!string.IsNullOrEmpty(cameraName))
                            AOTA_Set_VideoCamera.Invoke(m_AotaInstance, new object[] { cameraName });
                    }

                    // Now go and set any comparison stars
                    for (int i = 0; i < dataProvider.NumberOfMeasuredComparisonObjects; i++)
                    {
                        ISingleMeasurement[] compMeasurements = dataProvider.GetComparisonObjectMeasurements(i);

                        if (compMeasurements != null)
                        {
                            float[] compData = compMeasurements.Select(x => x.Measurement).ToArray();

                            if (i == 0)
                                AOTA_Set_Comp1Data.Invoke(m_AotaInstance, new object[] { compData });
                            else if (i == 1)
                                AOTA_Set_Comp2Data.Invoke(m_AotaInstance, new object[] { compData });
                            else if (i == 2)
                                AOTA_Set_Comp3Data.Invoke(m_AotaInstance, new object[] { compData });
                        }
                    }

                    int firstFrameIndex = 0;// (int)frameIds[0];
                    int framesInIntegration = 1;

                    AOTA_RunAOTAEx2.Invoke(m_AotaInstance, new object[] { null /*parentWindow*/, firstFrameIndex, framesInIntegration });

                    AotaReturnValue result = ReadAOTAResult();
                    result.IsMiss = (bool)AOTA_IsMiss.GetValue(m_AotaInstance, new object[] { });
                    result.AreResultsAvailable = (bool)AOTA_ResultsAreAvailable.GetValue(m_AotaInstance, new object[] { });
                    result.AOTAVersion = (string)AOTA_Version.GetValue(m_AotaInstance, new object[] { });

                    return result;
                }
                catch (Exception ex)
                {
                    Trace.WriteLine(ex.ToString());
                    MessageBox.Show(ex is TargetInvocationException ? ex.InnerException.Message : ex.Message, "AOTA Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
                }

                return null;
            }