/*
* Copyright (C) 2006 Steve Ratcliffe
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
*
* Author: Steve Ratcliffe
* Create date: 07-Dec-2006
*/
package uk.me.parabola.imgfmt.app.trergn;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import uk.me.parabola.imgfmt.Utils;
import uk.me.parabola.imgfmt.app.Area;
import uk.me.parabola.imgfmt.app.Coord;
import uk.me.parabola.imgfmt.app.ImgFileReader;
import uk.me.parabola.imgfmt.app.ImgFileWriter;
import uk.me.parabola.imgfmt.app.Label;
import uk.me.parabola.imgfmt.app.lbl.LBLFile;
import uk.me.parabola.log.Logger;
/**
* The map is divided into areas, depending on the zoom level. These are
* known as subdivisions.
*
* A subdivision 'belongs' to a zoom level and cannot be interpreted correctly
* without knowing the <i>bitsPerCoord</i> of the associated zoom level.
*
* Subdivisions also form a tree as subdivisions are further divided at
* lower levels. The subdivisions need to know their child divisions
* because this information is represented in the map.
*
* @author Steve Ratcliffe
*/
public class Subdivision {
private static final Logger log = Logger.getLogger(Subdivision.class);
private static final int MAP_POINT = 0;
private static final int MAP_INDEXED_POINT = 1;
private static final int MAP_LINE = 2;
private static final int MAP_SHAPE = 3;
private final LBLFile lblFile;
private final RGNFile rgnFile;
// The start pointer is set for read and write. The end pointer is only
// set for subdivisions that are read from a file.
private int startRgnPointer;
private int endRgnPointer;
private int lastMapElement;
// The zoom level contains the number of bits per coordinate which is
// critical for scaling quantities by.
private final Zoom zoomLevel;
private boolean hasPoints;
private boolean hasIndPoints;
private boolean hasPolylines;
private boolean hasPolygons;
private int numPolylines;
// The location of the central point, not scaled AFAIK
private final int longitude;
private final int latitude;
// The width and the height in map units scaled by the bits-per-coordinate
// that applies at the map level.
private final int width;
private final int height;
private int number;
// Set if this is the last one.
private boolean last;
private final List<Subdivision> divisions = new ArrayList<>();
private int extTypeAreasOffset;
private int extTypeLinesOffset;
private int extTypePointsOffset;
private int extTypeAreasSize;
private int extTypeLinesSize;
private int extTypePointsSize;
/**
* Subdivisions can not be created directly, use either the
* {@link #topLevelSubdivision} or {@link #createSubdivision} factory
* methods.
*
* @param ifiles The internal files.
* @param area The area this subdivision should cover.
* @param z The zoom level.
*/
private Subdivision(InternalFiles ifiles, Area area, Zoom z) {
this.lblFile = ifiles.getLblFile();
this.rgnFile = ifiles.getRgnFile();
this.zoomLevel = z;
int shift = getShift();
int mask = getMask();
// Calculate the center, move it right and up so that it lies on a point
// which is divisible by 2 ^shift
this.latitude = Utils.roundUp((area.getMinLat() + area.getMaxLat())/2, shift);
this.longitude = Utils.roundUp((area.getMinLong() + area.getMaxLong())/2, shift);
int w = 2 * (longitude - area.getMinLong());
int h = 2 * (latitude - area.getMinLat());
// encode the values for the img format
w = ((w + 1)/2 + mask) >> shift;
h = ((h + 1)/2 + mask) >> shift;
if (w > 0x7fff) {
log.warn("Subdivision width is " + w + " at " + getCenter());
w = 0x7fff;
}
if (h > 0xffff) {
log.warn("Subdivision height is " + h + " at " + getCenter());
h = 0xffff;
}
this.width = w;
this.height = h;
}
private Subdivision(Zoom z, SubdivData data) {
lblFile = null;
rgnFile = null;
zoomLevel = z;
latitude = data.getLat();
longitude = data.getLon();
this.width = data.getWidth();
this.height = data.getHeight();
startRgnPointer = data.getRgnPointer();
endRgnPointer = data.getEndRgnOffset();
int elem = data.getFlags();
if ((elem & 0x10) != 0)
setHasPoints(true);
if ((elem & 0x20) != 0)
setHasIndPoints(true);
if ((elem & 0x40) != 0)
setHasPolylines(true);
if ((elem & 0x80) != 0)
setHasPolygons(true);
}
/**
* Create a subdivision at a given zoom level.
*
* @param ifiles The RGN and LBL ifiles.
* @param area The (unshifted) area that the subdivision covers.
* @param zoom The zoom level that this division occupies.
*
* @return A new subdivision.
*/
public Subdivision createSubdivision(InternalFiles ifiles,
Area area, Zoom zoom)
{
Subdivision div = new Subdivision(ifiles, area, zoom);
zoom.addSubdivision(div);
addSubdivision(div);
return div;
}
/**
* This should be called only once per map to create the top level
* subdivision. The top level subdivision covers the whole map and it
* must be empty.
*
* @param ifiles The LBL and RGN ifiles.
* @param area The area bounded by the map.
* @param zoom The zoom level which must be the highest (least detailed)
* zoom in the map.
*
* @return The new subdivision.
*/
public static Subdivision topLevelSubdivision(InternalFiles ifiles,
Area area, Zoom zoom)
{
Subdivision div = new Subdivision(ifiles, area, zoom);
zoom.addSubdivision(div);
return div;
}
/**
* Create a subdivision that only contains the number. This is only
* used when reading cities and similar such usages that do not really
* require the full subdivision to be present.
* @param number The subdivision number.
* @return An empty subdivision. Any operation other than getting the
* subdiv number is likely to fail.
*/
public static Subdivision createEmptySubdivision(int number) {
Subdivision sd = new Subdivision(null, new SubdivData(0,0,0,0,0,0,0));
sd.setNumber(number);
return sd;
}
public static Subdivision readSubdivision(Zoom zoom, SubdivData subdivData) {
return new Subdivision(zoom, subdivData);
}
public Zoom getZoom() {
return zoomLevel;
}
/**
* Get the shift value, that is the number of bits to left shift by for
* values that need to be saved shifted in the file. Related to the
* resolution.
*
* @return The shift value. It is 24 minus the number of bits per coord.
* @see #getResolution()
*/
public final int getShift() {
return 24 - zoomLevel.getResolution();
}
/**
* Get the shift mask. The bits that will be lost due to the resolution
* shift level.
*
* @return A bit mask with the lower <i>shift</i> bits set.
*/
protected int getMask() {
return (1 << getShift()) - 1;
}
/**
* Get the resolution of this division. Resolution goes from 1 to 24
* and the higher the number the more detail there is.
*
* @return The resolution.
*/
public final int getResolution() {
return zoomLevel.getResolution();
}
/**
* Format this record to the file.
*
* @param file The file to write to.
*/
public void write(ImgFileWriter file) {
log.debug("write subdiv", latitude, longitude);
file.put3(startRgnPointer);
file.put(getType());
file.put3(longitude);
file.put3(latitude);
assert width <= 0x7fff;
assert height <= 0xffff;
file.putChar((char) (width | ((last) ? 0x8000 : 0)));
file.putChar((char) height);
if (!divisions.isEmpty()) {
file.putChar((char) getNextLevel());
}
}
public Point createPoint(String name) {
Point p = new Point(this);
Label label = lblFile.newLabel(name);
p.setLabel(label);
return p;
}
public Polyline createLine(String[] labels) {
// don't be tempted to "trim()" the name as it zaps the highway shields
Label label = lblFile.newLabel(labels[0]);
String nameSansGC = Label.stripGarminCodes(labels[0]);
Polyline pl = new Polyline(this);
pl.setLabel(label);
if(labels[1] != null) {
// ref may contain multiple ids separated by ";"
int maxSetIdx = 3;
if (labels[3] == null) {
if (labels[2] == null) {
maxSetIdx = 1;
} else {
maxSetIdx = 2;
}
}
String[] refs = Arrays.copyOfRange(labels, 1, maxSetIdx+1);
if(refs.length == 1) {
// don't bother to add a single ref that looks the
// same as the name (sans shield) because it doesn't
// change the routing directions
String tr = refs[0].trim();
String trSansGC = Label.stripGarminCodes(tr);
if(trSansGC.length() > 0 &&
!trSansGC.equalsIgnoreCase(nameSansGC)) {
pl.addRefLabel(lblFile.newLabel(tr));
}
}
else if (refs.length > 1){
// multiple refs, always add the first so that it will
// be used in routing instructions when the name has a
// shield prefix
pl.addRefLabel(lblFile.newLabel(refs[0].trim()));
// only add the remaining refs if they differ from the
// name (sans shield)
for(int i = 1; i < refs.length; ++i) {
String tr = refs[i].trim();
String trSansGC = Label.stripGarminCodes(tr);
if(trSansGC.length() > 0 &&
!trSansGC.equalsIgnoreCase(nameSansGC)) {
pl.addRefLabel(lblFile.newLabel(tr));
}
}
}
}
return pl;
}
public void setPolylineNumber(Polyline pl) {
pl.setNumber(++numPolylines);
}
public Polygon createPolygon(String name) {
Label label = lblFile.newLabel(name);
Polygon pg = new Polygon(this);
pg.setLabel(label);
return pg;
}
public void setNumber(int n) {
number = n;
}
public void setLast(boolean last) {
this.last = last;
}
public void setStartRgnPointer(int startRgnPointer) {
this.startRgnPointer = startRgnPointer;
}
public int getStartRgnPointer() {
return startRgnPointer;
}
public int getEndRgnPointer() {
return endRgnPointer;
}
public int getLongitude() {
return longitude;
}
public int getLatitude() {
return latitude;
}
public void setHasPoints(boolean hasPoints) {
this.hasPoints = hasPoints;
}
public void setHasIndPoints(boolean hasIndPoints) {
this.hasIndPoints = hasIndPoints;
}
public void setHasPolylines(boolean hasPolylines) {
this.hasPolylines = hasPolylines;
}
public void setHasPolygons(boolean hasPolygons) {
this.hasPolygons = hasPolygons;
}
public boolean hasPoints() {
return hasPoints;
}
public boolean hasIndPoints() {
return hasIndPoints;
}
public boolean hasPolylines() {
return hasPolylines;
}
public boolean hasPolygons() {
return hasPolygons;
}
/**
* Needed if it exists and is not first, ie there is a points
* section.
* @return true if pointer needed
*/
public boolean needsIndPointPtr() {
return hasIndPoints && hasPoints;
}
/**
* Needed if it exists and is not first, ie there is a points or
* indexed points section.
* @return true if pointer needed.
*/
public boolean needsPolylinePtr() {
return hasPolylines && (hasPoints || hasIndPoints);
}
/**
* As this is last in the list it is needed if it exists and there
* is another section.
* @return true if pointer needed.
*/
public boolean needsPolygonPtr() {
return hasPolygons && (hasPoints || hasIndPoints || hasPolylines);
}
public String toString() {
return "Sub" + zoomLevel + '(' + getCenter().toOSMURL() + ')';
}
/**
* Get a type that shows if this area has lines, points etc.
*
* @return A code showing what kinds of element are in this subdivision.
*/
private byte getType() {
byte b = 0;
if (hasPoints)
b |= 0x10;
if (hasIndPoints)
b |= 0x20;
if (hasPolylines)
b |= 0x40;
if (hasPolygons)
b |= 0x80;
return b;
}
/**
* Get the number of the first subdivision at the next level.
* @return The first subdivision at the next level.
*/
private int getNextLevel() {
return divisions.get(0).getNumber();
}
public boolean hasNextLevel() {
return !divisions.isEmpty();
}
public int getExtTypeAreasOffset() {
return extTypeAreasOffset;
}
public int getExtTypeLinesOffset() {
return extTypeLinesOffset;
}
public int getExtTypePointsOffset() {
return extTypePointsOffset;
}
public int getExtTypeAreasSize() {
return extTypeAreasSize;
}
public int getExtTypeLinesSize() {
return extTypeLinesSize;
}
public int getExtTypePointsSize() {
return extTypePointsSize;
}
public void startDivision() {
rgnFile.startDivision(this);
extTypeAreasOffset = rgnFile.getExtTypeAreasSize();
extTypeLinesOffset = rgnFile.getExtTypeLinesSize();
extTypePointsOffset = rgnFile.getExtTypePointsSize();
}
public void endDivision() {
extTypeAreasSize = rgnFile.getExtTypeAreasSize() - extTypeAreasOffset;
extTypeLinesSize = rgnFile.getExtTypeLinesSize() - extTypeLinesOffset;
extTypePointsSize = rgnFile.getExtTypePointsSize() - extTypePointsOffset;
}
public void writeExtTypeOffsetsRecord(ImgFileWriter file) {
file.putInt(extTypeAreasOffset);
file.putInt(extTypeLinesOffset);
file.putInt(extTypePointsOffset);
int kinds = 0;
if(extTypeAreasSize != 0)
++kinds;
if(extTypeLinesSize != 0)
++kinds;
if(extTypePointsSize != 0)
++kinds;
file.put((byte)kinds);
}
public void writeLastExtTypeOffsetsRecord(ImgFileWriter file) {
file.putInt(rgnFile.getExtTypeAreasSize());
file.putInt(rgnFile.getExtTypeLinesSize());
file.putInt(rgnFile.getExtTypePointsSize());
file.put((byte)0);
}
/**
* Read offsets for extended type data and set sizes for predecessor sub-div.
* Corresponds to {@link #writeExtTypeOffsetsRecord(ImgFileWriter)}
* @param reader the reader
* @param sdPrev the pred. sub-div or null
*/
public void readExtTypeOffsetsRecord(ImgFileReader reader,
Subdivision sdPrev) {
extTypeAreasOffset = reader.getInt();
extTypeLinesOffset = reader.getInt();
extTypePointsOffset = reader.getInt();
reader.get();
if (sdPrev != null){
sdPrev.extTypeAreasSize = extTypeAreasOffset - sdPrev.extTypeAreasOffset;
sdPrev.extTypeLinesSize = extTypeLinesOffset - sdPrev.extTypeLinesOffset;
sdPrev.extTypePointsSize = extTypePointsOffset - sdPrev.extTypePointsOffset;
}
}
/**
* Set the sizes for the extended type data. See {@link #writeLastExtTypeOffsetsRecord(ImgFileWriter)}
*/
public void readLastExtTypeOffsetsRecord(ImgFileReader reader) {
extTypeAreasSize = reader.getInt() - extTypeAreasOffset;
extTypeLinesSize = reader.getInt() - extTypeLinesOffset;
extTypePointsSize = reader.getInt() - extTypePointsOffset;
byte test = reader.get();
assert test == 0;
}
/**
* Add this subdivision as our child at the next level. Each subdivision
* can be further divided into smaller divisions. They form a tree like
* arrangement.
*
* @param sd One of our subdivisions.
*/
private void addSubdivision(Subdivision sd) {
divisions.add(sd);
}
public int getNumber() {
return number;
}
/**
* We are starting to draw the points. These must be done first.
*/
public void startPoints() {
if (lastMapElement > MAP_POINT)
throw new IllegalStateException("Points must be drawn first");
lastMapElement = MAP_POINT;
}
/**
* We are starting to draw the lines. These must be done before
* polygons.
*/
public void startIndPoints() {
if (lastMapElement > MAP_INDEXED_POINT)
throw new IllegalStateException("Indexed points must be done before lines and polygons");
lastMapElement = MAP_INDEXED_POINT;
rgnFile.setIndPointPtr();
}
/**
* We are starting to draw the lines. These must be done before
* polygons.
*/
public void startLines() {
if (lastMapElement > MAP_LINE)
throw new IllegalStateException("Lines must be done before polygons");
lastMapElement = MAP_LINE;
rgnFile.setPolylinePtr();
}
/**
* We are starting to draw the shapes. This is done last.
*/
public void startShapes() {
lastMapElement = MAP_SHAPE;
rgnFile.setPolygonPtr();
}
/**
* Convert an absolute Lat to a local, shifted value
*/
public int roundLatToLocalShifted(int absval) {
int shift = getShift();
int val = absval - getLatitude();
val += ((1 << shift) / 2);
return (val >> shift);
}
/**
* Convert an absolute Lon to a local, shifted value
*/
public int roundLonToLocalShifted(int absval) {
int shift = getShift();
int val = absval - getLongitude();
val += ((1 << shift) / 2);
return (val >> shift);
}
public Coord getCenter(){
return new Coord(getLatitude(),getLongitude());
}
/**
* Get the unshifted width of the subdivision.
* @return The true (unshifted) width.
*/
public int getWidth() {
return width << getShift();
}
/**
* Get the unshifted height of the subdivision.
* @return The true (unshifted) height.
*/
public int getHeight() {
return height << getShift();
}
}