/***************************************************************************
*
*N point_in_face_table
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Test whether a point is inside a face or not. Must have a valid path-
* name to a valid VPF Face file, or else be in graphics mode for the error
* message that will result. Filename must have all directory seperators
* escapes; eg. c:\\vpf NOT c:\vpf
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
* Parameters:
*A
* x <input> == (float) given point x coordinate.
* y <input> == (float) given point y coordinate.
* face_id <input> == (rspf_int32) face.
* fname <input> == (char *) pathname to VPF face file.
* point_in_face_table <output> == VPF_BOOLEAN:
* 1 --> point is inside
* 0 --> point is not inside
*E
**************************************************************************/
int point_in_face_table( float x, float y,
rspf_int32 face_id,
char *fname )
{
vpf_table_type facetable, ringtable, edgetable;
char *name;
int result;
name = (char *)vpfmalloc( 255*sizeof(char) );
facetable = vpf_open_table(fname,disk, "rb", NULL );
strupr(fname);
strcpy( name, fname );
dirpath( name );
strcat( name, "RNG" );
ringtable = vpf_open_table( name, disk , "rb", NULL );
strcpy( name, fname );
dirpath( name );
strcat( name, "EDG" );
edgetable = vpf_open_table( name, disk , "rb", NULL );
free( name );
result = point_in_face( x, y, face_id, facetable, ringtable, edgetable );
vpf_close_table(&facetable);
vpf_close_table(&ringtable);
vpf_close_table(&edgetable);
return result;
}
bool ossimVpfTable::openTable(const ossimFilename& tableName)
{
closeTable();
if(is_vpf_table(const_cast<char*>(tableName.c_str())))
{
if(theTableInformation)
{
delete theTableInformation;
theTableInformation = NULL;
}
theTableInformation = new vpf_table_type;
memset(theTableInformation, 0, sizeof(vpf_table_type));
theTableName = tableName;
*theTableInformation = vpf_open_table(const_cast<char*>(tableName.c_str()),
disk,
"rb",
NULL);
}
else
{
delete theTableInformation;
theTableInformation = NULL;
return false;
}
return true;
}
/**************************************************************************
*
*N vpf_dump_doc_table
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Dump the contents of a narrative-style .DOC VPF table into an
* ASCII file as a series of text strings. This function checks
* to make sure that the given table is a real narrative file
* (two fields: ID and TEXT). If not, it displays it as a normal
* VPF table.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* tablename <input> == (char *) narrative-style .DOC VPF table to dump.
* outname <input> == (char *) name of ASCII dump file.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
void vpf_dump_doc_table( char *tablename, char *outname )
{
vpf_table_type table;
long int i,n;
char *buf;
row_type row;
FILE *fp;
fp = fopen(outname,"w");
table = vpf_open_table(tablename,disk,"rb",NULL);
/* Check header to make sure the table is a narrative table */
if ((ossim_strcasecmp(table.header[1].name,"TEXT") != 0) ||
(table.nfields != 2)) {
/* Not a real narrative table -> normal VPF table dump */
vpf_close_table(&table);
vpf_dump_table(tablename,outname);
return;
}
fprintf(fp,"%s\n%s\n\n",tablename,table.description);
for (i=1;i<=table.nrows;i++) {
row = read_next_row(table);
buf = (char *)get_table_element(1,row,table,NULL,&n);
fprintf(fp,"%s\n",buf);
free(buf);
free_row(row,table);
}
fclose(fp);
vpf_close_table( &table );
}
/*************************************************************************
*
*N get_selected_features
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function gets the selection set for a given theme of the
* specified view, either by querying the table, or by reading a
* previously saved selection set file.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* view <input>==(view_type *) view structure.
* themenum <input>==(int) theme number.
* library <input>==(library-type) VPF library structure.
* return <output>==(set_type) set of selected features.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*************************************************************************/
set_type get_selected_features( view_type *view, int themenum,
library_type library )
{
set_type selset;
vpf_table_type ft;
register int i;
/* Read a selection set, if present */
if (strcmp(view->name,"") != 0) {
selset = read_selected_features( view, themenum );
if (selset.size > 0) return selset;
}
/* No selection set... */
/* Find the feature class for the theme */
for (i=0;i<library.nfc;i++)
if (strcasecmp(library.fc[i].name,view->theme[themenum].fc)==0) break;
if (i>=library.nfc) {
display_message("Invalid theme in view");
return selset;
}
/* Query the feature table */
ft = vpf_open_table( library.fc[i].table, disk, "rb", NULL );
selset = query_table( view->theme[themenum].expression, ft );
vpf_close_table( &ft );
/* Save the selection set so we don't have to query again */
if (strcmp(view->name,"") != 0) {
save_selected_features( view, themenum, selset );
}
return selset;
}
ossimErrorCode ossimVpfDatabaseHeader::open(const ossimFilename& databaseHeaderTable)
{
vpf_table_type tableTypeData;
if( is_vpf_table( databaseHeaderTable.c_str() ) )
{
tableTypeData = vpf_open_table(databaseHeaderTable.c_str(),
(storage_type)DISK,
"rb",
NULL);
if(isDatabaseHeaderTable(tableTypeData))
{
}
else
{
return ossimErrorCodes::OSSIM_ERROR;
}
}
else
{
return ossimErrorCodes::OSSIM_ERROR;
}
return ossimErrorCodes::OSSIM_OK;
}
/*************************************************************************
*
*N bounding_select
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function reads the bounding rectangle table to weed out the
* local primitives.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* path <input> == (char *) path to the bounding rectangle table.
* mapextent <input> == (extent_type) map extent to compare.
* dec_degrees <input> == (int) flag to indicate if data is in decimal
* degrees.
* bounding_select <output> == (set_type) set of bounding rectangle ids.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*************************************************************************/
set_type bounding_select( char *path, extent_type mapextent,
int dec_degrees )
{
vpf_table_type table;
set_type set;
rspf_int32 i, count;
extent_type box, pextent;
double x1,y1,x2,y2;
row_type row;
int XMIN_,YMIN_,XMAX_,YMAX_;
/* Project all extents to plate-carree for cartesian comparisons */
/* (decimal degree coordinate systems) */
x1 = mapextent.x1; y1 = mapextent.y1;
x2 = mapextent.x2; y2 = mapextent.y2;
if (dec_degrees) {
set_plate_carree_parameters( central_meridian(x1,x2), 0.0, 1.0 );
pcarree_xy(&x1,&y1);
pcarree_xy(&x2,&y2);
}
pextent.x1 = x1; pextent.y1 = y1;
pextent.x2 = x2; pextent.y2 = y2;
table = vpf_open_table(path,disk,"rb",NULL);
XMIN_ = table_pos("XMIN",table);
YMIN_ = table_pos("YMIN",table);
XMAX_ = table_pos("XMAX",table);
YMAX_ = table_pos("YMAX",table);
set = set_init(table.nrows+1);
for (i=1;i<=table.nrows;i++) {
row = read_next_row(table);
get_table_element(XMIN_,row,table,&box.x1,&count);
get_table_element(YMIN_,row,table,&box.y1,&count);
get_table_element(XMAX_,row,table,&box.x2,&count);
get_table_element(YMAX_,row,table,&box.y2,&count);
free_row(row,table);
x1 = box.x1; y1 = box.y1;
x2 = box.x2; y2 = box.y2;
if (dec_degrees) {
pcarree_xy(&x1,&y1);
pcarree_xy(&x2,&y2);
}
box.x1 = x1; box.y1 = y1;
box.x2 = x2; box.y2 = y2;
if ( contained(box,pextent) || contained(pextent,box) ) {
set_insert(i,set);
}
}
vpf_close_table(&table);
return set;
}
/*************************************************************************
*
*N outline_face_table
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function outlines the specified face from a previously unopened
* face primitive table in the given color.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* face_id <input>==(ossim_int32) id of the face to be outlined.
* fname <input>==(char *) file name of the face primitive table.
* color <input>==(int) color to outline the face.
* inner <input>==(int) if TRUE, draw inner rings;
* if FALSE, only draw outer ring.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*************************************************************************/
void outline_face_table( ossim_int32 face_id, char *fname,
int color, int inner )
{
vpf_table_type facetable, ringtable, edgetable;
char *name;
name = (char *)vpfmalloc( 255*sizeof(char) );
gpsetlinecolor( color );
facetable = vpf_open_table(fname,disk, "rb", (char *)NULL);
strupr(fname);
strcpy( name, facetable.path );
strcat( name, "RNG" );
ringtable = vpf_open_table( name, disk, "rb", (char *)NULL );
strcpy( name, facetable.path );
strcat( name, "EDG" );
edgetable = vpf_open_table( name, disk, "rb", (char *)NULL );
free( name );
hidemousecursor();
outline_face( face_id, facetable, ringtable, edgetable, color,
inner );
showmousecursor();
vpf_close_table(&facetable);
vpf_close_table(&ringtable);
vpf_close_table(&edgetable);
}
/**************************************************************************
*
*N distance_to_edge_table
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function reads the specified edge from the named edge table
* and computes the minimum distance from the given point to the
* specified edge. 'edge_id' must be contained in the edge table.
* 'fname' must be a valid path to a VPF edge table.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* x <input> == (float) given point x coordinate.
* y <input> == (float) given point y coordinate
* edge_id <input> == (long int) specified edge id.
* fname <input> == (char *) path to valid VPF edge table.
* dec_degrees <output> == (int) flag to indicate if coordinates are
* in decimal degrees.
* distance_to_edge_table <output> == (float) distance from the given
* point to the specified edge.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels, DOS Turbo C 1991
*E
*************************************************************************/
float distance_to_edge_table( float x, float y,
long int edge_id,
char *fname, int dec_degrees )
{
vpf_table_type edgetable;
float result;
char *defstr=" ";
edgetable = vpf_open_table(fname,disk, "rb", defstr);
result = distance_to_edge( x, y, edge_id, edgetable, dec_degrees );
vpf_close_table(&edgetable);
return result;
}
/*************************************************************************
*
*N display_attributes
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function displays all of the attributes of a particular
* feature, including the descriptions of the fields and their
* values.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* fc <input> == (int) feature class number.
* row <input> == (ossim_int32) row of the attribute table.
* library <input> == (library_type *) VPF library structure.
* fp <input> == (FILE *) pointer to the output file.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*************************************************************************/
void display_attributes( int fc,
ossim_int32 row,
library_type *library,
FILE *fp )
{
vpf_table_type feature_table;
row_type vpfrow;
feature_table = vpf_open_table(library->fc[fc].table,disk,"rb",NULL);
vpfrow = read_row( row, feature_table );
vpf_display_record( vpfrow, feature_table, fp );
free_row(vpfrow,feature_table);
vpf_close_table(&feature_table);
}
/**************************************************************************
*
*N select_feature_class_relate
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Set up the relationships between features and primitives or between
* primitives and features (one way only) for a specified feature class.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
fcrel_type select_feature_class_relate( int fcnum,
library_type *library,
char *start_table,
char *end_table )
{
int storage, cov;
vpf_table_type fcs;
long int i;
char path[255], covpath[255];
position_type p;
vpf_relate_struct rcell;
fcrel_type fcrel;
fcrel.nchain = 0;
fcrel.table = NULL;
fcrel.relate_list = NULL;
cov = library->fc[fcnum].coverage;
strcpy(covpath,library->cover[cov].path);
rightjust(covpath);
sprintf( path, "%sfcs", covpath );
/* Feature Class Schema table */
fcs = vpf_open_table( path, disk, "rb", NULL );
fcrel.relate_list = fcs_relate_list( library->fc[fcnum].name,
start_table,end_table,
fcs );
if (ll_empty(fcrel.relate_list)) {
ll_reset(fcrel.relate_list);
displaymessage("ERROR in feature class relationship!",
start_table,end_table,NULL);
return fcrel;
}
/* Find the number of tables in the relate chain */
p = ll_first(fcrel.relate_list);
fcrel.nchain = 0;
while (!ll_end(p)) {
fcrel.nchain++;
p = ll_next(p);
}
/* Allow for last table2 */
fcrel.nchain++;
fcrel.table = (vpf_table_type *)
vpfmalloc((fcrel.nchain+1)*
sizeof(vpf_table_type));
for (i=0;i<fcrel.nchain+1;i++)
vpf_nullify_table( &(fcrel.table[i]) );
p = ll_first(fcrel.relate_list);
for (i=0;i<fcrel.nchain-1;i++) {
ll_element(p,&rcell);
/** Can't open primitive table - may be several under tile **/
/** directories. Open all others **/
if (!is_primitive(rcell.table1)) {
sprintf(path,"%s%s",covpath,rcell.table1);
if (is_join(rcell.table1))
storage = ram;
else
storage = disk;
fcrel.table[i] = vpf_open_table(path,(storage_type)storage,"rb",NULL);
}
if (!ll_end(p)) p = ll_next(p);
}
/* End of relate chain */
i = fcrel.nchain-1;
if (!is_primitive(rcell.table2)) {
sprintf(path,"%s%s",covpath,rcell.table2);
storage = disk;
fcrel.table[i] = vpf_open_table(path,(storage_type)storage,"rb",NULL);
}
vpf_close_table( &fcs );
return fcrel;
}
/**************************************************************************
*
*N vpf_dump_table
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Dump the contents of a VPF table into an ASCII file
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* tablename <input> == (char *) VPF table to dump.
* outname <input> == (char *) name of ASCII dump file.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
void vpf_dump_table( char *tablename, char *outname )
{
vpf_table_type table;
long int i,j,k,n;
int ival,*iptr;
long int lval,*lptr;
float fval,*fptr;
date_type dval,*dptr;
id_triplet_type kval, *kptr;
coordinate_type cval, *cptr;
char *buf, ch, date[40];
row_type row;
FILE *fp;
fp = fopen(outname,"w");
table = vpf_open_table(tablename,disk,"rb",NULL);
fprintf(fp,"%s\n%s\n\n",tablename,table.description);
fprintf(fp,"Definition:\n");
for (i=0;i<table.nfields;i++) {
if (table.header[i].count < 0)
fprintf(fp,"%s (%c,*) %s\n",
table.header[i].name,table.header[i].type,
table.header[i].description);
else
fprintf(fp,"%s (%c,%ld) %s\n",
table.header[i].name,table.header[i].type,
table.header[i].count,table.header[i].description);
}
fprintf(fp,"\nContents:\n");
for (i=1;i<=table.nrows;i++) {
row = read_next_row(table);
for (j=0;j<table.nfields;j++) {
fprintf(fp,"%s: ",table.header[j].name);
switch (table.header[j].type) {
case 'T':
if (table.header[j].count==1) {
get_table_element(j,row,table,&ch,&n);
fprintf(fp,"%c\n",ch);
} else {
buf = (char *)get_table_element(j,row,table,NULL,&n);
n = (long)strlen(table.header[j].name) + 2;
for (k=0;(unsigned int)k<strlen(buf);k++) {
fprintf(fp,"%c",buf[k]);
n++;
if (n>80) {
fprintf(fp,"\n");
n = 0;
}
}
fprintf(fp,"\n");
free(buf);
}
break;
case 'I':
if (table.header[j].count==1) {
get_table_element(j,row,table,&lval,&n);
if (lval != MAXFLOAT)
fprintf(fp,"%ld\n",lval);
else
fprintf(fp,"(null)\n");
} else {
lptr = (long int*)get_table_element(j,row,table,NULL,&n);
for (k=0;k<n;k++) {
if (lptr[k] != MAXFLOAT)
fprintf(fp,"%ld ",lptr[k]);
else
fprintf(fp,"(null) ");
}
fprintf(fp,"\n");
free(lptr);
}
break;
case 'S':
if (table.header[j].count==1) {
get_table_element(j,row,table,&ival,&n);
if (ival != MAXINT)
fprintf(fp,"%d\n",ival);
else
fprintf(fp,"(null)\n");
} else {
iptr = (int*)get_table_element(j,row,table,NULL,&n);
for (k=0;k<n;k++) {
if (iptr[k] != MAXINT)
fprintf(fp,"%d ",iptr[k]);
else
fprintf(fp,"(null) ");
}
fprintf(fp,"\n");
free(iptr);
}
break;
case 'F':
if (table.header[j].count==1) {
get_table_element(j,row,table,&fval,&n);
if (fval != MAXFLOAT)
fprintf(fp,"%f\n",fval);
else
fprintf(fp,"(null)\n");
} else {
fptr = (float*)get_table_element(j,row,table,NULL,&n);
for (k=0;k<n;k++) {
if (fptr[k] != MAXFLOAT)
fprintf(fp,"%f ",fptr[k]);
else
fprintf(fp,"(null) ");
}
fprintf(fp,"\n");
free(fptr);
}
break;
case 'C':
if (table.header[j].count==1) {
get_table_element(j,row,table,&cval,&n);
fprintf(fp,"(%f,%f)\n",cval.x,cval.y);
} else {
cptr = (coordinate_type*)get_table_element(j,row,table,NULL,&n);
for (k=0;k<n;k++)
fprintf(fp,"(%f,%f) ",cptr[k].x,cptr[k].y);
fprintf(fp,"\n");
free(cptr);
}
break;
case 'K':
if (table.header[j].count==1) {
get_table_element(j,row,table,&kval,&n);
fprintf(fp,"(%ld,%ld,%ld)\n",
kval.id,kval.tile,kval.exid);
} else {
kptr = (id_triplet_type*)get_table_element(j,row,table,NULL,&n);
for (k=0;k<n;k++)
fprintf(fp,"(%ld,%ld,%ld) ",
kptr[k].id,kptr[k].tile,kptr[k].exid);
fprintf(fp,"\n");
free(kptr);
}
break;
case 'D': /* Date */
if (table.header[j].count==1) {
get_table_element(j,row,table,&dval,&n);
format_date(dval,date);
fprintf(fp,"%s\n",date);
} else {
dptr = (date_type*)get_table_element(j,row,table,NULL,&n);
for (k=0;k<n;k++) {
format_date((char*)(&dptr[k]),date);
fprintf(fp,"%s ",date);
}
fprintf(fp,"\n");
free(dptr);
}
break;
}
}
fprintf(fp,"\n");
free_row( row, table );
}
fclose(fp);
vpf_close_table( &table );
}
/*************************************************************************
*
*N get_selected_primitives
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function determines all of the selected primitive rows from
* the selected features.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* view <input> == (view_type *) view structure.
* themenum <input> == (int) theme number.
* library <input> == (library_type *) VPF library structure.
* mapenv <input> == (map_environment_type *) map environment.
* status <output> == (int *) status of the function:
* 1 if completed, 0 if user escape.
* get_selected_primitives <output> == (set_type *) array of sets, each position
* representing the set of primitives for the
* corresponding tile in the tileref.aft table.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*************************************************************************/
set_type *get_selected_primitives( view_type *view,
int themenum,
library_type *library,
map_environment_type *mapenv,
int *status )
{
int fcnum, finished, found, cov, tilecover, TILEPATH_, degree;
int feature, prim;
vpf_table_type tile_table;
row_type row;
char *ptable[] = {"","edg","fac","txt","end","cnd"};
char *spxname[] = {"","esi","fsi","tsi","nsi","csi"};
char *brname[] = {"","ebr","fbr","tbr","nbr","cbr"};
set_type feature_rows, primitive_rows, tile_features;
set_type *primitives;
rspf_int32 prim_rownum, count, tile;
register rspf_int32 i,j, pclass, start,end;
char path[255], covpath[255], tiledir[255], *buf, str[255];
fcrel_type fcrel;
linked_list_type primlist;
position_type p;
vpf_relate_struct rcell;
ThematicIndex idx;
primitives = (set_type *)vpfmalloc((library->ntiles+1)*sizeof(set_type));
for (i=0;i<=library->ntiles;i++) {
primitives[i].size = 0;
primitives[i].buf = NULL;
}
fcnum = view->theme[themenum].fcnum;
feature_rows = get_selected_features( view, themenum, *library );
/* Open the tile reference table, if present */
sprintf(path,"%stileref\\tileref.aft",library->path);
if (access(path,0) != 0) {
tilecover = FALSE;
} else {
tile_table = vpf_open_table(path,disk,"rb",NULL);
TILEPATH_ = table_pos("TILE_NAME",tile_table);
tilecover = TRUE;
}
for (pclass=EDGE;pclass<=CONNECTED_NODE;pclass++) {
if ((pclass != library->fc[fcnum].primclass) &&
(library->fc[fcnum].primclass != COMPLEX_FEATURE)) continue;
/* Set up the feature class table relate chain. */
/* The feature table is fcrel.table[0]. */
/* The primitive table is the last table in the chain: */
/* fcrel.table[ fcrel.nchain-1 ]. */
j = 0;
for (i=0;i<strlen(library->fc[fcnum].table);i++)
if (library->fc[fcnum].table[i] == '\\') j = i+1;
strcpy( str, &(library->fc[fcnum].table[j]));
fcrel = select_feature_class_relate(fcnum, library, str,
ptable[pclass]);
feature = 0;
prim = fcrel.nchain-1;
p = ll_previous(ll_last(fcrel.relate_list),fcrel.relate_list);
ll_element(p,&rcell);
degree = rcell.degree;
/*** 'Tile' number 1 is the universe polygon for the tileref cover ***/
for (tile = 2; tile <= library->ntiles; tile++ ) {
if (!set_member(tile,library->tile_set)) continue;
if (tilecover) {
row = get_row(tile,tile_table);
buf = (char *)get_table_element(TILEPATH_,row,tile_table,
NULL,&count);
free_row(row,tile_table);
strcpy(tiledir,buf);
rightjust(tiledir);
strcat(tiledir,"\\");
free(buf);
} else {
strcpy(tiledir,"");
}
cov = library->fc[fcnum].coverage;
strcpy( covpath, library->cover[cov].path );
finished = 1;
found = 0;
/* Open primitive table in tile */
sprintf(path,"%s%s%s",covpath,tiledir,ptable[pclass]);
if (access(path,0) != 0) continue;
found = 1;
fcrel.table[prim] = vpf_open_table(path,disk,"rb",NULL);
if (primitives[tile].size > 0) {
printf("Oops! size = %ld\n",primitives[tile].size);
exit(1);
}
primitives[tile] = set_init(fcrel.table[prim].nrows+1);
/* Get the set of primitive rows within the map extent */
/* Look for spatial index file */
primitive_rows.size = 0;
if (mapenv->projection == PLATE_CARREE &&
mapenv->mapextent.x1 < mapenv->mapextent.x2) {
sprintf(path,"%s%s%s",covpath,tiledir,spxname[pclass]);
if ((access(path,0)==0)&&(fcrel.table[prim].nrows > 20)) {
primitive_rows = spatial_index_search(path,
mapenv->mapextent.x1,mapenv->mapextent.y1,
mapenv->mapextent.x2,mapenv->mapextent.y2);
} else {
/* Next best thing - bounding rectangle table */
sprintf(path,"%s%s%s",covpath,tiledir,brname[pclass]);
if (access(path,0)==0) {
primitive_rows = bounding_select(path,mapenv->mapextent,
library->dec_degrees);
}
}
} /* projection check */
if (primitive_rows.size == 0) {
/* Search through all the primitives */
primitive_rows=set_init(fcrel.table[prim].nrows+1);
set_on(primitive_rows);
}
tile_thematic_index_name(fcrel.table[feature], path);
if ( (strcmp(path,"") != 0) && (access(path,4)==0) ) {
/* Tile thematic index for feature table present, */
tile_features = read_thematic_index( path, (char *)&tile );
} else {
tile_features = set_init(fcrel.table[feature].nrows+1);
set_on(tile_features);
}
idx.fp = NULL;
i = table_pos(rcell.key2,fcrel.table[prim]);
if (i >= 0) {
if (fcrel.table[prim].header[i].tdx) {
sprintf(path,"%s%s",fcrel.table[prim].path,
fcrel.table[prim].header[i].tdx);
if (access(path,0)==0)
idx = open_thematic_index(path);
}
if (fcrel.table[prim].header[i].keytype == 'U') degree = R_ONE;
if (fcrel.table[prim].header[i].keytype == 'N') degree = R_MANY;
if (fcrel.table[prim].header[i].keytype == 'P') degree = R_ONE;
}
finished = 1;
start = set_min(tile_features);
end = set_max(tile_features);
fseek(fcrel.table[feature].fp,
index_pos(start,fcrel.table[feature]),
SEEK_SET);
for (i=start;i<=end;i++) {
row = read_next_row(fcrel.table[feature]);
if (!set_member( i, feature_rows )) {
free_row(row,fcrel.table[feature]);
continue;
}
if (!set_member( i, tile_features )) {
free_row(row,fcrel.table[feature]);
continue;
}
if (degree == R_ONE) {
prim_rownum = fc_row_number( row, fcrel, tile );
primlist = NULL;
p = NULL;
} else {
primlist = fc_row_numbers( row, fcrel, tile, &idx );
}
free_row( row, fcrel.table[feature] );
if (!primlist) {
if ((prim_rownum<1)||
(prim_rownum>fcrel.table[prim].nrows))
continue;
if (set_member( prim_rownum, primitive_rows )) {
set_insert(prim_rownum,primitives[tile]);
}
} else {
p = ll_first(primlist);
while (!ll_end(p)) {
ll_element(p,&prim_rownum);
if ((prim_rownum<1)||
(prim_rownum>fcrel.table[prim].nrows))
continue;
if (set_member( prim_rownum, primitive_rows )) {
set_insert(prim_rownum,primitives[tile]);
}
p = ll_next(p);
}
}
if (kbhit()) {
if (getch()==27) {
*status = 0;
finished = 0;
break;
}
}
}
if (idx.fp) close_thematic_index(&idx);
vpf_close_table(&(fcrel.table[prim]));
set_nuke(&primitive_rows);
set_nuke(&tile_features);
if (set_empty(primitives[tile])) {
set_nuke(&primitives[tile]);
primitives[tile].size = 0;
primitives[tile].buf = NULL;
}
if (!finished) {
*status = 0;
break;
}
}
if (!finished) {
*status = 0;
deselect_feature_class_relate( &fcrel );
break;
}
if (found) *status = 1;
if (kbhit()) {
if (getch()==27) {
*status = 0;
deselect_feature_class_relate( &fcrel );
break;
}
}
deselect_feature_class_relate( &fcrel );
}
set_nuke(&feature_rows);
if (tilecover) {
vpf_close_table(&tile_table);
}
return primitives;
}
/*************************************************************************
*
*N draw_selected_features
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function draws the selected features from a specified feature
* class based upon a query (either an expression or the pre-compiled
* results of an expression).
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* view <inout>==(view_type *) view structure.
* themenum <input>==(int) theme number.
* library <input>==(library_type *) VPF library structure.
* mapenv <input>==(map_environment_type *) map environment structure.
* return <output>==(int) completion status:
* 1 if completed successfully,
* 0 if an error occurred.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels August 1991 DOS Turbo C
*E
*************************************************************************/
int draw_selected_features( view_type *view,
int themenum,
library_type *library,
map_environment_type *mapenv )
{
int status, fcnum, finished, cov, tilecover, TILEPATH_, prim;
int outline, color1, color2, color3, color4;
vpf_table_type rngtable,edgtable,fbrtable, tile_table;
row_type row;
char *ptable[] = {"","edg","fac","txt","end","cnd"};
register rspf_int32 i, j, p, pclass, tile;
int display_order[] = {FACE,EDGE,ENTITY_NODE,CONNECTED_NODE,TEXT};
register rspf_int32 starttile, endtile, startprim, endprim;
rspf_int32 count;
char path[255], covpath[255], tiledir[255], *buf, str[255];
char *drive, rngpath[255],edgpath[255],edxpath[255],fbrpath[255];
boolean rng_rdisk,edg_rdisk,fbr_rdisk;
set_type primitives, feature_rows;
fcrel_type fcrel;
window_type info;
struct viewporttype vp;
getviewsettings(&vp);
fcnum = view->theme[themenum].fcnum;
sprintf(path,"%stileref\\tileref.aft",library->path);
if (access(path,0) != 0) {
tilecover = FALSE;
} else {
tile_table = vpf_open_table(path,disk,"rb",NULL);
TILEPATH_ = table_pos("TILE_NAME",tile_table);
tilecover = TRUE;
}
feature_rows = get_selected_features( view, themenum, *library );
for (p=0;p<5;p++) {
pclass = display_order[p];
if ((pclass != library->fc[fcnum].primclass) &&
(library->fc[fcnum].primclass != COMPLEX_FEATURE)) continue;
if ((library->fc[fcnum].primclass == COMPLEX_FEATURE) &&
(!library->fc[fcnum].cprim[pclass])) continue;
/* Set up the feature class table relate chain. */
/* The feature table is fcrel.table[0]. */
/* The primitive table is the last table in the chain: */
/* fcrel.table[ fcrel.nchain-1 ]. */
j = 0;
for (i=0;i<strlen(library->fc[fcnum].table);i++)
if (library->fc[fcnum].table[i] == '\\') j = i+1;
strcpy( str, &(library->fc[fcnum].table[j]));
fcrel = select_feature_class_relate(fcnum, library, str,
ptable[pclass]);
prim = fcrel.nchain-1;
/*** 'Tile' number 1 is the universe polygon for
the tileref cover ***/
starttile = set_min(library->tile_set);
if (starttile < 2) starttile = 2;
endtile = set_max(library->tile_set);
if (endtile < 2) endtile = 2;
for (tile = starttile; tile <= endtile; tile++ ) {
if (!set_member(tile,library->tile_set)) continue;
if (tilecover) {
row = get_row(tile,tile_table);
buf = (char *)get_table_element(TILEPATH_,row,tile_table,
NULL,&count);
free_row(row,tile_table);
strcpy(tiledir,buf);
rightjust(tiledir);
strcat(tiledir,"\\");
free(buf);
} else {
strcpy(tiledir,"");
}
cov = library->fc[fcnum].coverage;
strcpy( covpath, library->cover[cov].path );
finished = TRUE;
sprintf(path,"%s%s%s",covpath,tiledir,ptable[pclass]);
if (access(path,0) != 0) continue;
fcrel.table[prim] = vpf_open_table(path,disk,"rb",NULL);
info = info_window("Searching...");
primitives = get_selected_tile_primitives( library,
fcnum, fcrel,
feature_rows,
mapenv,
tile, tiledir,
&status );
delete_window(&info);
setviewport(vp.left,vp.top,vp.right,vp.bottom,vp.clip);
/* Reset plate-carree parameters (changed in */
/* get_selected_tile_primitives() ) */
if (mapenv->projection == PLATE_CARREE)
set_plate_carree_parameters( central_meridian(
mapenv->mapextent.x1,
mapenv->mapextent.x2),
0.0, 1.0 );
if (primitives.size < 1) {
vpf_close_table(&fcrel.table[prim]);
continue;
}
if (!status) {
set_nuke(&primitives);
vpf_close_table(&fcrel.table[prim]);
break;
}
if (pclass == FACE) {
/* Must also open RNG, EDG, and FBR for drawing faces. */
/* If a RAM disk is specified, copy these to it and open */
/* them there. */
rng_rdisk = FALSE;
edg_rdisk = FALSE;
fbr_rdisk = FALSE;
drive = getenv("TMP");
buf = (char *)vpfmalloc(255);
sprintf(path,"%s%srng",covpath,tiledir);
strcpy(rngpath,path);
if (drive && filesize(path) < available_space(drive)) {
sprintf(rngpath,"%s\\RNG",drive);
sprintf(buf,"COPY %s %s > NUL",path,rngpath);
system(buf);
rng_rdisk = TRUE;
}
rngtable = vpf_open_table(rngpath,disk,"rb",NULL);
sprintf(path,"%s%sedg",covpath,tiledir);
strcpy(edgpath,path);
sprintf(edxpath,"%s%sedx",covpath,tiledir);
if (drive &&
(filesize(path)+filesize(edxpath))<available_space(drive)) {
sprintf(edgpath,"%s\\EDG",drive);
sprintf(buf,"COPY %s %s > NUL",path,edgpath);
system(buf);
sprintf(edxpath,"%s\\EDX",drive);
sprintf(buf,"COPY %s%sedx %s > NUL",covpath,tiledir,edxpath);
system(buf);
edg_rdisk = TRUE;
}
edgtable = vpf_open_table(edgpath,disk,"rb",NULL);
sprintf(path,"%s%sfbr",covpath,tiledir);
strcpy(fbrpath,path);
if (drive && filesize(path) < available_space(drive)) {
sprintf(fbrpath,"%s\\FBR",drive);
sprintf(buf,"COPY %s %s > NUL",path,fbrpath);
system(buf);
fbr_rdisk = TRUE;
}
fbrtable = vpf_open_table(fbrpath,disk,"rb",NULL);
free(buf);
}
finished = 1;
startprim = set_min(primitives);
endprim = set_max(primitives);
/* It turns out to be MUCH faster off of a CD-ROM to */
/* read each row and discard unwanted ones than to */
/* forward seek past them. It's about the same off */
/* of a hard disk. */
fseek(fcrel.table[prim].fp,
index_pos(startprim,fcrel.table[prim]),
SEEK_SET);
for (i=startprim;i<=endprim;i++) {
row = read_next_row(fcrel.table[prim]);
if (set_member( i, primitives )) {
/* Draw the primitive */
switch (pclass) {
case EDGE:
finished = draw_edge_row(row,fcrel.table[prim]);
break;
case ENTITY_NODE:
case CONNECTED_NODE:
finished = draw_point_row(row,fcrel.table[prim]);
break;
case FACE:
gpgetlinecolor( &outline );
gpgetpattern( &color1, &color2, &color3, &color4 );
hidemousecursor();
draw_face_row( row,fcrel.table[prim],
rngtable, edgtable, fbrtable,
outline,
color1, color2, color3, color4 );
showmousecursor();
finished = 1;
if (kbhit()) {
if (getch()==27) finished = 0;
}
break;
case TEXT:
finished = draw_text_row(row,fcrel.table[prim]);
break;
}
}
free_row(row,fcrel.table[prim]);
if (!finished) {
status = 0;
break;
}
}
if (pclass == FACE) {
vpf_close_table(&rngtable);
if (rng_rdisk) remove(rngpath);
vpf_close_table(&edgtable);
if (edg_rdisk) {
remove(edgpath);
remove(edxpath);
}
vpf_close_table(&fbrtable);
if (fbr_rdisk) remove(fbrpath);
}
vpf_close_table(&fcrel.table[prim]);
set_nuke(&primitives);
if (!finished) {
status = 0;
break;
}
}
if (!finished) {
status = 0;
deselect_feature_class_relate( &fcrel );
break;
}
status = 1;
if (kbhit()) {
if (getch()==27) {
status = 0;
deselect_feature_class_relate( &fcrel );
break;
}
}
deselect_feature_class_relate(&fcrel);
}
if (tilecover) {
vpf_close_table(&tile_table);
}
set_nuke(&feature_rows);
return status;
}
/*************************************************************************
*
*N vpf_display_record
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function displays all of the fields of a particular VPF
* record, including the descriptions of the fields and their
* values. It accesses the online data dictionary metadata
* contained in the specified Value Description Tables.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* row <input> == (row_type) vpf table row structure.
* table <input> == (vpf_table_type) vpf table.
* fp <input> == (FILE *) pointer to the output file.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels Sept 1991 DOS Turbo C
*E
*************************************************************************/
void vpf_display_record( row_type row,
vpf_table_type table,
FILE *fp )
{
register int i,j;
char *buf,*num, path[128], *tablename;
char *attr,*val,*descr, vdtpath[128], fmtdate[40];
vpf_table_type vdt;
row_type vdtrow;
int found;
ossim_int32 l, lval, count, *lptr;
short int s,sval,*sptr;
float f,*fptr;
date_type date;
int TABLE_ = 1, ATTR_ = 2, VAL_ = 3, DESCR_ = 4;
num = (char *)vpfmalloc(20*sizeof(char));
strcpy( vdtpath, "" );
/* Display all secondary attributes */
for (i=0;i<table.nfields;i++) {
switch (table.header[i].type) {
case 'T':
buf = (char *)get_table_element(i,row,table,
NULL,&count);
rightjust(buf);
if (strcmp( buf, "" ) != 0) {
fputs(table.header[i].name,fp);
fputs(" - ",fp);
fputs(table.header[i].description,fp);
fputs(": ",fp);
fputs(buf,fp);
strcpy( path, table.path );
strcat( path, table.header[i].vdt );
if ( (access(path,4)==0) &&
(strcmp(table.header[i].vdt,"") != 0) ) {
if (strcmp(vdtpath,path) != 0) {
if (strcmp(vdtpath,"") != 0) {
vpf_close_table(&vdt);
}
vdt = vpf_open_table( path, disk, "rb", NULL );
}
strcpy( vdtpath, path );
for (j=1;j<=vdt.nrows;j++) {
vdtrow = read_row( j, vdt );
tablename = (char *)get_table_element( TABLE_, vdtrow,
vdt, NULL, &count );
rightjust(tablename);
strupr2(tablename);
attr = (char *)get_table_element( ATTR_, vdtrow, vdt,
NULL, &count );
rightjust(attr);
val = (char *)get_table_element( VAL_, vdtrow, vdt,
NULL, &count );
rightjust(val);
found = FALSE;
if ( (strstr(table.name,tablename)) &&
(ossim_strcasecmp(attr,table.header[i].name)==0) &&
(ossim_strcasecmp(val,buf)==0) ) {
descr = (char *)get_table_element(DESCR_,vdtrow,vdt,
NULL, &count);
rightjust(descr);
fputs(" (",fp);
fputs(descr,fp);
fputs(")",fp);
free(descr);
found = TRUE;
}
free(tablename);
free(attr);
free(val);
free_row( vdtrow, vdt );
if (found) break;
}
}
fputc('\n',fp);
}
free(buf);
break;
case 'I':
if (table.header[i].count==1) {
get_table_element(i,row,table,&l,&count);
if (l != NULLINT) {
fputs(table.header[i].name,fp);
fputs(" - ",fp);
fputs(table.header[i].description,fp);
fputs(": ",fp);
ltoa((int)l,num,10);
fputs(num,fp);
strcpy( path, table.path );
strcat( path, table.header[i].vdt );
if ( (access(path,4)==0) &&
(strcmp(table.header[i].vdt,"") != 0) ) {
if (strcmp(vdtpath,path) != 0) {
if (strcmp(vdtpath,"") != 0) {
vpf_close_table(&vdt);
}
vdt = vpf_open_table( path, disk, "rb", NULL );
}
strcpy( vdtpath, path );
for (j=1;j<=vdt.nrows;j++) {
vdtrow = read_row( j, vdt );
tablename = (char *)get_table_element( TABLE_,
vdtrow, vdt, NULL, &count );
rightjust(tablename);
strupr2(tablename);
attr = (char *)get_table_element( ATTR_, vdtrow, vdt,
NULL, &count );
rightjust(attr);
get_table_element( VAL_, vdtrow, vdt,
&lval, &count );
found = FALSE;
if ( (strstr(table.name,tablename)) &&
(ossim_strcasecmp(attr,table.header[i].name)==0) &&
(lval==l) ) {
descr = (char *)get_table_element(DESCR_,vdtrow,
vdt, NULL, &count);
rightjust(descr);
fputs(" (",fp);
fputs(descr,fp);
fputs(")",fp);
free(descr);
found = TRUE;
}
free(tablename);
free(attr);
free_row( vdtrow, vdt );
if (found) break;
}
}
fputc('\n',fp);
}
} else {
get_table_element(i,row,table,&lptr,&count);
fputs(table.header[i].name,fp);
fputs(" - ",fp);
fputs(table.header[i].description,fp);
fputs(": (",fp);
for (j=0;j<count;j++) {
ltoa((int)lptr[j],num,10);
fputs(num,fp);
if (j<count-1) fputs(", ",fp);
}
fputs(")\n",fp);
}
break;
case 'S':
if (table.header[i].count==1) {
get_table_element(i,row,table,&s,&count);
if (s != NULLSHORT) {
fputs(table.header[i].name,fp);
fputs(" - ",fp);
fputs(table.header[i].description,fp);
fputs(": ",fp);
itoa(s,num,10);
fputs(num,fp);
strcpy( path, table.path );
strcat( path, table.header[i].vdt );
if ( (access(path,4)==0) &&
(strcmp(table.header[i].vdt,"") != 0) ) {
if (strcmp(vdtpath,path) != 0) {
if (strcmp(vdtpath,"") != 0) {
vpf_close_table(&vdt);
}
vdt = vpf_open_table( path, disk, "rb", NULL );
}
strcpy( vdtpath, path );
for (j=1;j<=vdt.nrows;j++) {
vdtrow = read_row( j, vdt );
tablename = (char *)get_table_element( TABLE_,
vdtrow, vdt, NULL, &count );
rightjust(tablename);
strupr2(tablename);
attr = (char *)get_table_element( ATTR_, vdtrow, vdt,
NULL, &count );
rightjust(attr);
get_table_element( VAL_, vdtrow, vdt,
&sval, &count );
found = FALSE;
if ( (strstr(table.name,tablename)) &&
(ossim_strcasecmp(attr,table.header[i].name)==0) &&
(sval==s) ) {
descr = (char *)get_table_element(DESCR_,vdtrow,
vdt, NULL, &count);
rightjust(descr);
fputs(" (",fp);
fputs(descr,fp);
fputs(")",fp);
free(descr);
found = TRUE;
}
free(tablename);
free(attr);
free_row( vdtrow, vdt );
if (found) break;
}
}
fputc('\n',fp);
}
} else {
get_table_element(i,row,table,&sptr,&count);
fputs(table.header[i].name,fp);
fputs(" - ",fp);
fputs(table.header[i].description,fp);
fputs(": (",fp);
for (j=0;j<count;j++) {
itoa(sptr[j],num,10);
fputs(num,fp);
if (j<count-1) fputs(", ",fp);
}
fputs(")\n",fp);
}
break;
case 'F':
if (table.header[i].count==1) {
get_table_element(i,row,table,&f,&count);
if (!is_vpf_null_float(f)) {
fputs(table.header[i].name,fp);
fputs(" - ",fp);
fputs(table.header[i].description,fp);
fputs(": ",fp);
#if !defined(__APPLE__) && !defined(__FreeBSD__)
gcvt(f,6,num);
#endif
fputs(num,fp);
fputc('\n',fp);
}
} else {
get_table_element(i,row,table,&fptr,&count);
fputs(table.header[i].name,fp);
fputs(" - ",fp);
fputs(table.header[i].description,fp);
fputs(": (",fp);
for (j=0;j<count;j++) {
if (is_vpf_null_float(fptr[j])) {
fputs("(null)",fp);
} else {
#if !defined(__APPLE__) && !defined(__FreeBSD__)
gcvt(fptr[j],6,num);
#endif
fputs(num,fp);
}
if (j<count-1) fputs(", ",fp);
}
fputs(")\n",fp);
}
break;
case 'D':
if (table.header[i].count==1) {
get_table_element(i,row,table,date,&count);
fputs(table.header[i].name,fp);
fputs(" - ",fp);
fputs(table.header[i].description,fp);
fputs(": ",fp);
format_date(date,fmtdate);
fputs(fmtdate,fp);
fputc('\n',fp);
}
break;
}
}
if (strcmp(vdtpath,"") != 0)
vpf_close_table( &vdt );
free(num);
}
