public ClusterItem Add(MarkerWrapper marker)
        {
            totalCount++;
            if (zoom < instance.clusterToZoom)
            {
                int mx, my;
                int z = zoom + 1;
                marker.GetTilePosition(z, out mx, out my);
                for (int i = 0; i < count; i++)
                {
                    ClusterItem item = childs[i];
                    if (item.CompareTiles(z, mx, my))
                    {
                        if (item is Cluster)
                        {
                            (item as Cluster).Add(marker);
                        }
                        else
                        {
                            Cluster c = new Cluster(z, item as MarkerWrapper, marker)
                            {
                                parent = this
                            };
                            childs[i] = c;
                        }
                        return(item);
                    }
                }
            }

            AddChild(marker);
            return(this);
        }
        protected Tuple <float, float> CalculateAffinity(ClusterItem item, TokenZipNode rootZipNode, ClusteringConfig config, int itemsCount)
        {
            Dictionary <int, int[]> itemTokenPlaceMap = item.GetTokenPlacesMap();

            Debug.Assert(itemTokenPlaceMap != null);

            int encounterThreshold = (int)Math.Floor(itemsCount * config.MinClusterAffinity * config.MinClusterAffinity);
            var itemTokensFound    = new HashSet <int>();
            Tuple <float, float> matchingAndTotalWeight = CalculateAffinity(0, itemTokenPlaceMap, rootZipNode, itemsCount, encounterThreshold, null, ref itemTokensFound);

            float foundWeight = 0.0f, notFoundWeight = 0.0f;
            int   seqIndex = 1;

            foreach (Token token in item.TokenIndex.Tokens)
            {
                if (itemTokensFound.Contains(token.Id))
                {
                    seqIndex     = 1;
                    foundWeight += 1;
                }
                else
                {
                    notFoundWeight += (float)(1 * Math.Pow(seqIndex++, 1.25));
                }
            }
            return(new Tuple <float, float>(matchingAndTotalWeight.Item1 + foundWeight, matchingAndTotalWeight.Item2 + foundWeight + notFoundWeight));
        }
        /// <summary>
        /// TokenZips zip chains are updated when adding an item to include the item's own sequences, extend TokenZips' sequences by an extra token and remote TokenZips chains that can be consolidated
        /// </summary>
        protected override void OnAddToCluster(ClusterItem item, float affinity)
        {
            this.MaxScore     = null;
            this.TokenZipRoot = this.TokenZipRoot ?? TokenZipNode.CreateRoot(item.TokenIndex.Tokens, this.Vocabulary);

            this.TokenZipRoot.Append(item.TokenIndex.Tokens.Distinct());

            this.TokenZipRoot.Compact();
        }
示例#4
0
 public void OnAddSingleClusterItem()
 {
     if (_clusterManager != null)
     {
         var latLng            = new LatLng(51.5005642, -0.1241729);
         var clusterItem       = new ClusterItem(latLng, "Westminster Bridge", latLng.ToString());
         var westminsterBridge = clusterItem;
         _clusterManager.AddItem(westminsterBridge);
     }
 }
 public void RemoveAll()
 {
     for (int i = 0; i < count; i++)
     {
         ClusterItem item = childs[i];
         if (item is Cluster)
         {
             (item as Cluster).RemoveAll();
         }
         item.Dispose();
     }
     childs     = null;
     count      = 0;
     capacity   = 0;
     totalCount = 0;
 }
示例#6
0
        private void ClusterRightMouseClick(object sender, MouseButtonEventArgs e)
        {
            FrameworkElement element = sender as FrameworkElement;

            if (element != null)
            {
                ClusterItem cluster = element.DataContext as ClusterItem;
                if (cluster != null)
                {
                    cluster.HideExpanded = true;
                    cluster.ClusterState = ClusterState.Expanded;
                }
            }

            e.Handled = true;
        }
        private bool TryRemoveMarker(OnlineMapsMarker marker)
        {
            for (int i = 0; i < count; i++)
            {
                ClusterItem item = childs[i];
                if (item is Cluster)
                {
                    if ((item as Cluster).TryRemoveMarker(marker))
                    {
                        return(true);
                    }
                }
                else if (item.markerRef == marker)
                {
                    item.Dispose();
                    for (int j = i; j < count - 1; j++)
                    {
                        childs[j] = childs[j + 1];
                    }
                    count--;
                    totalCount--;

                    Cluster p = parent;
                    while (p != null)
                    {
                        p.totalCount--;
                        p.Update();
                        p = p.parent;
                    }

                    childs[count] = null;

                    if (count == 1 && parent != null)
                    {
                        if (childs[0] is MarkerWrapper)
                        {
                            parent.Replace(this, childs[0] as MarkerWrapper);
                            Dispose();
                        }
                    }

                    return(true);
                }
            }
            return(false);
        }
        private void AddChild(ClusterItem child)
        {
            if (childs == null)
            {
                childs   = new ClusterItem[2];
                capacity = 2;
            }
            if (count == capacity)
            {
                capacity *= 2;
                Array.Resize(ref childs, capacity);
            }

            child.parent  = this;
            childs[count] = child;
            count++;
        }
示例#9
0
        public void AddIfNotExist(List<ClusterItem> cList, ClusterItem clusterToInsert)
        {
            var toRemoveIndices = new List<int>();
            #region if empty, insert

            if (cList.Count == 0)
            {
                cList.Add(clusterToInsert);
                return;
            }

            #endregion

            var cListCopy = new List<ClusterItem>(cList);

            for (int i = 0; i < cListCopy.Count; i++)
            {
                ClusterItem clusterItem = cList.ElementAt(i);
                var intersect = clusterItem.Cluster.Intersect(clusterToInsert.Cluster);
                if (intersect.Any())
                {

                    if (cList[i].Datum > clusterToInsert.Datum)
                    {

                        toRemoveIndices.Add(i);
                    }
                    else
                    {
                        //wird nicht eingefügt, weil datum älter?
                        //muss man schleife zu ende laufen lassen?
                        return;
                        //continue;
                    }

                }

                //}

            }
            foreach (int delKey in toRemoveIndices)
            {
                cList.RemoveAt(delKey);
            }
            cList.Add(clusterToInsert);
        }
 public bool UpdateMarker(OnlineMapsMarker marker)
 {
     for (int i = 0; i < count; i++)
     {
         ClusterItem item = childs[i];
         if (item is Cluster)
         {
             if ((item as Cluster).UpdateMarker(marker))
             {
                 return(true);
             }
         }
         else if (item.markerRef == marker)
         {
             (item as MarkerWrapper).UpdatePosition();
             return(true);
         }
     }
     return(false);
 }
        public MarkerWrapper FindMarkerWrapper(OnlineMapsMarker marker)
        {
            for (int i = 0; i < count; i++)
            {
                ClusterItem item = childs[i];
                if (item is Cluster)
                {
                    MarkerWrapper wrapper = (item as Cluster).FindMarkerWrapper(marker);
                    if (wrapper != null)
                    {
                        return(wrapper);
                    }
                }
                else if (item.markerRef == marker)
                {
                    return(item as MarkerWrapper);
                }
            }

            return(null);
        }
示例#12
0
        private void ClusterMouseClick(object sender, MouseButtonEventArgs e)
        {
            FrameworkElement element = sender as FrameworkElement;

            if (element != null)
            {
                ClusterItem cluster = element.DataContext as ClusterItem;
                if (cluster != null)
                {
                    if (cluster.ClusterState == ClusterState.ExpandedToPolygon ||
                        cluster.ClusterState == ClusterState.Expanded)
                    {
                        cluster.ClusterState = ClusterState.Collapsed;
                    }
                    else
                    {
                        cluster.HideExpanded = false;
                        cluster.ClusterState = ClusterState.ExpandedToPolygon;
                    }
                }
            }
        }
        /// <summary>
        /// ZIP-like comparison: the cluster maintains zip chains (TokenZips) which consist of sequences of tokens that are found across several items.
        /// Getting the affinity for an unknown item checks how many of these chains are encountered in the item
        /// </summary>
        protected override float OnGetAffinity(ClusterItem item, float minAffinity)
        {
            Tuple <float, float> matchingAndTotalWeight = CalculateAffinity(item, this.TokenZipRoot, this.Config, this.Items.Count);

            return(matchingAndTotalWeight.Item1 / matchingAndTotalWeight.Item2);
        }
示例#14
0
        public RoutePredictionResult PredictEndLocation(double lat, double lon, DateTime time)
        {
            var prediction = new RoutePredictionResult();

            // check how many start points we have within a cluster
            // and iterate through the cluster hierachy to get at least 1 location
            // TODO: filter using time of the day (morning, midday, evening, night), week day, month,...
            ClusterItem <LocationInstance <TripSummary> > cluster = startLocationRoot.GetLeaf(lat, lon);

            prediction.ClusterLevel = 0;
            while (cluster.GetNrOfLocations() == 0)
            {
                var parentItem = cluster.GetParentItem();
                if (parentItem != null)
                {
                    if (parentItem is ClusterItem <LocationInstance <TripSummary> > )
                    {
                        cluster = parentItem as ClusterItem <LocationInstance <TripSummary> >;
                        prediction.ClusterLevel++;
                    }
                    else
                    {
                        // return an empty prediction result
                        return(prediction);
                    }
                }
                else
                {
                    // return an empty prediction result
                    return(prediction);
                }
            }

            Dictionary <ClusterLeaf <TripSummary>, RoutePredictionItem> leafs = new Dictionary <ClusterLeaf <TripSummary>, RoutePredictionItem>();

            // create a list of endLocation leafs and count how many times an endlocation is part of the leaf
            foreach (var location in cluster.GetLocations())
            {
                ClusterLeaf <TripSummary> leaf = location.LocationObject.GetParentItem() as ClusterLeaf <TripSummary>;
                if (!leafs.ContainsKey(leaf))
                {
                    leafs[leaf] = new RoutePredictionItem()
                    {
                        Lat                = leaf.CenterLat,
                        Lon                = leaf.CenterLon,
                        NrOfEndPoints      = 0,
                        NrOfDayMatches     = 0,
                        NrOfTimeMatches    = 0,
                        NrOfWorkdayMatches = 0
                    };
                }
                leafs[leaf].NrOfEndPoints++;
                leafs[leaf].TripIds.Add(location.LocationObject.LocationObject.TripId);
                if (location.LocationObject.LocationObject.StartTime.DayOfWeek == time.DayOfWeek)
                {
                    leafs[leaf].NrOfDayMatches++;
                }
                ;
                if (IsWeekend(location.LocationObject.LocationObject.StartTime) == IsWeekend(time))
                {
                    leafs[leaf].NrOfWorkdayMatches++;
                }
                if (GetTimeSlot(location.LocationObject.LocationObject.StartTime) == GetTimeSlot(time))
                {
                    leafs[leaf].NrOfTimeMatches++;
                }
                leafs[leaf].CalculateProbability(cluster.GetNrOfLocations());
            }
            prediction.Predictions = leafs.Values.ToList();
            prediction.Predictions.Sort();
            return(prediction);
        }