373 lines
8.9 KiB
Java
373 lines
8.9 KiB
Java
/**
|
|
* Container for an osm node
|
|
*
|
|
* @author ab
|
|
*/
|
|
package btools.mapaccess;
|
|
|
|
|
|
|
|
public class OsmNode implements OsmPos
|
|
{
|
|
public static final int EXTERNAL_BITMASK = 0x80;
|
|
public static final int FIRSTFORWAY_BITMASK = 0x40;
|
|
public static final int TRANSFERNODE_BITMASK = 0x20;
|
|
public static final int WRITEDESC_BITMASK = 0x10;
|
|
public static final int SKIPDETAILS_BITMASK = 0x08;
|
|
public static final int NODEDESC_BITMASK = 0x04;
|
|
|
|
public OsmNode()
|
|
{
|
|
}
|
|
|
|
public OsmNode( int ilon, int ilat )
|
|
{
|
|
this.ilon = ilon;
|
|
this.ilat = ilat;
|
|
}
|
|
|
|
public OsmNode( long id )
|
|
{
|
|
ilon = (int)(id >> 32);
|
|
ilat = (int)(id & 0xffffffff);
|
|
}
|
|
|
|
/**
|
|
* The latitude
|
|
*/
|
|
public int ilat;
|
|
|
|
/**
|
|
* The longitude
|
|
*/
|
|
public int ilon;
|
|
|
|
/**
|
|
* The elevation
|
|
*/
|
|
public short selev;
|
|
|
|
public byte[] nodeDescription;
|
|
|
|
// interface OsmPos
|
|
public int getILat()
|
|
{
|
|
return ilat;
|
|
}
|
|
|
|
public int getILon()
|
|
{
|
|
return ilon;
|
|
}
|
|
|
|
public short getSElev()
|
|
{
|
|
return selev;
|
|
}
|
|
|
|
public double getElev()
|
|
{
|
|
return selev / 4.;
|
|
}
|
|
|
|
/**
|
|
* Whether there's a traffic signal
|
|
*/
|
|
|
|
/**
|
|
* The links to other nodes
|
|
*/
|
|
public OsmLink firstlink = null;
|
|
|
|
public OsmLink firstreverse = null;
|
|
|
|
// whether this node is completed and registerd for map-removal
|
|
public boolean completed;
|
|
|
|
public boolean wasProcessed;
|
|
public int maxcost; // maximum cost to consider for that node
|
|
|
|
public void addLink( OsmLink link )
|
|
{
|
|
if ( firstlink != null ) link.next = firstlink;
|
|
firstlink = link;
|
|
}
|
|
|
|
public int calcDistance( OsmPos p )
|
|
{
|
|
double l = (ilat-90000000) * 0.00000001234134;
|
|
double l2 = l*l;
|
|
double l4 = l2*l2;
|
|
double coslat = 1.- l2 + l4 / 6.;
|
|
|
|
double dlat = (ilat - p.getILat() )/1000000.;
|
|
double dlon = (ilon - p.getILon() )/1000000. * coslat;
|
|
double d = Math.sqrt( dlat*dlat + dlon*dlon ) * (6378000. / 57.3);
|
|
return (int)(d + 1.0 );
|
|
}
|
|
|
|
|
|
public void parseNodeBody( MicroCache is, int bodySize, OsmNodesMap hollowNodes, DistanceChecker dc )
|
|
{
|
|
selev = is.readShort();
|
|
bodySize -= 2;
|
|
|
|
OsmLink lastlink = null;
|
|
|
|
int lonIdx = ilon/62500;
|
|
int latIdx = ilat/62500;
|
|
|
|
while( bodySize > 0 )
|
|
{
|
|
OsmLink link = new OsmLink();
|
|
OsmTransferNode firstTransferNode = null;
|
|
OsmTransferNode lastTransferNode = null;
|
|
int linklon;
|
|
int linklat;
|
|
byte[] description = null;
|
|
for(;;)
|
|
{
|
|
int bitField = is.readByte();
|
|
bodySize -= 1;
|
|
if ( (bitField & EXTERNAL_BITMASK) != 0 )
|
|
{
|
|
// full position for external target
|
|
bodySize -= 8;
|
|
linklon = is.readInt();
|
|
linklat = is.readInt();
|
|
}
|
|
else
|
|
{
|
|
// reduced position for internal target
|
|
bodySize -= 4;
|
|
linklon = is.readShort();
|
|
linklat = is.readShort();
|
|
linklon += lonIdx*62500 + 31250;
|
|
linklat += latIdx*62500 + 31250;
|
|
}
|
|
if ( (bitField & WRITEDESC_BITMASK ) != 0 )
|
|
{
|
|
int dlen = is.readByte(); description = new byte[dlen]; is.readFully( description );
|
|
bodySize -= 1 + dlen;
|
|
}
|
|
if ( (bitField & NODEDESC_BITMASK ) != 0 )
|
|
{
|
|
int dlen = is.readByte(); nodeDescription = new byte[dlen]; is.readFully( nodeDescription );
|
|
bodySize -= 1 + dlen;
|
|
}
|
|
if ( (bitField & SKIPDETAILS_BITMASK ) != 0 )
|
|
{
|
|
link.counterLinkWritten = true;
|
|
}
|
|
|
|
if ( description == null && !link.counterLinkWritten ) throw new IllegalArgumentException( "internal error: missing way description!" );
|
|
|
|
boolean isTransfer = (bitField & TRANSFERNODE_BITMASK ) != 0;
|
|
if ( isTransfer )
|
|
{
|
|
OsmTransferNode trans = new OsmTransferNode();
|
|
trans.ilon = linklon;
|
|
trans.ilat = linklat;
|
|
trans.descriptionBitmap = description;
|
|
bodySize -= 2;
|
|
trans.selev = is.readShort();
|
|
if ( lastTransferNode == null )
|
|
{
|
|
firstTransferNode = trans;
|
|
}
|
|
else
|
|
{
|
|
lastTransferNode.next = trans;
|
|
}
|
|
lastTransferNode = trans;
|
|
}
|
|
else
|
|
{
|
|
link.descriptionBitmap = description;
|
|
break;
|
|
}
|
|
}
|
|
|
|
// performance shortcut: ignore link if out of reach
|
|
if ( dc != null && !link.counterLinkWritten )
|
|
{
|
|
if ( !dc.isWithinRadius( ilon, ilat, firstTransferNode, linklon, linklat ) )
|
|
{
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if ( linklon == ilon && linklat == ilat )
|
|
{
|
|
continue; // skip self-ref
|
|
}
|
|
|
|
if ( lastlink == null )
|
|
{
|
|
firstlink = link;
|
|
}
|
|
else
|
|
{
|
|
lastlink.next = link;
|
|
}
|
|
lastlink = link;
|
|
|
|
|
|
long targetNodeId = ((long)linklon)<<32 | linklat;
|
|
OsmNode tn = hollowNodes.get( targetNodeId ); // target node
|
|
|
|
if ( tn == null )
|
|
{
|
|
// node not yet known, create a hollow proxy
|
|
tn = new OsmNode(linklon, linklat);
|
|
tn.setHollow();
|
|
hollowNodes.put( targetNodeId, tn );
|
|
}
|
|
else
|
|
{
|
|
if ( !( tn.isHollow() || tn.hasHollowLinks() ) )
|
|
{
|
|
hollowNodes.registerCompletedNode( tn );
|
|
}
|
|
}
|
|
link.targetNode = tn;
|
|
|
|
link.encodeFirsttransfer(firstTransferNode);
|
|
|
|
// compute the reverse link
|
|
if ( !link.counterLinkWritten )
|
|
{
|
|
OsmLink rlink = new OsmLinkReverse();
|
|
|
|
rlink.ilonOrigin = tn.ilon;
|
|
rlink.ilatOrigin = tn.ilat;
|
|
rlink.targetNode = this;
|
|
rlink.descriptionBitmap = link.descriptionBitmap; // default for no transfer-nodes
|
|
OsmTransferNode previous = null;
|
|
OsmTransferNode rtrans = null;
|
|
for( OsmTransferNode trans = firstTransferNode; trans != null; trans = trans.next )
|
|
{
|
|
if ( previous == null )
|
|
{
|
|
rlink.descriptionBitmap = trans.descriptionBitmap;
|
|
}
|
|
else
|
|
{
|
|
previous.descriptionBitmap = trans.descriptionBitmap;
|
|
}
|
|
rtrans = new OsmTransferNode();
|
|
rtrans.ilon = trans.ilon;
|
|
rtrans.ilat = trans.ilat;
|
|
rtrans.selev = trans.selev;
|
|
rtrans.next = previous;
|
|
rtrans.descriptionBitmap = trans.descriptionBitmap;
|
|
previous = rtrans;
|
|
}
|
|
rlink.encodeFirsttransfer(rtrans);
|
|
rlink.next = firstreverse;
|
|
firstreverse = rlink;
|
|
}
|
|
|
|
}
|
|
|
|
if ( !hasHollowLinks() )
|
|
{
|
|
hollowNodes.registerCompletedNode( this );
|
|
}
|
|
}
|
|
|
|
public boolean isHollow()
|
|
{
|
|
return selev == -12345;
|
|
}
|
|
|
|
public void setHollow()
|
|
{
|
|
selev = -12345;
|
|
}
|
|
|
|
public long getIdFromPos()
|
|
{
|
|
return ((long)ilon)<<32 | ilat;
|
|
}
|
|
|
|
public boolean hasHollowLinks()
|
|
{
|
|
for( OsmLink link = firstlink; link != null; link = link.next )
|
|
{
|
|
if ( link.targetNode.isHollow() ) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
public int linkCnt()
|
|
{
|
|
int cnt = 0;
|
|
|
|
for( OsmLink link = firstlink; link != null; link = link.next )
|
|
{
|
|
cnt++;
|
|
}
|
|
return cnt;
|
|
}
|
|
|
|
public void unlinkLink( OsmLink link )
|
|
{
|
|
if ( link == firstlink )
|
|
{
|
|
firstlink = link.next;
|
|
return;
|
|
}
|
|
for( OsmLink l = firstlink; l != null; l = l.next )
|
|
{
|
|
if ( l.next == link )
|
|
{
|
|
l.next = link.next;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
// mark the link to the given node as written,
|
|
// don't want to write the counter-direction
|
|
// in full details
|
|
public void markLinkWritten( OsmNode t )
|
|
{
|
|
for( OsmLink link = firstlink; link != null; link = link.next )
|
|
{
|
|
if ( link.targetNode == t) link.counterLinkWritten = true;
|
|
}
|
|
}
|
|
|
|
public OsmLink getReverseLink( int lon, int lat )
|
|
{
|
|
for( OsmLink rlink = firstreverse; rlink != null; rlink = rlink.next )
|
|
{
|
|
if ( rlink.ilonOrigin == lon && rlink.ilatOrigin == lat )
|
|
{
|
|
unlinkRLink( rlink );
|
|
return rlink;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public void unlinkRLink( OsmLink rlink )
|
|
{
|
|
if ( rlink == firstreverse )
|
|
{
|
|
firstreverse = rlink.next;
|
|
return;
|
|
}
|
|
for( OsmLink l = firstreverse; l != null; l = l.next )
|
|
{
|
|
if ( l.next == rlink )
|
|
{
|
|
l.next = rlink.next;
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|