Application: gvSIG desktop » gvSIG 3D

# Locate gdal

# This module defines

# GDAL_LIBRARY

# GDAL_FOUND, if false, do not try to link to gdal 

# GDAL_INCLUDE_DIR, where to find the headers

#

# $GDALDIR is an environment variable that would

# correspond to the ./configure --prefix=$GDAL_DIR

# used in building gdal.

#

# Created by Eric Wing. I'm not a gdal user, but OpenSceneGraph uses it 

# for osgTerrain so I whipped this module together for completeness.

# I actually don't know the conventions or where files are typically

# placed in distros.

# Any real gdal users are encouraged to correct this (but please don't

# break the OS X framework stuff when doing so which is what usually seems 

# to happen).

# This makes the presumption that you are include gdal.h like

# #include "gdal.h"

FIND_PATH(GDAL_INCLUDE_DIR gdal.h

  PATHS

  $ENV{GDAL_DIR}

  NO_DEFAULT_PATH

    PATH_SUFFIXES include

)

FIND_PATH(GDAL_INCLUDE_DIR gdal.h

    PATHS ${CMAKE_PREFIX_PATH} # Unofficial: We are proposing this.

    NO_DEFAULT_PATH

    PATH_SUFFIXES include

)

FIND_PATH(GDAL_INCLUDE_DIR gdal.h

  PATHS

  ~/Library/Frameworks/gdal.framework/Headers

  /Library/Frameworks/gdal.framework/Headers

  /usr/local/include/gdal

  /usr/local/include/GDAL

  /usr/local/include

  /usr/include/gdal

  /usr/include/GDAL

  /usr/include

  /sw/include/gdal 

  /sw/include/GDAL 

  /sw/include # Fink

  /opt/local/include/gdal

  /opt/local/include/GDAL

  /opt/local/include # DarwinPorts

  /opt/csw/include/gdal

  /opt/csw/include/GDAL

  /opt/csw/include # Blastwave

  /opt/include/gdal

  /opt/include/GDAL

  /opt/include

)

MARK_AS_ADVANCED(GDAL_INCLUDE_DIR)

FIND_LIBRARY(GDAL_LIBRARY 

  NAMES gdal_i gdal1.5.0 gdal1.4.0 gdal1.3.2 GDAL

  PATHS

  $ENV{GDAL_DIR}

  NO_DEFAULT_PATH

  PATH_SUFFIXES lib64 lib

)

FIND_LIBRARY(GDAL_LIBRARY 

  NAMES gdal_i gdal1.5.0 gdal1.4.0 gdal1.3.2 GDAL

  PATHS ${CMAKE_PREFIX_PATH} # Unofficial: We are proposing this.

    NO_DEFAULT_PATH

    PATH_SUFFIXES lib64 lib

)

FIND_LIBRARY(GDAL_LIBRARY 

  NAMES gdal_i gdal1.5.0 gdal1.4.0 gdal1.3.2 GDAL

  PATHS

    ~/Library/Frameworks

    /Library/Frameworks

    /usr/local

    /usr

    /sw

    /opt/local

    /opt/csw

    /opt

    /usr/freeware

    [HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\Session\ Manager\\Environment;GDAL_ROOT]/lib

  PATH_SUFFIXES lib64 lib

)

MARK_AS_ADVANCED(GDAL_LIBRARY)

SET(GDAL_FOUND "NO")

IF(GDAL_LIBRARY AND GDAL_INCLUDE_DIR)

  SET(GDAL_FOUND "YES")

  SET(GDAL_LIBRARY_DEBUG ${GDAL_LIBRARY})

ENDIF(GDAL_LIBRARY AND GDAL_INCLUDE_DIR)

Notas de compilaci?n de la librer?a jgdal.

La compilaci?n de la librer?a jgdal se realiza autom?ticamente ejecutando el build.xml

del proyecto. Para ello el sistema tiene que tener instalado y accesible:

- CMake - Probado con la versi?n 2.4

- Compilador gcc - g++ en el caso de Linux - Compilado con gcc 4.1. Con la versi?n 3.3

	de gcc - g++ no compila correctamente.

- Entorno de desarrollo Visual Studio en caso de Windows con las variables de

	entorno cargadas. - Compilado con Visual Studio 2005

- Librer?a gdal instalada. Hasta el momento (0.6.3) se est? compilando con gdal 1.5.0 con 

	soporte para Grass y Modis (Hdf 4 y 5). Si el SDK est? en alguna ruta distinta a las que

	se incluyen en el archivo FindGDAL, habr? que a?adirla a dicho archivo o instalar el SDK

	en alguna de las indicadas.

- JDK de Java.

Con ejecutar el build.xml es suficiente para generar la librer?a y el jar.

*********************************************************

Cambios seg?n versiones a partir de la 0.6.1

0.6.1: Eliminaci?n de la comprobaci?n de direcciones de memoria negaticas ya que

		?stas se utilizan.

0.6.2: Versi?n en desarrollo. Migraci?n a CMake.

0.6.3: No se utiliza la captura de se?ales de las librer?as nativas ya que produce 

		inestabilidades en la librer?a. Soporte para grass y HDF 4 y 5. Grass solo en

		Linux.

0.6.4: Se incluyen comprobaciones de los par?metros que se pasan a JNI 

		y lanzamiento de excepciones desde la parte de java. 

0.7.0: Recubrimiento de la utilidad para reproyeccion gdalwarp.

		Incluido el recubrimiento del generador de overwiews gdaladdo.

		M?todo getMetadata con par?metro para poder seleccionar dominios de metadatos.

		Recubrimiento de la funcion GDALSetRaserColorInterpretation.

0.7.1: Resoluci?n de un bug en el m?todo createCopy de la clase GdalDriver.

0.7.2: Resoluci?n de bug en GdalDriver. El params de create debe admitir el valor de null

0.8.0: Llamada existsNoDataValue de GdalRasterBand

0.9.0: Quitadas las constantes de GdalWarp

		Quitado metodo setFormat de GdalWarp

		A?adido nuevo parametro al constructor de GdalWarp

		A?adido nuevo metodo a GdalWarp que devuelve los drivers reproyectables.

0.9.1: Agregado el control de excepciones a GdalWarp

		Corregido bug cuando params vale null en GdalDriver.java

0.9.2: Control de errores en el par?metro de salida para gdalwarp

*********************************************************

NOTAS DE COMPILACI?N:

Linux:

* Es necesario que haya instalado un gdal. Seg?n la versi?n de la librer?a, puede requerir

que gdal est? compilado con diferentes soportes.

Windows:

* Es necesario que haya un Visual Studio instalado con sus variables de entorno cargadas por

defecto en el sistema para poder acceder al copilador por linea de comandos.

* Es necesario que haya un CMake en el sistema con sus variable de entorno cargadas en el

sistema para generar los Makefiles.

* Es necesario que la variable JAVA_HOME exista y apunte a un Jdk.

* Es necesario indicar la variable de entorno JAVA_HOME al ejecutar el ant desde eclipse 

para que se puedan encontrar los includes JNI. La direcci?n de estos includes se guardar?

en las variables JAVA_INCLUDE_PATH y JAVA_INCLUDE_PATH2.

* En el archivo de configuraci?n para la compilaci?n de la librer?a gdal, es necesario

que se utilice la opci?n STDCALL. Tambi?n se tiene que deshabilitar el soporte para ODBC.

Comentar la linea ODBC_SUPPORTED=YES. Importante, comentar la linea, no poner valor =NO.

* En el caso de que se haya compilado la librer?a con soporte externo (tal como HDF4, HDF5...)

es necesario que las librer?as de las que depende gdal est?n accesibles.

* SOPORTE PARA HDF4:

	- La librer?a 1.5.0 de gdal se tiene que compilar con el sdk 4.2r2 de HDF4. La versi?n

	4.2r1 est? compilada con Visual Studio 6.0 y no soporta VS 2005. La versi?n 4.2r3 da un

	error en la compilaci?n de gdal posiblemente porque este ?ltimo no est? actualizado.

* SOPORTE PARA HDF5:

	- Al igual que ocurre con HDF4, gdal 1.5.0 no soporta la ?ltima versi?n hasta la fecha

	de HDF5 (1.8.0) por lo que hay que utilizar la (1.6.7) que si que soporta Visual Studio

	2005. Tambi?n es conveniente utilizar una version de szip compatible con Visual Studio

	2005.

set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS TRUE)

IF(WIN32)

    CMAKE_MINIMUM_REQUIRED(VERSION 2.4.6 FATAL_ERROR)

ELSE(WIN32)

    IF(APPLE)

        CMAKE_MINIMUM_REQUIRED(VERSION 2.6.0 FATAL_ERROR)

    ELSE(APPLE)

        CMAKE_MINIMUM_REQUIRED(VERSION 2.4.4 FATAL_ERROR)

    ENDIF(APPLE)

ENDIF(WIN32)

if(COMMAND cmake_policy)

    # Works around warnings libraries linked against that don't

    # have absolute paths (e.g. -lpthreads)

    cmake_policy(SET CMP0003 NEW)

    # Works around warnings about escaped quotes in ADD_DEFINITIONS

    # statements.

    cmake_policy(SET CMP0005 NEW)

    # cmake-2.6.1 introduces policy cmp0008 decide how to treat full path libraries that do not appear to be valid library file names

    # quote from cvslog "Such libraries worked by accident in the VS IDE and Xcode generators in CMake 2.4 and below."

    if(${CMAKE_MAJOR_VERSION} EQUAL 2 AND ${CMAKE_MINOR_VERSION} GREATER 4 AND ${CMAKE_PATCH_VERSION} GREATER 0)

        cmake_policy(SET CMP0008 OLD)

    endif()

endif()

PROJECT(jgdal)

SET(JGDAL_VERSION_MAJOR "0")

SET(JGDAL_VERSION_MINOR "9")

SET(JGDAL_VERSION_PATCH "2")

SET(VERSION "")#${JGDAL_VERSION_MAJOR}${JGDAL_VERSION_MINOR}${JGDAL_VERSION_PATCH}")

IF(WIN32)

SET(VERSION "${JGDAL_VERSION_MAJOR}${JGDAL_VERSION_MINOR}${JGDAL_VERSION_PATCH}")

ENDIF(WIN32)

SET(CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/../build/CMakeModules;${CMAKE_SOURCE_DIR}/CMakeModules;${CMAKE_MODULE_PATH}")

FIND_PACKAGE(DepMan REQUIRED) 

INCLUDE(GeneralMacros) 

CONFIGURE_DEFAULTS()

IF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)

  SET(CMAKE_INSTALL_PREFIX

    ${DEPMAN_PATH} CACHE PATH "depman path install prefix" FORCE

    )

ENDIF(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT)

FIND_PACKAGE(JNI REQUIRED) 

FIND_PACKAGE(GDAL REQUIRED) 

ADD_SUBDIRECTORY(src/main/native)

CONFIGURE_END()

	<project name="libjni-gdal" default="main" basedir=".">

	<description>

		Compila la librería jgdal

	</description>

	<property name="src-java" location="src/main/java" />

	<property name="src-tet-java" location="src/test/java" />

	<property name="jar-dist" location="jar-dist" />

	<property name="build" location="bin/" />

	<property name="cmake_build" location="BMCMake/" />

	<property environment="env"/>

	<condition property="jgdal_version" value="0.9.2">

		<os family="unix"/>

	</condition>

	<condition property="jgdal_version" value="092">

		<os family="windows"/>

	</condition>

	<property name="jgdal-jar" location="jgdal-0.9.2.jar" />

	<condition property="cmake_generator" value="'Unix Makefiles'">

		<os family="unix"/>

	</condition>

	<condition property="cmake_generator" value="'NMake Makefiles'">

		<os family="windows"/>

	</condition>		

	<target name="main" description="compile java code, make jars, prepare and compile natives" depends="clean,jar,prepare-natives,compile-natives">

	</target>

	<target name="jar" description="makes jar file">

		<mkdir dir="${build}" />

		<javac srcdir="${src-java}" destdir="${build}" debug="true" />

		<mkdir dir="${jar-dist}" />

		<jar jarfile="${jgdal-jar}" basedir="${build}" includes="es/gva/cit/**, org/gvsig/**" />

		<move file="${jgdal-jar}" todir="${jar-dist}" />

	</target>

	<target name="prepare-natives" description="prepares the natives to be compiled">

		<mkdir dir="${cmake_build}"/>

		<delete file="${cmake_build}/CMakeCache.txt"/>

		<exec dir="${cmake_build}" executable="cmake" os="Linux" >

			<arg line=".." />

			<arg line="-G${cmake_generator}" />

			<arg line="-DCMAKE_BUILD_TYPE=Release" />

			<arg line="-DJGDAL_VERSION=${jgdal_version}" />

		</exec>

		<exec dir="${cmake_build}" executable="cmake" os="Windows 98,Windows 2000,Windows XP,Windows NT (Unknown)">

			<arg line=".." />

			<arg line="-G${cmake_generator}" />

			<arg line="-DCMAKE_BUILD_TYPE=Release" />

			<arg line="-DJGDAL_VERSION=${jgdal_version}" />

			<arg line="-DHDF4=true"/>

			<arg line="-DHDF5=true"/>

		</exec>

	</target>

	<target name="compile-natives" description="compiles natives">

		<exec dir="${cmake_build}" executable="make" os="Linux">

			<arg line="install" />

		</exec>

		<exec dir="${cmake_build}" executable="nmake" os="Windows 98,Windows 2000,Windows XP,Windows NT (Unknown)">

			<arg line="install" />

		</exec>

	</target>

	<target name="clean" description="clean distribution">

		<delete dir="jar-dist"/>

		<delete dir="lib-dist"/>

		<delete dir="BMCMake"/>

	</target>

</project>

<?xml version="1.0" encoding="UTF-8"?>

<classpath>

	<classpathentry kind="src" path="src/main/java"/>

	<classpathentry kind="src" path="src/test/java"/>

	<classpathentry kind="src" path="src/main/resources"/>

	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>

	<classpathentry kind="con" path="org.eclipse.jdt.junit.JUNIT_CONTAINER/4"/>

	<classpathentry kind="output" path="bin"/>

</classpath>

<?xml version="1.0" encoding="UTF-8"?>

<projectDescription>

	<name>libjni-gdal</name>

	<comment></comment>

	<projects>

	</projects>

	<buildSpec>

		<buildCommand>

			<name>org.eclipse.jdt.core.javabuilder</name>

			<arguments>

			</arguments>

		</buildCommand>

	</buildSpec>

	<natures>

		<nature>org.eclipse.jdt.core.javanature</nature>

	</natures>

</projectDescription>

package es.gva.cit.jgdal;

import java.io.File;

import java.io.IOException;

import junit.framework.TestCase;

public class TestWarpDataset extends TestCase {

	private GdalWarp warp    = null;

	private String   baseDir = "./test-images/";

	private String   src     = baseDir + "testGdalWarp.tif";

	private String   dst     = baseDir + "warpedImage.tif";

	private String   frm     = "GTiff";

	private String   t_srs   = "EPSG:23030";

	public void start() {

		setUp();

		testStack();

	}

	public void setUp() {

		warp = new GdalWarp();

		File f = new File(src);

		Gdal dataset = new Gdal();

		try {

			assertTrue("El fichero no existe", f.exists());

			assertTrue("El fichero no se puede leer", f.canRead());

			dataset.open(src, Gdal.GA_ReadOnly);

			GdalRasterBand band = dataset.getRasterBand(1);

			band.readRaster(0, 0, 10, 10, 10, 10, Gdal.GDT_Byte);

		} catch (GdalException e) {

			new AssertionError("Fallo en gdal al acceder al fichero fuente");

		} catch (IOException e) {

			new AssertionError("Fallo en gdal al acceder al fichero fuente");

			e.printStackTrace();

		}

	}

	public void testStack() {

		assertNotNull(t_srs);

		warp.warp(t_srs, src, dst, frm);

		System.err.println("Proceso completado al " + warp.getPercent() + " %");

		File f = new File(dst);

		assertTrue("El fichero destino no existe", f.exists());

		assertTrue("El fichero destino no se puede leer", f.canRead());

	}

}

package es.gva.cit.jgdal;

import java.io.IOException;

import junit.framework.TestCase;

/**

 * Test de acceso a datos de la imagen. 

 * @author Miguel ?ngel Qierol Carratal? <miguelangel.querol@iver.es>

 *

 */

public class TestReadData extends TestCase{

	private Gdal gdal = null;

	private String baseDir = "./test-images/";

	private String file1 = baseDir + "testGdal.tif";

	private String[] metadata = null;

	public void start(){

		try {

			setUp();

			testStack();

		} catch (GdalException e) {

			e.printStackTrace();

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

	public void setUp() throws GdalException, IOException{

		gdal = new Gdal();

		gdal.open(file1, Gdal.GA_Update);

	}

	public void testStack() throws GdalException, IOException{

		//Llamada sin dominio

		metadata = gdal.getMetadata();

		assertNotNull("No se han devuelto metadatos", metadata);

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

			System.out.println("Metadato: " + metadata[i]);

		}

		//Llamada con dominio "Image Structure Metadata"

		metadata = gdal.getMetadata("Image Structure Metadata");

		assertNotNull("No se han devuelto metadatos", metadata);

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

			System.out.println("Metadato: " + metadata[i]);

		}

		//Comprobaci?n del tama?o de la imagen

		assertEquals(842, gdal.getRasterXSize());

		assertEquals(1023, gdal.getRasterYSize());

		//Comprobaci?n del n?mero de bandas

		assertEquals(4, gdal.getRasterCount());

		//Comprobaci?n del driver de la imagen

		assertEquals("GTiff", gdal.getDriverShortName());

		//Comprobaci?n del acceso a las bandas

		for (int i = 0 ; i < gdal.getRasterCount() ; i++){

			assertNotNull(gdal.getRasterBand(i+1));

		}

		gdal.close();

		gdal = null;

		System.gc();

	}

}

package es.gva.cit.jgdal;

import java.io.IOException;

import junit.framework.TestCase;

/**

 * Test de acceso a datos de las bandas de una imagen.

 * @author Miguel ?ngel Querol Carratal? <miguelangel.querol@iver.es>

 *

 */

public class TestReadBandData extends TestCase{

	private Gdal gdal = null;

	private GdalRasterBand band = null;

	private String baseDir = "./test-images/";

	private String file1 = baseDir + "testGdal.tif";

	public void start(){

		try {

			setUp();

			testStack();

		} catch (GdalException e) {

			e.printStackTrace();

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

	public void setUp() throws GdalException, IOException{

		gdal = new Gdal();

		gdal.open(file1, Gdal.GA_Update);

	}

	public void testStack() throws GdalException, IOException{

		//Llamada sin dominio

		String[] metadata = gdal.getMetadata();

		assertNotNull("No se han devuelto metadatos", metadata);

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

			System.out.println("Metadato: " + metadata[i]);

		}

		//Llamada con dominio "Image Structure Metadata"

		metadata = gdal.getMetadata("Image Structure Metadata");

		assertNotNull("No se han devuelto metadatos", metadata);

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

			System.out.println("Metadato: " + metadata[i]);

		}

		//Comprobaci?n del tama?o de la imagen

		assertEquals(842, gdal.getRasterXSize());

		assertEquals(1023, gdal.getRasterYSize());

		//Comprobaci?n del n?mero de bandas

		assertEquals(4, gdal.getRasterCount());

		//Comprobaci?n del driver de la imagen

		assertEquals("GTiff", gdal.getDriverShortName());

		//Comprobaci?n del acceso a las bandas

		for (int i = 0 ; i < gdal.getRasterCount() ; i++){

			assertNotNull(gdal.getRasterBand(i+1));

		}

	}

}

package org.gvsig.addo;

import java.io.IOException;

import junit.framework.TestCase;

import es.gva.cit.jgdal.Gdal;

import es.gva.cit.jgdal.GdalException;

/**

 * Test para la generacion de overviews sobre una imagen raster.

 * Registra un listener para mostrar el incremento de la tarea.

 *

 * 18-nov-2007

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

 */

public class TestBuildOverviews extends TestCase implements IOverviewIncrement {

	private int value = 0;

	private Jaddo addo = null;

	private Gdal gdal = null;

	private String path = "./test-images/testGdalWarp.tif";

	public void start(){

		setUp();

		testStack();

	}

	public void setUp(){

		addo = new Jaddo();

		addo.setIncrementListener(this);

		gdal = new Gdal();

	}

	public void testStack(){

		try {

			addo.buildOverviews(Jaddo.AVERAGE, path, new int[]{2, 4, 8, 16});

			gdal.open(path, Gdal.GA_ReadOnly);

			assertTrue("No hay overviews!!", gdal.getRasterBand(1).getOverviewCount()>0);

		} catch (BuildingOverviewsException e) {

			System.err.println(e);

		} catch (WritingException e) {

			System.err.println(e);

		} catch (GdalException e) {

			e.printStackTrace();

		} catch (IOException e) {

			e.printStackTrace();

		}

	}

	public int getPercent() {

		return value;

	}

	public void setPercent(int value) {

		this.value = value;

		System.out.println("Increment:" + value);

	}

}

add_subdirectory(jgdal)

 /**********************************************************************

 * $Id: ogrsfdriverregistrar_interfaz.cpp 7765 2006-10-03 07:05:18Z nacho $

 *

 * Name:     ogrsfdriverregistrar_interfaz.c

 * Project:  JGDAL. Interface java to gdal (Frank Warmerdam).

 * Purpose:  

 * Author:   Nacho Brodin, brodin_ign@gva.es

 *

 **********************************************************************/

/* gvSIG. Sistema de Informaci�n Geogr�fica de la Generalitat Valenciana

*

* Copyright (C) 2004 IVER T.I. and Generalitat Valenciana.

*

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

*

*  Generalitat Valenciana

*   Conselleria d'Infraestructures i Transport

*   Av. Blasco Ib��ez, 50

*   46010 VALENCIA

*   SPAIN

*

*      +34 963862235

*   gvsig@gva.es

*      www.gvsig.gva.es

*

*    or

*

*   IVER T.I. S.A

*   Salamanca 50

*   46005 Valencia

*   Spain

*

*   +34 963163400

*   dac@iver.es

*/

#include <jni.h>

#include "ogr_api.h"

#include "ogrsf_frmts.h"

/******************************************************************************/

//									open

/******************************************************************************/

JNIEXPORT jlong JNICALL Java_es_gva_cit_jogr_OGRSFDriverRegistrar_openNat

  (JNIEnv *env, jobject obj, jstring fte, jint bUpdate){

  	OGRDataSource       *poDS;

    OGRSFDriver         *poDriver;

    long				driver=0;

    long				dataset=0;

    const char 			*pszFilename;

    jclass 				clase;

  	jfieldID 			id_campo;

    pszFilename = env->GetStringUTFChars( fte, 0);

	poDS = OGRSFDriverRegistrar::Open( pszFilename, bUpdate, &poDriver );

    if( poDS == NULL )return -1;

    if(poDriver!=NULL)

	    driver = (long)&(*poDriver);

    clase = env->GetObjectClass(obj);

    id_campo = env->GetFieldID( clase, "driver", "J");

    env->SetLongField( obj, id_campo, (jlong)driver);    

    dataset = (long)&(*poDS);

    env->ReleaseStringUTFChars( fte, pszFilename);

    return (jlong)dataset;

  }

/******************************************************************************/

//									getDriverCount

/******************************************************************************/

JNIEXPORT jint JNICALL Java_es_gva_cit_jogr_JNIBase_getDriverCountNat

  (JNIEnv *env, jobject obj, jlong cPtr){

  	int res=-1;

  	OGRSFDriverRegistrar *drvreg  = (OGRSFDriverRegistrar *) 0 ;

  	drvreg = *(OGRSFDriverRegistrar **)&cPtr;

  	if(drvreg!=NULL)

	  	res = drvreg->GetDriverCount();

  	return res;

  }

/******************************************************************************/

//									getRegistrar

/******************************************************************************/

  JNIEXPORT jlong JNICALL Java_es_gva_cit_jogr_OGRSFDriverRegistrar_getRegistrarNat

  (JNIEnv *env, jobject obj){

  	long ptro;

  	OGRSFDriverRegistrar    *poR = OGRSFDriverRegistrar::GetRegistrar();

  	ptro = (long)&(*poR);

  	return (jlong)ptro;

  }	

/******************************************************************************/

//									getDriver

/******************************************************************************/

  JNIEXPORT jlong JNICALL Java_es_gva_cit_jogr_OGRSFDriverRegistrar_getDriverNat

  (JNIEnv *env, jobject obj, jlong cPtr, jint i){

  	OGRSFDriverRegistrar 	*drvreg  = (OGRSFDriverRegistrar *) 0 ;

  	OGRSFDriver 			*drv;

  	long					driver=0;

  	drvreg = *(OGRSFDriverRegistrar **)&cPtr;

  	if(drvreg!=NULL){

	  	drv = drvreg->GetDriver(i);

	  	driver = (long)&(*drv);

  	}

  	return (jlong)driver;

  }

/******************************************************************************/

//								~OGRSFDriverRegistrar

/******************************************************************************/

  JNIEXPORT void JNICALL Java_es_gva_cit_jogr_OGRSFDriverRegistrar_FreeOGRSFDriverRegistrarNat

  (JNIEnv *env, jobject obj, jlong cPtr){

  	OGRSFDriverRegistrar *df = (OGRSFDriverRegistrar *) 0 ;

  	df = *(OGRSFDriverRegistrar **)&cPtr;

  	if(df!=NULL){

  		delete df;

  	}

  }

/******************************************************************************

 * $Id: gdalwarp.cpp,v 1.27 2006/09/27 13:06:13 dron Exp $

 *

 * Project:  High Performance Image Reprojector

 * Purpose:  Test program for high performance warper API.

 * Author:   Frank Warmerdam <warmerdam@pobox.com>

 *

 ******************************************************************************

 * Copyright (c) 2002, i3 - information integration and imaging

 *                          Fort Collin, CO

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

 * DEALINGS IN THE SOFTWARE.

 ******************************************************************************

 *

 * $Log: gdalwarp.cpp,v $

 * Revision 1.27.1 2007/04/02 11:35:08  maquerol

 * main() function converted into an accesible warpFunction.

 *

 * Revision 1.27  2006/09/27 13:06:13  dron

 * Memory leak fixed.

 *

 * Revision 1.26  2006/07/06 20:30:11  fwarmerdam

 * use GDALSuggestedWarpOutput2() to avoid approximation implicit in using gt

 *

 * Revision 1.25  2006/06/29 21:10:29  fwarmerdam

 * Avoid a few memory leaks.

 *

 * Revision 1.24  2006/06/02 17:31:49  fwarmerdam

 * Modified -ts to allow width or height to be zero meaning, it should

 * be computed to retain square pixels.

 *

 * Revision 1.23  2006/05/29 17:32:15  fwarmerdam

 * added preliminary support for controlling longitude wrapping on input dataset

 *

 * Revision 1.22  2006/04/25 14:28:33  fwarmerdam

 * Check for no usable sources, avoid warning.

 *

 * Revision 1.21  2006/03/21 21:34:43  fwarmerdam

 * cleanup headers

 *

 * Revision 1.20  2006/01/05 19:51:10  fwarmerdam

 * fixed checking of targetsrs

 *

 * Revision 1.19  2005/12/19 20:20:00  fwarmerdam

 * preliminary support for multiple input files

 *

 * Revision 1.18  2005/09/13 01:57:31  fwarmerdam

 * Fixed usage message.

 *

 * Revision 1.17  2005/09/13 01:24:45  fwarmerdam

 * Set UNIFIED_SRC_NODATA by default for -srcnodata switch.

 *

 * Revision 1.16  2005/09/12 18:06:25  fwarmerdam

 * Added quotes around -srcnodata and -dstnodata in usage message.

 *

 * Revision 1.15  2004/12/26 16:14:53  fwarmerdam

 * added -tps flag

 *

 * Revision 1.14  2004/11/29 15:01:55  fwarmerdam

 * Fixed typo in printf as per Bug 691.

 *

 * Revision 1.13  2004/11/14 04:57:04  fwarmerdam

 * added -srcalpha switch, and automatic alpha detection

 *

 * Revision 1.12  2004/11/05 06:15:08  fwarmerdam

 * Don't double free the warpoptions array.

 *

 * Revision 1.11  2004/11/05 05:53:43  fwarmerdam

 * Avoid various memory leaks.

 *

 * Revision 1.10  2004/10/07 15:53:42  fwarmerdam

 * added preliminary alpha band support

 */

#include <jni.h>

#include "gdalwarper.h"

#include "cpl_string.h"

#include "ogr_spatialref.h"

#include "gdal.h"

//#include "../include/gdalwarp_interfaz.h"

CPL_CVSID("$Id: gdalwarp.cpp,v 1.27 2006/09/27 13:06:13 dron Exp $");

static CPLString InsertCenterLong( GDALDatasetH hDS, CPLString osWKT );

static GDALDatasetH

GDALWarpCreateOutput( char **papszSrcFiles, const char *pszFilename,

											const char *pszFormat, const char *pszSourceSRS,

											const char *pszTargetSRS, int nOrder,

											char **papszCreateOptions, GDALDataType eDT );

int CPL_STDCALL GDALFuncTermProgress( double dfComplete, const char *pszMessage,

											void * pProgressArg );

void CPL_STDCALL statusCallBack(int nPercent);

static double	       dfMinX=0.0, dfMinY=0.0, dfMaxX=0.0, dfMaxY=0.0;

static double	       dfXRes=0.0, dfYRes=0.0;

static int             nForcePixels=0, nForceLines=0, bQuiet = FALSE;

static int             bEnableDstAlpha = FALSE, bEnableSrcAlpha = FALSE;

static int             bVRT = FALSE;

/************************************************************************/

/*                             SanitizeSRS                              */

/************************************************************************/

char *SanitizeSRS( const char *pszUserInput )

{

		OGRSpatialReferenceH hSRS;

		char *pszResult = NULL;

		CPLErrorReset();

		hSRS = OSRNewSpatialReference( NULL );

		if( OSRSetFromUserInput( hSRS, pszUserInput ) == OGRERR_NONE )

				OSRExportToWkt( hSRS, &pszResult );

		else

		{

				CPLError( CE_Failure, CPLE_AppDefined,

									"Translating source or target SRS failed:\n%s",

									pszUserInput );

				exit( 1 );

		}

		OSRDestroySpatialReference( hSRS );

		return pszResult;

}

/************************************************************************/

/*                              WarpFunction()                          */

/************************************************************************/

int launchException(JNIEnv *env, char *msg) {

	env->ExceptionDescribe();

	env->ExceptionClear();

	jclass newExcCls = env->FindClass("es/gva/cit/jgdal/GdalException");

	if (newExcCls == 0)

		return CE_Failure;

	env->ThrowNew(newExcCls, msg);

	return CE_Failure;

}

int warpFunction(JNIEnv *env, char * s_srs, char * t_srs, char *source, char * dest, char *format) {

	GDALDatasetH hDstDS;

	const char *pszFormat = "GTiff";

	char *pszTargetSRS = NULL;

	char *pszSourceSRS = NULL;

	char **papszSrcFiles = NULL;

	char *pszDstFilename = NULL;

	int bCreateOutput = FALSE, i, nOrder = 0;

	void *hTransformArg, *hGenImgProjArg = NULL, *hApproxArg = NULL;

	char **papszWarpOptions = NULL;

	double dfErrorThreshold = 0.125;

	double dfWarpMemoryLimit = 0.0;

	GDALTransformerFunc pfnTransformer = NULL;

	char **papszCreateOptions = NULL;

	GDALDataType eOutputType = GDT_Unknown, eWorkingType = GDT_Unknown;

	GDALResampleAlg eResampleAlg = GRA_NearestNeighbour;

	const char *pszSrcNodata = NULL;

	const char *pszDstNodata = NULL;

	int bMulti = FALSE;

	char error[1024];

        int result = 4;

	GDALAllRegister();

/* -------------------------------------------------------------------- */

/*      Parse arguments.                                                */

/* -------------------------------------------------------------------- */

	pszTargetSRS = SanitizeSRS(t_srs);

	if (s_srs != NULL)

		pszSourceSRS = SanitizeSRS(s_srs);

	papszSrcFiles = CSLAddString(papszSrcFiles, source);

	papszSrcFiles = CSLAddString(papszSrcFiles, dest);

	if (format != NULL)

		pszFormat = format;

	bCreateOutput = FALSE;

/* -------------------------------------------------------------------- */

/*      The last filename in the file list is really our destination    */

/*      file.                                                           */

/* -------------------------------------------------------------------- */

	if (CSLCount(papszSrcFiles) > 1) {

		pszDstFilename = papszSrcFiles[CSLCount(papszSrcFiles) - 1];

		papszSrcFiles[CSLCount(papszSrcFiles) - 1] = NULL;

	}

/* -------------------------------------------------------------------- */

/*      Does the output dataset already exist?                          */

/* -------------------------------------------------------------------- */

	CPLPushErrorHandler(CPLQuietErrorHandler);

	hDstDS = GDALOpen(pszDstFilename, GA_Update);

	CPLPopErrorHandler();

	if (hDstDS != NULL && bCreateOutput) {

		sprintf(error, "warpfunc.cpp (218): Output dataset %s exists, "

			"but some commandline options were provided indicating a new dataset "

			"should be created.  Please delete existing dataset and run again.", pszDstFilename);

		return launchException(env, error);

	}

/* -------------------------------------------------------------------- */

/*      If not, we need to create it.                                   */

/* -------------------------------------------------------------------- */

	int bInitDestSetForFirst = FALSE;

	if (hDstDS == NULL) {

		hDstDS = GDALWarpCreateOutput(papszSrcFiles, pszDstFilename, pszFormat,

				pszSourceSRS, pszTargetSRS, nOrder, papszCreateOptions, eOutputType);

		bCreateOutput = TRUE;

		if (CSLFetchNameValue(papszWarpOptions, "INIT_DEST") == NULL && pszDstNodata == NULL) {

			papszWarpOptions = CSLSetNameValue(papszWarpOptions, "INIT_DEST", "0");

			bInitDestSetForFirst = TRUE;

		} else {

			if (CSLFetchNameValue(papszWarpOptions, "INIT_DEST") == NULL) {

				papszWarpOptions = CSLSetNameValue(papszWarpOptions, "INIT_DEST", "NO_DATA");

				bInitDestSetForFirst = TRUE;

			}

		}

		CSLDestroy(papszCreateOptions);

		papszCreateOptions = NULL;

	}

	if (hDstDS == NULL)

		return launchException(env, "warpfunc.cpp (249):");

	if (pszTargetSRS == NULL)

		pszTargetSRS = CPLStrdup(GDALGetProjectionRef(hDstDS));

/* -------------------------------------------------------------------- */

/*      Loop over all source files, processing each in turn.            */

/* -------------------------------------------------------------------- */

	for (int iSrc = 0; papszSrcFiles[iSrc] != NULL; iSrc++) {

		CPLString osThisSourceSRS;

		GDALDatasetH hSrcDS;

		if (pszSourceSRS != NULL)

			osThisSourceSRS = pszSourceSRS;

/* -------------------------------------------------------------------- */

/*      Open this file.                                                 */

/* -------------------------------------------------------------------- */

		hSrcDS = GDALOpen(papszSrcFiles[iSrc], GA_ReadOnly);

		if (hSrcDS == NULL)

			return launchException(env, "warpfunc.cpp (270):");

		// Processing input file papszSrcFiles[iSrc]

		if (strlen(osThisSourceSRS) == 0) {

			if (GDALGetProjectionRef(hSrcDS) != NULL && strlen(GDALGetProjectionRef(hSrcDS)) > 0) {

				osThisSourceSRS = GDALGetProjectionRef(hSrcDS);

			} else {

				if (GDALGetGCPProjection(hSrcDS) != NULL && strlen(GDALGetGCPProjection(hSrcDS)) > 0 && GDALGetGCPCount(hSrcDS) > 1) {

					osThisSourceSRS = GDALGetGCPProjection(hSrcDS);

				} else {

					osThisSourceSRS = "";

				}

			}

			if (pszTargetSRS != NULL && strlen(pszTargetSRS) > 0 && strlen(osThisSourceSRS) == 0) {

				return launchException(env, "warpfunc.cpp (285): A target coordinate system was specified, "

					"but there is no source coordinate system.  Consider using -s_srs option to provide a "

					"source coordinate system. Operation terminated.");

			}

		}

/* -------------------------------------------------------------------- */

/*      Do we have a source alpha band?                                 */

/* -------------------------------------------------------------------- */

		if (GDALGetRasterColorInterpretation(GDALGetRasterBand(hSrcDS, GDALGetRasterCount(hSrcDS))) == GCI_AlphaBand && !bEnableSrcAlpha) {

			// Using band GDALGetRasterCount(hSrcDS) of source image as alpha

			bEnableSrcAlpha = TRUE;

		}

/* -------------------------------------------------------------------- */

/*      If the source coordinate system is geographic, try and          */

/*      insert a CENTER_LONG extension parameter on the GEOGCS to       */

/*      handle wrapping better.                                         */

/* -------------------------------------------------------------------- */

		if (EQUALN(osThisSourceSRS.c_str(), "GEOGCS[", 7))

			osThisSourceSRS = InsertCenterLong(hSrcDS, osThisSourceSRS);

/* -------------------------------------------------------------------- */

/*      Create a transformation object from the source to               */

/*      destination coordinate system.                                  */

/* -------------------------------------------------------------------- */

		hTransformArg = hGenImgProjArg = GDALCreateGenImgProjTransformer(hSrcDS, osThisSourceSRS, hDstDS,

				pszTargetSRS, TRUE, 1000.0, nOrder);

		if (hTransformArg == NULL)

			return launchException(env, "warpfunc.cpp (315):");

		pfnTransformer = GDALGenImgProjTransform;

/* -------------------------------------------------------------------- */

/*      Warp the transformer with a linear approximator unless the      */

/*      acceptable error is zero.                                       */

/* -------------------------------------------------------------------- */

		if (dfErrorThreshold != 0.0) {

			hTransformArg = hApproxArg = GDALCreateApproxTransformer(GDALGenImgProjTransform, hGenImgProjArg, dfErrorThreshold);

			pfnTransformer = GDALApproxTransform;

		}

/* -------------------------------------------------------------------- */

/*      Clear temporary INIT_DEST settings after the first image.       */

/* -------------------------------------------------------------------- */

		if (bInitDestSetForFirst && iSrc == 1)

			papszWarpOptions = CSLSetNameValue(papszWarpOptions, "INIT_DEST", NULL);

/* -------------------------------------------------------------------- */

/*      Setup warp options.                                             */

/* -------------------------------------------------------------------- */

		GDALWarpOptions *psWO = GDALCreateWarpOptions();

		psWO->papszWarpOptions = CSLDuplicate(papszWarpOptions);

		psWO->eWorkingDataType = eWorkingType;

		psWO->eResampleAlg = eResampleAlg;

		psWO->hSrcDS = hSrcDS;

		psWO->hDstDS = hDstDS;

		psWO->pfnTransformer = pfnTransformer;

		psWO->pTransformerArg = hTransformArg;

		if (!bQuiet)

			psWO->pfnProgress = GDALFuncTermProgress;

		if (dfWarpMemoryLimit != 0.0)

			psWO->dfWarpMemoryLimit = dfWarpMemoryLimit;

/* -------------------------------------------------------------------- */

/*      Setup band mapping.                                             */

/* -------------------------------------------------------------------- */

		if (bEnableSrcAlpha)

			psWO->nBandCount = GDALGetRasterCount(hSrcDS) - 1;

		else

			psWO->nBandCount = GDALGetRasterCount(hSrcDS);

		psWO->panSrcBands = (int *) CPLMalloc(psWO->nBandCount * sizeof(int));

		psWO->panDstBands = (int *) CPLMalloc(psWO->nBandCount * sizeof(int));

		for (i = 0; i < psWO->nBandCount; i++) {

			psWO->panSrcBands[i] = i + 1;

			psWO->panDstBands[i] = i + 1;

		}

/* -------------------------------------------------------------------- */

/*      Setup alpha bands used if any.                                  */

/* -------------------------------------------------------------------- */

		if (bEnableSrcAlpha)

			psWO->nSrcAlphaBand = GDALGetRasterCount(hSrcDS);

		if (!bEnableDstAlpha && GDALGetRasterCount(hDstDS) == psWO->nBandCount + 1 &&

				GDALGetRasterColorInterpretation(GDALGetRasterBand(hDstDS, GDALGetRasterCount(hDstDS))) == GCI_AlphaBand) {

			// Using band GDALGetRasterCount(hDstDS) of destination image as alpha

			bEnableDstAlpha = TRUE;

		}

		if (bEnableDstAlpha)

			psWO->nDstAlphaBand = GDALGetRasterCount(hDstDS);

/* -------------------------------------------------------------------- */

/*      Setup NODATA options.                                           */

/* -------------------------------------------------------------------- */

		if (pszSrcNodata != NULL) {

			char **papszTokens = CSLTokenizeString(pszSrcNodata);

			int nTokenCount = CSLCount(papszTokens);

			psWO->padfSrcNoDataReal = (double *) CPLMalloc(psWO->nBandCount * sizeof(double));

			psWO->padfSrcNoDataImag = (double *) CPLMalloc(psWO->nBandCount * sizeof(double));

			for (i = 0; i < psWO->nBandCount; i++) {

				if (i < nTokenCount) {

					CPLStringToComplex(papszTokens[i], psWO->padfSrcNoDataReal + i, psWO->padfSrcNoDataImag + i);

				} else {

					psWO->padfSrcNoDataReal[i] = psWO->padfSrcNoDataReal[i - 1];

					psWO->padfSrcNoDataImag[i] = psWO->padfSrcNoDataImag[i - 1];

				}

			}

			CSLDestroy(papszTokens);

			psWO->papszWarpOptions = CSLSetNameValue(psWO->papszWarpOptions, "UNIFIED_SRC_NODATA", "YES");

		}

/* -------------------------------------------------------------------- */

/*      If the output dataset was created, and we have a destination    */

/*      nodata value, go through marking the bands with the information.*/

/* -------------------------------------------------------------------- */

		if (pszDstNodata != NULL && bCreateOutput) {

			char **papszTokens = CSLTokenizeString(pszDstNodata);

			int nTokenCount = CSLCount(papszTokens);

			psWO->padfDstNoDataReal = (double *) CPLMalloc(psWO->nBandCount * sizeof(double));

			psWO->padfDstNoDataImag = (double *) CPLMalloc(psWO->nBandCount * sizeof(double));

			for (i = 0; i < psWO->nBandCount; i++) {

				if (i < nTokenCount) {

					CPLStringToComplex(papszTokens[i], psWO->padfDstNoDataReal + i, psWO->padfDstNoDataImag + i);

				} else {

					psWO->padfDstNoDataReal[i] = psWO->padfDstNoDataReal[i - 1];

					psWO->padfDstNoDataImag[i] = psWO->padfDstNoDataImag[i - 1];

				}

				if (bCreateOutput) {

					GDALSetRasterNoDataValue(GDALGetRasterBand(hDstDS, psWO->panDstBands[i]), psWO->padfDstNoDataReal[i]);

				}

			}

			CSLDestroy(papszTokens);

		}

/* -------------------------------------------------------------------- */

/*      If we are producing VRT output, then just initialize it with    */

/*      the warp options and write out now rather than proceeding       */

/*      with the operations.                                            */

/* -------------------------------------------------------------------- */

		if (bVRT) {

			if (GDALInitializeWarpedVRT(hDstDS, psWO) != CE_None)

				return launchException(env, "warpfunc.cpp (444):");

			GDALClose(hDstDS);

			GDALClose(hSrcDS);

			//GDALDumpOpenDatasets( stderr );

			GDALDestroyDriverManager();

			return CE_None;

		}

/* -------------------------------------------------------------------- */

/*      Initialize and execute the warp.                                */

/* -------------------------------------------------------------------- */

		GDALWarpOperation oWO;

		result = CE_None;

		if (oWO.Initialize(psWO) == CE_None) {

			if (bMulti) {

				result = oWO.ChunkAndWarpMulti(0, 0, GDALGetRasterXSize(hDstDS), GDALGetRasterYSize(hDstDS));

			} else {

				result = oWO.ChunkAndWarpImage(0, 0, GDALGetRasterXSize(hDstDS), GDALGetRasterYSize(hDstDS));

			}

		} else

			result = CE_Failure;

/* -------------------------------------------------------------------- */

/*      Cleanup                                                         */

/* -------------------------------------------------------------------- */

		if (hApproxArg != NULL)

			GDALDestroyApproxTransformer(hApproxArg);

		if (hGenImgProjArg != NULL)

			GDALDestroyGenImgProjTransformer(hGenImgProjArg);

		GDALDestroyWarpOptions(psWO);

		GDALClose(hSrcDS);

	}

/* -------------------------------------------------------------------- */

/*      Final Cleanup.                                                  */

/* -------------------------------------------------------------------- */

	GDALClose(hDstDS);

	CPLFree(pszTargetSRS);

	CPLFree(pszDstFilename);

	CSLDestroy(papszSrcFiles);

	CSLDestroy(papszWarpOptions);

	GDALDestroyDriverManager();

	return result;

}

/************************************************************************/

/*                        GDALWarpCreateOutput()                        */

/*                                                                      */

/*      Create the output file based on various commandline options,    */

/*      and the input file.                                             */

/************************************************************************/

static GDALDatasetH

GDALWarpCreateOutput( char **papszSrcFiles, const char *pszFilename,

											const char *pszFormat, const char *pszSourceSRS,

											const char *pszTargetSRS, int nOrder,

											char **papszCreateOptions, GDALDataType eDT )

{

		GDALDriverH hDriver;

		GDALDatasetH hDstDS;

		void *hTransformArg;

		GDALColorTableH hCT = NULL;

		double dfWrkMinX=0, dfWrkMaxX=0, dfWrkMinY=0, dfWrkMaxY=0;

		double dfWrkResX=0, dfWrkResY=0;

		int nDstBandCount = 0;

/* -------------------------------------------------------------------- */

/*      Find the output driver.                                         */

/* -------------------------------------------------------------------- */

		hDriver = GDALGetDriverByName( pszFormat );

		if( hDriver == NULL

				|| GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL ) == NULL )

		{

				int	iDr;

				printf( "Output driver `%s' not recognised or does not support\n",

								pszFormat );

				printf( "direct output file creation.  The following format drivers are configured\n"

								"and support direct output:\n" );

				for( iDr = 0; iDr < GDALGetDriverCount(); iDr++ )

				{

						GDALDriverH hDriver = GDALGetDriver(iDr);

						if( GDALGetMetadataItem( hDriver, GDAL_DCAP_CREATE, NULL) != NULL )

						{

								printf( "  %s: %s\n",

												GDALGetDriverShortName( hDriver  ),

												GDALGetDriverLongName( hDriver ) );

						}

				}

				printf( "\n" );

				exit( 1 );

		}

/* -------------------------------------------------------------------- */

/*      For virtual output files, we have to set a special subclass     */

/*      of dataset to create.                                           */

/* -------------------------------------------------------------------- */

		if( bVRT )

				papszCreateOptions =

						CSLSetNameValue( papszCreateOptions, "SUBCLASS",

														 "VRTWarpedDataset" );

/* -------------------------------------------------------------------- */

/*      Loop over all input files to collect extents.                   */

/* -------------------------------------------------------------------- */

		int iSrc;

		for( iSrc = 0; papszSrcFiles[iSrc] != NULL; iSrc++ )

		{

				GDALDatasetH hSrcDS;

				const char *pszThisSourceSRS = pszSourceSRS;

				hSrcDS = GDALOpen( papszSrcFiles[iSrc], GA_ReadOnly );

				if( hSrcDS == NULL )

						exit( 1 );

				if( eDT == GDT_Unknown )

						eDT = GDALGetRasterDataType(GDALGetRasterBand(hSrcDS,1));

/* -------------------------------------------------------------------- */

/*      If we are processing the first file, and it has a color         */

/*      table, then we will copy it to the destination file.            */

/* -------------------------------------------------------------------- */

				if( iSrc == 0 )

				{

						nDstBandCount = GDALGetRasterCount(hSrcDS);

						hCT = GDALGetRasterColorTable( GDALGetRasterBand(hSrcDS,1) );

						if( hCT != NULL )

						{

								hCT = GDALCloneColorTable( hCT );

								printf( "Copying color table from %s to new file.\n",

												papszSrcFiles[iSrc] );

						}

				}

/* -------------------------------------------------------------------- */

/*      Get the sourcesrs from the dataset, if not set already.         */

/* -------------------------------------------------------------------- */

				if( pszThisSourceSRS == NULL )

				{

						if( GDALGetProjectionRef( hSrcDS ) != NULL

								&& strlen(GDALGetProjectionRef( hSrcDS )) > 0 )

								pszThisSourceSRS = GDALGetProjectionRef( hSrcDS );

						else if( GDALGetGCPProjection( hSrcDS ) != NULL

										 && strlen(GDALGetGCPProjection(hSrcDS)) > 0

										 && GDALGetGCPCount( hSrcDS ) > 1 )

								pszThisSourceSRS = GDALGetGCPProjection( hSrcDS );

						else

								pszThisSourceSRS = "";

				}

				if( pszTargetSRS == NULL )

						pszTargetSRS = pszThisSourceSRS;

/* -------------------------------------------------------------------- */

/*      Create a transformation object from the source to               */

/*      destination coordinate system.                                  */

/* -------------------------------------------------------------------- */

				hTransformArg =

						GDALCreateGenImgProjTransformer( hSrcDS, pszThisSourceSRS,

																						 NULL, pszTargetSRS,

																						 TRUE, 1000.0, nOrder );

				if( hTransformArg == NULL )

						return NULL;

/* -------------------------------------------------------------------- */

/*      Get approximate output definition.                              */

/* -------------------------------------------------------------------- */

				double adfThisGeoTransform[6];

				double adfExtent[4];

				int    nThisPixels, nThisLines;

				if( GDALSuggestedWarpOutput2( hSrcDS,

																			GDALGenImgProjTransform, hTransformArg,

																			adfThisGeoTransform,

																			&nThisPixels, &nThisLines,

																			adfExtent, 0 ) != CE_None )

						return NULL;

/* -------------------------------------------------------------------- */

/*      Expand the working bounds to include this region, ensure the    */

/*      working resolution is no more than this resolution.             */

/* -------------------------------------------------------------------- */

				if( dfWrkMaxX == 0.0 && dfWrkMinX == 0.0 )

				{

						dfWrkMinX = adfExtent[0];

						dfWrkMaxX = adfExtent[2];

						dfWrkMaxY = adfExtent[3];

						dfWrkMinY = adfExtent[1];

						dfWrkResX = adfThisGeoTransform[1];

						dfWrkResY = ABS(adfThisGeoTransform[5]);

				}

				else

				{

						dfWrkMinX = MIN(dfWrkMinX,adfExtent[0]);

						dfWrkMaxX = MAX(dfWrkMaxX,adfExtent[2]);

						dfWrkMaxY = MAX(dfWrkMaxY,adfExtent[3]);

						dfWrkMinY = MIN(dfWrkMinY,adfExtent[1]);

						dfWrkResX = MIN(dfWrkResX,adfThisGeoTransform[1]);

						dfWrkResY = MIN(dfWrkResY,ABS(adfThisGeoTransform[5]));

				}

				GDALDestroyGenImgProjTransformer( hTransformArg );

				GDALClose( hSrcDS );