| gvSIG desktop 1

bin

dist

project(jmrsid)

# 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)

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

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(JMRSID_VERSION "0.0.5" CACHE STRING "JMRSID_VERSION")

find_package(JNI) 

find_package(MRSID) 

link_directories(${LIBRARY_OUTPUT_PATH})

add_subdirectory(src/main/native/jmrsid)

# 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-mrsid" default="main" basedir=".">

	<description>

		Compila la librería jmrsid

	</description>

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

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

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

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

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

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

	<property name="sdk-dir" location="/home/miguel/mrsid/Geo_DSDK-6.0.7.1407" />

	<property environment="env"/>

	<condition property="jmrsid_version" value="0.0.5">

		<os family="unix"/>

	</condition>

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

		<os family="windows"/>

	</condition>

	<property name="jmrsid-jar" location="jmrsid-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="${jmrsid-jar}" basedir="${build}" includes="es/gva/cit/jmrsid/**" />

		<move file="${jmrsid-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="-DMRSID_DIR=${sdk-dir}" />

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

			<arg line="-DJGDAL_VERSION=${jmrsid_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"/>

	</target>

</project>

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

<?eclipse-cdt version="2.0"?>

<cdtproject id="org.eclipse.cdt.make.core.make">

<extension point="org.eclipse.cdt.core.BinaryParser" id="org.eclipse.cdt.core.ELF"/>

<data>

<item id="org.eclipse.cdt.core.pathentry">

<pathentry kind="src" path=""/>

<pathentry kind="out" path=""/>

<pathentry kind="con" path="org.eclipse.cdt.make.core.DISCOVERED_SCANNER_INFO"/>

</item>

<item id="cdt_indexer">

<indexEnabled indexValue="true"/>

<indexerProblemsEnabled indexProblemsValue="0"/>

</item>

<item id="org.eclipse.cdt.make.core.buildtargets">

<buildTargets>

<target name="all" targetID="org.eclipse.cdt.make.MakeTargetBuilder" path="">

<buildCommand>make</buildCommand>

<buildTarget>all</buildTarget>

<stopOnError>false</stopOnError>

<useDefaultCommand>true</useDefaultCommand>

</target>

<target name="clean" targetID="org.eclipse.cdt.make.MakeTargetBuilder" path="">

<buildCommand>make</buildCommand>

<buildTarget>clean</buildTarget>

<stopOnError>false</stopOnError>

<useDefaultCommand>true</useDefaultCommand>

</target>

</buildTargets>

</item>

</data>

</cdtproject>

<?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="lib" path="/home/miguel/eclipse/plugins/org.junit_3.8.2.v200706111738/junit.jar"/>

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

</classpath>

/* $Id: TIFFImageWriter.h 3539 2006-01-09 12:23:20Z nacho $ */

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

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

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

/* PUBLIC */

#ifndef TIFFIMAGEWRITER_H

#define TIFFIMAGEWRITER_H

// lt_lib_mrsid_core

#include "lti_geoFileImageWriter.h"

struct tiff;

LT_BEGIN_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

class LTIPixelLookupTable;

class LTReusableBuffer;

/**

 * writes an image stage to a TIFF file

 *

 * This class writes an image stage to a TIFF file.

 */

class TIFFImageWriter : public LTIGeoFileImageWriter

{

public:

   /**

    * constructor

    *

    * Creates a writer for TIFF images.

    *

    * @param  image  the image to write from

    */

   TIFFImageWriter(LTIImageStage *image);

   virtual ~TIFFImageWriter();

   virtual LT_STATUS initialize();

   /**

    * Output resolution information.  Set this to false to prevent writing

    * normal TIFF resolution information.

    *

    * The default is to write this information.

    *

    * @param enable set to true to write resolution information

    */

   void setWriteResolution(bool enable);

   LT_STATUS writeBegin(const LTIScene& scene);

   LT_STATUS writeStrip(LTISceneBuffer& stripBuffer, const LTIScene& stripScene);

   LT_STATUS writeEnd();

protected:

   virtual LT_STATUS writeHeaders(lt_uint32 width, lt_uint32 height);

   static LT_STATUS getLibtiffError(void);

   // GeoTIFFImageWriter sets this prior to calling Super::initialize()

   struct tiff *m_tiff;

   double m_x_resolution;

   double m_y_resolution;

private:

   LT_STATUS checkImpedance() const;

   typedef LTIGeoFileImageWriter Super;

   LT_STATUS initMetadata();

   LT_STATUS setColorMap(const LTIPixelLookupTable&);

   LT_STATUS writeFieldInformation(lt_uint32 width, lt_uint32 height);

   bool m_writeResolution;

   void init( const LTFileSpec& file );

   char* m_tiff_file_name;

   long m_currentRow;

   int m_compression;

   LTReusableBuffer* m_stripBuffer;

   // nope

   TIFFImageWriter();

   TIFFImageWriter(TIFFImageWriter&);

   TIFFImageWriter& operator=(const TIFFImageWriter&);

};

LT_END_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

	#pragma warning(pop)

#endif

#endif // TIFFIMAGEWRITER_H

/* $Id: lti_writersStatus.h 3539 2006-01-09 12:23:20Z nacho $ */

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

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

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

/* PUBLIC */

#ifndef LTI_WRITERSSTATUS_H

#define LTI_WRITERSSTATUS_H

#include "lt_base.h"

#define LTI_STS_Writers_Base                                      50400

LT_STATUSSTRING_ADD(LTI_STS_Writers_Base, "lt_lib_mrsid_imageWriters base")

#define LTI_STS_Writers_CannotWriteFile                           50401

LT_STATUSSTRING_ADD(LTI_STS_Writers_CannotWriteFile, "Cannot write to file %F")

#define LTI_STS_Writers_UnsupColorSpace                           50402

LT_STATUSSTRING_ADD(LTI_STS_Writers_UnsupColorSpace, "unsupported colorspace")

#define LTI_STS_Writers_UnsupDataType                             50403

LT_STATUSSTRING_ADD(LTI_STS_Writers_UnsupDataType, "unsupported datatype")

#define LTI_STS_Writers_TIFFFieldInfoNotSet                       50410

LT_STATUSSTRING_ADD(LTI_STS_Writers_TIFFFieldInfoNotSet, "TIFF: field info not set")

#define LTI_STS_Writers_TIFFLibraryError                          50411

LT_STATUSSTRING_ADD(LTI_STS_Writers_TIFFLibraryError, "TIFF: library error - %s")

#define LTI_STS_Writers_TIFFLibraryWarning                        50412

LT_STATUSSTRING_ADD(LTI_STS_Writers_TIFFLibraryWarning, "TIFF: library warning - %s")

#define LTI_STS_Writers_TIFFUnsupOutputFormat                     50413

LT_STATUSSTRING_ADD(LTI_STS_Writers_TIFFUnsupOutputFormat, "TIFF: unsupported output format")

#define LTI_STS_Writers_TIFFWriteDataFailed                       50414

LT_STATUSSTRING_ADD(LTI_STS_Writers_TIFFWriteDataFailed, "TIFF: write data failed")

#define LTI_STS_Writers_TIFFUnsupClutType                         50415

LT_STATUSSTRING_ADD(LTI_STS_Writers_TIFFUnsupClutType, "TIFF: unsupported CLUT type")

#define LTI_STS_Writers_TIFFMetadataError                         50416

LT_STATUSSTRING_ADD(LTI_STS_Writers_TIFFMetadataError, "TIFF: metadata error")

#define LTI_STS_Writers_GDALErrorMessage                          50420

LT_STATUSSTRING_ADD(LTI_STS_Writers_GDALErrorMessage, "GDAL error: %s - %d")

#define LTI_STS_Writers_GeoTIFFBadKeyDims                         50430

LT_STATUSSTRING_ADD(LTI_STS_Writers_GeoTIFFBadKeyDims, "GeoTIFF: bad metadata key format")

#define LTI_STS_Writers_GeoTIFFUnableToSetKey                     504131

LT_STATUSSTRING_ADD(LTI_STS_Writers_GeoTIFFUnableToSetKey, "GeoTIFF: unable to set key")

#define LTI_STS_Writers_GeoTIFFOpenFileError                      50432

LT_STATUSSTRING_ADD(LTI_STS_Writers_GeoTIFFUnableToSetKey, "GeoTIFF: error opening file")

#define LTI_STS_Writers_BBBCannotWriteFile                        50440

LT_STATUSSTRING_ADD(LTI_STS_Writers_BBBCannotWriteFile, "BBB: cannot write to file")

#define LTI_STS_Writers_BMPCannotWriteFile                        50450

LT_STATUSSTRING_ADD(LTI_STS_Writers_BMPCannotWriteFile, "BMP: cannot write to file")

#define LTI_STS_Writers_JPEGErrorMessage                          50460

LT_STATUSSTRING_ADD(LTI_STS_Writers_JPEGErrorMessage, "JPEG error: %s")

#define LTI_STS_Writers_JPEGOpenFileError                         50461

LT_STATUSSTRING_ADD(LTI_STS_Writers_JPEGOpenFileError, "JPEG: error opening file")

#define LTI_STS_Writers_Max                                       50499

LT_STATUSSTRING_ADD(LTI_STS_Writers_Max, "lt_lib_mrsid_imageWriters max")

#endif // LTI_WRITERSSTATUS_H

/* $Id: BMPImageWriter.h 3539 2006-01-09 12:23:20Z nacho $ */

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

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

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

/* PUBLIC */

#ifndef BMPIMAGEWRITER_H

#define BMPIMAGEWRITER_H

// lt_lib_mrsid_core

#include "lti_geoFileImageWriter.h"

// lt_lib_utils

#include "lti_imageWriter.h"

LT_BEGIN_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

class LTReusableBuffer;

/**

 * writes an image stage to a Windows BMP file

 *

 * This class writes an image stage to a Windows BMP file.

 */

class BMPImageWriter : public LTIGeoFileImageWriter

{

public:

   /**

    * constructor

    *

    * Creates a writer for Windows BMP images.

    *

    * @param  image  the image to write from

    */

   BMPImageWriter(LTIImageStage* image);

   virtual ~BMPImageWriter();

   LT_STATUS initialize();

   LT_STATUS writeBegin(const LTIScene& scene);

   LT_STATUS writeStrip(LTISceneBuffer& stripBuffer, const LTIScene& stripScene);

   LT_STATUS writeEnd();

private:

   typedef LTIGeoFileImageWriter Super;

   LT_STATUS checkImpedance() const;

   // override from LTIImageFilter

   LTIImageStage* getPreviousStage() const;

   LT_STATUS normalizeProperties(lt_uint32 width, lt_uint32 height);

   LT_STATUS initFile(lt_uint32 width, lt_uint32 height);

   LT_STATUS writeHeaders(lt_uint32 width, lt_uint32 height);

   LT_STATUS initBitmapHeader(lt_uint32 width, lt_uint32 height);

   LT_STATUS initEndian();

   LT_STATUS writeStrip(lt_uint32 stripHeight,

                        const lt_uint8* buf);

   LTIImageStage* m_mapTransform;

   lt_uint32 m_alignedRowBytes;

   lt_uint32 m_unalignedRowBytes;

   lt_uint8* m_padding;

   lt_uint32 m_padsize;

   struct bitmapFileHeaderType;

   struct bitmapHeaderType;

   bitmapFileHeaderType* m_bmpFileHeader;

   bitmapHeaderType* m_bmpHeader;

   //  This will provide a marker so the image doesn't write over itself

   // I need to know how far back to seek.

   int m_seekBackTo;

   LTReusableBuffer* m_stripBuffer;

   // nope

   BMPImageWriter();

   BMPImageWriter(BMPImageWriter&);

   BMPImageWriter& operator=(const BMPImageWriter&);

};

LT_END_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

	#pragma warning(pop)

#endif

#endif // BMPIMAGEWRITER_H

/* $Id: NITFImageWriter.h 3539 2006-01-09 12:23:20Z nacho $ */

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

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

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

/* PUBLIC */

#ifndef NITFIMAGEWRITER_H

#define NITFIMAGEWRITER_H

// lt_lib_mrsid_core

#include "lti_geoFileImageWriter.h"

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

class GDALDataset;

LT_BEGIN_NAMESPACE(LizardTech)

class LTFileSpec;

/**

 * writes an image stage to NITF file

 *

 * This class writes an image stage to NITF file.

 *

 * Only very limited NITF support is provided.  Specifically, only simple

 * 8-bit and 16-bit data, and no special metadata support.

 */

class NITFImageWriter : public LTIGeoFileImageWriter

{

public:

   /**

    * constructor

    *

    * Creates a writer for NITF images.

    *

    * @param  image  the image to write from

    */

   NITFImageWriter(LTIImageStage* image);

   virtual ~NITFImageWriter();

   LT_STATUS initialize();

   LT_STATUS writeBegin(const LTIScene& scene);

   LT_STATUS writeStrip(LTISceneBuffer& stripBuffer, const LTIScene& stripScene);

   LT_STATUS writeEnd();

private:

   typedef LTIGeoFileImageWriter Super;

   LT_STATUS checkImpedance() const;

   void allocTempBuffer(lt_uint32);

   lt_uint8* copyIntoBuffer(lt_uint32 w, lt_uint32 h, lt_uint8* bipData);

   double m_xUL;

   double m_yUL;

   double m_xDim;

   double m_yDim;

   double m_xRot;

   double m_yRot;

   bool m_hasWorldInfo;

   lt_uint32 m_myBytesPerSample;

   lt_uint32 m_myNumBands;

   lt_uint32 m_myWidth;

   lt_uint32 m_myHeight;

   int m_gdalDataType; // (cast to GDALDataType)

   GDALDataset* m_gdalDataset;

   lt_uint8* m_tempBuffer;

   lt_uint32 m_tempBufferSize;

   // nope

   NITFImageWriter();

   NITFImageWriter(NITFImageWriter&);

   NITFImageWriter& operator=(const NITFImageWriter&);

};

LT_END_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

	#pragma warning(pop)

#endif

#endif // NITFIMAGEWRITER_H

/* $Id: GeoTIFFImageWriter.h 3539 2006-01-09 12:23:20Z nacho $ */

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

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

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

/* PUBLIC */

#ifndef GEOTIFFIMAGEWRITER_H

#define GEOTIFFIMAGEWRITER_H

// lt_lib_mrsid_imageWriters

#include "TIFFImageWriter.h"

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

LT_BEGIN_NAMESPACE(LizardTech)

class LTIMetadataRecord;

/**

 * writes an image stage to a GeoTIFF file

 *

 * This class writes an image stage to a GeoTIFF file.

 */

class GeoTIFFImageWriter : public TIFFImageWriter

{

public:

   /**

    * constructor

    *

    * Creates a writer for GeoTIFF images.

    *

    * @param  image  the image to write from

    */

   GeoTIFFImageWriter(LTIImageStage* image);

   virtual ~GeoTIFFImageWriter();

   LT_STATUS initialize();

   LT_STATUS writeBegin(const LTIScene& scene);

   LT_STATUS writeEnd();

   /**

    * Sets the PIXELSCALE tag.  This function can be used to manually

    * override the value set for the PIXELSCALE tag.

    *

    * @param  pixScale  the array of pixel scale values to use

    */

   void setPixelScale(double pixScale[]);

   /**

    * Sets the TIEPOINTS tag.  This function can be used to manually

    * override the value set for the TIEPOINTS tag.

    *

    * @param  tiePoints  the array of tie point values to use

    * @param  number     the number of tie points in the array

    */

   void setTiePoints(double *tiePoints, int number);

private:

   typedef TIFFImageWriter Super;

   LT_STATUS writeHeaders(lt_uint32 width, lt_uint32 height);

   // we use a uint for the key, to avoid exposing geokey_t

   bool setKey(lt_uint32 key, unsigned char byteVal);

   bool setKey(lt_uint32 key, unsigned short shortVal);

   bool setKey(lt_uint32 key, const char* asciiVal);

   bool setKey(lt_uint32 key, double doubleVal);

   bool setKey(lt_uint32 key, unsigned long longVal);

   char* getKeyName(lt_uint32 key);

   LT_STATUS setKeysFromMetadata();

   LT_STATUS setKeyFromMetadata(const LTIMetadataRecord&);

   LT_STATUS setKeyFromMetadata_geotiffnum(const LTIMetadataRecord& rec);

   LT_STATUS setKeyFromMetadata_geo(const LTIMetadataRecord& rec);

   int getKeyId(const char*);

   void *m_geoTiffPtr;

   double m_tiePoints[6];

   double m_res[3];

   double m_xval;

   double m_yval;

   double m_xres;

   double m_yres;

   // nope

   GeoTIFFImageWriter();

   GeoTIFFImageWriter(GeoTIFFImageWriter&);

   GeoTIFFImageWriter& operator=(const GeoTIFFImageWriter&);

};

LT_END_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

	#pragma warning(pop)

#endif

#endif // GEOTIFFIMAGEWRITER_H

/* $Id: JpegImageWriter.h 3539 2006-01-09 12:23:20Z nacho $ */

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

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

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

/* PUBLIC */

#ifndef JPEGIMAGEWRITER_H

#define JPEGIMAGEWRITER_H

// lt_lib_mrsid_core

#include "lti_geoFileImageWriter.h"

// system

#include <stdio.h>

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

struct jpeg_compress_struct;

struct jpeg_error_mgr;

LT_BEGIN_NAMESPACE(LizardTech)

class LTFileSpec;

class LTReusableBuffer;

/**

 * writes an image stage to a JPEG file

 *

 * This class writes an image stage to a JPEG file.

 */

class JpegImageWriter : public LTIGeoFileImageWriter

{

public:

   /**

    * constructor

    *

    * Creates a writer for JPEG images.

    *

    * @param  image      the image to write from

    * @param  quality    sets the JPEG "quality" encoding parameter;

    *                    this is a value between 0 and 100

    * @param  smoothing  sets the JPEG "smoothing" encoding parameter;

    *                    this is a value between 0 and 100

    */

   JpegImageWriter(LTIImageStage* image,

                   int quality = 0,          // 0-100

                   int smoothing = 0);       // 0-100

   virtual ~JpegImageWriter();

   LT_STATUS initialize();

   LT_STATUS writeBegin(const LTIScene& scene);

   LT_STATUS writeStrip(LTISceneBuffer& stripBuffer, const LTIScene& stripScene);

   LT_STATUS writeEnd();

private:

   typedef LTIGeoFileImageWriter Super;

   LT_STATUS checkImpedance() const;

   FILE* m_file;

   //struct that contains the JPEG compression parameters

   struct jpeg_compress_struct* m_jpegObject;

   //struct to handle error messages 

   struct jpeg_error_mgr* m_jpegErr;

   //two parameters for setting compression quality

   int m_quality;

   int m_smoothingFactor;

   LTReusableBuffer* m_stripBuffer;

   // nope

   JpegImageWriter();

   JpegImageWriter(JpegImageWriter&);

   JpegImageWriter& operator=(const JpegImageWriter&);

};

LT_END_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

	#pragma warning(pop)

#endif

#endif // JPEGIMAGEWRITER_H

/* $Id: lti_metadataDumper.h 3539 2006-01-09 12:23:20Z nacho $ */

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

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

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

/* PUBLIC */

#ifndef LTIMETADATADUMPER_H

#define LTIMETADATADUMPER_H

// lt_lib_mrsid_metadata

#include "lti_metadataWriter.h"

LT_BEGIN_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

class LTIOStreamInf;

class LTIMetadataRecord;

/**

 * dumps contents of database in text form

 *

 * This class writes the given database in ASCII text, readable format

 * to a stream or stdout.

 */

class LTIMetadataDumper: public LTIMetadataWriter

{

public:

   /**

    * constructor

    *

    * This constructor creates an LTIMetadataWriter which will pretty-print

    * the records in the database to a stream or to stdout.

    *

    * @param database the database to write from

    * @param stream the stream to write to; if NULL, will write to stdout

    */

   LTIMetadataDumper(const LTIMetadataDatabase& database,

                     LTIOStreamInf* stream);

   /**

    * destructor

    */

   ~LTIMetadataDumper();

   /**

    * write records to stream

    */

   LT_STATUS write() const;

   /**

    * write a single record to stream

    *

    * This function writes (pretty-prints) the given record to the stream.

    *

    * It is public and static because it is useful on its own for debugging.

    *

    * @param record the record to write

    * @param stream the stream to write to

    * @return status code indicating success or failure

    */

   static LT_STATUS writeRecord(const LTIMetadataRecord& record,

                                LTIOStreamInf& stream);

   /**

    * INPUT_NAME metadata control

    *

    * Control if the IMAGE::INPUT_NAME tag is written out.

    * This can useful for certain debugging and validation situations.

    *

    * The default is to always write the INPUT_NAME tag.

    *

    * @param  enable  set to true to not skip the INPUT_NAME tag

    */

   void setWriteInputFilename(bool enable); 

private:

   LTIOStreamInf* m_stream;

   bool m_ownsStream;

   bool m_writeInputFilename;

   // nope

   LTIMetadataDumper(const LTIMetadataDumper&);

   LTIMetadataDumper& operator=(const LTIMetadataDumper&);

};

LT_END_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

	#pragma warning(pop)

#endif

#endif // LTIMETADATADUMPER_H

/* $Id: lti_metadataWriter.h 3539 2006-01-09 12:23:20Z nacho $ */

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

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

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

/* PUBLIC */

#ifndef LTI_METADATA_WRITER_H

#define LTI_METADATA_WRITER_H

// lt_lib_base

#include "lt_base.h"

LT_BEGIN_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

class LTIMetadataDatabase;

/**

 * abstract class for exporting a metadata database

 *

 * This abstract class provides an interface for exporting metadata records

 * from an LTIMetadataDatabase to a foreign source.

 *

 * This is used, for example, to provide a mechanism for writing the

 * format-neutral, in-memory database into binary TIFF tag format.  it

 * is also used to dump the database to plain-text format (for debugging).

 */

class LTIMetadataWriter

{

public:

   /**

    * default constructor

    *

    * This base constructor creates a writer object which can export

    * records from a database to some foreign format.

    *

    * @param database the database to be read into

    */

   LTIMetadataWriter(const LTIMetadataDatabase& database);

   /**

    * destructor

    */

   virtual ~LTIMetadataWriter();

   /**

    * write records out from database

    *

    * This function must be implemented in the derived class.  It should

    * write each of the LTIMetadataRecord objects in the database out to

    * the foreign format.

    *

    * @return status code indicating success or failure

    */

   virtual LT_STATUS write() const = 0;

protected:

   /**

    * the database to be written from

    *

    * This is the database to be written out from.  Derived classes may access

    * it directly.

    */

   const LTIMetadataDatabase& m_database;

private:

   // nope

   LTIMetadataWriter(const LTIMetadataWriter&);

   LTIMetadataWriter& operator=(const LTIMetadataWriter&);

};

LT_END_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

	#pragma warning(pop)

#endif

#endif // LTI_METADATA_WRITER_H

/* $Id: lti_metadataRecord.h 3539 2006-01-09 12:23:20Z nacho $ */

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

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

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

/* PUBLIC */

#ifndef LTIMETADATARECORD_H

#define LTIMETADATARECORD_H

// lt_lib_base

#include "lt_base.h"

// lt_lib_mrsid_metadata

#include "lti_metadataTypes.h"

LT_BEGIN_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

   #pragma warning(push,4)

#endif

/**

 * representation of a metadata record

 *

 * This class stores the data associated with a single record in the database.

 * The data consists of:

 *   - the tag (a string), used to uniquely identify the record

 *   - the type of the data, e.g. string, byte, etc

 *   - the dimensionality of the data, e.g. scalar, 2x3 array, etc

 *   - the actual data

 *

 * It is assumed each record has only a single set of data of a single datatype.

 * (That is, a record can't contain both a float and two ints.)

 *

 * Some of the functions for operating on records are cast in the guise

 * of scalar, vector, or array data.  This is for notational convenience only;

 * the internal representation does not distinguish and treats everything as

 * a (possibly degenerate) array.

 */

class LTIMetadataRecord

{

public:

   /**

    * default constructor for scalar data

    *

    * The constructor creates a record containing a scalar data value.

    *

    * Note that the object makes a local copy of the data passed into the

    * record.

    *

    * @param tag the tag number of the record 

    * @param type datatype of the data in the record 

    * @param data pointer to the data to insert into the record 

    */

   LTIMetadataRecord(LTIMetadataTag tag,

                     LTIMetadataDataType type,

                     const void* data);

   /**

    * default constructor for scalar data

    *

    * The constructor creates a record containing a scalar data value.

    *

    * Note that the object makes a local copy of the data passed into the

    * record.

    *

    * @param tagName the tag number of the record 

    * @param type datatype of the data in the record 

    * @param data pointer to the data to insert into the record 

    */

   LTIMetadataRecord(const char* tagName,

                     LTIMetadataDataType type,

                     const void* data);

   /**

    * default constructor for vector data

    *

    * The constructor creates a record containing a vector of data values.

    *

    * Note that the object makes a local copy of the data passed into the

    * record.

    *

    * @param tag the tag number of the record 

    * @param type datatype of the data in the record 

    * @param data pointer to the data to insert into the record 

    * @param vecLen the length of the data vector 

    */

   LTIMetadataRecord(LTIMetadataTag tag,

                     LTIMetadataDataType type,

                     const void* data,

                     lt_uint32 vecLen);

   /**

    * default constructor for vector data

    *

    * The constructor creates a record containing a vector of data values.

    *

    * Note that the object makes a local copy of the data passed into the

    * record.

    *

    * @param tagName the tag number of the record 

    * @param type datatype of the data in the record 

    * @param data pointer to the data to insert into the record 

    * @param vecLen the length of the data vector 

    */

   LTIMetadataRecord(const char* tagName,

                     LTIMetadataDataType type,

                     const void* data,

                     lt_uint32 vecLen);

   /**

    * default constructor for array data

    *

    * The constructor creates a record containing an array of data values.

    *

    * Note that the object makes a local copy of the data passed into the

    * record.

    *

    * @param tag the tag number of the record 

    * @param type datatype of the data in the record 

    * @param data pointer to the data to insert into the record 

    * @param numDims the length of the \a dims array 

    * @param dims the dimensionality of the data 

    */

   LTIMetadataRecord(LTIMetadataTag tag,

                     LTIMetadataDataType type,

                     const void* data,

                     lt_uint32 numDims,

                     const lt_uint32* dims);

   /**

    * default constructor for array data

    *

    * The constructor creates a record containing an array of data values.

    *

    * Note that the object makes a local copy of the data passed into the

    * record.

    *

    * @param tagName the tag number of the record 

    * @param type datatype of the data in the record 

    * @param data pointer to the data to insert into the record 

    * @param numDims the length of the \a dims array 

    * @param dims the dimensionality of the data 

    */

   LTIMetadataRecord(const char* tagName,

                     LTIMetadataDataType type,

                     const void* data,

                     lt_uint32 numDims,

                     const lt_uint32* dims);

   /**

    * copy constructor

    */

   LTIMetadataRecord(const LTIMetadataRecord&);

   /**

    * destructor

    */

   ~LTIMetadataRecord();

   /**

    * get tag

    *

    * This function returns the tag number (enum) associated with the record.

    *

    * @return the tag

    */

   LTIMetadataTag getTag() const;

   /**

    * get tag name

    *

    * This function returns the tag name (string) associated with the record.

    *

    * @return the tag name

    */

   const char* getTagName() const;

   /**

    * get datatype

    *

    * This function returns the datatype of the data in the record.

    *

    * @return the datatype

    */

   LTIMetadataDataType getDataType() const;

   /**

    * get number of dimensions of the data set

    *

    * This function returns the number of dimensions in the dimensionality

    * of the dataset.

    *

    * This is the length of the array returned by the getDims() function.

    *

    * @return the number of dimensions

    */

   lt_uint32 getNumDims() const;

   /**

    * get dimensionality of the data set

    *

    * This function returns an array with the length of each dimension of the

    * dataset.

    *

    * For example, a 2x3 dataset would return an array of length two with the

    * values {2,3}.

    *

    * This is the length of the returned array is equal to getNumDims().

    *

    * @return the number of dimensions

    */

   const lt_uint32* getDims() const;

   /**

    * is dataset a scalar?

    *

    * This function returns true iff the record's dataset consists only of a

    * single element.

    *

    * @return true if record data is a scalar value

    */

   bool isScalar() const;

   /**

    * is dataset a vector?

    *

    * This function returns true iff the record's dataset is a 1-D array.

    *

    * @return true if record data is a vector of values

    */

   bool isVector() const;

   /**

    * is dataset an array?

    *

    * This function returns true iff the record's dataset is neither

    * a scalar nor a vector.

    *

    * @return true if record data is not scalar or vector

    */

   bool isArray() const;

   /**

    * get scalar data value

    *

    * This function returns the record's data as a scalar value.  It is

    * the caller's responsibility to assure that the record does indeed

    * contain a scalar dataset.

    *

    * The user is responsible for casting the returned value to the correct

    * datatype.

    *

    * @return a pointer to the scalar data value

    */

   const void* getScalarData() const;

   /**

    * get vector data values

    *

    * This function returns the record's data as a vector of values.  It is

    * the caller's responsibility to assure that the record does indeed

    * contain a vector dataset.

    *

    * The user is responsible for casting the returned value to an array

    * of the correct datatype.

    *

    * @param vecLen the length of the returned vector 

    * @return a pointer to the vector of data values

    */

   const void* getVectorData(lt_uint32& vecLen) const;

   /**

    * get array data values

    *

    * This function returns the record's data as an array of values.

    *

    * Note the function returns via its parameters the same information as

    * getNumDims() and getDims().

    *

    * The user is responsible for casting the returned value to an array

    * of the correct datatype.

    *

    * @param numDims the number of dimensions in the \a dims parameter 

    * @param dims the dimensionality array 

    * @return a pointer to the array of data values

    */

   const void* getArrayData(lt_uint32& numDims, const lt_uint32*& dims) const;

   /**

    * get size of metadata record

    *

    * This function will return a close-enough estimate of the size of the

    * record, as if it were to be written directly to disk.

    *

    * @return  size in bytes of the record

    */

   lt_int32 getApproximateSize() const;

private:

   void initialize(LTIMetadataTag tag,

                   const void* data, const lt_uint32* dims);

   void initialize(const char* tagName,

                   const void* data, const lt_uint32* dims);

   lt_uint32 computeLen() const;

   char* m_tagName;

   LTIMetadataDataType m_type;

   lt_uint32 m_numDims;

   lt_uint32* m_dims;

   lt_uint8* m_data;

   // nope

   LTIMetadataRecord& operator=(const LTIMetadataRecord&);

};

LT_END_NAMESPACE(LizardTech)

#if defined(LT_COMPILER_MS)

	#pragma warning(pop)

#endif

#endif // LTIMETADATARECORD_H

/* $Id: lti_metadataUtils.h 3539 2006-01-09 12:23:20Z nacho $ */

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

//                                                                         //

// This code is Copyright (c) 2004 LizardTech, Inc, 1008 Western Avenue,   //

// Suite 200, Seattle, WA 98104.  Unauthorized use or distribution         //

// prohibited.  Access to and use of this code is permitted only under     //

// license from LizardTech, Inc.  Portions of the code are protected by    //

// US and foreign patents and other filings. All Rights Reserved.          //

//                                                                         //

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

/* PUBLIC */

#ifndef LTI_METADATAUTILS_H

#define LTI_METADATAUTILS_H

// lt_lib_base

#include "lt_base.h"

// lt_lib_mrsid_metadata

#include "lti_metadataTypes.h"

LT_BEGIN_NAMESPACE(LizardTech)