| gvSIG desktop 1

# INSTALL and SOURCE_GROUP commands for OSG/OT/Producer Modules

# Required Vars:

# ${LIB_NAME}

# ${LIB_PUBLIC_HEADERS}

SET(INSTALL_INCDIR include)

SET(INSTALL_BINDIR bin)

IF(WIN32)

	SET(INSTALL_BINDIR .)

    SET(INSTALL_LIBDIR .)

    SET(INSTALL_ARCHIVEDIR lib)

ELSE(WIN32)

	SET(INSTALL_BINDIR .)

    SET(INSTALL_LIBDIR .)

    SET(INSTALL_ARCHIVEDIR lib)

ENDIF(WIN32)

SET(HEADERS_GROUP "Header Files")

SOURCE_GROUP(

    ${HEADERS_GROUP}

    FILES ${LIB_PUBLIC_HEADERS}

)

INSTALL(

    TARGETS ${LIB_NAME}

    RUNTIME DESTINATION ${INSTALL_BINDIR}

    LIBRARY DESTINATION ${INSTALL_LIBDIR}

    ARCHIVE DESTINATION ${INSTALL_ARCHIVEDIR}

)

# FIXME: Do not run for OS X framework

#INSTALL(

#    FILES        ${LIB_PUBLIC_HEADERS}

#    DESTINATION ${INSTALL_INCDIR}/${LIB_NAME}

#)

# Locate ecw

# This module defines

# ECW_LIBRARY

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

# ECW_INCLUDE_DIR, where to find the headers

#

# $ECW_DIR is an environment variable that would

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

#

# Created by Robert Osfield. 

FIND_PATH(ECW_INCLUDE_DIR 

	NAMES ECW.h NCSError.h NCSErrors.h

	PATHS

    ${ECW_DIR}/include

    $ENV{ECW_DIR}/include

    $ENV{ECW_DIR}

    ~/Library/Frameworks

    /Library/Frameworks

    /usr/local/include

    /usr/include

    /usr/include/ecw

    /sw/include # Fink

    /opt/local/include # DarwinPorts

    /opt/csw/include # Blastwave

    /opt/include

    [HKEY_LOCAL_MACHINE\\SYSTEM\\CurrentControlSet\\Control\\Session\ Manager\\Environment;OSG_ROOT]/include

    /usr/freeware/include

    #"C:/libecwj2-3.3/Source/include"

    "C:/Archivos de programa/Earth Resource Mapping/ECW SDK/include"

    "C:/Earth Resource Mapping/ECW SDK/include"

    "C:/ECW SDK/include"

    "C:/ecw/include"

)

FIND_LIBRARY(ECW_LIBRARY 

    NAMES NCSEcw

    PATHS

    ${ECW_DIR}/lib

    $ENV{ECW_DIR}/lib

    $ENV{ECW_DIR}

    ~/Library/Frameworks

    /Library/Frameworks

    /usr/local/lib

    /usr/lib

    /sw/lib

    /opt/local/lib

    /opt/csw/lib

    /opt/lib

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

    /usr/freeware/lib64

    "C:/Archivos de programa/Earth Resource Mapping/ECW SDK/lib"

    "C:/Earth Resource Mapping/ECW SDK/lib"

    "C:/ECW SDK/lib/vc71"

    "C:/ECW SDK/lib"

    "C:/ecw/lib"

)

FIND_LIBRARY(ECW_LIBRARY2 

    NAMES NCSEcwC

    PATHS

    ${ECW_DIR}/lib

    $ENV{ECW_DIR}/lib

    $ENV{ECW_DIR}

    ~/Library/Frameworks

    /Library/Frameworks

    /usr/local/lib

    /usr/lib

    /sw/lib

    /opt/local/lib

    /opt/csw/lib

    /opt/lib

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

    /usr/freeware/lib64

    "C:/Archivos de programa/Earth Resource Mapping/ECW SDK/lib"

    "C:/Earth Resource Mapping/ECW SDK/lib"

    "C:/ECW SDK/lib/vc71"

    "C:/ECW SDK/lib"

    "C:/ecw/lib"

)

FIND_LIBRARY(ECW_LIBRARY3 

    NAMES NCSUtil

    PATHS

    ${ECW_DIR}/lib

    $ENV{ECW_DIR}/lib

    $ENV{ECW_DIR}

    ~/Library/Frameworks

    /Library/Frameworks

    /usr/local/lib

    /usr/lib

    /sw/lib

    /opt/local/lib

    /opt/csw/lib

    /opt/lib

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

    /usr/freeware/lib64

    "C:/Archivos de programa/Earth Resource Mapping/ECW SDK/lib"

    "C:/Earth Resource Mapping/ECW SDK/lib"

    "C:/ECW SDK/lib/vc71"

    "C:/ECW SDK/lib"

    "C:/ecw/lib"

)

FIND_LIBRARY(ECW_LIBRARY4 

    NAMES NCSCnet NCScnetS

    PATHS

    ${ECW_DIR}/lib

    $ENV{ECW_DIR}/lib

    $ENV{ECW_DIR}

    ~/Library/Frameworks

    /Library/Frameworks

    /usr/local/lib

    /usr/lib

    /sw/lib

    /opt/local/lib

    /opt/csw/lib

    /opt/lib

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

    /usr/freeware/lib64

)

SET(ECW_FOUND "NO")

IF(ECW_LIBRARY AND ECW_INCLUDE_DIR)

    SET(ECW_FOUND "YES")

ENDIF(ECW_LIBRARY AND ECW_INCLUDE_DIR)

project(jecw)

# Looking for arch extension!

SET(LIB_POSTFIX "32")

IF(UNIX)

	IF(NOT APPLE)

		IF(CMAKE_SIZEOF_VOID_P MATCHES "8")

      		SET(LIB_POSTFIX "64")

  		ENDIF(CMAKE_SIZEOF_VOID_P MATCHES "8")

	ENDIF(NOT APPLE)

ELSE(UNIX)

	IF(CMAKE_SYSTEM_NAME MATCHES Windows)

		IF(CMAKE_CL_64)

      		SET(LIB_POSTFIX "64")

		ENDIF(CMAKE_CL_64)	

	ENDIF(CMAKE_SYSTEM_NAME MATCHES Windows)

ENDIF(UNIX)

SET(platform_dir)

IF(WIN32)

	IF(NOT CYGWIN)

		SET(platform_dir "w${LIB_POSTFIX}")

	ENDIF(NOT CYGWIN)

ENDIF(WIN32)

IF(UNIX)

	IF(APPLE)

		SET(platform_dir "mac")

	ELSE(APPLE)

		SET(platform_dir "linux")

	ENDIF(APPLE)

ENDIF(UNIX)

IF(UNIX)

	SET(CMAKE_CXX_FLAGS_RELEASE "-O -DNDEBUG")

	SET(CMAKE_C_FLAGS_RELEASE "-O -DNDEBUG")

ENDIF(UNIX)

SET(GVSIG_BINARIES_PATH "${CMAKE_SOURCE_DIR}/../binaries/${platform_dir}/raster/ecw")

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

FILE(MAKE_DIRECTORY ${CMAKE_SOURCE_DIR}/lib-dist)

#FILE(MAKE_DIRECTORY ${CMAKE_SOURCE_DIR}/bin-dist)

set(LIBRARY_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/lib-dist)

#set(EXECUTABLE_OUTPUT_PATH ${CMAKE_SOURCE_DIR}/bin-dist)

#set(CMAKE_SKIP_RPATH TRUE)

IF(APPLE)

	SET(CMAKE_INSTALL_NAME_DIR @executable_path/../Resources/NativeLibs CACHE STRING "Executable Path for MacOS X" FORCE)

  	MARK_AS_ADVANCED(CMAKE_INSTALL_NAME_DIR)

ENDIF(APPLE)

SET(CMAKE_INSTALL_PREFIX ${GVSIG_BINARIES_PATH} CACHE STRING "Forcing install path" FORCE)

MARK_AS_ADVANCED(CMAKE_INSTALL_PREFIX)

# This is for an advanced option to give aggressive warnings

# under different compilers. If yours is not implemented, this option

# will not be made available.

IF(CMAKE_COMPILER_IS_GNUCXX)

    # To be complete, we might also do GNUCC flags,

    # but everything here is C++ code.

    # -Wshadow and -Woverloaded-virtual are also interesting flags, but OSG

    # returns too many hits.

    # FYI, if we do implement GNUCC, then -Wmissing-prototypes in another

    # interesting C-specific flag.

    # Also, there is a bug in gcc 4.0. Under C++, -pedantic will create

    # errors instead of warnings for certain issues, including superfluous

    # semicolons and commas, and the use of long long. -fpermissive seems

    # to be the workaround.

    SET(AGGRESSIVE_WARNING_FLAGS "-Wall -Wparentheses -Wformat=2 -Wno-long-long -Wno-import -pedantic -Wreturn-type -Wmissing-braces -Wunknown-pragmas -Wunused -fpermissive")

ELSE(CMAKE_COMPILER_IS_GNUCXX)

    IF(MSVC)

        # FIXME: What are good aggressive warning flags for Visual Studio?

        # And do we need to further subcase this for different versions of VS?

        # CMake variables: MSVC60, MSVC70, MSVC71, MSVC80, CMAKE_COMPILER_2005

        SET(AGGRESSIVE_WARNING_FLAGS "/Wall /W4")

    ELSE(MSVC)

        # CMake lacks an elseif, so other non-gcc, non-VS compilers need

        # to be listed below. If unhandled, OSG_AGGRESSIVE_WARNING_FLAGS should

        # remain unset.

    ENDIF(MSVC)

ENDIF(CMAKE_COMPILER_IS_GNUCXX)

# This part is for the CMake menu option to toggle the warnings on/off.

# This will only be made available if we set values for OSG_AGGRESSIVE_WARNING_FLAGS.

IF(AGGRESSIVE_WARNING_FLAGS)

    OPTION(USE_AGGRESSIVE_WARNINGS "Enable to activate aggressive warnings" OFF)

    MARK_AS_ADVANCED(USE_AGGRESSIVE_WARNINGS)

    IF(USE_AGGRESSIVE_WARNINGS)

        IF(NOT "${OLD_CMAKE_CXX_FLAGS_WAS_SET}")

            SET(OLD_CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}" CACHE INTERNAL "Old CXX flags")

            SET(OLD_CMAKE_CXX_FLAGS_WAS_SET 1 CACHE INTERNAL "Old CXX flags was set")

            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${AGGRESSIVE_WARNING_FLAGS}" CACHE STRING "Flags used by the compiler during all build types." FORCE)

        ENDIF(NOT "${OLD_CMAKE_CXX_FLAGS_WAS_SET}")

    ELSE(USE_AGGRESSIVE_WARNINGS)

        # FIXME: This will lose any changes made after OLD_CMAKE_CXX_FLAGS was

        # set. The better way would be to parse the string and remove each

        # option explicitly.

        IF("${OLD_CMAKE_CXX_FLAGS_WAS_SET}")

            SET(CMAKE_CXX_FLAGS "${OLD_CMAKE_CXX_FLAGS}" CACHE STRING "Flags used by the compiler during all build types." FORCE)

            SET(OLD_CMAKE_CXX_FLAGS_WAS_SET 0 CACHE INTERNAL "Old CXX flags was set")

        ENDIF("${OLD_CMAKE_CXX_FLAGS_WAS_SET}")

    ENDIF(USE_AGGRESSIVE_WARNINGS)

ENDIF(AGGRESSIVE_WARNING_FLAGS)

# Set defaults for Universal Binaries. We want 32-bit Intel/PPC on 10.4

# and 32/64-bit Intel/PPC on >= 10.5. Anything <= 10.3 doesn't support.

IF(APPLE)

    # These are just defaults/recommendations, but how we want to build

    # out of the box. But the user needs to be able to change these options.

    # So we must only set the values the first time CMake is run, or we

    # will overwrite any changes the user sets.

    # FORCE is used because the options are not reflected in the UI otherwise.

    # Seems like a good place to add version specific compiler flags too.

    IF(NOT CONFIG_HAS_BEEN_RUN_BEFORE)

        # This is really fragile, but CMake doesn't provide the OS system

        # version information we need. (Darwin versions can be changed

        # independently of OS X versions.)

        # It does look like CMake handles the CMAKE_OSX_SYSROOT automatically.

        IF(EXISTS /Developer/SDKs/10.5.sdk)

            SET(CMAKE_OSX_ARCHITECTURES "ppc;i386;ppc64;x86_64" CACHE STRING "Build architectures for OSX" FORCE)

            SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.5 -ftree-vectorize -fvisibility-inlines-hidden" CACHE STRING "Flags used by the compiler during all build types." FORCE)

        ELSE(EXISTS /Developer/SDKs/10.5.sdk)

            IF(EXISTS /Developer/SDKs/MacOSX10.4u.sdk)

                SET(CMAKE_OSX_ARCHITECTURES "ppc;i386" CACHE STRING "Build architectures for OSX" FORCE)

                SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -mmacosx-version-min=10.4 -ftree-vectorize -fvisibility-inlines-hidden" CACHE STRING "Flags used by the compiler during all build types." FORCE)

            ELSE(EXISTS /Developer/SDKs/MacOSX10.4u.sdk)

                # No Universal Binary support

                # Should break down further to set the -mmacosx-version-min,

                # but the SDK detection is too unreliable here.

            ENDIF(EXISTS /Developer/SDKs/MacOSX10.4u.sdk)

        ENDIF(EXISTS /Developer/SDKs/10.5.sdk)

    ENDIF(NOT CONFIG_HAS_BEEN_RUN_BEFORE)

ENDIF(APPLE)

SET(JECW_VERSION "0.0.5" CACHE STRING "JECW_VERSION")

find_package(JNI) 

find_package(ECW) 

link_directories(${LIBRARY_OUTPUT_PATH})

add_subdirectory(src/main/native/jecw)

# This needs to be run very last so other parts of the scripts can take

# advantage of this.

IF(NOT CONFIG_HAS_BEEN_RUN_BEFORE)

    SET(CONFIG_HAS_BEEN_RUN_BEFORE 1 CACHE INTERNAL "Flag to track whether this is the first time running CMake or if CMake has been configured before")

ENDIF(NOT CONFIG_HAS_BEEN_RUN_BEFORE)

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

	<description>

		Compila la librería jecw

	</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="jecw_version" value="0.0.5">

		<os family="unix"/>

	</condition>

	<condition property="jecw_version" value="005">

		<os family="windows"/>

	</condition>

	<property name="jecw-jar" location="jecw-0.0.5.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}" />

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

		<jar jarfile="${jecw-jar}" basedir="${build}" includes="com/ermapper/**,es/gva/cit/jecwcompress/**" />

		<move file="${jecw-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">

			<arg line=".." />

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

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

			<arg line="-DJECW_VERSION=${jecw_version}" />

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

		<delete dir="bin"/>

	</target>

</project>

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

<classpath>

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

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

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

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

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

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

</classpath>

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

<projectDescription>

	<name>libjni-ecw</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 com.ermapper.ecw;

import junit.framework.TestCase;

public class TestReadEcw extends TestCase{

	private JNCSFile 				file = null;

	private String 					fileName = "miniraster30x30.jp2";

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

	private String 					file1 = baseDir + fileName;

	private int						numBands = 0;

	private int 					width = 0;

	private int						height = 0;

	private String					projection = null;

	public void start(){

		setUp();

		testStack();

	}

	public void setUp(){

		try {

			System.out.println("***** TEST DE ACCESO A ECW *****");

			System.out.println("     IMAGEN: " + fileName + "\n");

			file = new JNCSFile();

			file.open(file1, true);

			System.out.println("Acedo a algunos datos de la imagen: ");

			numBands = file.numBands;

			height = file.height;

			width = file.width;

			projection = file.projection;

			System.out.println("Número de bandas: " + numBands);

			System.out.println("Alto: " + height);

			System.out.println("Ancho: " + width);

			System.out.println("Proyección: " + projection);

		} catch (JNCSException e) {

			e.printStackTrace();

		}

	}

	public void testStack(){

	}

}

package com.ermapper.ecw;

import junit.framework.TestCase;

import es.gva.cit.jecwcompress.CompressFormat;

import es.gva.cit.jecwcompress.EcwException;

import es.gva.cit.jecwcompress.JniObject;

import es.gva.cit.jecwcompress.NCSEcwCompressClient;

import es.gva.cit.jecwcompress.ReadCallBack;

public class TestCompressImage extends TestCase{

	private JNCSFile 				file = null;

	private String 					fileName = "miniraster30x30.jp2";

	private String					outFileName = "compressTestOutput.jp2";

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

	private String 					file1 = baseDir + fileName;

	private String					outFile = baseDir + outFileName;

	private NCSEcwCompressClient 	client = null;

	private Read 					lectura=null;

	private int						numBands = 0;

	private int						xSize = 0;

	private int						ySize = 0;

	public void start(){

		setUp();

		testStack();

	}

	public void setUp(){

		try {

			file = new JNCSFile();

			file.open(file1, true);

			numBands = file.numBands;

			xSize = file.width;

			ySize = file.height;

		} catch (JNCSException e) {

		} 

		  try{

		  	client = new NCSEcwCompressClient();

		  	client.setOutputFilename(outFile);  	

		  	client.setInputFilename(file1);

		    client.setTargetCompress(new Double(10.0));

		    client.setInOutSizeX(xSize);

		    client.setInOutSizeY(ySize);

		    client.setInputBands(numBands);

		    client.setCompressFormat(CompressFormat.COMPRESS_NONE);

			client.setProjection("WGS84");

			client.setCellIncrementX(file.cellIncrementX);

			client.setCellIncrementY(file.cellIncrementY);

			client.setOriginX(file.originX);

			client.setOriginY(file.originY);

			client.setCellSizeUnits(1);

			lectura = new Read(file, client, 0, ySize, xSize, ySize);

			client.NCSEcwCompressOpen(false);

			client.NCSEcwCompress(lectura);

			client.NCSEcwCompressClose();

		  }catch(EcwException e){

			  assertNotNull(client);

		  }

	}

	public void testStack(){

	}

}

/**

*

* Para la lectura hay que hacer una clase que extienda de JniObject e implemente ReadCallBack

* . Esto obliga a crear un m?todo loadBuffer. En el hay que meter la funcionalidad para que

* llene el buffer. El buffer esta en la clase cliente y tendr? una longitud de 

* ancho de una l?nea * n?mero de bandas

*/

class Read extends JniObject implements ReadCallBack {

	private JNCSFile miecw=null;

	private NCSEcwCompressClient client=null;

	private int width, height;

	private int ulX, ulY;

	private int[] readBandsFromECW = null;

	private int[] inputRow = null;

	public Read(JNCSFile ecw, NCSEcwCompressClient client,int ulx, int uly, int width, int height){

		this.miecw = ecw;

		this.client = client;

		this.width = width;

		this.height = height;

		this.ulX = ulx;

		this.ulY = uly;

		readBandsFromECW = new int[Math.max(miecw.numBands, 3)];

		inputRow = new int[miecw.width];

	}

	public void loadBuffer(){

		try {

			readBandsFromECW = new int[]{0, 1, 2};

			miecw.setView(miecw.numBands, readBandsFromECW, miecw.originX, miecw.originY + (miecw.cellIncrementY * nNextLine),

					miecw.originX + (miecw.cellIncrementX * miecw.width), 

					miecw.originY + (miecw.cellIncrementY * (nNextLine + 1)), 

					miecw.width, 1);

			miecw.readLineRGBA(inputRow);

			for(int col=0 ; col<inputRow.length ; col++){				

				client.buffer[col+(width*0)]=(byte)Math.abs(((inputRow[col] & 0x00ff0000) >> 16));

				client.buffer[col+(width*1)]=(byte)Math.abs(((inputRow[col] & 0x0000ff00) >> 8));

				client.buffer[col+(width*2)]=(byte)Math.abs((inputRow[col] & 0x000000ff));

			}

		} catch (JNCSFileNotOpenException e) {

		} catch (JNCSInvalidSetViewException e) {

		} catch (JNCSException e) {

		}

	}

	public void updatePercent(){

		System.out.println(client.getPercent()+"%");

	}

}

set(LIB_NAME jecw)

FILE(GLOB LIB_PUBLIC_HEADERS "${HEADER_PATH}/*.h")

FILE(GLOB LIB_COMMON_FILES "*.c*")

IF(WIN32)

	SET_SOURCE_FILES_PROPERTIES(${LIB_COMMON_FILES} PROPERTIES LANGUAGE CXX)

ENDIF(WIN32)

include_directories(

	${JAVA_INCLUDE_PATH}

	${JAVA_INCLUDE_PATH2}

	${ECW_INCLUDE_DIR}

)

add_library(${LIB_NAME} SHARED

	${LIB_PUBLIC_HEADERS}

	${LIB_COMMON_FILES}

)

IF(WIN32)

	target_link_libraries(${LIB_NAME}

		${ECW_LIBRARY}

		${ECW_LIBRARY2}

		${ECW_LIBRARY3}

	)

ELSEIF(WIN32)

	target_link_libraries(${LIB_NAME}

		${ECW_LIBRARY}

		${ECW_LIBRARY2}

		${ECW_LIBRARY3}

		$(ECW_LIBRARY4)

	)

ENDIF(WIN32)

if(APPLE)

SET_TARGET_PROPERTIES(${LIB_NAME}

	PROPERTIES

	SUFFIX .jnilib)

endif(APPLE)

INCLUDE(ModuleInstall OPTIONAL)

SET_TARGET_PROPERTIES(jecw PROPERTIES VERSION "${JECW_VERSION}")

IF(UNIX)

	SET_TARGET_PROPERTIES(jecw PROPERTIES OUTPUT_NAME "jecw${VERSION}")

ENDIF(UNIX)

IF(WIN32)

	SET_TARGET_PROPERTIES(jecw PROPERTIES OUTPUT_NAME "jecw${JECW_VERSION}")

ENDIF(WIN32)

IF(UNIX AND NOT APPLE)

	SET_TARGET_PROPERTIES ( ${LIB_NAME} PROPERTIES LINK_FLAGS "-Wl,-E")

ENDIF(UNIX AND NOT APPLE)

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

 * $Id: ncsecwcompressclient_wrapper.c 4274 2006-03-06 07:32:00Z nacho $

 *

 * Name:     bsb_interfaz.c

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

 * Purpose:  Interface functions to manage bsb files. This include gdal

 * 			code but it doesn't use the gdal API.

 * 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 <string.h>

#include <malloc.h>

#include "NCSECWCompressClient.h"

typedef struct ReadInfo {

	//NCSFileView 	*pNCSFileView;

	UINT8 			**ppInputBandBufferArray;

	UINT32 			nPercentComplete;

	jclass			clase;

	jobject			*jclient;

	jobject			*jreadcall;

	JNIEnv 			*env;

	char 			pErrorBuffer[1024];

} ReadInfo;

static BOOLEAN 	callBackOn = TRUE;

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

//								ReadCallback

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

static BOOLEAN ReadCallback(NCSEcwCompressClient *pClient,

							UINT32 nNextLine,

							IEEE4 **ppOutputBandBufferArray)

{

	ReadInfo *pReadInfo = (ReadInfo *)pClient->pClientData;

	UINT32 nBand;

	jfieldID fid;

	jbyteArray jarray;

	JNIEnv *env=pReadInfo->env;

	int longitud;

	jclass clase_client;

	jclass clase_readcall;

	jmethodID metodo;

    if(callBackOn){

		clase_client = (env)->GetObjectClass(*(pReadInfo->jclient));

		clase_readcall = (env)->GetObjectClass(*(pReadInfo->jreadcall));

		//Ponemos el valor de la banda un n?mero de l?nea en el objeto cliente		

	  	fid = (env)->GetFieldID(clase_readcall, "nNextLine", "I");

	  	(env)->SetIntField(*(pReadInfo->jreadcall), fid, nNextLine); 

	   	//Ejecutamos la funci?n de java que carga el buffer

		metodo = (env)->GetMethodID(clase_readcall, "loadBuffer", "()V");

		(env)->CallVoidMethod(*(pReadInfo->jreadcall), metodo);

		//Obtenemos el array de bytes desde java

		fid = (env)->GetFieldID(clase_client, "buffer", "[B");

	    jarray =(jbyteArray)(env)->GetObjectField(*(pReadInfo->jclient), fid);  

	    longitud = (env)->GetArrayLength(jarray);

	    (env)->GetByteArrayRegion(jarray,0,longitud,(jbyte *)pReadInfo->ppInputBandBufferArray[0]);

		for(nBand = 0; nBand < pClient->nInputBands; nBand++) {

			UINT32 nCell;		

			UINT8 *pInputValue = pReadInfo->ppInputBandBufferArray[nBand];

			IEEE4 *pOutputValue = ppOutputBandBufferArray[nBand];

			// Compression needs input to be IEEE4

			for (nCell = 0; nCell < pClient->nInOutSizeX; nCell++) {

				*pOutputValue++ = (IEEE4)*pInputValue++;

			}

		}

		return(TRUE);	

    }else

    	return(FALSE);

}

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

//								StatusCallback

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

//Asigna el tanto por cien de imagen que lleva comprimido en una variable de java

//Ejecuta la funci?n updatePercent de java despues de actualizar la varible.

static void StatusCallback(NCSEcwCompressClient *pClient,

						   UINT32 nCurrentLine)

{

	ReadInfo 	*pReadInfo = (ReadInfo *)pClient->pClientData;

	UINT32 		nPercentComplete = (nCurrentLine * 100) / (pClient->nInOutSizeY - 1);

	jclass 		clase_client;

	jclass 		clase_readcall;

	JNIEnv 		*env=pReadInfo->env;

	jfieldID 	fid;

	jmethodID 	metodo;

	clase_client = (env)->GetObjectClass(*(pReadInfo->jclient));

	clase_readcall = (env)->GetObjectClass(*(pReadInfo->jreadcall));

	if (nPercentComplete != pReadInfo->nPercentComplete) {

		fid = (env)->GetFieldID(clase_client, "porcentaje", "I");

	  	(env)->SetIntField(*(pReadInfo->jclient), fid, nPercentComplete);

  		metodo = (env)->GetMethodID(clase_readcall, "updatePercent", "()V");

		(env)->CallVoidMethod(*(pReadInfo->jreadcall), metodo); 

		pReadInfo->nPercentComplete = nPercentComplete;

	}

}

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

//								NCSEcwCompressClient

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

JNIEXPORT jlong JNICALL Java_es_gva_cit_jecwcompress_NCSEcwCompressClient_NCSEcwCompressClientNat

  (JNIEnv *env, jobject obj){

  	NCSEcwCompressClient 	*pClient;

  	jlong 					jresult = 0 ;

  	if(pClient = NCSEcwCompressAllocClient()){

  		*(NCSEcwCompressClient **)&jresult = pClient;

  		return jresult;

  	}else

  		return -1;

  }

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

//								NCSEcwCompressOpen

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

JNIEXPORT jint JNICALL Java_es_gva_cit_jecwcompress_NCSEcwCompressClient_NCSEcwCompressOpenNat

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

  	NCSEcwCompressClient 	*pClient = (NCSEcwCompressClient *) 0 ;

  	NCSError 				eError;

  	jfieldID 				fid;

    jobject					obj_str;

    const char				*str;

    ReadInfo 				*compress_readInfo;

    jmethodID 				metodo;

    UINT8 *pReadBuffer,nBand;

  	pClient = *(NCSEcwCompressClient **)&cPtr;

  	if(pClient!=NULL){

  		//Asignamos los valores de los campos de NCSEcwCompress

  		jclass clase = (env)->GetObjectClass(obj);

  		fid = (env)->GetFieldID(clase, "inputFilename", "Ljava/lang/String;");

  		obj_str = (env)->GetObjectField(obj, fid);

  		if(obj_str!=NULL){

			str = (env)->GetStringUTFChars((jstring)obj_str,0);

	  		strcpy(pClient->szInputFilename,str);

	  		str=NULL;

	  		(env)->ReleaseStringUTFChars((jstring)obj_str, str);

	  		//printf("inputFilename=%s\n",pClient->szInputFilename);

  		}

  		fid = (env)->GetFieldID(clase, "outputFilename", "Ljava/lang/String;");

  		obj_str = (env)->GetObjectField(obj, fid);

  		if(obj_str!=NULL){

			str = (env)->GetStringUTFChars((jstring)obj_str,0);

	  		strcpy(pClient->szOutputFilename,str);

	  		str=NULL;

	  		(env)->ReleaseStringUTFChars((jstring)obj_str, str);

	  		//printf("outputFilename=%s\n",pClient->szOutputFilename);

  		}

  		fid = (env)->GetFieldID(clase, "targetCompression", "D");

  		pClient->fTargetCompression = (IEEE4)(env)->GetDoubleField(obj, fid);

  		//printf("targetCompression=%f\n",pClient->fTargetCompression);

  		fid = (env)->GetFieldID(clase, "eCompressFormat", "I");

  		pClient->eCompressFormat = (CompressFormat)(env)->GetIntField(obj, fid);

  		//printf("eCompressFormat=%d\n",pClient->eCompressFormat);

  		fid = (env)->GetFieldID(clase, "eCompressHint", "I");

  		pClient->eCompressHint = (CompressHint)(env)->GetIntField(obj, fid);

  		//printf("eCompressHint=%d\n",pClient->eCompressHint);

  		fid = (env)->GetFieldID(clase, "nBlockSizeX", "I");

  		pClient->nBlockSizeX = (env)->GetIntField(obj, fid);

  		//printf("nBlockSizeX=%d\n",pClient->nBlockSizeX);

  		fid = (env)->GetFieldID(clase, "nBlockSizeY", "I");

  		pClient->nBlockSizeY = (env)->GetIntField(obj, fid);

  		//printf("nBlockSizeY=%d\n",pClient->nBlockSizeY);

  		fid = (env)->GetFieldID(clase, "nInOutSizeX", "I");

  		pClient->nInOutSizeX = (env)->GetIntField(obj, fid);

  		//printf("nInOutSizeX=%d\n",pClient->nInOutSizeX);

  		fid = (env)->GetFieldID(clase, "nInOutSizeY", "I");

  		pClient->nInOutSizeY = (env)->GetIntField(obj, fid);

  		//printf("nInOutSizeY=%d\n",pClient->nInOutSizeY);

  		fid = (env)->GetFieldID(clase, "nInputBands", "I");

  		pClient->nInputBands = (env)->GetIntField(obj, fid);

  		//printf("nInputBands=%d\n",pClient->nInputBands);

  		fid = (env)->GetFieldID(clase, "nOutputBands", "I");

  		pClient->nOutputBands = (env)->GetIntField(obj, fid);

		//printf("nOutputBands=%d\n",pClient->nOutputBands);

  		fid = (env)->GetFieldID(clase, "nInputSize", "J");

  		pClient->nInputSize = (env)->GetLongField(obj, fid);

  		//printf("nInputSize=%ld\n",pClient->nInputSize);

  		fid = (env)->GetFieldID(clase, "fCellIncrementX", "D");

  		pClient->fCellIncrementX = (env)->GetDoubleField(obj, fid);

  		//printf("fCellIncrementX=%f\n",pClient->fCellIncrementX);

  		fid = (env)->GetFieldID(clase, "fCellIncrementY", "D");

  		pClient->fCellIncrementY = (env)->GetDoubleField(obj, fid);

  		//printf("fCellIncrementY=%f\n",pClient->fCellIncrementY);

  		fid = (env)->GetFieldID(clase, "fOriginX", "D");

  		pClient->fOriginX = (env)->GetDoubleField(obj, fid);

  		//printf("fOriginX=%f\n",pClient->fOriginX);

  		fid = (env)->GetFieldID(clase, "fOriginY", "D");

  		pClient->fOriginY = (env)->GetDoubleField(obj, fid);

  		//printf("fOriginY=%f\n",pClient->fOriginY);

  		fid = (env)->GetFieldID(clase, "eCellSizeUnits", "I");

  		pClient->fActualCompression = (IEEE4)(env)->GetIntField(obj, fid);

  		//printf("eCellSizeUnits=%d\n",pClient->fActualCompression);

  		fid = (env)->GetFieldID(clase, "szDatum", "Ljava/lang/String;");

  		obj_str = (env)->GetObjectField(obj, fid);

  		if(obj_str!=NULL){

			str = (env)->GetStringUTFChars((jstring)obj_str,0);

	  		strcpy(pClient->szDatum,str);

	  		str=NULL;

	  		(env)->ReleaseStringUTFChars((jstring)obj_str, str);

	  		//printf("szDatum=%s\n",pClient->szDatum);

  		}

  		fid = (env)->GetFieldID(clase, "szProjection", "Ljava/lang/String;");

  		obj_str = (env)->GetObjectField(obj, fid);

  		if(obj_str!=NULL){

			str = (env)->GetStringUTFChars((jstring)obj_str,0);

	  		strcpy(pClient->szProjection,str);

	  		str=NULL;

	  		(env)->ReleaseStringUTFChars((jstring)obj_str, str);

	  		//printf("szProjection=%s\n",pClient->szProjection);

  		}

  		fid = (env)->GetFieldID(clase, "fActualCompression", "D");

  		pClient->fActualCompression = (IEEE4)(env)->GetDoubleField(obj, fid);

  		//printf("fActualCompression=%f\n",pClient->fActualCompression);

  		fid = (env)->GetFieldID(clase, "fCompressionSeconds", "D");

  		pClient->fCompressionSeconds = (env)->GetDoubleField(obj, fid);

  		//printf("fCompressionSeconds=%f\n",pClient->fCompressionSeconds);

  		fid = (env)->GetFieldID(clase, "fCompressionMBSec", "D");

  		pClient->fCompressionMBSec = (env)->GetDoubleField(obj, fid);

  		//printf("fCompressionMBSec=%f\n",pClient->fCompressionMBSec);

  		fid = (env)->GetFieldID(clase, "nOutputSize", "J");

  		pClient->nOutputSize = (env)->GetLongField(obj, fid);

  		//printf("nOutputSize=%ld\n",pClient->nOutputSize);

  		pClient->pReadCallback = ReadCallback;

		pClient->pStatusCallback = StatusCallback;

		//Inicializar el buffer que tendr? una l?nea de entrada x el n?m de bandas

		metodo = (env)->GetMethodID(clase, "initialize", "()V");

		(env)->CallIntMethod(obj,metodo);

		compress_readInfo = (ReadInfo *)malloc(sizeof(ReadInfo));

		pReadBuffer = (UINT8 *)malloc(sizeof(UINT8) *

								  pClient->nInOutSizeX *

								  pClient->nInputBands);

		compress_readInfo->ppInputBandBufferArray = (UINT8 **)malloc(sizeof(UINT8 *) *

								   pClient->nInputBands);

		for (nBand = 0; nBand < pClient->nInputBands; nBand++) {

			compress_readInfo->ppInputBandBufferArray[nBand] = pReadBuffer + 

			(nBand * pClient->nInOutSizeX * sizeof(UINT8));

		}

		if (compress_readInfo->ppInputBandBufferArray == NULL) return 46;

		compress_readInfo->nPercentComplete = 0;

		pClient->pClientData = (void *)compress_readInfo;

	  	eError = NCSEcwCompressOpen(pClient, ((bCalculateSizesOnly==0)? FALSE : TRUE));

		return eError;

  	}

  	return -1;

  }

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

//								NCSEcwCompress

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

JNIEXPORT jint JNICALL Java_es_gva_cit_jecwcompress_NCSEcwCompressClient_NCSEcwCompressNat

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

  	NCSEcwCompressClient 	*pClient = (NCSEcwCompressClient *) 0 ;

  	ReadInfo 				*compress_readInfo = (ReadInfo *) 0 ;

  	NCSError 				eError;

	pClient = *(NCSEcwCompressClient **)&cPtr;

	compress_readInfo = (ReadInfo *)pClient->pClientData;

	compress_readInfo->jclient=&obj;

	compress_readInfo->jreadcall=&obj_read;

	compress_readInfo->env=env;	

	eError = NCSEcwCompress(pClient);

	return eError;  	

  }

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

//								NCSEcwCompressClose

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

JNIEXPORT jint JNICALL Java_es_gva_cit_jecwcompress_NCSEcwCompressClient_NCSEcwCompressCloseNat

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

  	NCSEcwCompressClient 	*pClient = (NCSEcwCompressClient *) 0 ;

  	NCSError 				eError;

	pClient = *(NCSEcwCompressClient **)&cPtr;	

	eError = NCSEcwCompressClose(pClient);

	return eError;  	

  }  

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

//								NCSEcwCompressCancel

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

JNIEXPORT void JNICALL Java_es_gva_cit_jecwcompress_NCSEcwCompressClient_NCSEcwCompressCancelNat

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

  	callBackOn = FALSE;

  }

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

//								finalize

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

JNIEXPORT void JNICALL Java_es_gva_cit_jecwcompress_NCSEcwCompressClient_finalizeNat

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

  	ReadInfo 				*compress_readInfo = (ReadInfo *) 0 ;

  	NCSEcwCompressClient 	*pClient = (NCSEcwCompressClient *) 0 ;

    int 					nBand;	

	pClient = *(NCSEcwCompressClient **)&cPtr;	

  	//Liberamos la memoria

  	compress_readInfo = (ReadInfo *)pClient->pClientData;

  	for (nBand = 0; nBand < pClient->nInputBands; nBand++) {

			free(compress_readInfo->ppInputBandBufferArray[nBand]);

	}

  	free(compress_readInfo->ppInputBandBufferArray);

  	free(pClient->pClientData);

  	pClient->pClientData = NULL;

  	NCSEcwCompressFreeClient(pClient);

  }

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

** Copyright 1998 Earth Resource Mapping Ltd.

** This document contains proprietary source code of

** Earth Resource Mapping Ltd, and can only be used under

** one of the three licenses as described in the 

** license.txt file supplied with this distribution. 

** See separate license.txt file for license details 

** and conditions.

**

** This software is covered by US patent #6,442,298,

** #6,102,897 and #6,633,688.  Rights to use these patents 

** is included in the license agreements.

** 

** FILE:   	ecw_jni.c

** CREATED:	4 Jan 2000

** AUTHOR: 	Mark Sheridan

** PURPOSE:	Java wrappers for JNI usage of the ECW library in Java.

** EDITS:

** 

** [01] 01Nov00 mjs Rewrote to be JVM 1.1 compliant.

** [02] 08Mar04 mjs Removed old 1.1 spec stuff, now needs a 1.2 compatible virtual machine.

** [03] 01Oct05 nbt ECWOpenArray function to support name parameter in char array

**

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

#include "NCSErrors.h"

#include "NCSECWClient.h"

#include "NCSMalloc.h" 

#include "NCSUtil.h"

#include "NCSBuildNumber.h"

#include "JNCSFile.h"

#include "NCSFile.h"

#include "NCSDynamicLib.h"

//#ifndef JNI_VERSION_1_2

//#error You must compile this class against a 1.2 virtual machine specification

//#endif

static JavaVM *pJavaVirtualMachineInst = NULL;

struct NCSJNIFieldIDs *pGlobalJNCSFieldIDs = NULL;

typedef struct NCSJNIFieldIDs {

	jfieldID jIDNativeDataPointer;

	jfieldID jIDWidth;

	jfieldID jIDHeight;	

	jfieldID jIDNumberOfBands;

	jfieldID jIDCompressionRate;

	jfieldID jIDCellIncrementX;

	jfieldID jIDCellIncrementY;

	jfieldID jIDCellSizeUnits;

	jfieldID jIDOriginX;

	jfieldID jIDOriginY;

	jfieldID jIDDatum;

	jfieldID jIDProjection;

	jfieldID jIDFilename;

	jfieldID jIDIsOpen;

	jmethodID jIDRefreshUpdateMethod;

	jfieldID jIDFileType;

	jfieldID jIDFileMimeType;

} NCSJNIFieldIDs;

// This is the object specific data structure, its cached.

typedef struct NCSJNIInfo {

	//jobject  ECWFile;

	NCSFileView *pFileView;

} NCSJNIInfo;

void NCSJNIThrowException(JNIEnv *pEnv, const char *pSignature, const char *pMessage)

{

	jclass jExceptionClass = NULL;

	if ((pEnv)->ExceptionCheck()) {

		(pEnv)->ExceptionDescribe();

		(pEnv)->ExceptionClear();

	}

	jExceptionClass = (pEnv)->FindClass(pSignature);

	if (jExceptionClass != NULL) {

		(pEnv)->ThrowNew(jExceptionClass, pMessage); 

	}

	(pEnv)->DeleteLocalRef(jExceptionClass);

}

NCSError NCSCreateJNIInfoStruct(JNIEnv *pEnv, jobject ECWFile, NCSFileView *pNCSFileView, NCSJNIInfo **pReturn)

{

	NCSJNIInfo *pJNIInfo;

	//char *pErrorString = NULL;

	pJNIInfo = (NCSJNIInfo *)NCSMalloc(sizeof(NCSJNIInfo), TRUE);

	if (pJNIInfo != NULL)

	{

		pJNIInfo->pFileView = pNCSFileView;

		//pJNIInfo->ECWFile = (void *)(*pEnv)->NewGlobalRef(pEnv, ECWFile);

		*pReturn = pJNIInfo;

	}

	else

	{

		return NCS_COULDNT_ALLOC_MEMORY;

	}

	return NCS_SUCCESS;

}

/*

 * Class:     None

 * Method:    JNI_OnLoad

 * Signature: ()Z

 */

JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *pJVM, void *reserved)

{

	JNIEnv *pEnv;

	if ((pJVM)->GetEnv((void **)&pEnv, JNI_VERSION_1_2)) {

		NCSJNIThrowException(pEnv, "java/lang/Exception", "JNCS classes require a version 1.2 or higher virtual machine.");

		return JNI_ERR;

	}

	else {

		pJavaVirtualMachineInst = pJVM;

#ifndef WIN32

		NCSecwInit();

#endif

	}

	return JNI_VERSION_1_2;

}

/*

 * Class:     None

 * Method:    JNI_OnUnload

 * Signature: ()Z

 */

JNIEXPORT void JNICALL JNI_OnUnload(JavaVM *pJVM, void *reserved)

{

#ifndef WIN32

		NCSecwShutdown();

#endif

		NCSFree((void *)pGlobalJNCSFieldIDs);

	return;

}

/*

 * Class:     com_ermapper_ecw_JNCSFile

 * Method:    NCSJNIInit

 * Signature: ()I

 */

JNIEXPORT jint JNICALL Java_com_ermapper_ecw_JNCSFile_NCSJNIInit

  (JNIEnv *pEnv, jclass ECWFileClass)

{

	NCSJNIFieldIDs *pJNIInfo = NULL;

	char *pErrorString = NULL;

	if (!pGlobalJNCSFieldIDs) {

		pJNIInfo = (NCSJNIFieldIDs *)NCSMalloc(sizeof(NCSJNIFieldIDs), TRUE);

		// Get all the field ids of the ECWFile object

		pJNIInfo->jIDNativeDataPointer	= (pEnv)->GetFieldID(ECWFileClass, "nativeDataPointer", "J" );

		pJNIInfo->jIDWidth				= (pEnv)->GetFieldID(ECWFileClass, "width", "I" );

		pJNIInfo->jIDHeight				= (pEnv)->GetFieldID(ECWFileClass, "height", "I" );

		pJNIInfo->jIDNumberOfBands		= (pEnv)->GetFieldID(ECWFileClass, "numBands", "I" );

		pJNIInfo->jIDCompressionRate	= (pEnv)->GetFieldID(ECWFileClass, "compressionRate", "D" );

		pJNIInfo->jIDCellIncrementX		= (pEnv)->GetFieldID(ECWFileClass, "cellIncrementX", "D" );

		pJNIInfo->jIDCellIncrementY		= (pEnv)->GetFieldID(ECWFileClass, "cellIncrementY", "D" );

		pJNIInfo->jIDCellSizeUnits		= (pEnv)->GetFieldID(ECWFileClass, "cellSizeUnits", "I" );

		pJNIInfo->jIDOriginX			= (pEnv)->GetFieldID(ECWFileClass, "originX", "D" );

		pJNIInfo->jIDOriginY			= (pEnv)->GetFieldID(ECWFileClass, "originY", "D" );

		pJNIInfo->jIDDatum				= (pEnv)->GetFieldID(ECWFileClass, "datum", "Ljava/lang/String;" );

		pJNIInfo->jIDProjection			= (pEnv)->GetFieldID(ECWFileClass, "projection", "Ljava/lang/String;" );

		pJNIInfo->jIDFilename			= (pEnv)->GetFieldID(ECWFileClass, "fileName", "Ljava/lang/String;" );

		pJNIInfo->jIDIsOpen				= (pEnv)->GetFieldID(ECWFileClass, "bIsOpen", "Z" );

		pJNIInfo->jIDRefreshUpdateMethod= (pEnv)->GetMethodID(ECWFileClass, "refreshUpdate", "(IIDDDD)V");

		//pJNIInfo->jIDFileType			= (pEnv)->GetFieldID(ECWFileClass, "fileType", "I" );

		//pJNIInfo->jIDFileMimeType		= (pEnv)->GetFieldID(ECWFileClass, "mimeType", "Ljava/lang/String;" );

		// Do some error checking

		if (!pJNIInfo->jIDNativeDataPointer)

			pErrorString = "Could not determine fieldID for 'nativeDataPointer' in ECWFile object.";

		if (!pJNIInfo->jIDWidth)

			pErrorString = "Could not determine fieldID for 'width' in ECWFile object.";

		if (!pJNIInfo->jIDHeight)

			pErrorString = "Could not determine fieldID for 'height' in ECWFile object.";

		if (!pJNIInfo->jIDNumberOfBands)

			pErrorString = "Could not determine fieldID for 'numBands' in ECWFile object.";

		if (!pJNIInfo->jIDCompressionRate)

			pErrorString = "Could not determine fieldID for 'compressionRate' in ECWFile object.";

		if (!pJNIInfo->jIDCellIncrementX)

			pErrorString = "Could not determine fieldID for 'cellIncrementX' in ECWFile object.";

		if (!pJNIInfo->jIDCellIncrementY)

			pErrorString = "Could not determine fieldID for 'cellIncrementY' in ECWFile object.";

		if (!pJNIInfo->jIDCellSizeUnits)

			pErrorString = "Could not determine fieldID for 'cellSizeUnits' in ECWFile object.";

		if (!pJNIInfo->jIDOriginX)

			pErrorString = "Could not determine fieldID for 'originX' in ECWFile object.";

		if (!pJNIInfo->jIDOriginY)

			pErrorString = "Could not determine fieldID for 'originY' in ECWFile object.";

		if (!pJNIInfo->jIDDatum)

			pErrorString = "Could not determine fieldID for 'datum' in ECWFile object.";

		if (!pJNIInfo->jIDProjection)

			pErrorString = "Could not determine fieldID for 'projection' in ECWFile object.";

		if (!pJNIInfo->jIDFilename)

			pErrorString = "Could not determine fieldID for 'fileName' in ECWFile object.";

		if (!pJNIInfo->jIDIsOpen)

			pErrorString = "Could not determine fieldID for 'bIsOpen' in ECWFile object.";

		/*if (!pJNIInfo->jIDFileType)

			pErrorString = "Could not determine fieldID for 'fileType' in ECWFile object.";

		if (!pJNIInfo->jIDFileMimeType)

			pErrorString = "Could not determine fieldID for 'mimeType' in ECWFile object.";*/

		if (pErrorString) {

#ifdef WIN32

			MessageBox(NULL, OS_STRING(pErrorString), TEXT("JNCSClass Library (JNI)"), MB_OK);

#else

			fprintf(stderr, "JNCSClass Library (JNI) : %s\n", pErrorString);

#endif

			NCSFormatErrorText(NCS_JNI_ERROR, pErrorString);

			return NCS_JNI_ERROR;

		}

		else {

			pGlobalJNCSFieldIDs = pJNIInfo;

			return NCS_SUCCESS;

		}

	}

	else {

		return NCS_SUCCESS;

	}

}

/*

 * There is so much that can go wrong in this call, that is why there is so much error checking.

 *

 * Class:     None

 * Method:    NCSJNIRefreshCallback

 * Signature: 

 */

NCSEcwReadStatus NCSJNIRefreshCallback(NCSFileView *pNCSFileView)

{

	NCSFileViewSetInfo	*pViewInfo;

	NCSJNIInfo *pJNIInfo;

	jint nError;

	JNIEnv *pEnv;

	jclass EcwObjectClass = NULL;

	jobject pECWFile = NULL;

	NCScbmGetViewInfo(pNCSFileView, &pViewInfo);

	// Must attach to the vm thread before calling any java methods.

	nError = (pJavaVirtualMachineInst)->AttachCurrentThread((void **)&pEnv, NULL);

	if (nError != 0) {

		char Message[] = "The ECW JNI interface could not attach to the current thread in\n"

						 "the Java virtual machine. Please refer to the Image Web Server\n"

						 "Java SDK documentation for more information about JVM threads.\n\n"

						 "Progressive imagery will not be available.";

#ifdef WIN32

		MessageBox(GetActiveWindow(), OS_STRING(Message), TEXT("JNCSFile VM Error"), MB_OK);

#else

		fprintf(stderr, "JNCSFile VM Error : %s\n", Message);

#endif

		return NCSECW_READ_FAILED;

	}

	// Make sure we got a view info struct.

	if (!pViewInfo) {

		NCSJNIThrowException(pEnv, "java/lang/Exception", "ECW JNI component could not obtain the NCSViewInfo pointer from the NCSFileView. No refreshUpdate() will occur.");

		(pJavaVirtualMachineInst)->DetachCurrentThread();

		return NCSECW_READ_FAILED;

	}

	// The file is the global reference stashed in the client data pointer.

	pECWFile = (jobject)pViewInfo->pClientData;

	// Check to make sure that the ECW object has not been free'd or garbaged collected. This is only valid for JNI 1.2

	if ((pEnv)->IsSameObject(pECWFile/*pViewInfo->pClientData*/, NULL) == JNI_TRUE) {

		(pJavaVirtualMachineInst)->DetachCurrentThread();

		return NCSECW_READ_FAILED;

	}

	// Use the valid reference to the object, to obtain the data pointer.

	pJNIInfo = (NCSJNIInfo *)(pEnv)->GetLongField((jobject)pViewInfo->pClientData, pGlobalJNCSFieldIDs->jIDNativeDataPointer);

	if (!pJNIInfo) {

		NCSJNIThrowException(pEnv, "java/lang/Exception", "The ECW JNI component could not obtain the client data pointer from the NCSViewInfo struct. No refreshUpdate() will occur.");

		(pJavaVirtualMachineInst)->DetachCurrentThread();

		return NCSECW_READ_FAILED;

	}

	EcwObjectClass = (pEnv)->GetObjectClass(pECWFile/*pJNIInfo->ECWFile*/);

	if (EcwObjectClass == NULL) {

		NCSJNIThrowException(pEnv, "java/lang/Exception", "The ECW JNI component could not determine the class signature of the ECW object.");

		(pJavaVirtualMachineInst)->DetachCurrentThread();

		return NCSECW_READ_FAILED;

	}

	(pEnv)->DeleteLocalRef(EcwObjectClass);

	//Call the  "refreshUpdate" method on this object, if it implements the JNCSProgressiveUpdate interface.

	if (pGlobalJNCSFieldIDs->jIDRefreshUpdateMethod) {

		(pEnv)->CallVoidMethod(	pECWFile, \

								pGlobalJNCSFieldIDs->jIDRefreshUpdateMethod, \

								pViewInfo->nSizeX, pViewInfo->nSizeY, \

								pViewInfo->fTopX, pViewInfo->fLeftY, \

								pViewInfo->fBottomX, pViewInfo->fRightY);

	}

	else {

		NCSJNIThrowException(pEnv, "java/lang/ClassNotFoundException", "'refreshUpdate' method not found. Derived classes must implement the interface 'JNCSProgressiveUpdate' to use progressive imagery.");

		(pJavaVirtualMachineInst)->DetachCurrentThread();

		return NCSECW_READ_FAILED;

	}

	(pJavaVirtualMachineInst)->DetachCurrentThread();

	return NCSECW_READ_OK;

}

/**

 * 

 */

int openFile(JNIEnv *pEnv, jobject *JNCSFile, jstring Filename, char *pFilename, jboolean bProgressive, NCSFileViewSetInfo *pNCSFileViewSetInfo, NCSFileView *pNCSFileView){

	NCSError nError;

	if (bProgressive) {

		nError = NCScbmOpenFileView((char *)pFilename, &pNCSFileView, NCSJNIRefreshCallback);

	}

	else {

		nError = NCScbmOpenFileView((char *)pFilename, &pNCSFileView, NULL);

	}

	if (NCS_FAILED(nError)) {

		// Return the short filename, since people dont like diplaying the full ecwp url

		char	*pProtocol, *pHost, *pECWFilename, *pShortFileName;

		int		nProtocolLength, nHostLength, nFilenameLength;

		NCSecwNetBreakdownUrl((char *)pFilename, &pProtocol, &nProtocolLength,

									 &pHost, &nHostLength,

									 &pECWFilename, &nFilenameLength);

		if (pECWFilename && nFilenameLength > 0 && (strstr(pECWFilename, "/") || strstr(pECWFilename, "\\")))

		{

			int len = strlen(pECWFilename), index = 0;

			for (index=len; index > 0; index--)

			{

				pShortFileName = &pECWFilename[index];

				if (pECWFilename[index] == '\\' || pECWFilename[index] == '/')

				{

					pShortFileName ++;

					break;

				}

			}

		}

		else 

		{

			pShortFileName = (char *)pFilename;

		}

		NCSFormatErrorText(NCS_FILE_OPEN_FAILED, pShortFileName, NCSGetLastErrorText(nError));

		return NCS_FILE_OPEN_FAILED;

	}

	else {

		NCSJNIInfo *pJNIInfo = NULL;

		char *pMimeType = NULL;

		NCSFileViewFileInfo	*pNCSFileInfo = NULL;

		nError = NCSCreateJNIInfoStruct(pEnv, (*JNCSFile), pNCSFileView, &pJNIInfo);