Normalisation

Tangra 3/Controller/LightCurveContext.cs

@@ -86,7 +86,8 @@ internal enum LightCurveMode
 		private int m_Binning = 0;
 	    private int m_BinningFirstFrame = 0;
 		private int m_Normalisation = -1;
-		private FilterType m_Filter = FilterType.NoFilter;
+        private bool[] m_Normalisations = new bool[4];
+        private FilterType m_Filter = FilterType.NoFilter;
 		private NormalisationMethod m_NormMethod = NormalisationMethod.Average4Frame;
 		private float[] m_ReProcessApertures = new float[4];
 		private int[] m_ReProcessFitAreas = new int[4];
@@ -102,7 +103,7 @@ internal enum LightCurveMode
 		public uint MinFrame;
 		public uint MaxFrame;
 		public int ObjectCount;
-
+        
 		public uint m_SelectedFrameNo = 0;
 
 		private XAxisMode m_XAxisMode;
@@ -140,6 +141,7 @@ public uint SelectedFrameNo
 		private ProcessingType m_bu_ProcessingType = ProcessingType.SignalMinusBackground;
 		private int m_bu_Binning = 0;
 		private int m_bu_Normalisation = -1;
+        private bool[] m_bu_Normalisations = new bool[4];
 		private FilterType m_bu_Filter = FilterType.NoFilter;
 		private NormalisationMethod mbu__NormMethod = NormalisationMethod.Average4Frame;
 		private float[] m_bu_ReProcessApertures = new float[4];
@@ -155,7 +157,10 @@ internal void PrepareForCancelling()
 			m_bu_ProcessingType = m_ProcessingType;
 			m_bu_Binning = m_Binning;
 			m_bu_Normalisation = m_Normalisation;
-			m_bu_Filter = m_Filter;
+            for (int i = 0; i < 4; i++)
+                m_bu_Normalisations[i] = m_Normalisations[i];
+
+            m_bu_Filter = m_Filter;
 			mbu__NormMethod = m_NormMethod;
 			bu_SelectedFrameNo = SelectedFrameNo;
 
@@ -178,7 +183,10 @@ internal void CancelChanges()
 			m_ProcessingType = m_bu_ProcessingType;
 			m_Binning = m_bu_Binning;
 			m_Normalisation = m_bu_Normalisation;
-			m_Filter = m_bu_Filter;
+            for (int i = 0; i < 4; i++)
+                m_Normalisations[i] = m_bu_Normalisations[i];
+
+            m_Filter = m_bu_Filter;
 			m_NormMethod = mbu__NormMethod;
 			SelectedFrameNo = bu_SelectedFrameNo;
 
@@ -313,6 +321,11 @@ public int Normalisation
 			}
 		}
 
+        public bool[] Normalisations
+        {
+            get { return m_Normalisations; }
+        }
+
 		public FilterType Filter
 		{
 			get { return m_Filter; }
@@ -327,15 +340,15 @@ public FilterType Filter
 			}
 		}
 
-		public NormalisationMethod NormMethod
+        public NormalisationMethod NormMethod
 		{
 			get { return m_NormMethod; }
 			set
 			{
 				if (m_NormMethod != value)
 				{
 					m_NormMethod = value;
-					// If the normalization is specified, changing the method will make the data durty
+					// If the normalization is specified, changing the method will make the data dirty
 					m_Dirty = m_Normalisation > -1;
 				}
 			}

Tangra 3/VideoOperations/LightCurves/frmLightCurve.Computations.cs

@@ -269,44 +269,84 @@ private void ComputeBinning()
 
         private void PerformNormalization()
         {
+            // Calculate the normalisation factor for each star chosen as a normalisation star
+            // and then calculate the normalisation factor averaged over all normalisation stars.
+
             List<double> normalIndexes = new List<double>();
+            List<double> averagedNormalIndexes = new List<double>();
+
+            int numberOfNormalisationStars = 0;
 
-            switch(m_LightCurveController.Context.NormMethod)
+            for (int starIndx = 0; starIndx < m_Header.ObjectCount; starIndx++)
             {
-                case LightCurveContext.NormalisationMethod.LinearFit:
-                    if (m_LightCurveController.Context.Binning > 0)
-                        PerformLinearFitBinnedNormalisation(ref normalIndexes);
-                    else
-                        PerformLinearFitReadingsNormalisation(ref normalIndexes);
-                    break;
+
+                if (!m_LightCurveController.Context.Normalisations[starIndx]) continue;
 
-                case LightCurveContext.NormalisationMethod.FrameByFrame:
-                    if (m_LightCurveController.Context.Binning > 0)
-                        PerformAverageBinnedNormalisation(ref normalIndexes, 1);
-                    else
-                        PerformAverageReadingsNormalisation(ref normalIndexes, 1);
-                    break;
+                normalIndexes.Clear();
 
-                case LightCurveContext.NormalisationMethod.Average4Frame:
-                    if (m_LightCurveController.Context.Binning > 0)
-                        PerformAverageBinnedNormalisation(ref normalIndexes, 4);
-                    else
-                        PerformAverageReadingsNormalisation(ref normalIndexes, 4);
-                    break;
+                numberOfNormalisationStars++;
 
-				case LightCurveContext.NormalisationMethod.Average8Frame:
-					if (m_LightCurveController.Context.Binning > 0)
-						PerformAverageBinnedNormalisation(ref normalIndexes, 8);
-					else
-						PerformAverageReadingsNormalisation(ref normalIndexes, 8);
-					break;
+                m_LightCurveController.Context.Normalisation = starIndx;
 
-                case LightCurveContext.NormalisationMethod.Average16Frame:
-                    if (m_LightCurveController.Context.Binning > 0)
-                        PerformAverageBinnedNormalisation(ref normalIndexes, 16);
-                    else
-                        PerformAverageReadingsNormalisation(ref normalIndexes, 16);
-                    break;
+                switch (m_LightCurveController.Context.NormMethod)
+                {
+                    case LightCurveContext.NormalisationMethod.LinearFit:
+                        if (m_LightCurveController.Context.Binning > 0)
+                            PerformLinearFitBinnedNormalisation(ref normalIndexes);
+                        else
+                            PerformLinearFitReadingsNormalisation(ref normalIndexes);
+                        break;
+
+                    case LightCurveContext.NormalisationMethod.FrameByFrame:
+                        if (m_LightCurveController.Context.Binning > 0)
+                            PerformAverageBinnedNormalisation(ref normalIndexes, 1);
+                        else
+                            PerformAverageReadingsNormalisation(ref normalIndexes, 1);
+                        break;
+
+                    case LightCurveContext.NormalisationMethod.Average4Frame:
+                        if (m_LightCurveController.Context.Binning > 0)
+                            PerformAverageBinnedNormalisation(ref normalIndexes, 4);
+                        else
+                            PerformAverageReadingsNormalisation(ref normalIndexes, 4);
+                        break;
+
+                    case LightCurveContext.NormalisationMethod.Average8Frame:
+                        if (m_LightCurveController.Context.Binning > 0)
+                            PerformAverageBinnedNormalisation(ref normalIndexes, 8);
+                        else
+                            PerformAverageReadingsNormalisation(ref normalIndexes, 8);
+                        break;
+
+                    case LightCurveContext.NormalisationMethod.Average16Frame:
+                        if (m_LightCurveController.Context.Binning > 0)
+                            PerformAverageBinnedNormalisation(ref normalIndexes, 16);
+                        else
+                            PerformAverageReadingsNormalisation(ref normalIndexes, 16);
+                        break;
+                }
+
+                if (numberOfNormalisationStars == 1)
+                {
+                    for (int indx = 0; indx < normalIndexes.Count; indx++)
+                    {
+                        averagedNormalIndexes.Add(normalIndexes[indx]);
+                    }
+                }
+                else
+                {
+                    for (int indx = 0; indx < normalIndexes.Count; indx++)
+                    {
+                        averagedNormalIndexes[indx] = averagedNormalIndexes[indx] + normalIndexes[indx];
+                    }
+                }
+
+            }
+
+            // calculate the normalisation factor averaged over all the normalisation stars
+            for (int indx = 0; indx < normalIndexes.Count; indx++)
+            {
+                normalIndexes[indx] = averagedNormalIndexes[indx] / numberOfNormalisationStars;
             }
 
             int minValue = int.MaxValue;