Application: gvSIG desktop » gvSIG raster

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.cache.tile.impl;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

import org.gvsig.raster.cache.tile.TileCache;

import org.gvsig.raster.cache.tile.TileCacheLibrary;

import org.gvsig.raster.cache.tile.TileCacheLocator;

import org.gvsig.raster.cache.tile.disk.ITileFileSystemStrategy;

import org.gvsig.raster.cache.tile.impl.layer.TiledLayerImpl;

import org.gvsig.raster.cache.tile.layer.TiledLayer;

import org.gvsig.raster.cache.tile.provider.TileServer;

/**

 * Main implementation for the tile cache

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class TileCacheImpl implements TileCache {

	private ArrayList<TiledLayerImpl>   layerList            = null;

	//private MemoryManager               memoryManager        = null;

	private String                      baseDir              = null;

	private double                      currentSize          = 0;

	protected String                    preffixSizeFileName  = "c_len";

	protected String                    configDir            = ".metadata";

	public TileCacheImpl(String baseDir) {

		this.layerList = new ArrayList<TiledLayerImpl>();

		//memoryManager = new MemoryManager();

		this.baseDir = baseDir;

		loadSize();

	}

	public void updateBaseDirectory(String dir) {

		this.baseDir = dir;

		for (int i = 0; i < layerList.size(); i++) {

			layerList.get(i).updateBaseDirectory(dir);

		}

	}

	/**

	 * Updates the size of the tiles downloaded

	 * @param sizeBytes

	 */

	public synchronized void updateSize(long sizeBytes) {

		currentSize +=  ((double)sizeBytes);

	}

	/**

	 * Loads the size of the directory

	 */

	private void loadSize() {

		File f = new File(baseDir + File.separator + configDir);

		if(!f.exists()) {

			f.mkdirs();

			saveSize();

		}

		String[] list = f.list();

		for (int i = 0; i < list.length; i++) {

			if(list[i].startsWith(preffixSizeFileName)) {

				String s = list[i].substring(5, list[i].length());

				try {

					currentSize = Double.valueOf(s);

				} catch (NumberFormatException e) {

				}

			}

		}

	}

	/**

	 * Saves a size file

	 * @throws IOException

	 */

	public synchronized void saveSize() {

		String dir = baseDir + File.separator + configDir;

		File f = new File(dir);

		if(!f.exists()) {

			f.mkdirs();

		}

		String[] list = f.list();

		if(list != null) {

			for (int i = 0; i < list.length; i++) {

				if(list[i].startsWith(preffixSizeFileName)) {

					new File(dir + File.separator + list[i]).delete();

				}

			}

		}

		try {

			new File(dir + File.separator + preffixSizeFileName + (int)currentSize).createNewFile();

		} catch (IOException e) {

		}

	}

	public boolean isFullDiskCache() {

		return currentSize >= (TileCacheLibrary.MAX_CACHE_SIZE *  1048576);

	}

	public TiledLayer createLayer(TileServer provider, String strategyType) {

		ITileFileSystemStrategy strat = ((DefaultTileCacheManager)TileCacheLocator.getManager()).createStrategy(strategyType);

		TiledLayerImpl l = new TiledLayerImpl(this, provider, strat/*, memoryManager.createLRUTileCache()*/);

		layerList.add(l);

		return l;

	}

	/**

	 * Gets the base directory

	 * @return

	 */

	public String getBaseDirectory() {

		return baseDir;

	}

	public String getConfigurationDirectory() {

		return configDir;

	}

	public void removeLayer(TiledLayer layer) {

		layerList.remove(layer);

		updateSize(-layer.delete());

		saveSize();

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.cache.tile.impl.memory;

/**

 * Manager for the memory distribution among different layers when the LRUTileCache

 * is used

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class MemoryManager {

	/**

	 * Gets a new LRUTileCache object

	 * @return

	 */

	public LRUTileCache createLRUTileCache() {

		return null;

	}

}

/* gvSIG Mini. A free mobile phone viewer of free maps.

 *

 * Copyright (C) 2009 Prodevelop.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *

 *   Prodevelop, S.L.

 *   Pza. Don Juan de Villarrasa, 14 - 5

 *   46001 Valencia

 *   Spain

 *

 *   +34 963 510 612

 *   +34 963 510 968

 *   prode@prodevelop.es

 *   http://www.prodevelop.es

 *

 *   gvSIG Mini has been partially funded by IMPIVA (Instituto de la Peque�a y

 *   Mediana Empresa de la Comunidad Valenciana) &

 *   European Union FEDER funds.

 *   

 *   2009.

 *   author Rub�n Blanco rblanco@prodevelop.es

 *

 *

 * Original version of the code made by Nicolas Gramlich.

 * No header license code found on the original source file.

 * 

 * Original source code downloaded from http://code.google.com/p/osmdroid/

 * package org.andnav.osm.views.util;

 * 

 * License stated in that website is 

 * http://www.gnu.org/licenses/lgpl.html

 * As no specific LGPL version was specified, LGPL license version is LGPL v2.1

 * is assumed.

 *  

 * 

 */

package org.gvsig.raster.cache.tile.impl.memory;

//import org.gvsig.raster.cache.buffer.Buffer;

/**

 * A Last Recent Used cache of Bitmaps

 * @author aromeu 

 * @author rblanco

 *

 */

public class LRUTileCache {

//	extends HashMap<String, Buffer> {

//	private static final long        serialVersionUID = 6215141;

//	private final int                maxCacheSize;

//	private LinkedList<String>       list             = null;

//	private final static Logger      log              = Logger.getLogger("LRUTileCache");

//

//	/**

//	 * The Constructor

//	 * @param maxCacheSize The cache size in number of Bitmaps

//	 */

//	public LRUTileCache(final int maxCacheSize) {

//		super(maxCacheSize);

//		this.maxCacheSize = Math.max(0, maxCacheSize);

//		this.list = new LinkedList<String>();

//	}

//

//	/**

//	 * Clears the cache

//	 */

//	public synchronized void clear() {		

//		try {

//			/*for (final Buffer b : this.values()) {

//				if (b != null) {

//					b.recycle();

//				}

//			}*/

//			super.clear();

//			list.clear();

//		} catch (Exception e) {

//			log.log(Level.SEVERE, "clear cache: ", e);

//		}

//	}

//

//	/**

//	 * Adds a Bitmap to the cache. If the cache is full, removes the last

//	 */

//	public synchronized Buffer put(final String key, final Buffer value) {

//		try {

//			if (maxCacheSize == 0) {

//				return null;

//			}

//

//			// if the key isn't in the cache and the cache is full...

//			if (!super.containsKey(key) && !list.isEmpty()

//					&& list.size() + 1 > maxCacheSize) {

//				final Object deadKey = list.removeLast();

//				super.remove(deadKey);

//				//if (bitmap != null)

//					//bitmap.recycle();

//			}

//

//			updateKey(key);			

//		} catch (Exception e) {

//			log.log(Level.SEVERE, "put", e);

//		}

//		return super.put(key, value);		

//	}

//

//	/**

//	 * Returns a cached Bitmap given a key

//	 * @param key The key of the Bitmap stored on the HashMap

//	 * @return The Bitmap or null if it is not stored in the cache

//	 */

//	public synchronized Buffer get(final String key) {

//		try {

//			final Buffer value = super.get(key);

//			if (value != null) {

//				updateKey(key);

//			}

//			return value;

//		} catch (Exception e) {

//			log.log(Level.SEVERE, "get",  e);

//			return null;

//		}		

//	} 

//

//	/**

//	 * Removes a Bitmap from the cache

//	 * @param key The key of the Bitmap to remove

//	 */

//	public synchronized void remove(final String key) {

//		try {

//			list.remove(key);			

//		} catch (Exception e) {

//			log.log(Level.SEVERE, "remove", e);			

//		}

//		super.remove(key);

//		//if (bitmap != null)

//			//bitmap.recycle();		

//	}

//

//	/**

//	 * The key is touched (recent used) and added to the top of the list

//	 * @param key The key to be updated

//	 */

//	private void updateKey(final String key) {

//		try {

//			list.remove(key);

//			list.addFirst(key);

//		} catch (Exception e) {

//			log.log(Level.SEVERE, "updatekey", e);

//		}		

//	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.cache.tile.impl.pool;

import java.util.Collections;

import java.util.LinkedList;

import org.gvsig.raster.cache.tile.Tile;

import org.gvsig.raster.cache.tile.exception.TileGettingException;

import org.gvsig.raster.cache.tile.pool.AtomicTask;

import org.gvsig.raster.cache.tile.pool.ThreadPool;

import org.gvsig.raster.cache.tile.pool.TilePipe;

import org.gvsig.raster.cache.tile.provider.TileListener;

/**

 * Pool of threads. This class contains a list of tasks and a limited number

 * of threads to execute them. When a thread is free will execute the next task 

 * in the list. 

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class ThreadPoolImpl implements ThreadPool {

	private int                        NTHREADS_POOL   = 5;

	private ThreadTask[]               threadList      = null;

	private LinkedList<AtomicTask>     tasks           = new LinkedList<AtomicTask>();

	private boolean                    priorityActive  = false;

	private TilePipe                   tilePipe        = null;

	/**

	 * Constructor. Only for testing purposes. After this constructor the method init

	 * has to be called

	 */

	public ThreadPoolImpl() {

		this.priorityActive = true;

		threadList = new ThreadTask[NTHREADS_POOL];

	}

	/**

	 * Constructor

	 * @param priorityActive true if the pool runs using priorities and false if doesn't

	 * @param nThreads Number of threads of this pool

	 */

	public ThreadPoolImpl(boolean priorityActive, int nThreads) {

		this.priorityActive = true;

		NTHREADS_POOL = nThreads;

		init();

	}

	/**

	 * Constructor

	 * @param priorityActive true if the pool runs using priorities and false if doesn't

	 */

	public ThreadPoolImpl(boolean priorityActive) {

		this.priorityActive = priorityActive;

		init();

	}

	public void init() {

		if(threadList == null)

			threadList = new ThreadTask[NTHREADS_POOL];

		for (int i = 0; i < NTHREADS_POOL; i++) {

			threadList[i] = new ThreadTask(this);

			threadList[i].start();

		}

	}

	/**

	 * Cancel the pool of threads and destroy the pool

	 * @param listener

	 */

	public void cancelPool(TileListener listener) {

		if(threadList != null) {

			for (int i = 0; i < NTHREADS_POOL; i++) {

				if(threadList[i] != null) {

					Runnable r = threadList[i].stopThread();

					try {

						if(listener != null)

							listener.tileReady((Tile)r);

					} catch (TileGettingException e) {

					}

				}

			}

		}

		for (int i = 0; i < tasks.size(); i++) {

			try {

				if(listener != null)

					listener.tileReady((Tile)tasks.get(i));

			} catch (TileGettingException e) {

			}

		}

		synchronized (tasks) {

			tasks.notifyAll();

		}

		destroyPool();

	}

	/**

	 * Cleans the input and output pool

	 * @param listener

	 */

	public void emptyPool() {

		//Don't get and set more tiles

		for (int i = 0; i < threadList.length; i++) {

			threadList[i].cancelTaskInProgress();

		}

		//Cleans queues

		synchronized (tasks) {

			tasks.clear();

			getTilePipe().clear();

			tasks.notifyAll();

		}

		//Gets tiles again

		for (int i = 0; i < threadList.length; i++) {

			threadList[i].resumeTasks();

		}

	}

	public LinkedList<AtomicTask> getInputTaskList() {

		return tasks;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.cache.tile.pool.ThreadPool#getTilePipe()

	 */

	public TilePipe getTilePipe() {

		if(tilePipe == null)

			tilePipe = new TilePipeImpl();

		return tilePipe;

	}

	/**

	 * Stops all threads in the list and sets the list to null

	 * @deprecated

	 */

	public void destroyPool() {

		for (int i = 0; i < NTHREADS_POOL; i++) {

			threadList[i].stopThread();

			threadList[i] = null;

		}

		threadList = null;

	}

	/**

	 * Returns true if the pool is valid

	 * @return

	 */

	public boolean isPoolValid() {

		return !(threadList == null);

	}

	/**

	 * Adds a new task to the list

	 * @param task

	 */

	public void addTask(AtomicTask task) {

		synchronized (tasks) {

			tasks.addLast(task);

			tasks.notify();

		}

	}

	/**

	 * Gets the next task in the list

	 * @return

	 */

	public AtomicTask getNext() {

		AtomicTask returnVal = null;

		synchronized (tasks) {

			while (tasks.isEmpty()) {

				try {

					tasks.wait();

				} catch (InterruptedException ex) {

					System.err.println("Interrupted");

				}

			}

			if(priorityActive)

				sort(tasks);

			returnVal = tasks.removeFirst();

		}

		return returnVal;

	}

	/**

	 * Sorts the array of tasks. Each atomic task have to implement AtomicTask interface

	 * which is Runnable and Comparable. The last one allow to sort the array 

	 * by priorities.

	 * @param tasks

	 */

	private void sort(LinkedList<AtomicTask> tasks) {

		Collections.sort(tasks);

	}

}

package org.gvsig.raster.cache.tile.impl.pool;

import org.gvsig.raster.cache.tile.pool.AtomicTask;

/**

 * This represents one thread in the pool. This thread gets a new task in

 * the pool and executes it.

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

class ThreadTask extends Thread {

	private ThreadPoolImpl pool         = null;

	private boolean        stop         = false;

	private AtomicTask     currentJob   = null; 

	private boolean        getMoreTiles = true;

	public ThreadTask(ThreadPoolImpl thePool) {

		pool = thePool;

	}

	public void run() {

		while (!stop) {

			if(getMoreTiles) {

				currentJob = pool.getNext();

				currentJob.run();

			} else {

				try {

					Thread.sleep(500);

				} catch (InterruptedException e) {

				}

			}

		}

	}

	/**

	 * Stops this thread

	 */

	public Runnable stopThread() {

		stop = true;

		return currentJob;

	}

	/**

	 * Cancels the task in progress and avoids that next tiles are gotten

	 */

	public void cancelTaskInProgress() {

		if(currentJob != null)

			currentJob.cancelTask();

		getMoreTiles = false;

	}

	/**

	 * Gets new tiles to processed of the input queue

	 */

	public void resumeTasks() {

		getMoreTiles = true;

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.cache.tile.impl.pool;

import java.util.LinkedList;

import java.util.Queue;

import org.gvsig.raster.cache.tile.Tile;

import org.gvsig.raster.cache.tile.pool.AtomicTask;

import org.gvsig.raster.cache.tile.pool.TilePipe;

/**

 * This class manages transactions between the producer and the consumer. The

 * producer download tiles from a server and the consumer is a tile provider

 * which will return downloaded tiles.

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class TilePipeImpl implements TilePipe {

	private boolean              isEmpty        = true;

	private Queue<AtomicTask>    buffer         = new LinkedList<AtomicTask>();

	private boolean              debug          = false;

	public TilePipeImpl() {

		this.debug = false;

	}

	public TilePipeImpl(boolean debug) {

		this.debug = debug;

	}

	/**

	 * Sets a tile in the pipe

	 * @param tile

	 */

	public synchronized void setAtomicTask(AtomicTask task) {

		if(task != null)

			buffer.add(task);

		isEmpty = false;

		if(debug)

			System.err.println("Setting tile " + ((Tile)task).getCol() + " " + ((Tile)task).getRow());

		notify();

	}

	/**

	 * Gets a tile from the pipe

	 * @return

	 */

	public synchronized AtomicTask getAtomicTask() {

		if(debug)

			System.out.println("0-Getting tile ");

		while( isEmpty == true ) {

			try {

				wait();

			} catch( InterruptedException e ) {

			}

		}

		AtomicTask task = buffer.poll() ;

		if(debug)

			System.out.println("1-Getting tile " + ((Tile)task).getCol() + " " + ((Tile)task).getRow());

		if( getSize() == 0 )

			isEmpty = true;

		return task;

	}

	/**

	 * Returns the number of elements in the queue

	 * @return

	 */

	public synchronized int getSize() {

		return buffer.size();

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.cache.tile.pool.TilePipe#clear()

	 */

	public void clear() {

		synchronized (buffer) {

			buffer.clear();

		}

	}

}

package org.gvsig.raster.cache.tile.impl.disk;

import org.gvsig.raster.cache.tile.disk.ITileFileSystemStrategy;

public abstract class DefaultFileSystemStrategy implements ITileFileSystemStrategy {

	private String              tileNameSuffix;

	private final static String DEFAULT_TILE_SUFFIX = ".tile.gvsig";

	public DefaultFileSystemStrategy() {

	}

	public DefaultFileSystemStrategy(String tileNameSuffix) {	

		this.tileNameSuffix = tileNameSuffix;	

	}

	public String getTileNameSuffix() {

		if (tileNameSuffix == null)

			return DEFAULT_TILE_SUFFIX;

		return this.tileNameSuffix;

	}

	public void setTileNameSuffix(String suffix) {

		this.tileNameSuffix = suffix;

	}

}

/* TileRasterCache, a library to download tiles from several sources.

 *

 * Copyright (C) 2010 Prodevelop SL.

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307,USA.

 *

 * For more information, contact:

 *  

 *   Prodevelop Integraci�n de Tecnolog�as SL

 *   Plaza don Juan de Vilarrasa , 14-5

 *   46000 Valencia

 *   Spain

 *

 *   +34 963 510 612

 *   +34 963 510 968

 *   gis@prodevelop.es

 *   http://www.prodevelop.es

 *   

 *   author: Alberto Romeu Carrasco (aromeu@prodevelop.es)

 */

package org.gvsig.raster.cache.tile.impl.disk;

import java.io.File;

/**

 * This IFileSystemStrategy creates a directory for each zoom level of a layer.

 * Inside the directory of a zoom level, creates a directory for each X row and

 * inside the directory of an X row stores a file with the Y row, so

 * OSM/0/0/0.tile represents the tile http://osm/0/0/0.png

 * 

 * This strategy is the most spread for mobile map viewers (although is not the most efficient)

 * @author aromeu

 *

 */

public class FlatXFileSystemStrategy extends DefaultFileSystemStrategy {

	public FlatXFileSystemStrategy() {

		super();

	}

	public FlatXFileSystemStrategy(String tileNameSuffix) {

		super(tileNameSuffix);		

	}

	public String getRelativeToLayerDirTilePath(int row, 

			int col, 

			int zoomLevel, 

			String var, 

			String z, 

			String time) {

		if(zoomLevel < 0) {  //Real zoom level

			return new StringBuffer()

			.append(var)

			.append(File.separator)

			.append(z)

			.append(File.separator)

			.append(time)

			.append(File.separator)

			.append("real")

			.append(File.separator)

			.append(col)

			.append(File.separator)

			.append(row).toString();

		} else {

			return new StringBuffer()

			.append(var)

			.append(File.separator)

			.append(z)

			.append(File.separator)

			.append(time)

			.append(File.separator)

			.append(zoomLevel)

			.append(File.separator)

			.append(col)

			.append(File.separator)

			.append(row).toString();

		}

	}

	public String getLayerNameSuffix() {

		return "_flatx";

	}	

	public String getName() {

		return FLATX;

	}	

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.cache.tile.impl.provider;

import java.awt.geom.Point2D;

/**

 * Limits of a tile matrix

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class TileMatrixLimits {

	private TileMatrix             tileMatrix           = null;

	private int                    minTileRow           = 0;

	private int                    maxTileRow           = 0;

	private int                    minTileCol           = 0;

	private int                    maxTileCol           = 0;

	public TileMatrix getTileMatrix() {

		if(tileMatrix == null)

			tileMatrix = new TileMatrix();

		return tileMatrix;

	}

	/**

	 * Gets the upper left corner and the lower right corner of the 

	 * selected tile

	 * @param x X tile position

	 * @param y Y tile position

	 * @return

	 */

	public Point2D[] getTileExtent(int x, int y) {

		double sizeTile = getTileMatrix().getTileWidth() * getTileMatrix().getScaleDenominator();

		double initX = getTileMatrix().getTopLeftCorner()[0] + (sizeTile * x);

		double initY = getTileMatrix().getTopLeftCorner()[1] - (sizeTile * y);

		Point2D[] p = new Point2D[2];

		p[0] = new Point2D.Double(initX, initY);

		p[1] = new Point2D.Double(initX + sizeTile, initY - sizeTile);

		return p;

	}

	public int getMinTileRow() {

		return minTileRow;

	}

	public void setMinTileRow(int minTileRow) {

		this.minTileRow = minTileRow;

	}

	public int getMaxTileRow() {

		return maxTileRow;

	}

	public void setMaxTileRow(int maxTileRow) {

		this.maxTileRow = maxTileRow;

	}

	public int getMinTileCol() {

		return minTileCol;

	}

	public void setMinTileCol(int minTileCol) {

		this.minTileCol = minTileCol;

	}

	public int getMaxTileCol() {

		return maxTileCol;

	}

	public void setMaxTileCol(int maxTileCol) {

		this.maxTileCol = maxTileCol;

	}

	public void print() {

		System.out.println("  *****TileMatrixLimits******");

		System.out.println("  MaxTileCol:" + getMaxTileCol());

		System.out.println("  MaxTileRow:" + getMaxTileRow());

		System.out.println("  MinTileCol:" + getMinTileCol());

		System.out.println("  MinTileRow:" + getMinTileRow());

		if(tileMatrix != null)

			tileMatrix.print();

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.cache.tile.impl.provider;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.raster.cache.tile.Tile;

import org.gvsig.raster.cache.tile.TileCacheLocator;

import org.gvsig.raster.cache.tile.disk.ITileFileSystemStrategy;

import org.gvsig.raster.cache.tile.exception.TileBuildException;

import org.gvsig.raster.cache.tile.impl.TileImpl;

import org.gvsig.raster.cache.tile.provider.CacheStruct;

/**

 * Implementation for a structure of a cache

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class DefaultCacheStruct implements CacheStruct {

    private TileMatrixSet                 tileMatrixSet  = null;

    private ArrayList<TileMatrixLimits>   limits         = null;

    private String                        layerName      = null;

    private String                        uri            = null;

	private Rectangle2D                   worldExtent    = null;

	private String                        fileSuffix     = null;

	private String                        epsg           = null;

	private long                          fileSize       = 0;

	private double                        realPixelSize  = 0;

	private Rectangle2D                   layerExtent    = null;

    public DefaultCacheStruct(int typeOfCoords, 

    		int levels, 

    		Rectangle2D layerExtent, 

    		double pixelSize,

    		int tilePxWidth,

    		int tilePxHeight,

    		String uri,

    		String layerName,

    		ITileFileSystemStrategy strategy,

    		String baseDir,

    		String fileSuffix,

    		String epsg,

    		long size) {

    	this.uri = uri;

    	this.layerName = layerName;

    	this.fileSuffix = fileSuffix;

    	this.fileSize = size;

    	this.realPixelSize = pixelSize;

    	this.layerExtent = layerExtent;

    	if(epsg != null && epsg.startsWith("EPSG:"))

    		this.epsg = epsg;

    	//Coordenadas del mundo en geogr�ficas y planas

    	if(typeOfCoords == CacheStruct.GEOGRAFIC) {

    		worldExtent = new Rectangle2D.Double(-180, -90, 360, 180);

    	} 

    	if(typeOfCoords == CacheStruct.FLAT) {

    		worldExtent = new Rectangle2D.Double(-20037508, -20037508, 40075016, 40075016);

    	}

    	double[] pixelSizeList = buildWorldMatrix(typeOfCoords, levels, tilePxWidth, tilePxHeight, worldExtent);

        buildLayerMatrix(levels, tilePxWidth, tilePxHeight, worldExtent, layerExtent, pixelSizeList, pixelSize);

    }

    private void buildLayerMatrix(int levels, 

    		int tilePxWidth, 

    		int tilePxHeight,

    		Rectangle2D worldExtent,

    		Rectangle2D layerExtent,

    		double[] pixelSizeList,

    		double maxPixelSize) {

    	limits = new ArrayList<TileMatrixLimits>();

    	for (int i = 0; i < levels; i++) {

    		//Calculo de tiles para ese nivel en la capa actual

    		int minTileCol = (int)(Math.abs(layerExtent.getMinX() - worldExtent.getMinX()) / pixelSizeList[i]) / tilePxWidth;

    		int minTileRow = (int)(Math.abs(layerExtent.getMaxY() - worldExtent.getMaxY()) / pixelSizeList[i]) / tilePxHeight;

    		int maxTileCol = (int)(Math.abs(layerExtent.getMaxX() - worldExtent.getMinX()) / pixelSizeList[i]) / tilePxWidth;

    		int maxTileRow = (int)(Math.abs(layerExtent.getMinY() - worldExtent.getMaxY()) / pixelSizeList[i]) / tilePxHeight;

    		//int imageTileWidth = (int)Math.ceil((layerExtent.getWidth() / pixelSizeList[i]) / tilePxWidth);

    		//int imageTileHeight = (int)Math.ceil((layerExtent.getHeight() / pixelSizeList[i]) / tilePxHeight);

    		TileMatrixLimits limit = new TileMatrixLimits();

    		limit.setMinTileRow(minTileRow);

    		limit.setMinTileCol(minTileCol);

    		limit.setMaxTileRow(maxTileRow);

    		limit.setMaxTileCol(maxTileCol);

    		//Calcula las coordenadas de la esquina superior izquierda del TileMatrixLimits

    		double ulx = worldExtent.getMinX() + (minTileCol * tilePxWidth * pixelSizeList[i]);

    		double uly = worldExtent.getMaxY() - (minTileRow * tilePxHeight * pixelSizeList[i]);

    		limit.getTileMatrix().setTopLeftCorner(new double[]{ulx, uly});

    		limit.getTileMatrix().setScaleDenominator(pixelSizeList[i]);

    		limit.getTileMatrix().setTileWidth(tilePxWidth);

    		limit.getTileMatrix().setTileHeight(tilePxHeight);

    		limits.add(limit);

    		if(i == (levels - 1) || (maxPixelSize != Double.POSITIVE_INFINITY && maxPixelSize != Double.NEGATIVE_INFINITY && pixelSizeList[i] < maxPixelSize)) {

    			//System.out.println("Image res:" + maxPixelSize + " Real res:" + pixelSizeList[i]);

    			break;

    		}

    	}

    }

    private double[] buildWorldMatrix(int typeOfCoords,

    		int levels, 

    		int tilePxWidth, 

    		int tilePxHeight,

    		Rectangle2D worldExtent) {

    	double[] pixelSizeList = new double[levels];

    	limits = new ArrayList<TileMatrixLimits>();

    	tileMatrixSet = new TileMatrixSet();

    	tileMatrixSet.setBbox(worldExtent);

    	int nTilesWidth = 0;

    	int nTilesHeight = 0;

    	for (int i = 0; i < levels; i++) {

    		TileMatrix tm = new TileMatrix();

    		tm.setTileWidth(tilePxWidth);

    		tm.setTileHeight(tilePxHeight);

    		if(i == 0) {

    			nTilesWidth = (typeOfCoords == CacheStruct.FLAT) ? 1 : 2;

    			nTilesHeight = 1;

    		} else {

    			nTilesWidth *= 2;

    			nTilesHeight *= 2;

    		}

    		tm.setMatrixWidth(nTilesWidth);

    		tm.setMatrixHeight(nTilesHeight);

    		if(tilePxWidth > 0 && nTilesWidth > 0)

    			pixelSizeList[i] = worldExtent.getWidth() / ((long)tilePxWidth * (long)nTilesWidth);

    		else

    			pixelSizeList[i] = 0;

    		//System.out.println("-Level:" + i + " " + nTilesWidth + " " + nTilesHeight + " " + pixelSizeList[i]);

    		tm.setScaleDenominator(pixelSizeList[i]);

    		tileMatrixSet.getTileMatrix().add(tm);

    	}

    	return pixelSizeList;

    }

    public Rectangle2D getWorldExtent() {

    	return worldExtent;

    }

	public int getNumberOfLevels() {

		return tileMatrixSet.getTileMatrix().size();

	}

	public String getLayerName() {

		return layerName;

	}

	public String getServerURL() {

		return uri;

	}

	public String getFileSuffix() {

		return fileSuffix;

	}

	public int[] getTileSizeByLevel(int level) {

		return new int[] {

			tileMatrixSet.getTileMatrix().get(level).getTileWidth(),

			tileMatrixSet.getTileMatrix().get(level).getTileHeight()

		};

	}

	public double[] getTileSizeInRealCoordsByLevel(int level) {

		return new double[] {

				getPixelSizeByLevel(level) * tileMatrixSet.getTileMatrix().get(level).getTileWidth(),

				getPixelSizeByLevel(level) *  tileMatrixSet.getTileMatrix().get(level).getTileHeight()

			};

	}

	public int getLayerWidthOfTileMatrixByLevel(int level) {

		if(level < limits.size()) {

			TileMatrixLimits l = limits.get(level);

			return (l.getMaxTileRow() - l.getMinTileRow()) + 1;

		}

		return 0;

	}

	public int getLayerHeightOfTileMatrixByLevel(int level) {

		if(level < limits.size()) {

			TileMatrixLimits l = limits.get(level);

			return (l.getMaxTileCol() - l.getMinTileCol()) + 1;

		}

		return 0;

	}

	public int getLayerInitXTilePositionByLevel(int level) {

		TileMatrixLimits l = limits.get(level);

		return l.getMinTileCol();

	}

	public int getLayerInitYTilePositionByLevel(int level) {

		TileMatrixLimits l = limits.get(level);

		return l.getMinTileRow();

	}

	public long getWorldHeightOfTileMatrixByLevel(int level) {

		return tileMatrixSet.getTileMatrix().get(level).getMatrixWidth();

	}

	public long getWorldWidthOfTileMatrixByLevel(int level) {

		return tileMatrixSet.getTileMatrix().get(level).getMatrixHeight();

	}

	public double getPixelSizeByLevel(int level) {

		if(level < 0)

			return realPixelSize;

		return tileMatrixSet.getTileMatrix().get(level).getScaleDenominator();

	}

	public Point2D[] getTileExtent(Tile tile) {

		return limits.get(tile.getLevel()).getTileExtent(tile.getRow(), tile.getCol());

	}

	public Point2D[] getTileExtent(int level, int col, int row) {

		return limits.get(level).getTileExtent(row, col);

	}

	public Tile getTileStructure(int level, int tileCol, int tileRow, Point2D ul, Point2D lr) throws TileBuildException  {

		int[] size = getTileSizeByLevel(level);

		Tile tile = TileCacheLocator.getManager().createTile(level, tileRow, tileCol);

		tile.setUl(ul);

		tile.setLr(lr);

		tile.setWidthPx(size[0]);

		tile.setHeightPx(size[1]);

		return tile;

	}

	public List<Tile> getTileList(Rectangle2D r) {

		int tilePxWidth = tileMatrixSet.getTileMatrix().get(0).getTileWidth();

		int tilePxHeight = tileMatrixSet.getTileMatrix().get(0).getTileHeight();

		int minTileCol = (int)(r.getX() / tilePxWidth);

		int minTileRow = (int)(r.getY() / tilePxHeight);

		int maxTileCol = (int)((r.getX() + r.getWidth()) / tilePxWidth);

		int maxTileRow = (int)((r.getY() + r.getHeight()) / tilePxHeight);

		double tileWCWidth = tilePxWidth * realPixelSize;

		double tileWCHeight = tilePxHeight * realPixelSize;

		//Calculo de tiles con sus coordenadas

		List<Tile> tileList = new ArrayList<Tile>();

		for (int i = minTileRow; i <= maxTileRow; i++) {

			for (int j = minTileCol; j <= maxTileCol; j++) {

				Point2D ulTile = new Point2D.Double(

						layerExtent.getMinX() + (tileWCWidth * j),

						layerExtent.getMaxY() - (tileWCHeight * i));

				Point2D lrTile = new Point2D.Double(ulTile.getX() + tileWCWidth, ulTile.getY() - tileWCHeight);

				Tile t = new TileImpl(tilePxWidth, tilePxHeight, i, j, ulTile, lrTile);

				t.setLevel(-1);

				int initTileX = tilePxWidth * j;

				int initTileY = tilePxHeight * i;

				Rectangle2D rTile = new Rectangle2D.Double(initTileX, initTileY, tilePxWidth, tilePxHeight);

				t.setCoordsPx(rTile);

				tileList.add(t);

			}

		}

		return tileList;

	}

	public List<Tile> getTileList(Point2D ul, Point2D lr, double mtsPixelRequest) {

		return getTileList(ul, lr, mtsPixelRequest, false);

	}

	public List<Tile> getTileList(Point2D ul, Point2D lr, double mtsPixelRequest, boolean increaseResolution) {

		//Selecci?n de nivel de resoluci?n

		int tilePxWidth = 0;

		int tilePxHeight = 0;

		double tileWCWidth = 0;

		double tileWCHeight = 0;

		int level = 0;

		double mtsPixelLevel = 0;

		boolean levelAssigned = false;

		for (int i = 0; i < tileMatrixSet.getTileMatrix().size(); i++) {

			mtsPixelLevel = tileMatrixSet.getTileMatrix().get(i).getScaleDenominator();

			if(clipDecimals(mtsPixelRequest, 6) >= clipDecimals(mtsPixelLevel, 6) || 

			   (!levelAssigned && i == (tileMatrixSet.getTileMatrix().size() - 1))) {

				level = Math.max(i, 0);

				if(increaseResolution)

					level ++;

				//Se ajusta al m?ximo nivel disponible para esa capa

				if(level > (limits.size() - 1)) {

					level = limits.size() - 1;

				}

				mtsPixelLevel = tileMatrixSet.getTileMatrix().get(level).getScaleDenominator();

				tilePxWidth = tileMatrixSet.getTileMatrix().get(level).getTileWidth();

				tilePxHeight = tileMatrixSet.getTileMatrix().get(level).getTileHeight();

				tileWCWidth = tilePxWidth * mtsPixelLevel;

				tileWCHeight = tilePxHeight * mtsPixelLevel;

				levelAssigned = true;

				break;

			}

		}

		//Calculo del rectangulo de tiles

		int minTileCol = (int)((Math.abs(ul.getX() - worldExtent.getMinX()) / mtsPixelLevel) / tilePxWidth);

		int minTileRow = (int)((Math.abs(ul.getY() - worldExtent.getMaxY()) / mtsPixelLevel) / tilePxHeight);

		double maxTC = ((Math.abs(lr.getX() - worldExtent.getMinX()) / mtsPixelLevel) / tilePxWidth);

		double maxTR = ((Math.abs(lr.getY() - worldExtent.getMaxY()) / mtsPixelLevel) / tilePxHeight);

		int maxTileCol = ((maxTC - ((int)maxTC)) == 0) ? (int)(maxTC - 1) : (int)maxTC;

		int maxTileRow = ((maxTR - ((int)maxTR)) == 0) ? (int)(maxTR - 1) : (int)maxTR;

		//Calculo de tiles con sus coordenadas

		List<Tile> tileList = new ArrayList<Tile>();

		for (int i = minTileRow; i <= maxTileRow; i++) {

			for (int j = minTileCol; j <= maxTileCol; j++) {

				Point2D ulTile = new Point2D.Double(

						worldExtent.getMinX() + (tileWCWidth * j),

						worldExtent.getMaxY() - (tileWCHeight * i));

				Point2D lrTile = new Point2D.Double(ulTile.getX() + tileWCWidth, ulTile.getY() - tileWCHeight);

				Tile t = new TileImpl(tilePxWidth, tilePxHeight, i, j, ulTile, lrTile);

				t.setLevel(level);

				tileList.add(t);

			}

		}

		return tileList;

	}

	public boolean compare(CacheStruct struct) {

		//Compara: n?mero de niveles, tama?o de tile, 

		//anchoXalto de la matriz, tama?o de pixel por nivel, 

		//coordenadas de al menos un tile de la matriz

		if(struct.getNumberOfLevels() == getNumberOfLevels()) {

			for (int i = 0; i < getNumberOfLevels(); i++) {

				if(	struct.getTileSizeByLevel(i)[0] == getTileSizeByLevel(i)[0] && 

					struct.getTileSizeByLevel(i)[1] == getTileSizeByLevel(i)[1] &&

					struct.getWorldHeightOfTileMatrixByLevel(i) == getWorldHeightOfTileMatrixByLevel(i) &&

					struct.getWorldWidthOfTileMatrixByLevel(i) == getWorldWidthOfTileMatrixByLevel(i) &&

					clipDecimals(struct.getPixelSizeByLevel(i), 2) == clipDecimals(getPixelSizeByLevel(i), 2) &&

					compareExtents(struct.getTileExtent(i, 0, 0), getTileExtent(i, 0, 0))) {

					return true;

				}

			}

		}

		return false;

	}

	public String getEPSG() {

		return epsg;

	}

	public String getFileSize() {

		return fileSize + "";

	}

	private boolean compareExtents(Point2D[] p, Point2D[] p1) {

		return (p[0].getX() == p1[0].getX() && p[0].getY() == p1[0].getY() &&

				p[1].getX() == p1[1].getX() && p[1].getY() == p1[1].getY());

	}

	public double clipDecimals(double num, int n) {

		long m = (long) Math.pow(10, n);

		long aux = Math.round(num * m);

		return (double) aux / (double) m;

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.cache.tile.impl.provider;

import java.awt.geom.Rectangle2D;

import java.io.IOException;

import java.util.ArrayList;

import org.kxml2.io.KXmlParser;

import org.xmlpull.v1.XmlPullParserException;

/**

 * <p>Defines a set of tiles</p>