示例#1
0
        /// <summary>
        /// Detects light sources on the input image using hysteresis thresholding. Requires input image to be astrometrically reduced.
        /// </summary>
        /// <param name="Input">Input image.</param>
        /// <returns>A list of detections.</returns>
        public List <ImageDetection> Detect(Image Input)
        {
            Detections = new List <DotDetection>();
            PositionDependentExtractor <DotDetector> Extractor = DetectSources;

            Extractor.Run(this, Input, Parameters);

            List <ImageDetection> Mdect = Detections.Select((x) => StandardDetectionFactory.CreateDetection(Input, x.Pixels, x.PixelValues)).ToList();

            foreach (ImageDetection m in Mdect)
            {
                m.SetResetProperty(new PairingProperties()
                {
                    IsDotDetection = true
                });
            }
            return(Mdect);
        }
示例#2
0
        /// <summary>
        /// Attempts to recover a detection on a given image, comparing with the entire set of exposures.
        /// </summary>
        /// <returns><c>true</c>, if detection was recovered, <c>false</c> otherwise.</returns>
        /// <param name="DetPos">Position of the detection to recover.</param>
        /// <param name="Img">Image on which to recover.</param>
        /// <param name="Radius">Maximum radius of the detection.</param>
        /// <param name="InputImages">Input images.</param>
        /// <param name="Recovered">Recovered detection.</param>
        public bool RecoverDetection(Position DetPos, Image Img, double Radius, IEnumerable <Image> InputImages, out ImageDetection Recovered)
        {
            Recovered = null;
            DotDetector.DotDetection dd = Recover(DetPos.PP, Radius, Img);
            if (dd.Pixels.Count < MinPix)
            {
                return(false);
            }
            int NoiseCnt = 0;
            int FixedCnt = 0;

            foreach (Image img in InputImages)
            {
                /* Noise scanner -- same position in pixel coordinates */
                DotDetector.DotDetection detN = Recover(dd.Barycenter, Radius, img);
                PixelPoint npp = img.Transform.GetPixelPoint(Img.Transform.GetEquatorialPoint(dd.Barycenter));
                /* Star scanner -- same position in equatorial coordinates */
                DotDetector.DotDetection detF = Recover(npp, Radius, img);
                if (detN.Pixels.Count > NoisePixelThreshold * dd.Pixels.Count)
                {
                    NoiseCnt++;
                }
                if (detF.Flux > StarFluxThreshold * dd.Flux)
                {
                    EquatorialPoint org = DetPos.EP;
                    EquatorialPoint nw  = img.Transform.GetEquatorialPoint(detF.Barycenter);
                    if ((org ^ nw) < MinMoveArcSec)
                    {
                        FixedCnt++;
                    }
                }
            }
            if (NoiseCnt > CrossMatchRemove)
            {
                return(false);
            }
            if (FixedCnt > CrossMatchRemove)
            {
                return(false);
            }

            Recovered = StandardDetectionFactory.CreateDetection(Img, dd.Pixels, dd.PixelValues);
            return(true);
        }
示例#3
0
        /// <summary>
        /// The segment detector function. It calls the RLHT scorer and if line segments are sensed, it calls the LineAnalyzer to find the source blobs.
        /// </summary>
        /// <param name="Input">Input data.</param>
        /// <param name="Position">Position of the input data array in the image.</param>
        /// <param name="Data">Bag of algorithm parameters and data.</param>
        static void LTD_RLHT(double[,] Input, SchedCore.ImageSegmentPosition Position, LongTrailData Data)
        {
            /* Extracts the size of the input data */
            int    Height = Input.GetLength(0), Width = Input.GetLength(1);
            double Diagonal = Math.Sqrt(Width * Width + Height * Height);

            /* Initialize VPool */
            lock (Data.AgData.VPool)
                if (Data.AgData.VPool.Constructor == null)
                {
                    Data.AgData.VPool.Constructor = () => new List <Vector>();
                }

            /* Applies the RLHT algorithm */
            Data.AgData.StrongValueFunction = (x) => ThresholdComputer(x, Data, Diagonal);
            var Result = RLHT.SmartSkipRLHT(Input, Data.ImageParameters, Data.AgData);

            /* Prepare common data for the LineAnalyzer */
            bool[,] Mask = new bool[Height, Width];
            double SST = Data.SegmentSelectThreshold * Data.Sigma, SDT = Data.SegmentDropThreshold * Data.Sigma;
            int    MIB = Data.MaxInterblobDistance, SW = Data.ScanWidth, pX = (int)Position.Alignment.X, pY = (int)Position.Alignment.Y;

            if (Data.DropCrowdedRegion)                   /* If the region is too crowded, it's very likely to be some luminous residue - for example star halos */
            {
                if (Result.StrongPoints.Count > Diagonal) /* There is no deep meaning between this comparison; a reasonable Diagonal seems to correspond to a reasonable number of lines */
                {
                    goto clear_end;
                }
            }

            /* Analyze each possible trail line and store the detections */
            foreach (Vector vx in Result.StrongPoints)
            {
                var z = LineAnalyzer.AnalyzeLine(Input, Mask, Height, Width, vx.X, vx.Y, SST, SDT, MIB, SW, pX, pY);
                lock (Data.Results)
                    Data.Results.AddRange(z.Select((x) => StandardDetectionFactory.CreateDetection(Data.RunningImage, x.Points, x.PointValues)));
            }

clear_end:
            /* Release resources */
            Result.StrongPoints.Clear();
            Data.AgData.HTPool.Release();
            Data.AgData.VPool.Release();
        }
示例#4
0
        /// <summary>
        /// Match detections and merge those that seem to belong to the same object.
        /// </summary>
        /// <param name="RawDetections">Input set of detections.</param>
        /// <param name="MaxDistance">Maximum distance possible between two detections part of the same object.</param>
        /// <param name="MixMatch">Number of overlapping pixels before two detections are considered part of the same object.</param>
        /// <param name="PSFMatch">Distance between the barycenters of 2 detections before they are considered the same (for external detections mostly).</param>
        public static void MatchDetections(List <ImageDetection> RawDetections, double MaxDistance, int MixMatch, double PSFMatch)
        {
            int i, j;
            List <HashSet <PixelPoint> > LHP          = RawDetections.Select((x) => x.TryFetchProperty(out ObjectPoints op) ? new HashSet <PixelPoint>(op.PixelPoints) : null).ToList();
            List <PairingProperties>     PairPropList = RawDetections.Select((x) => x.TryFetchProperty(out PairingProperties Prop) ? Prop : null).ToList();

            for (i = 0; i < RawDetections.Count; i++)
            {
                for (j = i + 1; j < RawDetections.Count; j++)
                {
                    /* Must be two detections captured at the same time */
                    if (RawDetections[i].Time.Time != RawDetections[j].Time.Time)
                    {
                        continue;
                    }
                    /* Check distance */
                    double D0 = (RawDetections[i].Barycenter.PP ^ RawDetections[j].Barycenter.PP);
                    double D1 = (RawDetections[i].FetchProperty <ObjectSize>().PixelEllipse.SemiaxisMajor + RawDetections[j].FetchProperty <ObjectSize>().PixelEllipse.SemiaxisMajor);
                    if (D0 - D1 > MaxDistance)
                    {
                        continue;
                    }

                    HashSet <PixelPoint> PixPi = LHP[i], PixPj = LHP[j];

                    bool FlagAnyCond = false;
                    /* If there are MinPix overlapping pixels, merge detections */
                    if (PixPi != null & PixPj != null)
                    {
                        if (PixPi.Overlaps(PixPj))
                        {
                            FlagAnyCond = true;
                        }
                        if (!FlagAnyCond)
                        {
                            /* Detections that are somewhat linear are checked for colinearity with others */
                            IEnumerable <PixelPoint> Plist = PixPi.Concat(PixPj);
                            LinearRegression.LinearRegressionParameters pc = LinearRegression.ComputeLinearRegression(Plist);
                            LinearRegression.LinearRegressionParameters p1 = LinearRegression.ComputeLinearRegression(PixPi);
                            LinearRegression.LinearRegressionParameters p2 = LinearRegression.ComputeLinearRegression(PixPj);
                            if (Math.Abs(pc.PearsonR) > Math.Abs(p1.PearsonR) && Math.Abs(pc.PearsonR) > Math.Abs(p2.PearsonR) &&
                                Math.Abs(pc.PearsonR) < Math.Abs(p1.PearsonR) + Math.Abs(p2.PearsonR))
                            {
                                FlagAnyCond = true;
                            }
                        }
                    }
                    if (D0 < PSFMatch)
                    {
                        FlagAnyCond = true;
                    }
                    /* If any merging condition is satisfied, merge the detections */
                    if (FlagAnyCond)
                    {
                        if (LHP[i] != null & LHP[j] != null)
                        {
                            LHP[i].UnionWith(LHP[j]);
                        }
                        else if (LHP[i] == null)
                        {
                            LHP[i] = LHP[j];
                        }
                        if (PairPropList[i] != null && PairPropList[j] != null)
                        {
                            PairPropList[i].Algorithm |= PairPropList[i].Algorithm;
                        }
                        LHP.RemoveAt(j);
                        RawDetections.RemoveAt(j);
                        PairPropList.RemoveAt(j);
                        j--;
                    }
                }
            }
            for (i = 0; i < LHP.Count; i++)
            {
                if (LHP[i] != null)
                {
                    try
                    {
                        RawDetections[i] = StandardDetectionFactory.CreateDetection(RawDetections[i].ParentImage, LHP[i]);
                        if (PairPropList[i] != null)
                        {
                            RawDetections[i].SetResetProperty(PairPropList[i]);
                        }
                    }
                    catch { RawDetections.RemoveAt(i); PairPropList.RemoveAt(i); LHP.RemoveAt(i); i--; }
                }
            }
        }