initial commit of BRouter Version 0.98

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

@@ -0,0 +1,223 @@
+/**
+ * Efficient cache or osmnodes
+ *
+ * @author ab
+ */
+package btools.mapaccess;
+
+import java.util.*;
+import java.io.*;
+
+public final class NodesCache
+{
+  private String segmentDir;
+  private OsmNodesMap nodesMap;
+  private int lookupVersion;
+  private boolean carMode;
+  private String currentFileName;
+
+  private HashMap<String,RandomAccessFile> fileCache;
+  private HashMap<String,long[]> indexCache;
+  private byte[] iobuffer;
+  
+  private OsmFile[][] fileRows = new OsmFile[180][];
+  private ArrayList<MicroCache> segmentList = new ArrayList<MicroCache>();
+
+  public DistanceChecker distanceChecker;
+  
+  public boolean oom_carsubset_hint = false;
+
+  public NodesCache( String segmentDir, OsmNodesMap nodesMap, int lookupVersion, boolean carMode, NodesCache oldCache )
+  {
+    this.segmentDir = segmentDir;
+    this.nodesMap = nodesMap;
+    this.lookupVersion = lookupVersion;
+    this.carMode = carMode;
+
+    if ( oldCache != null )
+    {
+      fileCache = oldCache.fileCache;
+      indexCache = oldCache.indexCache;
+      iobuffer = oldCache.iobuffer;
+      oom_carsubset_hint = oldCache.oom_carsubset_hint;
+    }
+    else
+    {
+      fileCache = new HashMap<String,RandomAccessFile>(4);
+      indexCache = new HashMap<String,long[]>(4);
+      iobuffer = new byte[65636];
+    }
+  }
+
+  public int loadSegmentFor( int ilon, int ilat )
+  {
+    MicroCache mc = getSegmentFor( ilon, ilat );
+    return mc == null ? 0 : mc.getSize();
+  }
+
+  public MicroCache getSegmentFor( int ilon, int ilat )
+  {
+    try
+    {
+        int lonIdx80 = ilon/12500;
+        int latIdx80 = ilat/12500;
+        int lonDegree = lonIdx80/80;
+        int latDegree = latIdx80/80;
+        OsmFile osmf = null;
+        OsmFile[] fileRow = fileRows[latDegree];
+        int ndegrees = fileRow == null ? 0 : fileRow.length;
+        for( int i=0; i<ndegrees; i++ )
+        {
+          if ( fileRow[i].lonDegree == lonDegree )
+          {
+            osmf = fileRow[i];
+            break;
+          }
+        }
+        if ( osmf == null )
+        {
+          osmf = fileForSegment( lonDegree, latDegree );
+          OsmFile[] newFileRow = new OsmFile[ndegrees+1];
+          for( int i=0; i<ndegrees; i++ )
+          {
+            newFileRow[i] = fileRow[i];
+          }
+          newFileRow[ndegrees] = osmf;
+          fileRows[latDegree] = newFileRow;
+        }
+        currentFileName = osmf.filename;
+        if ( osmf.microCaches == null )
+        {
+          return null;
+        }
+        int subIdx = (latIdx80-80*latDegree)*80 + (lonIdx80-80*lonDegree);
+        MicroCache segment = osmf.microCaches[subIdx];
+        if ( segment == null )
+        {
+          // nodesMap.removeCompleteNodes();
+
+          segment = new MicroCache( osmf, lonIdx80, latIdx80, iobuffer );
+          osmf.microCaches[subIdx] = segment;
+          segmentList.add( segment );
+        }
+        return segment;
+    }
+    catch( RuntimeException re )
+    {
+      throw re;
+    }
+    catch( Exception e )
+    {
+      throw new RuntimeException( "error reading datafile " + currentFileName + ": " + e );
+    }
+  }
+
+
+  public boolean obtainNonHollowNode( OsmNode node )
+  {
+    if ( !node.isHollow() ) return true;
+
+    MicroCache segment = getSegmentFor( node.ilon, node.ilat );
+    if ( segment == null )
+    {
+      return false;
+    }
+    segment.fillNode( node, nodesMap, distanceChecker );
+    return !node.isHollow();
+  }
+
+  private OsmFile fileForSegment( int lonDegree, int latDegree ) throws Exception
+  {
+    File base = new File( segmentDir );
+    if ( !base.isDirectory() ) throw new RuntimeException( "segment directory " + segmentDir + " does not exist" );
+
+    int lonMod5 = lonDegree % 5;
+    int latMod5 = latDegree % 5;
+    int tileIndex = lonMod5 * 5 + latMod5;
+
+    int lon = lonDegree - 180 - lonMod5;
+    String slon = lon < 0 ? "W" + (-lon) : "E" + lon;
+    int lat = latDegree - 90 - latMod5;
+
+    String slat = lat < 0 ? "S" + (-lat) : "N" + lat;
+    String filenameBase = slon + "_" + slat;
+
+    currentFileName = filenameBase + ".rd5/cd5";
+
+    if ( !fileCache.containsKey( filenameBase ) )
+    {
+      File f = null;
+      if ( carMode )
+      {
+        File carFile = new File( new File( base, "carsubset" ), filenameBase + ".cd5" );
+    	if ( carFile.exists() ) f = carFile;
+      }
+      if ( f == null )
+      {
+        File fullFile = new File( base, filenameBase + ".rd5" );
+        if ( fullFile.exists() ) f = fullFile;
+        if ( carMode && f != null ) oom_carsubset_hint = true;
+      }
+      RandomAccessFile ra = f != null ? new RandomAccessFile( f, "r" ) : null;
+      fileCache.put( filenameBase, ra );
+      if ( ra != null )
+      {
+        long[] fileIndex = new long[25];
+        ra.readFully( iobuffer, 0, 200 );
+        ByteDataReader dis = new ByteDataReader( iobuffer );
+        for( int i=0; i<25; i++ )
+        {
+          long lv = dis.readLong();
+          short readVersion = (short)(lv >> 48);
+          if ( readVersion != lookupVersion )
+          {
+            throw new IllegalArgumentException( "lookup version mismatch (old rd5?) lookups.dat="
+                     + lookupVersion + " " + f. getAbsolutePath() + "=" + readVersion );
+          }
+          fileIndex[i] = lv & 0xffffffffffffL;
+        }
+        indexCache.put( filenameBase, fileIndex );
+      }
+    }
+    RandomAccessFile ra = fileCache.get( filenameBase );
+    long startPos = 0L;
+    if ( ra != null )
+    {
+      long[] index = indexCache.get( filenameBase );
+      startPos = tileIndex > 0 ? index[ tileIndex-1 ] : 200L;
+      if ( startPos == index[ tileIndex] ) ra = null;
+    }
+    OsmFile osmf = new OsmFile( ra, startPos, iobuffer );
+    osmf.lonDegree = lonDegree;
+    osmf.latDegree = latDegree;
+    osmf.filename = currentFileName;
+    return osmf;
+  }
+
+  public List<OsmNode> getAllNodes()
+  {
+    List<OsmNode> all = new ArrayList<OsmNode>();
+    for( MicroCache segment :  segmentList )
+    {
+      List<OsmNode> positions = segment.getPositions( nodesMap );
+      all.addAll( positions );
+    }
+    return all;
+  }
+
+
+  public void close()
+  {
+    for( RandomAccessFile f: fileCache.values() )
+    {
+      try
+      {
+        f.close();
+      }
+      catch( IOException ioe )
+      {
+        // ignore
+      }
+    }
+  }
+}