示例#1
0
        protected override LocationResult CalculateCommonPoint(List <NearbyBluetoothTag> Distances, LocationResult LastLocation)
        {
            List <Point> adjacentPoints = new List <Point>(); // ebben lesznek az egyes metszetek legközelebbi pontjai után kiválogatott szomszédos pontok

            // kiszámoljuk minden kör, minden másik körhöz mért metszéspontját
            List <Intersection> intersectionPoints = GetIntersections(Distances); // ebben lesznek két-két kör metszéspontjai

            // eddig jó
            for (int i = 0; i < intersectionPoints.Count; i++)
            {
                for (int j = i + 1; j < intersectionPoints.Count; j++)
                {
                    if (i == j)
                    {
                        continue;
                    }
                    adjacentPoints.Add(LocationCalculator.ClosestPoint(intersectionPoints[i], intersectionPoints[j]));
                }
            }

            return(new LocationResult(LocationCalculator.PointAverage(adjacentPoints), Precision.ThreeOrMoreTag));
        }
        /// <summary>
        /// Ez működik általános esetre, amikor nincs pontos metszéspont
        ///
        /// A legközelebbi 3 metszéspont átlagpontját adjuk vissza
        /// Válasszuk ki a metszéspontok távolságai közül a legrövidebb hármat
        /// Elméletileg a 3 távolság 6 metszéspontja lényegében 3 pont, amit keresünk, ezek átlaga kell
        /// </summary>
        public override Point CalculateCommonPoint(List <Intersection> intersections)
        {
            List <IntersectDistance> idistances = new List <IntersectDistance>();     // A metszéspontok távolságai
            IntersectDistance        idist;

            for (int i = 0; i < intersections.Count; i++)
            {
                for (int j = 0; j < intersections.Count; j++)
                {
                    if (i != j)
                    {
                        // Egy metszet két metszéspontjának távolságát nem is vesszük figyelembe
                        idist = new IntersectDistance(intersections[i].Points[0], intersections[j].Points[1]);
                        if (!idistances.Contains(idist))
                        {
                            idistances.Add(idist);
                        }
                        idist = new IntersectDistance(intersections[i].Points[0], intersections[j].Points[0]);
                        if (!idistances.Contains(idist))
                        {
                            idistances.Add(idist);
                        }
                        idist = new IntersectDistance(intersections[i].Points[1], intersections[j].Points[1]);
                        if (!idistances.Contains(idist))
                        {
                            idistances.Add(idist);
                        }
                    }
                }
            }

            //---------------------új megoldás:--------------------

            // Az összes metszéspontot ebben a listában tároljuk
            List <Point> intersectPoints = new List <Point>();

            //Ebben a listában tároljuk el a k legközelebbi metszéspontokat
            List <Point> closestPoints = new List <Point>();

            IntersectDistance firstDistance = getMinimumDistance(idistances);

            closestPoints.Add(firstDistance.P1);
            closestPoints.Add(firstDistance.P2);

            foreach (Intersection i in intersections)
            {
                foreach (Point p in i.Points)
                {
                    if (!p.Equals(firstDistance.P1) && !p.Equals(firstDistance.P2))
                    {
                        intersectPoints.Add(p);
                    }
                }
            }

            Point candidate1 = getClosestPoint(firstDistance.P1, intersectPoints);
            Point candidate2 = getClosestPoint(firstDistance.P2, intersectPoints);

            closestPoints.Add(getThirdPoint(candidate1, candidate2, firstDistance));

            return(LocationCalculator.PointAverage(closestPoints));
        }