/// <summary>
        /// Első eset: a két távolság által jelzett kör messze van egymástól:
        /// Megoldás: mindkettőt arányosan növeljük
        /// </summary>
        protected bool CheckFarDistances(NearbyBluetoothTag tag1, NearbyBluetoothTag tag2)
        {
            if (LocationCalculator.Distance(tag1.Origo, tag2.Origo) > tag1.AveragePredictedDistanceFromTag + tag2.AveragePredictedDistanceFromTag)
            {
                double deviance = LocationCalculator.Distance(tag1.Origo, tag2.Origo) - (tag1.AveragePredictedDistanceFromTag + tag2.AveragePredictedDistanceFromTag);
                deviance += BIAS;  // Az eltérés torzítása, így biztosan lesz metszéspont
                double max   = tag1.AveragePredictedDistanceFromTag + tag2.AveragePredictedDistanceFromTag;
                double rate1 = tag1.AveragePredictedDistanceFromTag / max;
                double rate2 = tag2.AveragePredictedDistanceFromTag / max;
                tag1.SetAveragePredictedDistance(tag1.AveragePredictedDistanceFromTag + deviance * rate1);
                tag2.SetAveragePredictedDistance(tag2.AveragePredictedDistanceFromTag + deviance * rate2);


                //TEST
                double dist = LocationCalculator.Distance(tag1.Origo, tag2.Origo) - (tag1.AveragePredictedDistanceFromTag + tag2.AveragePredictedDistanceFromTag);
                if (dist > 0.0)
                {
                    dist = 0; /* throw new Exception("Calculation error: distance must be 0.0"); */
                }
                //TEST

                return(true);
            }
            else
            {
                return(false);
            }
        }
        public void BeaconReceived(NearbyBluetoothTag Sender, int RSSI)
        {
            /*
             * RssiMeasure rssi = distanceMeasureHelper.GetRSSI(RSSI);
             * double distance = rssi.DistanceAverage;
             *
             * RssiMeasure avgrssi = distanceMeasureHelper.GetRSSI(AverageRSSI);
             * double avgdistance = avgrssi.DistanceAverage;
             */
            double distance    = distcalc.GetDistanceByRSSI(RSSI);
            double avgdistance = distcalc.GetDistanceByRSSI(Sender.AverageRSSI);

            Sender.SetAveragePredictedDistance(avgdistance);

            foreach (BluetoothTagDisplay tag in tags)
            {
                if (tag.MAC.Equals(Sender.MAC))
                {
                    tag.BeaconSent(RSSI, distance, Sender.AverageRSSI, avgdistance);
                }
            }

            LocationResult location = PredictPosition();

            mainWindow.Dispatcher.Invoke((Action)(() =>
            {
                DrawSimulatedPosition(location);
            }));
        }
Beispiel #3
0
 /// <summary>
 /// Az egyik tag távolságából felírható kör tartalmazza-e a másik tag távolsága alapján felírható kört (average predicted distance alapján)
 /// </summary>
 public bool Includes(NearbyBluetoothTag tag)
 {
     if (this.avgPredictedDistance > LocationCalculator.Distance(this.origo, tag.origo) + tag.avgPredictedDistance)
     {
         return(true);
     }
     return(false);
 }
Beispiel #4
0
        public override bool Equals(object obj)
        {
            NearbyBluetoothTag dist = obj as NearbyBluetoothTag;

            if (dist == null)
            {
                return(false);
            }
            return(this.Origo.X == dist.Origo.X && this.Origo.Y == dist.Origo.Y);
        }
        /// <summary>
        /// Leellenőrzi azokat az eseteket, amikor nincs metszéspont, és beállítja a távolságokat úgy, hogy legyen
        /// </summary>
        /// <returns>
        /// true, ha módosítani kellett, mert nem volt metszéspont
        /// false, ha volt metszéspont
        /// </returns>
        protected bool IntersectionCheck(NearbyBluetoothTag t0, NearbyBluetoothTag t1)
        {
            // Első eset: a két távolság által jelzett kör messze van egymástól:
            // Megoldás: mindkettőt arányosan növeljük
            bool requiredModification = CheckFarDistances(t0, t1);

            // Második eset: az egyik kör a másikon belül helyezkedik el:
            // Megoldás: a nagyobb kört arányosan csökkentjük, a kisebb kört pedig arányosan növeljük
            if (!requiredModification)
            {
                requiredModification = CheckInclude(t0, t1);
            }
            return(requiredModification);
        }
        /// <summary>
        /// Második eset: az egyik kör a másikon belül helyezkedik el:
        /// Megoldás: a nagyobb kört arányosan csökkentjük, a kisebb kört pedig arányosan növeljük
        /// </summary>
        protected bool CheckInclude(NearbyBluetoothTag tag1, NearbyBluetoothTag tag2)
        {
            NearbyBluetoothTag bigger, smaller;

            if (tag1.Includes(tag2))
            {
                bigger  = tag1;
                smaller = tag2;
            }
            else if (tag2.Includes(tag1))
            {
                bigger  = tag2;
                smaller = tag1;
            }
            else
            {
                return(false);
            }

            double deviance = bigger.AveragePredictedDistanceFromTag - (LocationCalculator.Distance(bigger.Origo, smaller.Origo) + smaller.AveragePredictedDistanceFromTag);

            deviance += BIAS;   // Az eltérés torzítása, így biztosan lesz metszéspont
            double max   = bigger.AveragePredictedDistanceFromTag + smaller.AveragePredictedDistanceFromTag;
            double brate = bigger.AveragePredictedDistanceFromTag / max;
            double srate = smaller.AveragePredictedDistanceFromTag / max;

            bigger.SetAveragePredictedDistance(bigger.AveragePredictedDistanceFromTag - deviance * brate);
            smaller.SetAveragePredictedDistance(smaller.AveragePredictedDistanceFromTag + deviance * srate);


            //TEST
            double dist = bigger.AveragePredictedDistanceFromTag - (LocationCalculator.Distance(bigger.Origo, smaller.Origo) + smaller.AveragePredictedDistanceFromTag);

            if (dist > 0.0)
            {
                dist = 0; /* throw new Exception("Calculation error: distance must be 0.0"); */
            }
            //TEST

            return(true);
        }
 public void DeviceAppear(Point Origo, double Distance, String MAC)
 {
     NearbyBluetoothTag dist = new NearbyBluetoothTag(Origo, MAC, Distance, BeaconReceived);
     nearbyTags.Add(dist);
 }
        public void BeaconReceived(NearbyBluetoothTag Sender, int RSSI)
        {
            /*
            RssiMeasure rssi = distanceMeasureHelper.GetRSSI(RSSI);
            double distance = rssi.DistanceAverage;

            RssiMeasure avgrssi = distanceMeasureHelper.GetRSSI(AverageRSSI);
            double avgdistance = avgrssi.DistanceAverage;
            */
            double distance = distcalc.GetDistanceByRSSI(RSSI);
            double avgdistance = distcalc.GetDistanceByRSSI(Sender.AverageRSSI);
            Sender.SetAveragePredictedDistance(avgdistance);

            foreach (BluetoothTagDisplay tag in tags)
            {
                if (tag.MAC.Equals(Sender.MAC))
                {
                    tag.BeaconSent(RSSI, distance, Sender.AverageRSSI, avgdistance);
                }
            }
                        
            LocationResult location = PredictPosition();
            mainWindow.Dispatcher.Invoke((Action)(() =>
            {
                DrawSimulatedPosition(location);
            }));
        }
        /// <summary>
        /// Leellenőrzi azokat az eseteket, amikor nincs metszéspont, és beállítja a távolságokat úgy, hogy legyen
        /// </summary>
        /// <returns>
        /// true, ha módosítani kellett, mert nem volt metszéspont
        /// false, ha volt metszéspont
        /// </returns>
        protected bool IntersectionCheck(NearbyBluetoothTag t0, NearbyBluetoothTag t1)
        {
            // Első eset: a két távolság által jelzett kör messze van egymástól:
            // Megoldás: mindkettőt arányosan növeljük
            bool requiredModification = CheckFarDistances(t0, t1);

            // Második eset: az egyik kör a másikon belül helyezkedik el:
            // Megoldás: a nagyobb kört arányosan csökkentjük, a kisebb kört pedig arányosan növeljük
            if (!requiredModification) requiredModification = CheckInclude(t0, t1);
            return requiredModification;
        }
        /// <summary>
        /// Második eset: az egyik kör a másikon belül helyezkedik el:
        /// Megoldás: a nagyobb kört arányosan csökkentjük, a kisebb kört pedig arányosan növeljük
        /// </summary>
        protected bool CheckInclude(NearbyBluetoothTag tag1, NearbyBluetoothTag tag2)
        {
            NearbyBluetoothTag bigger, smaller;
            if (tag1.Includes(tag2))
            {
                bigger = tag1;
                smaller = tag2;
            }
            else if (tag2.Includes(tag1))
            {
                bigger = tag2;
                smaller = tag1;
            }
            else return false;

            double deviance = bigger.AveragePredictedDistanceFromTag - (LocationCalculator.Distance(bigger.Origo, smaller.Origo) + smaller.AveragePredictedDistanceFromTag);
            deviance += BIAS;   // Az eltérés torzítása, így biztosan lesz metszéspont
            double max = bigger.AveragePredictedDistanceFromTag + smaller.AveragePredictedDistanceFromTag;
            double brate = bigger.AveragePredictedDistanceFromTag / max;
            double srate = smaller.AveragePredictedDistanceFromTag / max;
            bigger.SetAveragePredictedDistance(bigger.AveragePredictedDistanceFromTag - deviance * brate);
            smaller.SetAveragePredictedDistance(smaller.AveragePredictedDistanceFromTag + deviance * srate);


            //TEST
            double dist = bigger.AveragePredictedDistanceFromTag - (LocationCalculator.Distance(bigger.Origo, smaller.Origo) + smaller.AveragePredictedDistanceFromTag);
            if (dist > 0.0)
                dist = 0; /* throw new Exception("Calculation error: distance must be 0.0"); */
            //TEST

            return true;
        }
        /// <summary>
        /// Első eset: a két távolság által jelzett kör messze van egymástól:
        /// Megoldás: mindkettőt arányosan növeljük
        /// </summary>
        protected bool CheckFarDistances(NearbyBluetoothTag tag1, NearbyBluetoothTag tag2)
        {
            if (LocationCalculator.Distance(tag1.Origo, tag2.Origo) > tag1.AveragePredictedDistanceFromTag + tag2.AveragePredictedDistanceFromTag)
            {
                double deviance = LocationCalculator.Distance(tag1.Origo, tag2.Origo) - (tag1.AveragePredictedDistanceFromTag + tag2.AveragePredictedDistanceFromTag);
                deviance += BIAS;  // Az eltérés torzítása, így biztosan lesz metszéspont
                double max = tag1.AveragePredictedDistanceFromTag + tag2.AveragePredictedDistanceFromTag;
                double rate1 = tag1.AveragePredictedDistanceFromTag / max;
                double rate2 = tag2.AveragePredictedDistanceFromTag / max;
                tag1.SetAveragePredictedDistance(tag1.AveragePredictedDistanceFromTag + deviance * rate1);
                tag2.SetAveragePredictedDistance(tag2.AveragePredictedDistanceFromTag + deviance * rate2);


                //TEST
                double dist = LocationCalculator.Distance(tag1.Origo, tag2.Origo) - (tag1.AveragePredictedDistanceFromTag + tag2.AveragePredictedDistanceFromTag);
                if (dist > 0.0)
                    dist = 0; /* throw new Exception("Calculation error: distance must be 0.0"); */
                //TEST

                return true;
            }
            else return false;
        }
 /// <summary>
 /// Az egyik tag távolságából felírható kör tartalmazza-e a másik tag távolsága alapján felírható kört (average predicted distance alapján)
 /// </summary>
 public bool Includes(NearbyBluetoothTag tag)
 {
     if (this.avgPredictedDistance > LocationCalculator.Distance(this.origo, tag.origo) + tag.avgPredictedDistance) return true;
     return false;
 }
        public void DeviceAppear(Point Origo, double Distance, String MAC)
        {
            NearbyBluetoothTag dist = new NearbyBluetoothTag(Origo, MAC, Distance, BeaconReceived);

            nearbyTags.Add(dist);
        }