Application: gvSIG desktop » gvSIG raster

<?xml version="1.0" encoding="ISO-8859-1"?>

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">

    <modelVersion>4.0.0</modelVersion>

    <artifactId>org.gvsig.raster.cache</artifactId>

    <packaging>pom</packaging>

    <name>org.gvsig.raster.cache</name>

    <description>Cache management for raster files</description>

    <version>2.2.49</version>

    <scm>

        <connection>scm:svn:https://devel.gvsig.org/svn/gvsig-raster/org.gvsig.raster.cache/tags/org.gvsig.raster.cache-2.2.49</connection>

        <developerConnection>scm:svn:https://devel.gvsig.org/svn/gvsig-raster/org.gvsig.raster.cache/tags/org.gvsig.raster.cache-2.2.49</developerConnection>

        <url>https://devel.gvsig.org/redmine/projects/gvsig-raster/repository/show/org.gvsig.raster.cache/tags/org.gvsig.raster.cache-2.2.49</url>

    </scm>

    <repositories>

      <repository>

        <id>gvsig-public-http-repository</id>

        <name>gvSIG maven public HTTP repository</name>

        <url>http://devel.gvsig.org/m2repo/j2se</url>

        <releases>

          <enabled>true</enabled>

          <updatePolicy>daily</updatePolicy>

          <checksumPolicy>warn</checksumPolicy>

        </releases>

        <snapshots>

          <enabled>true</enabled>

          <updatePolicy>daily</updatePolicy>

          <checksumPolicy>warn</checksumPolicy>

        </snapshots>

      </repository>

    </repositories>

    <parent>

      <groupId>org.gvsig</groupId>

      <artifactId>org.gvsig.desktop</artifactId>

      <version>2.0.274</version>

    </parent>

    <developers>

        <developer>

            <id>nbrodin</id>

            <name>Nacho Brodin</name>

            <email>nachobrodin@gmail.com</email>

            <roles>

                <role>Architect</role>

                <role>Developer</role>

            </roles>

        </developer>

    </developers>

     <dependencyManagement>

        <dependencies>

            <!--

            Versions of child projects

            -->

            <dependency>

                <groupId>org.gvsig</groupId>

                <artifactId>org.gvsig.raster.cache.lib.api</artifactId>

                <version>2.2.49</version>

            </dependency>

            <dependency>

                <groupId>org.gvsig</groupId>

                <artifactId>org.gvsig.raster.cache.lib.impl</artifactId>

                <version>2.2.49</version>

            </dependency>

        </dependencies>

    </dependencyManagement>

    <build>

        <plugins>

            <plugin>

                <groupId>org.apache.maven.plugins</groupId>

                <artifactId>maven-release-plugin</artifactId>

                <configuration>

                    <tagBase>https://devel.gvsig.org/svn/gvsig-raster/org.gvsig.raster.cache/tags/</tagBase>

                    <goals>deploy</goals>

                </configuration>

            </plugin>

            <plugin>

				<groupId>org.apache.maven.plugins</groupId>

				<artifactId>maven-compiler-plugin</artifactId>

				<configuration>

					<source>1.5</source>

					<target>1.5</target>

				</configuration>

			</plugin>

			<plugin>

                <groupId>org.codehaus.mojo</groupId>

                <artifactId>animal-sniffer-maven-plugin</artifactId>

                <configuration>

                    <skip>true</skip>

                </configuration>

            </plugin>

        </plugins>

    </build>

    <modules>

        <module>org.gvsig.raster.cache.lib.api</module>

        <module>org.gvsig.raster.cache.lib.impl</module>

    </modules>

</project>

org.gvsig.raster.cache.tile.impl.TileCacheDefaultImplLibrary

/* 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();

		}

	}

}

/* 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;

	}	

}

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;

	}

}

/* 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;

/**

 * Description of a tile matrix

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

 */

public class TileMatrix {

    private double                      scaleDenominator    = 0;

    private double[]                    topLeftCorner       = null;

    private int                         tileWidth           = 0;

    private int                         tileHeight          = 0;

    private long                        matrixWidth         = 0;

    private long                        matrixHeight        = 0;

    private static final double         MTS_X_GRADO         = 111319.490793274;

	public double getScaleDenominator() {

		return scaleDenominator;

	}

	public void setScaleDenominator(double scaleDenominator) {

		this.scaleDenominator = scaleDenominator;

	}

	public int getTileWidth() {

		return tileWidth;

	}

	public void setTileWidth(int tileWidth) {

		this.tileWidth = tileWidth;

	}

	public int getTileHeight() {

		return tileHeight;

	}

	public void setTileHeight(int tileHeight) {

		this.tileHeight = tileHeight;

	}

	public long getMatrixWidth() {

		return matrixWidth;

	}

	public void setMatrixWidth(long matrixWidth) {

		this.matrixWidth = matrixWidth;

	}

	public long getMatrixHeight() {

		return matrixHeight;

	}

	public void setMatrixHeight(long matrixHeight) {

		this.matrixHeight = matrixHeight;

	}

	public double[] getTopLeftCorner() {

		return topLeftCorner;

	}

	public void setTopLeftCorner(double[] topLeftCorner) {

		this.topLeftCorner = topLeftCorner;

	}

    /**

     * Gets the width in meters of a tile

     * @param projected

     * @return

     */

    public double getWidthMtsTile(boolean projected) {

    	if(!projected) {

    		return (scaleDenominator * tileWidth * 0.00028) / MTS_X_GRADO;

    	} else {

    		return (scaleDenominator * tileWidth * 0.00028);

    	}

    }

    /**

     * Gets the height in meters of a tile

     * @param projected

     * @return

     */

    public double getHeightMtsTile(boolean projected) {

    	if(!projected) {

    		return (scaleDenominator * tileHeight * 0.00028) / MTS_X_GRADO;

    	} else {

    		return (scaleDenominator * tileHeight * 0.00028);

    	}

    }

	public void print() {

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

		System.out.println("   scaleDenominator:" + getScaleDenominator());

		if(topLeftCorner != null)

			System.out.println("   topLeftCorner:" + topLeftCorner[0] + ", " + topLeftCorner[1]);

		System.out.println("   tileWidth:" + getTileWidth());

		System.out.println("   tileHeight:" + getTileHeight());

		System.out.println("   matrixWidth:" + getMatrixWidth());

		System.out.println("   matrixHeight:" + getMatrixHeight());

	}

}

/* 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>

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

 */

public class TileMatrixSet {

    protected Rectangle2D                 bbox                = null;

    private String                        supportedCRS        = null;

    protected ArrayList<TileMatrix>       tileMatrix          = null;

	public void setBbox(Rectangle2D bbox) {

		this.bbox = bbox;

	}

    public Rectangle2D getBoundingBox() {

    	return bbox;

    }

	public ArrayList<TileMatrix> getTileMatrix() {

		if(tileMatrix == null)

			tileMatrix = new ArrayList<TileMatrix>();

		return tileMatrix;

	}

	public String getSupportedCRS() {

		return supportedCRS;

	}

	public void setSupportedCRS(String supportedCRS) {

		this.supportedCRS = supportedCRS;

	}

	public void parse(KXmlParser parser) throws IOException,

			XmlPullParserException {

	}

	public void print() {

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

		if(bbox != null)

			System.out.println(bbox.toString());

		System.out.println("supportedCRS:" + getSupportedCRS());

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

			((TileMatrix)tileMatrix.get(i)).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.layer;

import java.io.File;

import java.security.MessageDigest;

import java.security.NoSuchAlgorithmException;

import java.util.List;

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

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

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

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

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

import org.gvsig.raster.cache.tile.impl.pool.ThreadPoolImpl;

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

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

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

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

import org.gvsig.tools.task.TaskStatus;

/**

 * Main implementation for the tile cache

 *

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

 */

public class TiledLayerImpl implements TiledLayer {

	private TileServer                  provider          = null;

	private TileCacheImpl               tileCache         = null;

	private String                      basePath          = null;

	private String                      pathToDirLayer    = null;

	private String                      idLayer           = null;

	//private LRUTileCache                memoryCache = null;

	private ThreadPoolImpl              pool              = null;

	private ITileFileSystemStrategy     strategy          = null;

	private TimerOneTile                timerOneTile      = null;

	private TimerTilePool               timerTilePool     = null;

	public TiledLayerImpl(TileCacheImpl tileCache, 

			TileServer provider, 

			ITileFileSystemStrategy strategy

			/*LRUTileCache memCache*/) {

		this.tileCache = tileCache;

		this.provider = provider;

		this.basePath = tileCache.getBaseDirectory();

		//this.memoryCache = memCache;

		this.strategy = strategy;

	}

	/**

	 * Gets the timer of one tile

	 * @return

	 */

	private TimerOneTile getTimerOneTile() {

		if(timerOneTile == null)

			timerOneTile = new TimerOneTile();