Esempio n. 1
0
            public ObjFilter(FilterF[] flist, string fstr)
            {
                int i;

                F    = new NumericalTools.CStyleParsedFunction(fstr);
                FMap = new FilterF[F.ParameterList.Length];

                for (i = 0; i < FMap.Length; i++)
                {
                    string z = F.ParameterList[i];
                    foreach (FilterF ff1 in flist)
                    {
                        if (String.Compare(ff1.Name, z, true) == 0)
                        {
                            FMap[i] = ff1;
                            break;
                        }
                    }
                    if (FMap[i] == null)
                    {
                        throw new Exception("Unknown parameter \"" + z + "\".");
                    }
                }
            }
Esempio n. 2
0
        internal void Check(CheckMode mode, string textout, NumericalTools.Function slf, bool dumpfound, bool dumpnotfound)
        {
            Mode = mode;
            SelectionFunction = slf;
            string [] pars = new string[0];
            if (slf != null)
            {
                pars = slf.ParameterList;
                if (pars.Length == 0)
                {
                    throw new Exception("The selection function must have parameters.");
                }
            }
            System.IO.StreamWriter wr = null;
            int Searched = 0, Found = 0;

            SySal.DAQSystem.Scanning.IntercalibrationInfo Inv = new SySal.DAQSystem.Scanning.IntercalibrationInfo();
            try
            {
                wr = new System.IO.StreamWriter(textout);
                wr.WriteLine("ID\tPX\tPY\tSX\tSY\tN");
                SySal.TotalScan.Layer lay = null;
                switch (Mode)
                {
                case CheckMode.Center:  lay = Vol.Layers[1]; break;

                case CheckMode.Upstream:        lay = Vol.Layers[Vol.Layers.Length - 1]; break;

                case CheckMode.Downstream:      lay = Vol.Layers[0]; break;

                default:                                        throw new Exception("Unsupported mode");
                }
                Inv.RX = Vol.RefCenter.X + lay.AlignData.TranslationX;
                Inv.RY = Vol.RefCenter.Y + lay.AlignData.TranslationY;
                double iden = 1.0 / (lay.AlignData.AffineMatrixXX * lay.AlignData.AffineMatrixYY - lay.AlignData.AffineMatrixXY * lay.AlignData.AffineMatrixYX);
                Inv.MXX = lay.AlignData.AffineMatrixYY * iden;
                Inv.MXY = -lay.AlignData.AffineMatrixXY * iden;
                Inv.MYX = -lay.AlignData.AffineMatrixYX * iden;
                Inv.MYY = lay.AlignData.AffineMatrixXX * iden;
                Inv.TX  = -lay.AlignData.TranslationX;
                Inv.TY  = -lay.AlignData.TranslationY;
                int tkn = Vol.Tracks.Length;
                int t, p;
                SySal.TotalScan.Track tk;
                string ps;
                double ipx, ipy, isx, isy;
                for (t = 0; t < tkn; t++)
                {
                    tk = Vol.Tracks[t];
                    if (SelectionFunction != null)
                    {
                        for (p = 0; p < pars.Length; p++)
                        {
                            ps = pars[p].ToUpper();
                            switch (ps)
                            {
                            case "N":       SelectionFunction[p] = tk.Length; break;

                            case "DZ":      SelectionFunction[p] = tk.Downstream_Z; break;

                            case "UZ":      SelectionFunction[p] = tk.Upstream_Z; break;

                            case "DSX":     SelectionFunction[p] = tk.Downstream_SlopeX; break;

                            case "DSY":     SelectionFunction[p] = tk.Downstream_SlopeY; break;

                            case "USX":     SelectionFunction[p] = tk.Upstream_SlopeX; break;

                            case "USY":     SelectionFunction[p] = tk.Upstream_SlopeY; break;

                            case "D0X":     SelectionFunction[p] = tk.Downstream_PosX - tk.Downstream_SlopeX * tk.Downstream_PosZ; break;

                            case "D0Y":     SelectionFunction[p] = tk.Downstream_PosY - tk.Downstream_SlopeY * tk.Downstream_PosZ; break;

                            case "U0X":     SelectionFunction[p] = tk.Upstream_PosX - tk.Upstream_SlopeX * tk.Upstream_PosZ; break;

                            case "U0Y":     SelectionFunction[p] = tk.Upstream_PosY - tk.Upstream_SlopeY * tk.Upstream_PosZ; break;

                            case "DPX":     SelectionFunction[p] = tk.Downstream_PosX + tk.Downstream_SlopeX * (tk.Downstream_Z - tk.Downstream_PosZ); break;

                            case "DPY":     SelectionFunction[p] = tk.Downstream_PosY + tk.Downstream_SlopeY * (tk.Downstream_Z - tk.Downstream_PosZ); break;

                            case "UPX":     SelectionFunction[p] = tk.Upstream_PosX + tk.Upstream_SlopeX * (tk.Upstream_Z - tk.Upstream_PosZ); break;

                            case "UPY":     SelectionFunction[p] = tk.Upstream_PosY + tk.Upstream_SlopeY * (tk.Upstream_Z - tk.Upstream_PosZ); break;

                            default:        throw new Exception("Unknown parameter " + ps);
                            }
                        }
                        if (SelectionFunction.Evaluate() == 0)
                        {
                            continue;
                        }
                    }
                    switch (Mode)
                    {
                    case CheckMode.Center:
                    {
                        if (tk.UpstreamLayerId == 2 && tk.DownstreamLayerId == 0)
                        {
                            Searched++;
                            if (tk.Length == 3)
                            {
                                Found++;
                                if (dumpfound)
                                {
                                    SySal.Tracking.MIPEmulsionTrackInfo info = tk[1].Info;
                                    ipx = Inv.MXX * (info.Intercept.X - Inv.RX) + Inv.MXY * (info.Intercept.Y - Inv.RY) + Inv.TX + Inv.RX;
                                    ipy = Inv.MYX * (info.Intercept.X - Inv.RX) + Inv.MYY * (info.Intercept.Y - Inv.RY) + Inv.TY + Inv.RY;
                                    isx = Inv.MXX * info.Slope.X + Inv.MXY * info.Slope.Y;
                                    isy = Inv.MYX * info.Slope.X + Inv.MYY * info.Slope.Y;
                                    wr.WriteLine(tk.Id + "\t" + ipx.ToString("F1", System.Globalization.CultureInfo.InvariantCulture) + "\t" + ipy.ToString("F1", System.Globalization.CultureInfo.InvariantCulture) + "\t" + isx.ToString("F4", System.Globalization.CultureInfo.InvariantCulture) + "\t" + isy.ToString("F4", System.Globalization.CultureInfo.InvariantCulture) + "\t" + tk.Length);
                                }
                            }
                            else
                            {
                                if (dumpnotfound)
                                {
                                    SySal.Tracking.MIPEmulsionTrackInfo info = new SySal.Tracking.MIPEmulsionTrackInfo();
                                    info.Intercept.X = tk.Downstream_PosX + tk.Downstream_SlopeX * (lay.RefCenter.Z - tk.Downstream_PosZ);
                                    info.Intercept.Y = tk.Downstream_PosY + tk.Downstream_SlopeY * (lay.RefCenter.Z - tk.Downstream_PosZ);
                                    info.Slope.X     = tk.Downstream_SlopeX;
                                    info.Slope.Y     = tk.Downstream_SlopeY;
                                    ipx = Inv.MXX * (info.Intercept.X - Inv.RX) + Inv.MXY * (info.Intercept.Y - Inv.RY) + Inv.TX + Inv.RX;
                                    ipy = Inv.MYX * (info.Intercept.X - Inv.RX) + Inv.MYY * (info.Intercept.Y - Inv.RY) + Inv.TY + Inv.RY;
                                    isx = Inv.MXX * info.Slope.X + Inv.MXY * info.Slope.Y;
                                    isy = Inv.MYX * info.Slope.X + Inv.MYY * info.Slope.Y;
                                    wr.WriteLine(tk.Id + "\t" + ipx.ToString("F1", System.Globalization.CultureInfo.InvariantCulture) + "\t" + ipy.ToString("F1", System.Globalization.CultureInfo.InvariantCulture) + "\t" + isx.ToString("F4", System.Globalization.CultureInfo.InvariantCulture) + "\t" + isy.ToString("F4", System.Globalization.CultureInfo.InvariantCulture) + "\t" + tk.Length);
                                }
                            }
                        }
                    }
                    break;

                    case CheckMode.Upstream:
                    {
                        if (tk.DownstreamLayerId == 0 && tk.Length >= (Vol.Layers.Length - 1))
                        {
                            Searched++;
                            if (tk.Length == Vol.Layers.Length)
                            {
                                Found++;
                                if (dumpfound)
                                {
                                    SySal.Tracking.MIPEmulsionTrackInfo info = tk[tk.Length - 1].Info;
                                    ipx = Inv.MXX * (info.Intercept.X - Inv.RX) + Inv.MXY * (info.Intercept.Y - Inv.RY) + Inv.TX + Inv.RX;
                                    ipy = Inv.MYX * (info.Intercept.X - Inv.RX) + Inv.MYY * (info.Intercept.Y - Inv.RY) + Inv.TY + Inv.RY;
                                    isx = Inv.MXX * info.Slope.X + Inv.MXY * info.Slope.Y;
                                    isy = Inv.MYX * info.Slope.X + Inv.MYY * info.Slope.Y;
                                    wr.WriteLine(tk.Id + "\t" + ipx.ToString("F1", System.Globalization.CultureInfo.InvariantCulture) + "\t" + ipy.ToString("F1", System.Globalization.CultureInfo.InvariantCulture) + "\t" + isx.ToString("F4", System.Globalization.CultureInfo.InvariantCulture) + "\t" + isy.ToString("F4", System.Globalization.CultureInfo.InvariantCulture) + "\t" + tk.Length);
                                }
                            }
                            else
                            {
                                if (dumpnotfound)
                                {
                                    SySal.Tracking.MIPEmulsionTrackInfo info = new SySal.Tracking.MIPEmulsionTrackInfo();
                                    info.Intercept.X = tk.Upstream_PosX + tk.Upstream_SlopeX * (lay.RefCenter.Z - tk.Upstream_PosZ);
                                    info.Intercept.Y = tk.Upstream_PosY + tk.Upstream_SlopeY * (lay.RefCenter.Z - tk.Upstream_PosZ);
                                    info.Slope.X     = tk.Upstream_SlopeX;
                                    info.Slope.Y     = tk.Upstream_SlopeY;
                                    ipx = Inv.MXX * (info.Intercept.X - Inv.RX) + Inv.MXY * (info.Intercept.Y - Inv.RY) + Inv.TX + Inv.RX;
                                    ipy = Inv.MYX * (info.Intercept.X - Inv.RX) + Inv.MYY * (info.Intercept.Y - Inv.RY) + Inv.TY + Inv.RY;
                                    isx = Inv.MXX * info.Slope.X + Inv.MXY * info.Slope.Y;
                                    isy = Inv.MYX * info.Slope.X + Inv.MYY * info.Slope.Y;
                                    wr.WriteLine(tk.Id + "\t" + ipx.ToString("F1", System.Globalization.CultureInfo.InvariantCulture) + "\t" + ipy.ToString("F1", System.Globalization.CultureInfo.InvariantCulture) + "\t" + isx.ToString("F4", System.Globalization.CultureInfo.InvariantCulture) + "\t" + isy.ToString("F4", System.Globalization.CultureInfo.InvariantCulture) + "\t" + tk.Length);
                                }
                            }
                        }
                    }
                    break;

                    case CheckMode.Downstream:
                    {
                        if (tk.UpstreamLayerId == (Vol.Layers.Length - 1) && tk.Length >= (Vol.Layers.Length - 1))
                        {
                            Searched++;
                            if (tk.Length == Vol.Layers.Length)
                            {
                                Found++;
                                if (dumpfound)
                                {
                                    SySal.Tracking.MIPEmulsionTrackInfo info = tk[0].Info;
                                    ipx = Inv.MXX * (info.Intercept.X - Inv.RX) + Inv.MXY * (info.Intercept.Y - Inv.RY) + Inv.TX + Inv.RX;
                                    ipy = Inv.MYX * (info.Intercept.X - Inv.RX) + Inv.MYY * (info.Intercept.Y - Inv.RY) + Inv.TY + Inv.RY;
                                    isx = Inv.MXX * info.Slope.X + Inv.MXY * info.Slope.Y;
                                    isy = Inv.MYX * info.Slope.X + Inv.MYY * info.Slope.Y;
                                    wr.WriteLine(tk.Id + "\t" + ipx.ToString("F1", System.Globalization.CultureInfo.InvariantCulture) + "\t" + ipy.ToString("F1", System.Globalization.CultureInfo.InvariantCulture) + "\t" + isx.ToString("F4", System.Globalization.CultureInfo.InvariantCulture) + "\t" + isy.ToString("F4", System.Globalization.CultureInfo.InvariantCulture) + "\t" + tk.Length);
                                }
                            }
                            else
                            {
                                if (dumpnotfound)
                                {
                                    SySal.Tracking.MIPEmulsionTrackInfo info = new SySal.Tracking.MIPEmulsionTrackInfo();
                                    info.Intercept.X = tk.Downstream_PosX + tk.Downstream_SlopeX * (lay.RefCenter.Z - tk.Downstream_PosZ);
                                    info.Intercept.Y = tk.Downstream_PosY + tk.Downstream_SlopeY * (lay.RefCenter.Z - tk.Downstream_PosZ);
                                    info.Slope.X     = tk.Downstream_SlopeX;
                                    info.Slope.Y     = tk.Downstream_SlopeY;
                                    ipx = Inv.MXX * (info.Intercept.X - Inv.RX) + Inv.MXY * (info.Intercept.Y - Inv.RY) + Inv.TX + Inv.RX;
                                    ipy = Inv.MYX * (info.Intercept.X - Inv.RX) + Inv.MYY * (info.Intercept.Y - Inv.RY) + Inv.TY + Inv.RY;
                                    isx = Inv.MXX * info.Slope.X + Inv.MXY * info.Slope.Y;
                                    isy = Inv.MYX * info.Slope.X + Inv.MYY * info.Slope.Y;
                                    wr.WriteLine(tk.Id + "\t" + ipx.ToString("F1", System.Globalization.CultureInfo.InvariantCulture) + "\t" + ipy.ToString("F1", System.Globalization.CultureInfo.InvariantCulture) + "\t" + isx.ToString("F4", System.Globalization.CultureInfo.InvariantCulture) + "\t" + isy.ToString("F4", System.Globalization.CultureInfo.InvariantCulture) + "\t" + tk.Length);
                                }
                            }
                        }
                    }
                    break;
                    }
                }
                wr.Flush();
            }
            catch (Exception x)
            {
                Console.WriteLine("Unrecoverable error:\n" + x.Message);
            }
            finally
            {
                if (wr != null)
                {
                    wr.Close();
                }
                Console.WriteLine("Searched: " + Searched);
                Console.WriteLine("Found: " + Found);
                if (Searched > 1)
                {
                    double p = (double)Found / (double)Searched;
                    Console.WriteLine("Efficiency: " + (p * 100.0).ToString("F2", System.Globalization.CultureInfo.InvariantCulture) + "% \xb1" + (Math.Sqrt(p * (1.0 - p) / Searched) * 100.0).ToString("F2", System.Globalization.CultureInfo.InvariantCulture) + "%");
                }
            }
        }
Esempio n. 3
0
 public Exe(SySal.TotalScan.Volume v)
 {
     Vol = v;
     SelectionFunction = null;
 }