static void PrintTag(int tag, int nrows, double *dptr, int ncols,
GTIFPrintMethod print,void *aux)
{
int i,j;
double *data=dptr;
char message[1024];
print(" ",aux);
print(GTIFTagName(tag),aux);
sprintf(message," (%d,%d):\n",nrows,ncols);
print(message,aux);
for (i=0; i<nrows; i++)
{
print(" ",aux);
for (j=0; j<ncols; j++)
{
sprintf(message,FMT_DOUBLE,*data++);
print(message,aux);
if( j < ncols-1 )
print(" ",aux);
}
print("\n",aux);
}
_GTIFFree(dptr); /* free up the allocated memory */
}
void GTIFFree(GTIF* gtif)
{
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);
if (gtif->own_pj_context)
{
proj_context_destroy(gtif->pj_context);
}
_GTIFFree (gtif);
}
static int ReadTag(GTIF *gt,GTIFReadMethod scan,void *aux)
{
int i,j,tag;
char *vptr;
char tagname[100];
double *data,*dptr;
int count,nrows,ncols,num;
char message[1024];
scan(message,aux);
if (!strncmp(message,FMT_TAGEND,8)) return 0;
num=sscanf(message,"%[^( ] (%d,%d):\n",tagname,&nrows,&ncols);
if (num!=3) return StringError(message);
tag = GTIFTagCode(tagname);
if (tag < 0) return StringError(tagname);
count = nrows*ncols;
data = (double *) _GTIFcalloc(count * sizeof(double));
dptr = data;
for (i=0; i<nrows; i++)
{
scan(message,aux);
vptr = message;
for (j=0; j<ncols; j++)
{
if (!sscanf(vptr,"%lg",dptr++))
return StringError(vptr);
FINDCHAR(vptr,' ');
SKIPWHITE(vptr);
}
}
(gt->gt_methods.set)(gt->gt_tif, (pinfo_t) tag, count, data );
_GTIFFree( data );
return 1;
}
int GTIFWriteKeys(GTIF *gt)
{
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;
}
GTIF* GTIFNewWithMethods(void *tif, TIFFMethod* methods)
{
GTIF* gt=(GTIF*)0;
int count,bufcount,index;
GeoKey *keyptr;
pinfo_t *data;
KeyEntry *entptr;
KeyHeader *header;
TempKeyData tempData;
memset( &tempData, 0, sizeof(tempData) );
gt = (GTIF*)_GTIFcalloc( sizeof(GTIF));
if (!gt) goto failure;
/* install TIFF file and I/O methods */
gt->gt_tif = (tiff_t *)tif;
memcpy( >->gt_methods, methods, sizeof(TIFFMethod) );
/* since this is an array, GTIF will allocate the memory */
if ( tif == NULL
|| !(gt->gt_methods.get)(tif, GTIFF_GEOKEYDIRECTORY, >->gt_nshorts, &data ))
{
/* No ProjectionInfo, create a blank one */
data=(pinfo_t*)_GTIFcalloc((4+MAX_VALUES)*sizeof(pinfo_t));
if (!data) goto failure;
header = (KeyHeader *)data;
header->hdr_version = GvCurrentVersion;
header->hdr_rev_major = GvCurrentRevision;
header->hdr_rev_minor = GvCurrentMinorRev;
gt->gt_nshorts=sizeof(KeyHeader)/sizeof(pinfo_t);
}
else
{
/* resize data array so it can be extended if needed */
data = (pinfo_t*) _GTIFrealloc(data,(4+MAX_VALUES)*sizeof(pinfo_t));
}
gt->gt_short = data;
header = (KeyHeader *)data;
if (header->hdr_version > GvCurrentVersion) goto failure;
if (header->hdr_rev_major > GvCurrentRevision)
{
/* issue warning */
}
/* If we got here, then the geokey can be parsed */
count = header->hdr_num_keys;
if (count * sizeof(KeyEntry) >= (4 + MAX_VALUES) * sizeof(pinfo_t))
goto failure;
gt->gt_num_keys = count;
gt->gt_version = header->hdr_version;
gt->gt_rev_major = header->hdr_rev_major;
gt->gt_rev_minor = header->hdr_rev_minor;
bufcount = count+MAX_KEYS; /* allow for expansion */
/* Get the PARAMS Tags, if any */
if (tif == NULL
|| !(gt->gt_methods.get)(tif, GTIFF_DOUBLEPARAMS,
>->gt_ndoubles, >->gt_double ))
{
gt->gt_double=(double*)_GTIFcalloc(MAX_VALUES*sizeof(double));
if (!gt->gt_double) goto failure;
}
else
{
/* resize data array so it can be extended if needed */
gt->gt_double = (double*) _GTIFrealloc(gt->gt_double,
(MAX_VALUES)*sizeof(double));
}
if ( tif == NULL
|| !(gt->gt_methods.get)(tif, GTIFF_ASCIIPARAMS,
&tempData.tk_asciiParamsLength,
&tempData.tk_asciiParams ))
{
tempData.tk_asciiParams = 0;
tempData.tk_asciiParamsLength = 0;
}
else
{
/* last NULL doesn't count; "|" used for delimiter */
--tempData.tk_asciiParamsLength;
}
/* allocate space for GeoKey array and its index */
gt->gt_keys = (GeoKey *)_GTIFcalloc( sizeof(GeoKey)*bufcount);
if (!gt->gt_keys) goto failure;
gt->gt_keyindex = (int *)_GTIFcalloc( sizeof(int)*(MAX_KEYINDEX+1));
if (!gt->gt_keyindex) goto failure;
/* Loop to get all GeoKeys */
entptr = ((KeyEntry *)data) + 1;
keyptr = gt->gt_keys;
gt->gt_keymin = MAX_KEYINDEX;
gt->gt_keymax = 0;
for (index=1; index<=count; index++,entptr++)
{
if (!ReadKey(gt, &tempData, entptr, ++keyptr))
goto failure;
/* Set up the index (start at 1, since 0=unset) */
gt->gt_keyindex[entptr->ent_key] = index;
}
if( tempData.tk_asciiParams != NULL )
_GTIFFree( tempData.tk_asciiParams );
return gt;
failure:
/* Notify of error */
if( tempData.tk_asciiParams != NULL )
_GTIFFree( tempData.tk_asciiParams );
GTIFFree (gt);
return (GTIF *)0;
}
static int ReadKey(GTIF *gt, GTIFReadMethod scan, void *aux)
{
tagtype_t ktype;
int count,outcount;
int vals_now,i;
geokey_t key;
int icode;
pinfo_t code;
short *sptr;
char name[1000];
char type[20];
double data[100];
double *dptr;
char *vptr;
int num;
char message[2048];
scan(message,aux);
if (!strncmp(message,FMT_KEYEND,8)) return 0;
num=sscanf(message,"%[^( ] (%[^,],%d):\n",name,type,&count);
if (num!=3) return StringError(message);
vptr = message;
FINDCHAR(vptr,':');
if (!*vptr) return StringError(message);
vptr+=2;
if( GTIFKeyCode(name) < 0 )
return StringError(name);
else
key = (geokey_t) GTIFKeyCode(name);
if( GTIFTypeCode(type) < 0 )
return StringError(type);
else
ktype = (tagtype_t) GTIFTypeCode(type);
/* skip white space */
SKIPWHITE(vptr);
if (!*vptr) return StringError(message);
switch (ktype)
{
case TYPE_ASCII:
{
char *cdata;
int out_char = 0;
FINDCHAR(vptr,'"');
if (!*vptr) return StringError(message);
cdata = (char *) _GTIFcalloc( count+1 );
vptr++;
while( out_char < count-1 )
{
if( *vptr == '\0' )
break;
else if( vptr[0] == '\\' && vptr[1] == 'n' )
{
cdata[out_char++] = '\n';
vptr += 2;
}
else if( vptr[0] == '\\' && vptr[1] == '\\' )
{
cdata[out_char++] = '\\';
vptr += 2;
}
else
cdata[out_char++] = *(vptr++);
}
if( out_char < count-1 ) return StringError(message);
if( *vptr != '"' ) return StringError(message);
cdata[count-1] = '\0';
GTIFKeySet(gt,key,ktype,count,cdata);
_GTIFFree( cdata );
}
break;
case TYPE_DOUBLE:
outcount = count;
for (dptr = data; count > 0; count-= vals_now)
{
vals_now = count > 3? 3: count;
for (i=0; i<vals_now; i++,dptr++)
{
if (!sscanf(vptr,"%lg" ,dptr))
StringError(vptr);
FINDCHAR(vptr,' ');
SKIPWHITE(vptr);
}
if (vals_now<count)
{
scan(message,aux);
vptr = message;
}
}
if (outcount==1)
GTIFKeySet(gt,key,ktype,outcount,data[0]);
else
GTIFKeySet(gt,key,ktype,outcount,data);
break;
case TYPE_SHORT:
if (count==1)
{
icode = GTIFValueCode(key,vptr);
if (icode < 0) return StringError(vptr);
code = (pinfo_t) icode;
GTIFKeySet(gt,key,ktype,count,code);
}
else /* multi-valued short - no such thing yet */
{
char* cdata;
memcpy(&cdata, &data, sizeof(void*));
sptr = (short *)cdata;
outcount = count;
for (; count > 0; count-= vals_now)
{
vals_now = count > 3? 3: count;
for (i=0; i<vals_now; i++,sptr++)
{
int work_int;
/* note: FMT_SHORT (%11hd) not supported on IRIX */
sscanf(message,"%11d",&work_int);
*sptr = (short) work_int;
scan(message,aux);
}
if (vals_now<count)
{
scan(message,aux);
vptr = message;
}
}
GTIFKeySet(gt,key,ktype,outcount,sptr);
}
break;
default:
return -1;
}
return 1;
}
int GTIFPCSToImage( GTIF *gtif, double *x, double *y )
{
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 GTIFImageToPCS( GTIF *gtif, double *x, double *y )
{
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;
}
