Beispiel #1
0
        public override IList <TDWay> getInnerWaysOfMultipolygon(long outerWayID)
        {
            TLongArrayList innerwayIDs = this.outerToInnerMapping.get(outerWayID);

            if (innerwayIDs == null)
            {
                return(null);
            }
            return(getInnerWaysOfMultipolygon(innerwayIDs.toArray()));
        }
            internal virtual void addInnerWays(TDWay outer)
            {
                if (this.inner != null && this.inner.Count > 0)
                {
                    TLongArrayList innerList = outerInstance.outerToInnerMapping.get(outer.Id);
                    if (innerList == null)
                    {
                        innerList = new TLongArrayList();
                        outerInstance.outerToInnerMapping.put(outer.Id, innerList);
                    }

                    foreach (int?innerIndex in this.inner)
                    {
                        Deque <TDWay> innerSegments = this.extractedPolygons[innerIndex.Value];
                        TDWay         innerWay      = null;

                        if (innerSegments.size() == 1)
                        {
                            innerWay = innerSegments.First;
                            if (innerWay.hasTags() && outer.hasTags())
                            {
                                short[] iTags     = innerWay.Tags;
                                short[] oTags     = outer.Tags;
                                int     contained = 0;
                                foreach (short iTagID in iTags)
                                {
                                    foreach (short oTagID in oTags)
                                    {
                                        if (iTagID == oTagID)
                                        {
                                            contained++;
                                        }
                                    }
                                }
                                if (contained == iTags.Length)
                                {
                                    outerInstance.innerWaysWithoutAdditionalTags.add(innerWay.Id);
                                }
                            }
                        }
                        else
                        {
                            IList <TDNode> waynodeList = new List <TDNode>();
                            foreach (TDWay innerSegment in innerSegments)
                            {
                                if (innerSegment.ReversedInRelation)
                                {
                                    for (int i = innerSegment.WayNodes.length - 1; i >= 0; i--)
                                    {
                                        waynodeList.Add(innerSegment.WayNodes[i]);
                                    }
                                }
                                else
                                {
                                    foreach (TDNode tdNode in innerSegment.WayNodes)
                                    {
                                        waynodeList.Add(tdNode);
                                    }
                                }
                            }
                            TDNode[] waynodes = waynodeList.ToArray();
                            // TODO which layer?
                            innerWay = new TDWay(++outerInstance.maxWayID, (sbyte)0, null, null, null, waynodes);
                            outerInstance.handleVirtualInnerWay(innerWay);
                            // does not need to be added to corresponding tiles
                            // virtual inner ways do not have any tags, they are holes in the outer polygon
                        }
                        innerList.add(innerWay.Id);
                    }
                }
            }
Beispiel #3
0
 internal HDTileData() : base()
 {
     this.pois = new TLongArrayList();
     this.ways = new TLongArrayList();
 }