automatically ignore islands

brouter-codec/src/main/java/btools/codec/MicroCache2.java

@@ -170,9 +170,15 @@ public final class MicroCache2 extends MicroCache
         if ( !isReverse ) // write geometry for forward links only
         {
           WaypointMatcher matcher = wayTags == null || wayTags.accessType < 2 ? null : waypointMatcher;
-          if ( matcher != null ) matcher.startNode( ilon, ilat, wayTags.data );
           int ilontarget = ilon + dlon_remaining;
           int ilattarget = ilat + dlat_remaining;
+          if ( matcher != null )
+          {
+            if ( !matcher.start( ilon, ilat, ilontarget, ilattarget ) )
+            {
+              matcher = null;
+            }
+          }
           
           int transcount = bc.decodeVarBits();
           if ( debug ) System.out.println( "***       decoding geometry with count=" + transcount );
@@ -194,7 +200,7 @@ public final class MicroCache2 extends MicroCache
             
             if ( matcher != null ) matcher.transferNode( ilontarget - dlon_remaining, ilattarget - dlat_remaining );
           }
-          if ( matcher != null ) matcher.endNode( ilontarget, ilattarget );
+          if ( matcher != null ) matcher.end();
         }
         if ( wayTags != null )
         {

brouter-codec/src/main/java/btools/codec/WaypointMatcher.java

@@ -7,7 +7,7 @@ package btools.codec;
  */
 public interface WaypointMatcher
 {
-  void startNode( int ilon, int ilat, byte[] wayTags );
+  boolean start( int ilonStart, int ilatStart, int ilonTarget, int ilatTarget );
   void transferNode( int ilon, int ilat );
-  void endNode( int ilon, int ilat );
+  void end();
 }

brouter-core/src/main/java/btools/router/RoutingEngine.java

@@ -14,6 +14,7 @@ import btools.mapaccess.NodesCache;
 import btools.mapaccess.OsmLink;
 import btools.mapaccess.OsmLinkHolder;
 import btools.mapaccess.OsmNode;
+import btools.mapaccess.OsmNodePairSet;
 import btools.mapaccess.OsmNodesMap;
 import btools.util.SortedHeap;
 import btools.util.StackSampler;
@@ -30,6 +31,8 @@ public class RoutingEngine extends Thread
   private int linksProcessed = 0;
 
   private int nodeLimit; // used for target island search
+  private int MAXNODES_ISLAND_CHECK = 500;
+  private OsmNodePairSet islandNodePairs = new OsmNodePairSet(MAXNODES_ISLAND_CHECK);
 
   protected OsmTrack foundTrack = new OsmTrack();
   private OsmTrack foundRawTrack = null;
@@ -328,9 +331,24 @@ public class RoutingEngine extends Thread
       terminate();
   }      
   
-  
-
   private OsmTrack findTrack( OsmTrack[] refTracks, OsmTrack[] lastTracks )
+  {
+    for(;;)
+    {
+      try
+      {
+        return tryFindTrack( refTracks, lastTracks );
+      }
+      catch( RoutingIslandException rie )
+      {
+        islandNodePairs.freezeTempPairs();
+        nodesCache.clean( true );
+        matchedWaypoints = null;
+      }
+    }
+  }  
+
+  private OsmTrack tryFindTrack( OsmTrack[] refTracks, OsmTrack[] lastTracks )
   {
     OsmTrack totaltrack = new OsmTrack();
     int nUnmatched = waypoints.size();
@@ -377,7 +395,7 @@ public class RoutingEngine extends Thread
       airDistanceCostFactor = 0.;
       for( int i=0; i<matchedWaypoints.size() -1; i++ )
       {
-        nodeLimit = 200;
+        nodeLimit = MAXNODES_ISLAND_CHECK;
         if ( routingContext.inverseRouting )
         {
           OsmTrack seg = findTrack( "start-island-check", matchedWaypoints.get(i), matchedWaypoints.get(i+1), null, null, false );
@@ -435,7 +453,7 @@ public class RoutingEngine extends Thread
   private void matchWaypointsToNodes( List<MatchedWaypoint> unmatchedWaypoints )
   {
     resetCache( false );
-    nodesCache.waypointMatcher = new WaypointMatcherImpl( unmatchedWaypoints, 250. );
+    nodesCache.waypointMatcher = new WaypointMatcherImpl( unmatchedWaypoints, 250., islandNodePairs );
     for( MatchedWaypoint mwp : unmatchedWaypoints )
     {
       preloadPosition( mwp.waypoint );
@@ -466,10 +484,13 @@ public class RoutingEngine extends Thread
     }
     for( int idxLat=-1; idxLat<=1; idxLat++ )
       for( int idxLon=-1; idxLon<=1; idxLon++ )
+      {
+        if ( idxLon != 0 || idxLat != 0 )
         {
           nodesCache.loadSegmentFor( n.ilon + d*idxLon , n.ilat +d*idxLat );
         }
       }
+  }
 
 
 
@@ -608,6 +629,7 @@ public class RoutingEngine extends Thread
     long maxmem = routingContext.memoryclass * 131072L; // 1/8 of total
     
     nodesCache = new NodesCache(segmentDir, nodesMap, routingContext.expctxWay, routingContext.forceSecondaryData, maxmem, nodesCache, detailed );
+    islandNodePairs.clearTempPairs();
   }
 
   private OsmNode getStartNode( long startId )
@@ -741,7 +763,7 @@ public class RoutingEngine extends Thread
     }
     finally
     {
-      nodesCache.cleanNonVirgin();
+      nodesCache.clean( false ); // clean only non-virgin caches
     }
   }
 
@@ -878,6 +900,10 @@ public class RoutingEngine extends Thread
       OsmNode currentNode = path.getTargetNode();
 
       long currentNodeId = currentNode.getIdFromPos();
+      long sourceNodeId = sourceNode.getIdFromPos();
+      
+      islandNodePairs.addTempPair( sourceNodeId, currentNodeId );
+      
       if ( path.treedepth != 1 )
       {
         if ( path.treedepth == 0 ) // hack: sameSegment Paths marked treedepth=0 to pass above check
@@ -885,7 +911,6 @@ public class RoutingEngine extends Thread
           path.treedepth = 1;
         }
       
-        long sourceNodeId = sourceNode.getIdFromPos();
         if ( ( sourceNodeId == endNodeId1 && currentNodeId == endNodeId2 )
           || ( sourceNodeId == endNodeId2 && currentNodeId == endNodeId1 ) )
         {
@@ -1078,7 +1103,6 @@ public class RoutingEngine extends Thread
               {
                 bestPath.airdistance += boundary.getBoundaryDistance( nextNode );
               }
-
               bestPath.treedepth = path.treedepth + 1;
               link.addLinkHolder( bestPath, currentNode );
               synchronized( openSet )
@@ -1092,6 +1116,12 @@ public class RoutingEngine extends Thread
             
       path.unregisterUpTree( routingContext );
     }
+    
+    if ( nodesVisited < MAXNODES_ISLAND_CHECK && islandNodePairs.getFreezeCount() < 5 )
+    {
+      throw new RoutingIslandException();
+    }
+    
     return null;
   }
   

brouter-core/src/main/java/btools/router/RoutingIslandException.java

@@ -0,0 +1,5 @@
+package btools.router;
+
+public class RoutingIslandException extends RuntimeException
+{
+}

brouter-core/src/main/java/btools/router/WaypointMatcherImpl.java

@@ -4,6 +4,7 @@ import java.util.List;
 
 import btools.codec.WaypointMatcher;
 import btools.mapaccess.OsmNode;
+import btools.mapaccess.OsmNodePairSet;
 
 /**
  * the WaypointMatcher is feeded by the decoder with geoemtries of ways that are
@@ -15,16 +16,20 @@ import btools.mapaccess.OsmNode;
 public final class WaypointMatcherImpl implements WaypointMatcher
 {
   private List<MatchedWaypoint> waypoints;
+  private OsmNodePairSet islandPairs;
 
   private int lonStart;
   private int latStart;
+  private int lonTarget;
+  private int latTarget;
   private boolean anyUpdate;
   private int lonLast;
   private int latLast;
 
-  public WaypointMatcherImpl( List<MatchedWaypoint> waypoints, double maxDistance )
+  public WaypointMatcherImpl( List<MatchedWaypoint> waypoints, double maxDistance, OsmNodePairSet islandPairs )
   {
     this.waypoints = waypoints;
+    this.islandPairs = islandPairs;
     for ( MatchedWaypoint mwp : waypoints )
     {
       mwp.radius = maxDistance * 110984.; //  6378000. / 57.3;
@@ -105,11 +110,23 @@ public final class WaypointMatcherImpl implements WaypointMatcher
   }
 
   @Override
-  public void startNode( int ilon, int ilat, byte[] wayTags )
+  public boolean start( int ilonStart, int ilatStart, int ilonTarget, int ilatTarget )
   {
-    lonLast = lonStart = ilon;
-    latLast = latStart = ilat;
+    if ( islandPairs.size() > 0 )
+    {
+      long n1 = ( (long) ilonStart ) << 32 | ilatStart;
+      long n2 = ( (long) ilonTarget ) << 32 | ilatTarget;
+      if ( islandPairs.hasPair( n1, n2 ) )
+      {
+        return false;
+      }
+    }
+    lonLast = lonStart = ilonStart;
+    latLast = latStart = ilatStart;
+    lonTarget = ilonTarget;
+    latTarget = ilatTarget;
     anyUpdate = false;
+    return true;
   }
 
   @Override
@@ -121,9 +138,9 @@ public final class WaypointMatcherImpl implements WaypointMatcher
   }
 
   @Override
-  public void endNode( int ilon, int ilat )
+  public void end()
   {
-    checkSegment( lonLast, latLast, ilon, ilat );
+    checkSegment( lonLast, latLast, lonTarget, latTarget );
     if ( anyUpdate )
     {
       for ( MatchedWaypoint mwp : waypoints )
@@ -132,7 +149,7 @@ public final class WaypointMatcherImpl implements WaypointMatcher
         {
           mwp.hasUpdate = false;
           mwp.node1 = new OsmNode( lonStart, latStart );
-          mwp.node2 = new OsmNode( ilon, ilat );
+          mwp.node2 = new OsmNode( lonTarget, latTarget );
         }
       }
     }

brouter-mapaccess/src/main/java/btools/mapaccess/NodesCache.java

@@ -110,7 +110,7 @@ public final class NodesCache
     ghostSum = cacheSum;
   }
   
-  public void cleanNonVirgin()
+  public void clean( boolean all )
   {
       for ( OsmFile[] fileRow : fileRows )
       {
@@ -118,7 +118,7 @@ public final class NodesCache
           continue;
         for ( OsmFile osmf : fileRow )
         {
-          osmf.cleanNonVirgin();
+          osmf.clean( all);
         }
       }
   }

brouter-mapaccess/src/main/java/btools/mapaccess/OsmFile.java

@@ -217,7 +217,7 @@ final class OsmFile
     return deleted;
   }
 
-  void cleanNonVirgin()
+  void clean( boolean all )
   {
     int nc = microCaches == null ? 0 : microCaches.length;
     for ( int i = 0; i < nc; i++ )
@@ -225,7 +225,7 @@ final class OsmFile
       MicroCache mc = microCaches[i];
       if ( mc == null )
         continue;
-      if ( !mc.virgin )
+      if ( all || !mc.virgin )
       {
         microCaches[i] = null;
       }

brouter-mapaccess/src/main/java/btools/mapaccess/OsmNodePairSet.java

@@ -0,0 +1,122 @@
+/**
+ * Set holding pairs of osm nodes
+ *
+ * @author ab
+ */
+package btools.mapaccess;
+
+import btools.util.CompactLongMap;
+
+public class OsmNodePairSet
+{
+  private long[] n1a;
+  private long[] n2a;
+  private int tempNodes = 0;
+  private int maxTempNodes = 0;
+  private int npairs = 0;
+  private int freezecount = 0;
+
+  public OsmNodePairSet( int maxTempNodeCount )
+  {
+    maxTempNodes = maxTempNodeCount;
+    n1a = new long[maxTempNodes];
+    n2a = new long[maxTempNodes];
+  }
+
+  private static class OsmNodePair
+  {
+    public long node2;
+    public OsmNodePair next;
+  }
+  
+  private CompactLongMap<OsmNodePair> map;
+
+  public void addTempPair( long n1, long n2 )
+  {
+    if ( tempNodes < maxTempNodes )
+    {
+      n1a[tempNodes] = n1;
+      n2a[tempNodes] = n2;
+      tempNodes++;
+    }
+  }
+  
+  public void freezeTempPairs()
+  {
+    freezecount++;
+    for( int i=0; i<tempNodes; i++ )
+    {
+      addPair( n1a[i], n2a[i] );
+    }
+    tempNodes = 0;
+  }
+  
+  public void clearTempPairs()
+  {
+    tempNodes = 0;
+  }
+
+  private void addPair( long n1, long n2 )
+  {
+    if ( map == null )
+    {
+      map = new CompactLongMap<OsmNodePair>();
+    }
+    npairs++;
+  
+    OsmNodePair e = getElement( n1, n2 );
+    if ( e == null )
+    {
+      e = new OsmNodePair();
+      e.node2 = n2;
+
+      OsmNodePair e0 = map.get( n1 );
+      if ( e0 != null )
+      {
+        while( e0.next != null )
+        {
+          e0 = e0.next;
+        }
+        e0.next = e;
+      }
+      else
+      {
+        map.fastPut( n1, e );
+      }
+    }
+  }
+  
+  public int size()
+  {
+    return npairs;
+  }
+
+  public int tempSize()
+  {
+    return tempNodes;
+  }
+
+  public int getFreezeCount()
+  {
+    return freezecount;
+  }
+  
+  public boolean hasPair( long n1, long n2 )
+  {
+    return map != null && ( getElement( n1, n2 ) != null || getElement( n2, n1 ) != null );
+  }
+
+  private OsmNodePair getElement( long n1, long n2 )
+  {
+    OsmNodePair e = map.get( n1 );
+    while (e != null)
+    {
+      if ( e.node2 == n2 )
+      {
+        return e;
+      }
+      e = e.next;
+    }
+    return null;
+  }
+}