geotiff.h File Reference

Primary libgeotiff include file. More...

#include "geo_config.h"
#include "geokeys.h"

Include dependency graph for geotiff.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Defines
#define	GvCurrentVersion   1
#define	LIBGEOTIFF_VERSION   1300
Typedefs
typedef struct gtiff	GTIF
typedef struct _TIFFMethod	TIFFMethod
typedef unsigned short	tifftag_t
typedef unsigned short	geocode_t
typedef int(*	GTIFPrintMethod )(char *string, void *aux)
typedef int(*	GTIFReadMethod )(char *string, void *aux)
Enumerations
enum	tagtype_t {   TYPE_BYTE = 1, TYPE_SHORT = 2, TYPE_LONG = 3, TYPE_RATIONAL = 4,   TYPE_ASCII = 5, TYPE_FLOAT = 6, TYPE_DOUBLE = 7, TYPE_SBYTE = 8,   TYPE_SSHORT = 9, TYPE_SLONG = 10, TYPE_UNKNOWN = 11 }
Functions
GTIF CPL_DLL *	GTIFNew (void *tif)
	Given an open TIFF file, look for GTIF keys and values and return GTIF structure.
GTIF CPL_DLL *	GTIFNewSimpleTags (void *tif)
GTIF CPL_DLL *	GTIFNewWithMethods (void *tif, TIFFMethod *)
void CPL_DLL	GTIFFree (GTIF *gtif)
	This function deallocates an existing GeoTIFF access handle previously created with GTIFNew().
int CPL_DLL	GTIFWriteKeys (GTIF *gtif)
	This function flushes all the GeoTIFF keys that have been set with the GTIFKeySet() function into the associated TIFF file.
void CPL_DLL	GTIFDirectoryInfo (GTIF *gtif, int *versions, int *keycount)
int CPL_DLL	GTIFKeyInfo (GTIF *gtif, geokey_t key, int *size, tagtype_t *type)
int CPL_DLL	GTIFKeyGet (GTIF *gtif, geokey_t key, void *val, int index, int count)
	This function reads the value of a single GeoKey from a GeoTIFF file.
int CPL_DLL	GTIFKeySet (GTIF *gtif, geokey_t keyID, tagtype_t type, int count,...)
	This function writes a geokey_t value to a GeoTIFF file.
void CPL_DLL	GTIFPrint (GTIF *gtif, GTIFPrintMethod print, void *aux)
int CPL_DLL	GTIFImport (GTIF *gtif, GTIFReadMethod scan, void *aux)
char CPL_DLL *	GTIFKeyName (geokey_t key)
char CPL_DLL *	GTIFValueName (geokey_t key, int value)
char CPL_DLL *	GTIFTypeName (tagtype_t type)
char CPL_DLL *	GTIFTagName (int tag)
int CPL_DLL	GTIFKeyCode (char *key)
int CPL_DLL	GTIFValueCode (geokey_t key, char *value)
int CPL_DLL	GTIFTypeCode (char *type)
int CPL_DLL	GTIFTagCode (char *tag)
int CPL_DLL	GTIFImageToPCS (GTIF *gtif, double *x, double *y)
	Translate a pixel/line coordinate to projection coordinates.
int CPL_DLL	GTIFPCSToImage (GTIF *gtif, double *x, double *y)
	Translate a projection coordinate to pixel/line coordinates.

---

Detailed Description

Primary libgeotiff include file.

This is the defacto registry for valid GEOTIFF GeoKeys and their associated symbolic values. This is also the only file of the GeoTIFF library which needs to be included in client source code.

---

Function Documentation

void CPL_DLL GTIFFree

(

GTIF *

gtif

)

This function deallocates an existing GeoTIFF access handle previously created with GTIFNew().

If the handle was used to write GeoTIFF keys to the TIFF file, the GTIFWriteKeys() function should be used to flush results to the file before calling GTIFFree(). GTIFFree() should be called before XTIFFClose() is called on the corresponding TIFF file handle.

{
    int     i;
        
    if (!gtif) return;
        
    /* Free parameter arrays */
    if (gtif->gt_double) _GTIFFree (gtif->gt_double);
    if (gtif->gt_short) _GTIFFree (gtif->gt_short);
        
    /* Free GeoKey arrays */
    if (gtif->gt_keys)
    {
        for (i = 0; i < MAX_KEYS; i++)
        {
            if (gtif->gt_keys[i].gk_type == TYPE_ASCII)
            {
                _GTIFFree (gtif->gt_keys[i].gk_data);
            }
        }
        _GTIFFree (gtif->gt_keys);
    }
    if (gtif->gt_keyindex) _GTIFFree (gtif->gt_keyindex);
        
    _GTIFFree (gtif);
}

int CPL_DLL GTIFImageToPCS	(	GTIF *	gtif,
		double *	x,
		double *	y
	)

Translate a pixel/line coordinate to projection coordinates.

At this time this function does not support image to PCS translations for tiepoints-only definitions, only pixelscale and transformation matrix formulations.

Parameters:

	gtif	The handle from GTIFNew() indicating the target file.
	x	A pointer to the double containing the pixel offset on input, and into which the easting/longitude will be put on completion.
	y	A pointer to the double containing the line offset on input, and into which the northing/latitude will be put on completion.

Returns:

TRUE if the transformation succeeds, or FALSE if it fails. It may fail if the file doesn't have properly setup transformation information, or it is in a form unsupported by this function.

{
    int     res = FALSE;
    int     tiepoint_count, count, transform_count;
    tiff_t *tif=gtif->gt_tif;
    double *tiepoints   = 0;
    double *pixel_scale = 0;
    double *transform   = 0;


    if (!(gtif->gt_methods.get)(tif, GTIFF_TIEPOINTS,
                              &tiepoint_count, &tiepoints ))
        tiepoint_count = 0;

    if (!(gtif->gt_methods.get)(tif, GTIFF_PIXELSCALE, &count, &pixel_scale ))
        count = 0;

    if (!(gtif->gt_methods.get)(tif, GTIFF_TRANSMATRIX,
                                &transform_count, &transform ))
        transform_count = 0;

/* -------------------------------------------------------------------- */
/*      If the pixelscale count is zero, but we have tiepoints use      */
/*      the tiepoint based approach.                                    */
/* -------------------------------------------------------------------- */
    if( tiepoint_count > 6 && count == 0 ) 
    {
        res = GTIFTiepointTranslate( tiepoint_count / 6,
                                     tiepoints, tiepoints + 3,
                                     *x, *y, x, y );
    }

/* -------------------------------------------------------------------- */
/*      If we have a transformation matrix, use it.                     */
/* -------------------------------------------------------------------- */
    else if( transform_count == 16 ) 
    {
        double x_in = *x, y_in = *y;

        *x = x_in * transform[0] + y_in * transform[1] + transform[3];
        *y = x_in * transform[4] + y_in * transform[5] + transform[7];
        
        res = TRUE;
    } 

/* -------------------------------------------------------------------- */
/*      For now we require one tie point, and a valid pixel scale.      */
/* -------------------------------------------------------------------- */
    else if( count < 3 || tiepoint_count < 6 ) 
    {
        res = FALSE;
    } 

    else 
    {
        *x = (*x - tiepoints[0]) * pixel_scale[0] + tiepoints[3];
        *y = (*y - tiepoints[1]) * (-1 * pixel_scale[1]) + tiepoints[4];

        res = TRUE;
    }

/* -------------------------------------------------------------------- */
/*      Cleanup                                                         */
/* -------------------------------------------------------------------- */
    if(tiepoints)   
        _GTIFFree(tiepoints);
    if(pixel_scale)
        _GTIFFree(pixel_scale);
    if(transform)  
        _GTIFFree(transform);

    return res;
}

int CPL_DLL GTIFKeyGet	(	GTIF *	gtif,
		geokey_t	thekey,
		void *	val,
		int	index,
		int	count
	)

This function reads the value of a single GeoKey from a GeoTIFF file.

Parameters:

	gtif	The geotiff information handle from GTIFNew().
	thekey	The geokey_t name (such as ProjectedCSTypeGeoKey). This must come from the list of legal geokey_t values (an enumeration) listed below.
	val	The val argument is a pointer to the variable into which the value should be read. The type of the variable varies depending on the geokey_t given. While there is no ready mapping of geokey_t values onto types, in general code values are of type short, citations are strings, and everything else is of type double. Note that pointer's to int should never be passed to GTIFKeyGet() for integer values as they will be shorts, and the int's may not be properly initialized (and will be grossly wrong on MSB systems).
	index	Indicates how far into the list of values for this geokey to offset. Should normally be zero.
	count	Indicates how many values to read. At this time all keys except for strings have only one value, so index should be zero, and count should be one.

Returns:

The GTIFKeyGet() function returns the number of values read. Normally this would be one if successful or zero if the key doesn't exist for this file.

From geokeys.inc we see the following geokey_t values are possible:

-- 6.2.1 GeoTIFF Configuration Keys --

ValuePair(  GTModelTypeGeoKey,	1024) -- Section 6.3.1.1 Codes       --
ValuePair(  GTRasterTypeGeoKey,	1025) -- Section 6.3.1.2 Codes       --
ValuePair(  GTCitationGeoKey,	1026) -- documentation --

-- 6.2.2 Geographic CS Parameter Keys --

ValuePair(  GeographicTypeGeoKey,	2048) -- Section 6.3.2.1 Codes     --
ValuePair(  GeogCitationGeoKey,	2049) -- documentation             --
ValuePair(  GeogGeodeticDatumGeoKey,	2050) -- Section 6.3.2.2 Codes     --
ValuePair(  GeogPrimeMeridianGeoKey,	2051) -- Section 6.3.2.4 codes     --
ValuePair(  GeogLinearUnitsGeoKey,	2052) -- Section 6.3.1.3 Codes     --
ValuePair(  GeogLinearUnitSizeGeoKey,	2053) -- meters                    --
ValuePair(  GeogAngularUnitsGeoKey,	2054) -- Section 6.3.1.4 Codes     --
ValuePair(  GeogAngularUnitSizeGeoKey,	2055) -- radians                   --
ValuePair(  GeogEllipsoidGeoKey,	2056) -- Section 6.3.2.3 Codes     --
ValuePair(  GeogSemiMajorAxisGeoKey,	2057) -- GeogLinearUnits           --
ValuePair(  GeogSemiMinorAxisGeoKey,	2058) -- GeogLinearUnits           --
ValuePair(  GeogInvFlatteningGeoKey,	2059) -- ratio                     --
ValuePair(  GeogAzimuthUnitsGeoKey,	2060) -- Section 6.3.1.4 Codes     --
ValuePair(  GeogPrimeMeridianLongGeoKey,	2061) -- GeoAngularUnit            --

-- 6.2.3 Projected CS Parameter Keys --
--    Several keys have been renamed,--
--    and the deprecated names aliased for backward compatibility --

ValuePair(  ProjectedCSTypeGeoKey,	3072)     -- Section 6.3.3.1 codes   --
ValuePair(  PCSCitationGeoKey,	3073)     -- documentation           --
ValuePair(  ProjectionGeoKey,	3074)     -- Section 6.3.3.2 codes   --
ValuePair(  ProjCoordTransGeoKey,	3075)     -- Section 6.3.3.3 codes   --
ValuePair(  ProjLinearUnitsGeoKey,	3076)     -- Section 6.3.1.3 codes   --
ValuePair(  ProjLinearUnitSizeGeoKey,	3077)     -- meters                  --
ValuePair(  ProjStdParallel1GeoKey,	3078)     -- GeogAngularUnit --
ValuePair(  ProjStdParallelGeoKey,ProjStdParallel1GeoKey) -- ** alias **   --
ValuePair(  ProjStdParallel2GeoKey,	3079)     -- GeogAngularUnit --
ValuePair(  ProjNatOriginLongGeoKey,	3080)     -- GeogAngularUnit --
ValuePair(  ProjOriginLongGeoKey,ProjNatOriginLongGeoKey) -- ** alias **     --
ValuePair(  ProjNatOriginLatGeoKey,	3081)     -- GeogAngularUnit --
ValuePair(  ProjOriginLatGeoKey,ProjNatOriginLatGeoKey)   -- ** alias **     --
ValuePair(  ProjFalseEastingGeoKey,	3082)     -- ProjLinearUnits --
ValuePair(  ProjFalseNorthingGeoKey,	3083)     -- ProjLinearUnits --
ValuePair(  ProjFalseOriginLongGeoKey,	3084)     -- GeogAngularUnit --
ValuePair(  ProjFalseOriginLatGeoKey,	3085)     -- GeogAngularUnit --
ValuePair(  ProjFalseOriginEastingGeoKey,	3086)     -- ProjLinearUnits --
ValuePair(  ProjFalseOriginNorthingGeoKey,	3087)     -- ProjLinearUnits --
ValuePair(  ProjCenterLongGeoKey,	3088)     -- GeogAngularUnit --
ValuePair(  ProjCenterLatGeoKey,	3089)     -- GeogAngularUnit --
ValuePair(  ProjCenterEastingGeoKey,	3090)     -- ProjLinearUnits --
ValuePair(  ProjCenterNorthingGeoKey,	3091)     -- ProjLinearUnits --
ValuePair(  ProjScaleAtNatOriginGeoKey,	3092)     -- ratio   --
ValuePair(  ProjScaleAtOriginGeoKey,ProjScaleAtNatOriginGeoKey)  -- ** alias **   --
ValuePair(  ProjScaleAtCenterGeoKey,	3093)     -- ratio   --
ValuePair(  ProjAzimuthAngleGeoKey,	3094)     -- GeogAzimuthUnit --
ValuePair(  ProjStraightVertPoleLongGeoKey,	3095)     -- GeogAngularUnit --

 6.2.4 Vertical CS Keys

ValuePair(  VerticalCSTypeGeoKey,	4096)  -- Section 6.3.4.1 codes   --
ValuePair(  VerticalCitationGeoKey,	4097)  -- documentation --
ValuePair(  VerticalDatumGeoKey,	4098)  -- Section 6.3.4.2 codes   --
ValuePair(  VerticalUnitsGeoKey,	4099)  -- Section 6.3.1 (.x) codes   --

{
        int kindex = gtif->gt_keyindex[ thekey ];
        GeoKey *key;
        gsize_t size;
        char *data;
        tagtype_t type;

        if (!kindex) return 0;

        key = gtif->gt_keys+kindex;
        if (!count) count = key->gk_count - index;
        if (count <=0) return 0;
        if (count > key->gk_count) count = key->gk_count;
        size = key->gk_size;
        type = key->gk_type;

        if (count==1 && type==TYPE_SHORT) data = (char *)&key->gk_data;
        else data = key->gk_data;

        _GTIFmemcpy( val, data + index*size, count*size );

        if (type==TYPE_ASCII)
           ((char *)val)[count-1] = '\0'; /* replace last char with NULL */

        return count;
}

int CPL_DLL GTIFKeySet	(	GTIF *	gtif,
		geokey_t	keyID,
		tagtype_t	type,
		int	count,
			...
	)

This function writes a geokey_t value to a GeoTIFF file.

Parameters:

	gtif	The geotiff information handle from GTIFNew().
	keyID	The geokey_t name (such as ProjectedCSTypeGeoKey). This must come from the list of legal geokey_t values (an enumeration) listed below.
	val	The val argument is a pointer to the variable into which the value should be read. The type of the variable varies depending on the geokey_t given. While there is no ready mapping of geokey_t values onto types, in general code values are of type short, citations are strings, and everything else is of type double. Note that pointer's to int should never be passed to GTIFKeyGet() for integer values as they will be shorts, and the int's may not be properly initialized (and will be grossly wrong on MSB systems).
	index	Indicates how far into the list of values for this geokey to offset. Should normally be zero.
	count	Indicates how many values to read. At this time all keys except for strings have only one value, so index should be zero, and count should be one.

The key indicates the key name to be written to the file and should from the geokey_t enumeration (eg. ProjectedCSTypeGeoKey). The full list of possible geokey_t values can be found in geokeys.inc, or in the online documentation for GTIFKeyGet().

The type should be one of TYPE_SHORT, TYPE_ASCII, or TYPE_DOUBLE and will indicate the type of value being passed at the end of the argument list (the key value). The count should be one except for strings when it should be the length of the string (or zero to for this to be computed internally). As a special case a count of -1 can be used to request an existing key be deleted, in which no value is passed.

The actual value is passed at the end of the argument list, and should be a short, a double, or a char * value. Note that short and double values are passed by value rather than as pointers when count is 1, but as pointers if count is larger than 1.

Note that key values aren't actually flushed to the file until GTIFWriteKeys() is called. Till then the new values are just kept with the GTIF structure.

Example:

    GTIFKeySet(gtif, GTRasterTypeGeoKey, TYPE_SHORT, 1, 
               RasterPixelIsArea);
    GTIFKeySet(gtif, GTCitationGeoKey, TYPE_ASCII, 0, 
               "UTM 11 North / NAD27" );

{
    va_list ap;
    int index = gtif->gt_keyindex[ keyID ];
    int newvalues = 0;
    GeoKey *key;
    char *data = NULL;
    char *val = NULL;
    pinfo_t sval;
    double dval;

    va_start(ap, count);
    /* pass singleton keys by value */
    if (count>1 && type!=TYPE_ASCII) 
    {
        val = va_arg(ap, char*);
    }
    else if( count == -1 )
    {
        /* delete the indicated tag */
        va_end(ap);

        if( index < 1 )
            return 0;

        if (gtif->gt_keys[index].gk_type == TYPE_ASCII)
        {
            _GTIFFree (gtif->gt_keys[index].gk_data);
        }

        while( index < gtif->gt_num_keys )
        {
            _GTIFmemcpy( gtif->gt_keys + index, 
                         gtif->gt_keys + index + 1, 
                         sizeof(GeoKey) );
            gtif->gt_keyindex[gtif->gt_keys[index].gk_key] = index;
            index++;
        }

        gtif->gt_num_keys--;
        gtif->gt_nshorts -= sizeof(KeyEntry)/sizeof(pinfo_t);
        gtif->gt_keyindex[keyID] = 0;
        gtif->gt_flags |= FLAG_FILE_MODIFIED;

        return 1;
    }
    else switch (type)
    {
      case TYPE_SHORT:  sval=(pinfo_t) va_arg(ap, int); val=(char *)&sval;     break;
      case TYPE_DOUBLE: dval=va_arg(ap, dblparam_t); val=(char *)&dval;  break;
      case TYPE_ASCII: 
        val=va_arg(ap, char*);
        count = strlen(val) + 1; /* force = string length */
        break;
      default:
        assert( FALSE );
        break;
    }
    va_end(ap);
    
    /* We assume here that there are no multi-valued SHORTS ! */
    if (index)
    {
        /* Key already exists */
        key = gtif->gt_keys+index;
        if (type!=key->gk_type || count > key->gk_count)
        {
            /* need to reset data pointer */
            key->gk_type = type;
            key->gk_count = count;
            key->gk_size = _gtiff_size[ type ];
            newvalues = 1;
        }
    }
    else
    {
        /* We need to create the key */
        if (gtif->gt_num_keys == MAX_KEYS) return 0;
        key = gtif->gt_keys + ++gtif->gt_num_keys;
        index = gtif->gt_num_keys;
        gtif->gt_keyindex[ keyID ] = index;
        key->gk_key = keyID;
        key->gk_type = type;
        key->gk_count = count;
        key->gk_size = _gtiff_size[ type ];
        if (gtif->gt_keymin > keyID)  gtif->gt_keymin=keyID;
        if (gtif->gt_keymax < keyID)  gtif->gt_keymax=keyID;
        newvalues = 1;
    }

    if (newvalues)
    {
        switch (type)
        {
          case TYPE_SHORT:  
            if (count > 1) return 0;
            data = (char *)&key->gk_data; /* store value *in* data */
            break;
          case TYPE_DOUBLE:
            key->gk_data = (char *)(gtif->gt_double + gtif->gt_ndoubles);
            data = key->gk_data;
            gtif->gt_ndoubles += count;
            break;
          case TYPE_ASCII:
            break;
          default:
            va_end(ap);
            return 0;
        }
        gtif->gt_nshorts += sizeof(KeyEntry)/sizeof(pinfo_t);
    }

    /* this fixes a bug where if a request is made to write a duplicate
       key, we must initialize the data to a valid value.
       Bryan Wells (bryan@athena.bangor.autometric.com) */
        
    else /* no new values, but still have something to write */
    {
        switch (type)
        {
          case TYPE_SHORT:  
            if (count > 1) return 0;
            data = (char *)&key->gk_data; /* store value *in* data */
            break;
          case TYPE_DOUBLE:
            data = key->gk_data;
            break;
          case TYPE_ASCII:
            break;
          default:
            return 0;
        }
    }
        
    switch (type)
    {
      case TYPE_ASCII:
        /* throw away existing data and allocate room for new data */
        if (key->gk_data != 0)
        {
            _GTIFFree(key->gk_data);
        }
        key->gk_data = (char *)_GTIFcalloc(count);
        key->gk_count = count;
        data = key->gk_data;
        break;
      default:
        break;
    }

    _GTIFmemcpy(data, val, count*key->gk_size);
    
    gtif->gt_flags |= FLAG_FILE_MODIFIED;
    return 1;
}

GTIF CPL_DLL* GTIFNew

(

void *

tif

)

Given an open TIFF file, look for GTIF keys and values and return GTIF structure.

This function creates a GeoTIFF information interpretation handle (GTIF *) based on a passed in TIFF handle originally from XTIFFOpen(). Even though the argument (tif) is shown as type void *, it is really normally of type TIFF *.

The returned GTIF handle can be used to read or write GeoTIFF tags using the various GTIF functions. The handle should be destroyed using GTIFFree() before the file is closed with TIFFClose().

If the file accessed has no GeoTIFF keys, an valid (but empty) GTIF is still returned. GTIFNew() is used both for existing files being read, and for new TIFF files that will have GeoTIFF tags written to them.

{
    TIFFMethod default_methods;
    _GTIFSetDefaultTIFF( &default_methods );

    return GTIFNewWithMethods( tif, &default_methods );
}

int CPL_DLL GTIFPCSToImage	(	GTIF *	gtif,
		double *	x,
		double *	y
	)

Translate a projection coordinate to pixel/line coordinates.

At this time this function does not support PCS to image translations for tiepoints-only based definitions, only matrix and pixelscale/tiepoints formulations are supposed.

Parameters:

	gtif	The handle from GTIFNew() indicating the target file.
	x	A pointer to the double containing the pixel offset on input, and into which the easting/longitude will be put on completion.
	y	A pointer to the double containing the line offset on input, and into which the northing/latitude will be put on completion.

Returns:

TRUE if the transformation succeeds, or FALSE if it fails. It may fail if the file doesn't have properly setup transformation information, or it is in a form unsupported by this function.

{
    double      *tiepoints = NULL;
    int         tiepoint_count, count, transform_count = 0;
    double      *pixel_scale = NULL;
    double      *transform   = NULL;
    tiff_t      *tif=gtif->gt_tif;
    int         result = FALSE;

/* -------------------------------------------------------------------- */
/*      Fetch tiepoints and pixel scale.                                */
/* -------------------------------------------------------------------- */
    if (!(gtif->gt_methods.get)(tif, GTIFF_TIEPOINTS,
                              &tiepoint_count, &tiepoints ))
        tiepoint_count = 0;

    if (!(gtif->gt_methods.get)(tif, GTIFF_PIXELSCALE, &count, &pixel_scale ))
        count = 0;

    if (!(gtif->gt_methods.get)(tif, GTIFF_TRANSMATRIX,
                                &transform_count, &transform ))
        transform_count = 0;

/* -------------------------------------------------------------------- */
/*      If the pixelscale count is zero, but we have tiepoints use      */
/*      the tiepoint based approach.                                    */
/* -------------------------------------------------------------------- */
    if( tiepoint_count > 6 && count == 0 )
    {
        result = GTIFTiepointTranslate( tiepoint_count / 6,
                                        tiepoints + 3, tiepoints,
                                        *x, *y, x, y );
    }

/* -------------------------------------------------------------------- */
/*      Handle matrix - convert to "geotransform" format, invert and    */
/*      apply.                                                          */
/* -------------------------------------------------------------------- */
    else if( transform_count == 16 )
    {
        double  x_in = *x, y_in = *y;
        double  gt_in[6], gt_out[6];
        
        gt_in[0] = transform[0];
        gt_in[1] = transform[1];
        gt_in[2] = transform[3];
        gt_in[3] = transform[4];
        gt_in[4] = transform[5];
        gt_in[5] = transform[7];

        if( !inv_geotransform( gt_in, gt_out ) )
            result = FALSE;
        else
        {
            *x = x_in * gt_out[0] + y_in * gt_out[1] + gt_out[2];
            *y = x_in * gt_out[3] + y_in * gt_out[4] + gt_out[5];
            
            result = TRUE;
        }
    }

/* -------------------------------------------------------------------- */
/*      For now we require one tie point, and a valid pixel scale.      */
/* -------------------------------------------------------------------- */
    else if( count >= 3 && tiepoint_count >= 6 )
    {
        *x = (*x - tiepoints[3]) / pixel_scale[0] + tiepoints[0];
        *y = (*y - tiepoints[4]) / (-1 * pixel_scale[1]) + tiepoints[1];

        result = TRUE;
    }

/* -------------------------------------------------------------------- */
/*      Cleanup.                                                        */
/* -------------------------------------------------------------------- */
    if(tiepoints)   
        _GTIFFree(tiepoints);
    if(pixel_scale)
        _GTIFFree(pixel_scale);
    if(transform)  
        _GTIFFree(transform);

    return result;
}

int CPL_DLL GTIFWriteKeys

(

GTIF *

gt

)

This function flushes all the GeoTIFF keys that have been set with the GTIFKeySet() function into the associated TIFF file.

Parameters:

gt

The GeoTIFF handle returned by GTIFNew.

GTIFWriteKeys() should be called before GTIFFree() is used to deallocate a GeoTIFF access handle.

{
    int i;
    GeoKey *keyptr;
    KeyEntry *entptr;
    KeyHeader *header;
    TempKeyData tempData;
    int sortkeys[MAX_KEYS];
        
    if (!(gt->gt_flags & FLAG_FILE_MODIFIED)) return 1;

    if( gt->gt_tif == NULL )
        return 0;
        
    tempData.tk_asciiParams = 0;
    tempData.tk_asciiParamsLength = 0;
    tempData.tk_asciiParamsOffset = 0;

    /*  Sort the Keys into numerical order */
    if (!SortKeys(gt,sortkeys))
    {
        /* XXX error: a key was not recognized */
    }
        
    /* Set up header of ProjectionInfo tag */
    header = (KeyHeader *)gt->gt_short;
    header->hdr_num_keys = (pinfo_t) gt->gt_num_keys;
    header->hdr_version  = GvCurrentVersion;
    header->hdr_rev_major  = GvCurrentRevision;
    header->hdr_rev_minor  = GvCurrentMinorRev;
        
    /* Sum up the ASCII tag lengths */
    for (i = 0; i < gt->gt_num_keys; i++)
    {
        keyptr = gt->gt_keys + sortkeys[i];
        if (keyptr->gk_type == TYPE_ASCII)
        {
            tempData.tk_asciiParamsLength += keyptr->gk_count;
        }
    }
    if (tempData.tk_asciiParamsLength > 0)
    {
        tempData.tk_asciiParams =
            (char *)_GTIFcalloc(tempData.tk_asciiParamsLength + 1);
        tempData.tk_asciiParams[tempData.tk_asciiParamsLength] = '\0';
    }

    /* Set up the rest of SHORT array properly */
    keyptr = gt->gt_keys;
    entptr = (KeyEntry*)(gt->gt_short + 4);
    for (i=0; i< gt->gt_num_keys; i++,entptr++)
    {
        if (!WriteKey(gt,&tempData,entptr,keyptr+sortkeys[i])) return 0;
    }   
        
    /* Write out the Key Directory */
    (gt->gt_methods.set)(gt->gt_tif, GTIFF_GEOKEYDIRECTORY, gt->gt_nshorts, gt->gt_short );     
        
    /* Write out the params directories */
    if (gt->gt_ndoubles)
        (gt->gt_methods.set)(gt->gt_tif, GTIFF_DOUBLEPARAMS, gt->gt_ndoubles, gt->gt_double );
    if (tempData.tk_asciiParamsLength > 0)
    {
        /* just to be safe */
        tempData.tk_asciiParams[tempData.tk_asciiParamsLength] = '\0';
        (gt->gt_methods.set)(gt->gt_tif,
                             GTIFF_ASCIIPARAMS, 0, tempData.tk_asciiParams);
    }
        
    gt->gt_flags &= ~FLAG_FILE_MODIFIED;

    if (tempData.tk_asciiParamsLength > 0)
    {
        _GTIFFree (tempData.tk_asciiParams);
    }
    return 1;
}