/* * Copyright 2010, 2011, 2012 mapsforge.org * * This program is free software: you can redistribute it and/or modify it under the * terms of the GNU Lesser General Public License as published by the Free Software * Foundation, either version 3 of the License, or (at your option) any later version. * * 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 Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public License along with * this program. If not, see <http://www.gnu.org/licenses/>. */ package org.mapsforge.map.writer.model; /** * Represents the configuration of zoom intervals. A zoom interval is defined by a base zoom level, a minimum zoom level * and a maximum zoom level. * * @author bross */ public final class ZoomIntervalConfiguration { private final byte[] baseZoom; private final byte[] minZoom; private final byte[] maxZoom; private final byte minMinZoom; private final byte maxMaxZoom; private ZoomIntervalConfiguration(byte[][] intervals) { this.baseZoom = new byte[intervals.length]; this.minZoom = new byte[intervals.length]; this.maxZoom = new byte[intervals.length]; int i = 0; for (byte[] interval : intervals) { i++; if (interval.length != 3) { throw new IllegalArgumentException("invalid interval configuration, found only " + interval.length + "parameters for interval " + i); } if (interval[0] < interval[1] || interval[0] > interval[2]) { throw new IllegalArgumentException("invalid configuration for interval " + i + ", make sure that minZoom < baseZoom < maxZoom"); } if (i > 1) { if (interval[0] < this.baseZoom[i - 2]) { throw new IllegalArgumentException("interval configurations must follow an increasing order"); } if (interval[1] != ((this.maxZoom[i - 2]) + 1)) { throw new IllegalArgumentException("minZoom of interval " + i + " not adjacent to maxZoom of interval " + (i - 1)); } } this.baseZoom[i - 1] = interval[0]; this.minZoom[i - 1] = interval[1]; this.maxZoom[i - 1] = interval[2]; } this.minMinZoom = this.minZoom[0]; this.maxMaxZoom = this.maxZoom[this.maxZoom.length - 1]; } /** * @return the standard configuration */ public static ZoomIntervalConfiguration getStandardConfiguration() { return new ZoomIntervalConfiguration(new byte[][] { new byte[] { 5, 0, 7 }, new byte[] { 10, 8, 11 }, new byte[] { 14, 12, 21 } }); } /** * Create a new ZoomIntervalConfiguration from the given byte array. Checks for validity. * * @param intervals * the intervals * @return a zoom interval configuration that represents the given intervals */ public static ZoomIntervalConfiguration newInstance(byte[]... intervals) { return new ZoomIntervalConfiguration(intervals); } /** * Create a new ZoomIntervalConfiguration from the given string representation. Checks for validity. * * @param confString * the string representation of a zoom interval configuration * @return a new zoom interval configuration */ public static ZoomIntervalConfiguration fromString(String confString) { String[] splitted = confString.split(","); if (splitted.length % 3 != 0) { throw new IllegalArgumentException( "invalid zoom interval configuration, amount of comma-separated values must be a multiple of 3"); } byte[][] intervals = new byte[splitted.length / 3][3]; for (int i = 0; i < intervals.length; i++) { intervals[i][0] = Byte.parseByte(splitted[i * 3]); intervals[i][1] = Byte.parseByte(splitted[i * 3 + 1]); intervals[i][2] = Byte.parseByte(splitted[i * 3 + 2]); } return ZoomIntervalConfiguration.newInstance(intervals); } /** * @return the minMinZoom */ public byte getMinMinZoom() { return this.minMinZoom; } /** * @return the maxMaxZoom */ public byte getMaxMaxZoom() { return this.maxMaxZoom; } /** * @return the number of zoom intervals */ public int getNumberOfZoomIntervals() { if (this.baseZoom == null) { return 0; } return this.baseZoom.length; } /** * @param index * the zoom interval index * @return the corresponding base zoom level */ public byte getBaseZoom(int index) { checkValidIndex(index); return this.baseZoom[index]; } private void checkValidIndex(int index) { if (index < 0 || index >= this.baseZoom.length) { throw new IllegalArgumentException("illegal zoom interval index: " + index); } } /** * @param index * the index * @return the corresponding max zoom level */ public byte getMaxZoom(int index) { checkValidIndex(index); return this.maxZoom[index]; } /** * @param index * the zoom interval index * @return the minimum zoom level for this index */ public byte getMinZoom(int index) { checkValidIndex(index); return this.minZoom[index]; } }