/*************************************************************************
*
*N draw_text_row
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function draws annotation for a given row in the text
* pseudo-primitive table.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* row <input>==(row_type) row of the text table.
* table <input>==(vpf_table_type) text primitive table.
* return <output>==(int) 0 if the user escapes, 1 upon successful
* completion.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels August 1991 DOS Turbo C
*E
*************************************************************************/
int draw_text_row( row_type row, vpf_table_type table )
{
int xscr,yscr, shape_pos, text_pos;
ossim_int32 n, nshape;
coordinate_type *shape_line;
char *text;
struct viewporttype vp;
shape_pos = table_pos("SHAPE_LINE",table);
/**** MUST CHECK FOR 'Z', 'B', AND 'Y' TYPES - SEE VPFPRIM.C ****/
shape_line = (coordinate_type *)get_table_element(shape_pos,row,table,
NULL,&nshape);
text_pos = table_pos("STRING",table);
text = (char *)get_table_element(text_pos,row,table,NULL,&n);
screenxy(shape_line[0].x,shape_line[0].y,&xscr,&yscr);
getviewsettings(&vp);
if ((gpgetfont() != DEFAULT_FONT) || (yscr > gptextheight(text))) {
hidemousecursor();
gptext(xscr,yscr,text);
showmousecursor();
}
free(shape_line);
free(text);
while (kbhit()) {
if (getch()==27) {
return 0;
}
}
return 1;
}
/*************************************************************************
*
*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;
}
std::vector<ossimString> ossimVpfTable::getColumnValues(const ossimString& columnName)const
{
std::vector<ossimString> result;
if(theTableInformation &&
theTableInformation->status == OPENED)
{
long int columnNumber = table_pos(const_cast<char*>(columnName.c_str()), *theTableInformation);
if(columnNumber >=0 &&
(columnNumber < theTableInformation->nfields))
{
row_type row;
// start at the first row of the table
reset();
for (int rowIndex = 1;
rowIndex <= theTableInformation->nrows;
++rowIndex)
{
row = read_next_row(*theTableInformation);
ossimString value = getColumnValueAsString(row,
columnNumber);
value.trim();
result.push_back(value);
free_row(row, *theTableInformation);
}
}
}
return result;
}
/**************************************************************************
*
*N related_row
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Return the related row of table2 based upon the value of table 1's key
* Table 2 must be the '1' side of an n:1 relationship -- If it isn't,
* use 'related_rows()'.
* Supported data types - I and T<n>.
* Binary search supported only for data type I. (column must be sorted)
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
long int related_row( void *keyval1,
vpf_table_type table2, char *key2,
int sort_flag )
{
long int rowid, i, ival, kval, n;
row_type row;
int KEY2_;
char cval, *tval;
if (ossim_strcasecmp(key2,"ID")==0) {
memcpy( &rowid, keyval1, sizeof(rowid) );
return rowid;
}
rowid = 0;
KEY2_ = table_pos(key2,table2);
if ((table2.header[KEY2_].type != 'I')&&
(table2.header[KEY2_].type != 'T')) return rowid;
if ((table2.header[KEY2_].type == 'I')&&
(table2.header[KEY2_].count != 1)) return rowid;
if ((table2.header[KEY2_].type == 'T')&&(sort_flag)) sort_flag = 0;
if (table2.header[KEY2_].type == 'I') memcpy(&kval,keyval1,sizeof(kval));
if (!sort_flag) { /* Sequential search */
for (i=1;i<=table2.nrows;i++) {
row = get_row(i,table2);
if (table2.header[KEY2_].type == 'I') {
get_table_element(KEY2_,row,table2,&ival,&n);
if (ival == kval) rowid = i;
} else {
if (table2.header[KEY2_].count==1) {
get_table_element(KEY2_,row,table2,&cval,&n);
if (memcmp(&cval,keyval1,sizeof(ival))==0) rowid = i;
} else {
tval = (char*)get_table_element(KEY2_,row,table2,NULL,&n);
if (strcmp(tval,(char *)keyval1)==0) rowid = i;
}
}
free_row(row,table2);
if (rowid > 0) break;
}
} else { /* Binary search */
memcpy(&kval,keyval1,sizeof(kval));
rowid = vpf_binary_search( kval, KEY2_, table2 );
}
return rowid;
}
/*************************************************************************
*
*N tile_thematic_index_name
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function determines the name of the tile thematic index for
* the given table. If the table does not have a "TILE_ID" field,
* the name is set to null.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* table <input>==(vpf_table_type) opened VPF table.
* path <output>==(char *) name of the thematic index file.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*************************************************************************/
void tile_thematic_index_name( vpf_table_type table,
char *path )
{
int i;
i = table_pos("TILE_ID",table);
if (i<0) {
strcpy(path,"");
} else {
/* Thematic index name from the table header */
sprintf(path,"%s%s",table.path,table.header[i].tdx);
}
}
/*
* currently being used by converter routines, not by vpfview
* routines
*/
int add_null_values ( char *name, vpf_table_type table, FILE * fpout )
{
FILE *nullfp;
ossim_int32 i , ptr ;
char *cval, *line, *field ;
nullfp = fopen( name, "r");
if ( !nullfp )
return 0;
/* Now read nulls from file and populate table structure */
while ( (line = get_line ( nullfp )) ) {
ptr = 0 ;
field = get_string ( &ptr, line, FIELD_SEPERATOR ) ;
i = table_pos ( field, table ) ;
switch ( table.header[i].type ) {
case 'T':
cval = get_string ( &ptr, line, FIELD_SEPERATOR ) ;
free ( table.header[i].nullval.Char ) ; /* get rid of default */
table.header[i].nullval.Char = (char *) vpfmalloc ( (unsigned long)strlen (cval)+1) ;
strcpy ( table.header[i].nullval.Char, cval ) ;
free (cval) ;
break ;
case 'I':
table.header[i].nullval.Int = get_number ( &ptr, line, FIELD_SEPERATOR );
break ;
case 'S':
table.header[i].nullval.Short =
(short int) get_number ( &ptr, line, FIELD_SEPERATOR );
break ;
case 'R':
cval = get_string ( &ptr, line, FIELD_SEPERATOR ) ;
table.header[i].nullval.Double = atof ( cval ) ;
free ( cval ) ;
break ;
case 'F':
cval = get_string ( &ptr, line, FIELD_SEPERATOR ) ;
table.header[i].nullval.Float = (float) atof ( cval ) ;
free ( cval ) ;
break ;
default:
return 0 ;
break ;
}
}
return 1 ;
}
ossimString ossimVpfTable::getColumnValueAsString(const ossimString& columnName)
{
if(theTableInformation &&
(theTableInformation->status!=CLOSED))
{
long int columnNumber = table_pos(const_cast<char*>(columnName.c_str()),
*theTableInformation);
row_type row = read_next_row(*theTableInformation);
ossimString result = getColumnValueAsString(row,
columnNumber);
free_row(row, *theTableInformation);
return result;
}
return "";
}
/*************************************************************************
*
*N draw_point_row
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function draws an entity node for the row in the given
* entity node primitive table.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* row <input>==(row_type) row of the entity node
* primitive table.
* table <input>==(vpf_table_type) entity node primitive table.
* return <output>==(int) 0 if the user escapes, 1 upon successful
* completion.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels August 1991 DOS Turbo C
*E
*************************************************************************/
int draw_point_row( row_type row, vpf_table_type table )
{
int xscr,yscr, coord_pos;
ossim_int32 n;
coordinate_type pnt;
coord_pos = table_pos("COORDINATE",table);
get_table_element(coord_pos,row,table,&pnt,&n);
screenxy(pnt.x,pnt.y,&xscr,&yscr);
hidemousecursor();
gpmarker(xscr,yscr);
showmousecursor();
while (kbhit()) {
if (getch()==27) {
return 0;
}
}
return 1;
}
/*************************************************************************
*
*N named_table_element
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function returns the element in the specified row in the column
* matching the given field name. If the element is a single element
* (count=1), the value is passed back via the void pointer *value;
* otherwise, an array is allocated and passed back as the return value.
* NOTE: If an array is allocated in this function, it should be freed
* when no longer needed.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* field_name <input> == (char *) field name.
* row_number <input> == (ossim_int32) row_number.
* table <input> == (vpf_table_type) VPF table structure.
* value <output> == (void *) pointer to a single element value.
* count <output> == (ossim_int32 *) pointer to the array size for a multiple
* element value.
* return <output> == (void *) returned multiple element value.
* or NULL if field_name could not be found
* as a column
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* External Variables:
*X
* None
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Functions Called:
*F
* void *vpfmalloc() VPFREAD.C
* row_type get_row() VPFREAD.C
* void free_row() VPFREAD.C
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Portability:
*O
* This module should be ANSI C compatible.
*E
*************************************************************************/
void *named_table_element( char * field_name,
ossim_int32 row_number,
vpf_table_type table,
void * value,
ossim_int32 * count )
{
ossim_int32 col;
row_type row;
void * retvalue;
col = table_pos(field_name, table);
if (col < 0) {
fprintf(stderr,"%s: Invalid field name <%s>\n",table.name,field_name);
return NULL;
}
row = get_row(row_number,table);
retvalue = get_table_element( col, row, table, value, count );
free_row(row, table);
return retvalue;
}
/**************************************************************************
*
*N fcs_relate_list
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Read the feature class schema table and create the list of
* tables to chain through.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* fcname <input> == (char *) feature class name.
* start_table <input> == (char *) table to start from.
* end_table <input> == (char *) table to end with.
* fcs <input> == (vpf_table_type) feature class schema table.
* fcs_relate_list <output> == (linked_list_type) list of tables to
* chain through.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
linked_list_type fcs_relate_list( char *fcname, char *start_table,
char *end_table, vpf_table_type fcs )
{
linked_list_type rlist;
vpf_relate_struct rstruct;
set_type fcset, set1, set2;
char tablename[255], *buf, expr[255];
row_type row;
long int rownum,n;
int TABLE1_, KEY1_, TABLE2_, KEY2_;
rlist = ll_init();
sprintf(expr,"FEATURE_CLASS = %s",fcname);
fcset = query_table(expr,fcs);
if (set_empty(fcset)) {
set_nuke(&fcset);
return rlist;
}
TABLE1_ = table_pos("TABLE1",fcs);
KEY1_ = table_pos("FOREIGN_KEY",fcs);
if (KEY1_ < 0) KEY1_ = table_pos("TABLE1_KEY",fcs);
TABLE2_ = table_pos("TABLE2",fcs);
KEY2_ = table_pos("PRIMARY_KEY",fcs);
if (KEY2_ < 0) KEY2_ = table_pos("TABLE2_KEY",fcs);
strcpy( tablename, start_table );
while (1) {
sprintf(expr,"TABLE1 = %s",tablename);
set1 = query_table(expr,fcs);
set2 = set_intersection(set1,fcset);
set_nuke(&set1);
if (set_empty(set2)) {
set_nuke(&fcset);
set_nuke(&set2);
return rlist;
}
rownum = set_min(set2);
set_nuke(&set2);
row = get_row(rownum,fcs);
buf = (char *)get_table_element(TABLE1_,row,fcs,NULL,&n);
strcpy(rstruct.table1,buf);
rightjust(rstruct.table1);
free(buf);
buf = (char *)get_table_element(KEY1_,row,fcs,NULL,&n);
strcpy(rstruct.key1,buf);
rightjust(rstruct.key1);
free(buf);
buf = (char *)get_table_element(TABLE2_,row,fcs,NULL,&n);
strcpy(rstruct.table2,buf);
rightjust(rstruct.table2);
free(buf);
buf = (char *)get_table_element(KEY2_,row,fcs,NULL,&n);
strcpy(rstruct.key2,buf);
rightjust(rstruct.key2);
free(buf);
rstruct.degree = R_ONE; /* Default */
free_row( row, fcs );
if (table_in_list(rstruct.table1, rlist)) break;
ll_insert( &rstruct, sizeof(rstruct), ll_last(rlist) );
strcpy( tablename, rstruct.table2 );
if (ossim_strcasecmp(tablename,end_table)==0) break;
}
set_nuke(&fcset);
return rlist;
}
/*************************************************************************
*
*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;
}
void Organ::process(float** ports, int offset, int sampleCount)
{
/*
//
// get and process all pending events from the
// synthesizer GUI
//
while (gui->fifoSize()) {
MidiPlayEvent ev = gui->readEvent();
if (ev.type() == ME_CONTROLLER) {
// process local?
setController(ev.dataA(), ev.dataB());
sendEvent(ev);
}
else
printf("Organ::process(): unknown event\n");
}
*/
float* buffer = *ports + offset;
for (int i = 0; i < VOICES; ++i) {
Voice* v = &voices[i];
if (!v->isOn)
continue;
double vol = velo ? v->velocity : 1.0;
vol *= volume;
unsigned freq_256 = freq256[v->pitch];
unsigned* harm0_accum = &(v->harm0_accum);
unsigned* harm1_accum = &(v->harm1_accum);
unsigned* harm2_accum = &(v->harm2_accum);
unsigned* harm3_accum = &(v->harm3_accum);
unsigned* harm4_accum = &(v->harm4_accum);
unsigned* harm5_accum = &(v->harm5_accum);
unsigned long freq_256_harm2, freq_256_harm3;
unsigned long freq_256_harm4, freq_256_harm5;
float* reed_table = reed ? g_pulse_table : sine_table;
float* flute_table = flute ? g_triangle_table : sine_table;
unsigned freq_256_harm0 = freq_256 / 2;
unsigned freq_256_harm1 = freq_256;
if (brass) {
freq_256_harm2 = freq_256 * 2;
freq_256_harm3 = freq_256_harm2 * 2;
freq_256_harm4 = freq_256_harm3 * 2;
freq_256_harm5 = freq_256_harm4 * 2;
for (int i = 0; i < sampleCount; i++) {
int a1=0, a2=0; //prevent compiler warning: unitialized usage of vars a1 & a2
switch(v->state1) {
case ATTACK:
if (v->envL1.step(&a1))
break;
v->state1 = DECAY;
case DECAY:
if (v->envL2.step(&a1))
break;
v->state1 = SUSTAIN;
case SUSTAIN:
a1 = sustain0;
break;
case RELEASE:
if (v->envL3.step(&a1))
break;
v->state1 = OFF;
a1 = MAX_ATTENUATION;
break;
}
switch(v->state2) {
case ATTACK:
if (v->envH1.step(&a2))
break;
v->state2 = DECAY;
case DECAY:
if (v->envH2.step(&a2))
break;
v->state2 = SUSTAIN;
case SUSTAIN:
a2 = sustain1;
break;
case RELEASE:
if (v->envH3.step(&a2))
break;
v->state2 = OFF;
a1 = MAX_ATTENUATION;
break;
}
if (v->state1 == OFF && v->state2 == OFF) {
v->isOn = false;
break;
}
buffer[i] +=
(table_pos (sine_table, freq_256_harm0, harm0_accum) * harm0
+ table_pos (sine_table, freq_256_harm1, harm1_accum) * harm1
+ table_pos (reed_table, freq_256_harm2, harm2_accum) * harm2)
* cb2amp(a1) * vol
+ (table_pos (sine_table, freq_256_harm3, harm3_accum) * harm3
+ table_pos (flute_table, freq_256_harm4, harm4_accum) * harm4
+ table_pos (flute_table, freq_256_harm5, harm5_accum) * harm5)
* cb2amp(a2) * vol;
}
}
else {
freq_256_harm2 = freq_256 * 3 / 2;
freq_256_harm3 = freq_256 * 2;
freq_256_harm4 = freq_256 * 3;
freq_256_harm5 = freq_256_harm3 * 2;
for (int i = 0; i < sampleCount; i++) {
int a1=0, a2=0;//prevent compiler warning: unitialized usage of vars a1 & a2
switch(v->state1) {
case ATTACK:
if (v->envL1.step(&a1))
break;
v->state1 = DECAY;
case DECAY:
if (v->envL2.step(&a1))
break;
v->state1 = SUSTAIN;
case SUSTAIN:
a1 = sustain0;
break;
case RELEASE:
if (v->envL3.step(&a1))
break;
v->state1 = OFF;
a1 = MAX_ATTENUATION;
break;
}
switch(v->state2) {
case ATTACK:
if (v->envH1.step(&a2))
break;
v->state2 = DECAY;
case DECAY:
if (v->envH2.step(&a2))
break;
v->state2 = SUSTAIN;
case SUSTAIN:
a2 = sustain1;
break;
case RELEASE:
if (v->envH3.step(&a2))
break;
v->state2 = OFF;
a1 = MAX_ATTENUATION;
break;
}
if (v->state1 == OFF && v->state2 == OFF) {
v->isOn = false;
break;
}
buffer[i] +=
(table_pos (sine_table, freq_256_harm0, harm0_accum) * harm0
+ table_pos (sine_table, freq_256_harm1, harm1_accum) * harm1
+ table_pos (sine_table, freq_256_harm2, harm2_accum) * harm2)
* cb2amp(a1) * vol
+ (table_pos (reed_table, freq_256_harm3, harm3_accum) * harm3
+ table_pos (sine_table, freq_256_harm4, harm4_accum) * harm4
+ table_pos (flute_table, freq_256_harm5, harm5_accum) * harm5)
* cb2amp(a2) * vol;
}
}
}
}
ossim_int32 ossimVpfTable::getColumnPosition(const ossimString& columnName)const
{
return ((ossim_int32)table_pos(const_cast<char*>(columnName.c_str()), *theTableInformation));
}
bool ossimVpfDatabaseHeaderTableValidator::isValid(ossimVpfTable& aTable)const
{
// make sure the table is not null
if(&aTable == NULL)
{
return false;
}
// and make sure that the table is not closed
if(aTable.isClosed())
{
return false;
}
// get the table data defined in vpf_util/vpftable.h"
const vpf_table_type* data = aTable.getVpfTableData();
if(!data)
{
return false;
}
// if the file is not open then we can't validate
if(!data->fp)
{
return false;
}
// The way that we will validate is to see if the columns of a dht
// exist. if the column didn't exist then the position
// will be negative
long column = table_pos("ID", *data);
if(column < 0)
{
return false;
}
column = table_pos("VPF_VERSION", *data);
if(column < 0)
{
return false;
}
column = table_pos("DATABASE_NAME", *data);
if(column < 0)
{
return false;
}
column = table_pos("DATABASE_DESC", *data);
if(column < 0)
{
return false;
}
column = table_pos("MEDIA_STANDARD", *data);
if(column < 0)
{
return false;
}
column = table_pos("ORIGINATOR", *data);
if(column < 0)
{
return false;
}
column = table_pos("ADDRESSEE", *data);
if(column < 0)
{
return false;
}
column = table_pos("MEDIA_VOLUMES", *data);
if(column < 0)
{
return false;
}
column = table_pos("SEQ_NUMBERS", *data);
if(column < 0)
{
return false;
}
column = table_pos("NUM_DATA_SETS", *data);
if(column < 0)
{
return false;
}
column = table_pos("SECURITY_CLASS", *data);
if(column < 0)
{
return false;
}
column = table_pos("DOWNGRADING", *data);
if(column < 0)
{
return false;
}
column = table_pos("DOWNGRADE_DATE", *data);
if(column < 0)
{
return false;
}
column = table_pos("RELEASABILITY", *data);
if(column < 0)
{
return false;
}
column = table_pos("TRANSMITTAL_ID", *data);
if(column < 0)
{
return false;
}
column = table_pos("EDITION_NUMBER", *data);
if(column < 0)
{
return false;
}
column = table_pos("EDITION_DATE", *data);
if(column < 0)
{
return false;
}
return true;
}
bool ossimVpfLibrary::getExtent(ossimVpfExtent& extent)const
{
bool result = false;
ossimVpfTable tempTable;
// this code was basically cut paste from vhcl with just
// a couple modifications.
/* Get library extent from Library Attribute Table (LAT) */
/* char* buf;*/
/* long int n;*/
/* double xmin,ymin,xmax,ymax;*/
int libraryNamePosition, xminPosition, yminPosition;
int xmaxPosition, ymaxPosition;
int i;
bool found;
row_type row;
extent_type libextent;
if(!theDatabase)
{
return false;
}
ossimFilename file(theDatabase->getLibraryAttributeTable());
if(!tempTable.openTable(file))
{
return result;
}
vpf_table_type *table = tempTable.getVpfTableData();
libraryNamePosition = table_pos( "LIBRARY_NAME", *table );
found = false;
for (i=1;(i<=tempTable.getNumberOfRows())&&(!found);i++)
{
row = read_row( i, *table );
ossimString libraryName = tempTable.getColumnValueAsString(row, libraryNamePosition);
libraryName = libraryName.trim();
if (libraryName == theLibraryName)
{
xminPosition = table_pos( "XMIN", *table );
yminPosition = table_pos( "YMIN", *table );
xmaxPosition = table_pos( "XMAX", *table );
ymaxPosition = table_pos( "YMAX", *table );
libextent.x1 = tempTable.getColumnValueAsString(row, xminPosition).toDouble();
libextent.y1 = tempTable.getColumnValueAsString(row, yminPosition).toDouble();
libextent.x2 = tempTable.getColumnValueAsString(row, xmaxPosition).toDouble();
libextent.y2 = tempTable.getColumnValueAsString(row, ymaxPosition).toDouble();
found = true;
}
else
{
result = false;
}
free_row( row, *table );
}
extent = ossimVpfExtent(libextent);
return result;
}
/*************************************************************************
*
*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 fc_row_numbers
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Given the starting row of a feature class relationship, return the
* list of row numbers of the table at the end of the feature class
* relate chain.
* If your relate goes from the feature to the primitive, this will
* return the primitive ids for the given feature row.
* If your relate goes from the primitive to the feature, this will
* return the feature ids of the given primitive row.
*
* Currently only supports relates on 'I' or 'K' fields.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
linked_list_type fc_row_numbers( row_type row,
fcrel_type fcrel,
long int tile,
ThematicIndex *idx )
{
row_type relrow;
long int count;
long int n, rownum, keyval;
id_triplet_type triplet_keyval;
int KEY1_, KEY_;
position_type p, prow, pkey;
vpf_relate_struct rcell;
linked_list_type rowlist, keylist, templist;
p = ll_first(fcrel.relate_list);
ll_element(p,&rcell);
KEY1_ = table_pos(rcell.key1,fcrel.table[0]);
get_table_element(0,row,fcrel.table[0],&rownum,&count);
if (KEY1_ == 0) { /* "ID" */
keyval = rownum;
} else {
switch (fcrel.table[0].header[KEY1_].type) {
case 'I':
get_table_element(KEY1_,row,fcrel.table[0],&keyval,&count);
break;
case 'K':
get_table_element(KEY1_,row,fcrel.table[0],&triplet_keyval,
&count);
keyval = triplet_keyval.exid;
if (tile != triplet_keyval.tile) {
keyval = -2;
}
break;
default:
keyval = 0;
break;
}
}
keylist = ll_init();
ll_insert(&keyval,sizeof(keyval),keylist);
n = 0;
p = ll_first(fcrel.relate_list);
for (n=1;n<(fcrel.nchain-1);n++) {
/* Relate through Join table(s) */
rowlist = ll_init();
pkey = ll_first(keylist);
while (!ll_end(pkey)) {
ll_element(pkey,&keyval);
templist = related_rows(&keyval,fcrel.table[n],rcell.key2,0,NULL);
prow = ll_first(templist);
while (!ll_end(prow)) {
ll_element(prow,&rownum);
if (!ll_locate(&rownum,rowlist))
ll_insert(&rownum,sizeof(rownum),ll_last(rowlist));
prow = ll_next(prow);
}
ll_reset(templist);
pkey = ll_next(pkey);
}
ll_reset(keylist);
p = ll_next(p);
ll_element(p,&rcell);
KEY_ = table_pos(rcell.key1,fcrel.table[n]);
keylist = ll_init();
prow = ll_first(rowlist);
while (!ll_end(prow)) {
ll_element(prow,&rownum);
relrow = get_row(rownum,fcrel.table[n]);
if (KEY_ == 0) { /* "ID" */
keyval = rownum;
} else {
switch (fcrel.table[n].header[KEY_].type) {
case 'I':
get_table_element(KEY_,relrow,fcrel.table[n],&keyval,&count);
break;
case 'K':
get_table_element(KEY_,relrow,fcrel.table[n],&triplet_keyval,
&count);
keyval = triplet_keyval.exid;
if (tile != triplet_keyval.tile) {
keyval = -2;
}
break;
default:
keyval = 0;
break;
}
}
if (keyval > 0)
ll_insert(&keyval,sizeof(keyval),ll_last(keylist));
prow = ll_next(prow);
free_row(relrow,fcrel.table[n]);
}
ll_reset(rowlist);
}
rowlist = ll_init();
p = ll_first(keylist);
while (!ll_end(p)) {
ll_element(p,&keyval);
templist = related_rows(&keyval,fcrel.table[n],rcell.key2,0,idx);
prow = ll_first(templist);
while (!ll_end(prow)) {
ll_element(prow,&rownum);
if (!ll_locate(&rownum,rowlist))
ll_insert(&rownum,sizeof(rownum),ll_last(rowlist));
prow = ll_next(prow);
}
ll_reset(templist);
p = ll_next(p);
}
ll_reset(keylist);
return rowlist;
}
/**************************************************************************
*
*N related_rows
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Return the list of related rows of table2 based upon the value of
* table 1's key.
* Supported data types - I and T<n>.
* Binary search supported only for data type I. (column must be sorted)
* Thematic index used, if present on key column.
* NOTE: A sequential search operation will search the entire
* table ...zzz...
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
linked_list_type related_rows( void *keyval1,
vpf_table_type table2, char *key2,
int sort_flag,
ThematicIndex *idx )
{
linked_list_type rowlist;
set_type rowset;
long int rowid, i, ival, kval, n, start,end;
row_type row = 0;
int KEY2_;
char cval, *tval;
rowlist = ll_init();
if (ossim_strcasecmp(key2,"ID")==0) {
memcpy( &rowid, keyval1, sizeof(rowid) );
ll_insert(&rowid,sizeof(rowid),rowlist);
return rowlist;
}
KEY2_ = table_pos(key2,table2);
if ((table2.header[KEY2_].type != 'I')&&
(table2.header[KEY2_].type != 'T')) return rowlist;
if ((table2.header[KEY2_].type == 'I')&&
(table2.header[KEY2_].count != 1)) return rowlist;
if ((table2.header[KEY2_].type == 'T')&&(sort_flag)) sort_flag = 0;
if (idx) {
if (idx->fp) {
rowset = search_thematic_index(idx,(char *)keyval1);
start = set_min(rowset);
end = set_max(rowset);
for (i=start;i<=end;i++)
if (set_member(i,rowset)) {
ll_insert(&i,sizeof(i),ll_last(rowlist));
}
set_nuke(&rowset);
return rowlist;
}
}
if (!sort_flag) { /* Sequential search */
for (i=1;i<=table2.nrows;i++) {
row = get_row(i,table2);
if (table2.header[KEY2_].type == 'I') {
get_table_element(KEY2_,row,table2,&ival,&n);
if (memcmp(&ival,keyval1,sizeof(ival))==0)
ll_insert(&i,sizeof(i),ll_last(rowlist));
} else {
if (table2.header[KEY2_].count==1) {
get_table_element(KEY2_,row,table2,&cval,&n);
if (memcmp(&cval,keyval1,sizeof(ival))==0)
ll_insert(&i,sizeof(i),ll_last(rowlist));
} else {
tval = (char*)get_table_element(KEY2_,row,table2,NULL,&n);
if (strcmp(tval,(char *)keyval1)==0)
ll_insert(&i,sizeof(i),ll_last(rowlist));
}
}
free_row(row,table2);
}
} else { /* Binary search */
memcpy(&kval,keyval1,sizeof(kval));
rowid = vpf_binary_search( kval, KEY2_, table2 );
if (rowid > 0) {
ll_insert(&rowid,sizeof(rowid),ll_last(rowlist));
i = rowid-1L;
do {
get_row(i,table2);
get_table_element(KEY2_,row,table2,&ival,&n);
if (ival == kval)
ll_insert(&i,sizeof(i),ll_last(rowlist));
i--;
} while ((ival==kval)&&(i>0));
i = rowid+1L;
do {
get_row(i,table2);
get_table_element(KEY2_,row,table2,&ival,&n);
if (ival == kval)
ll_insert(&i,sizeof(i),ll_last(rowlist));
i++;
} while ((ival==kval)&&(i<=table2.nrows));
}
}
return rowlist;
}
/**************************************************************************
*
*N fc_row_number
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Given the starting row of a feature class relationship, return the
* row number of the table at the end of the feature class relate
* chain.
* If your relate goes from the feature to the primitive, this will
* return the primitive id for the given feature row.
* If your relate goes from the primitive to the feature, this will
* return the feature id of the given primitive row.
*
* Currently only supports relates on 'I' or 'K' fields.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
long int fc_row_number( row_type row, fcrel_type fcrel, long int tile )
{
row_type relrow;
long int count;
long int i, rownum, keyval;
id_triplet_type triplet_keyval;
int KEY1_, KEY_;
position_type p;
vpf_relate_struct rcell;
p = ll_first(fcrel.relate_list);
ll_element(p,&rcell);
KEY1_ = table_pos(rcell.key1,fcrel.table[0]);
get_table_element(0,row,fcrel.table[0],&rownum,&count);
if (KEY1_ == 0) { /* "ID" */
keyval = rownum;
} else {
switch (fcrel.table[0].header[KEY1_].type) {
case 'I':
get_table_element(KEY1_,row,fcrel.table[0],&keyval,&count);
break;
case 'K':
get_table_element(KEY1_,row,fcrel.table[0],&triplet_keyval,
&count);
keyval = triplet_keyval.exid;
if (tile != triplet_keyval.tile) {
return -2;
}
break;
default:
keyval = 0;
break;
}
}
p = ll_first(fcrel.relate_list);
for (i=1;i<(fcrel.nchain-1);i++) {
/* Relate through Join table(s) */
rownum = related_row(&keyval,fcrel.table[i],rcell.key2,0);
relrow = get_row(rownum,fcrel.table[i]);
p = ll_next(p);
ll_element(p,&rcell);
KEY_ = table_pos(rcell.key1,fcrel.table[i]);
if (KEY_ == 0) { /* "ID" */
keyval = rownum;
} else {
switch (fcrel.table[i].header[KEY_].type) {
case 'I':
get_table_element(KEY_,relrow,fcrel.table[i],&keyval,&count);
break;
case 'K':
get_table_element(KEY_,relrow,fcrel.table[i],&triplet_keyval,
&count);
keyval = triplet_keyval.exid;
if (tile != triplet_keyval.tile) {
return -2;
}
break;
default:
keyval = 0;
break;
}
}
free_row(relrow,fcrel.table[i]);
}
if (ossim_strcasecmp(rcell.key2,"ID")==0)
rownum = keyval;
else
rownum = related_row(&keyval,fcrel.table[i],rcell.key2,0);
return rownum;
}
/*************************************************************************
*
*N get_selected_tile_primitives
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function determines all of the selected primitive rows from
* the selected features of a given tile.
*
* This function expects a feature class relationship structure that
* has been successfully created with select_feature_class_relate()
* from the feature table to the primitive. The primitive table in
* the feature class relate structure must have been successfully
* opened for the given tile.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* library <input>==(library_type *) VPF library structure.
* fcnum <input>==(int) feature class number of the feature table.
* fcrel <input>==(fcrel_type) feature class relate structure.
* feature_rows <input>==(set_type) set of selected features.
* mapenv <input>==(map_environment_type *) map environment.
* tile <input>==(rspf_int32) tile number.
* tiledir <input>==(char *) path to the tile directory.
* status <output>==(int *) status of the function:
* 1 if completed, 0 if user escape.
* return <output>==(set_type) set of primitives for the features
* in the corresponding tile.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*************************************************************************/
set_type get_selected_tile_primitives( library_type *library,
int fcnum,
fcrel_type fcrel,
set_type feature_rows,
map_environment_type *mapenv,
rspf_int32 tile,
char *tiledir,
int *status )
{
int cov, degree;
int feature, prim;
row_type row;
char *spxname[] = {"","esi","fsi","tsi","nsi","csi"};
char *brname[] = {"","ebr","fbr","tbr","nbr","cbr"};
set_type primitive_rows, tile_features;
set_type primitives;
rspf_int32 prim_rownum;
register rspf_int32 i,pclass, start,end;
char path[255], covpath[255];
linked_list_type primlist;
position_type p;
vpf_relate_struct rcell;
ThematicIndex idx;
feature = 0;
prim = fcrel.nchain-1;
/* Assume that fcrel.table[prim] has been opened */
primitives.size = 0;
primitives.buf = NULL;
cov = library->fc[fcnum].coverage;
strcpy( covpath, library->cover[cov].path );
p = ll_previous(ll_last(fcrel.relate_list),fcrel.relate_list);
ll_element(p,&rcell);
degree = rcell.degree;
for (pclass=EDGE;pclass<=CONNECTED_NODE;pclass++) {
if ((pclass != library->fc[fcnum].primclass) &&
(library->fc[fcnum].primclass != COMPLEX_FEATURE)) continue;
primitives = set_init(fcrel.table[prim].nrows+1);
/* Get the set of primitive rows within the map extent */
/* Look for the spatial index file to weed out primitives in the */
/* given tile but outside of the viewing area. If a projection */
/* other than plate-carree (rectangular) is on, or if the extent */
/* crosses the meridian, the quick check is no longer valid. */
primitive_rows.size = 0;
if (mapenv->projection == PLATE_CARREE &&
mapenv->mapextent.x1 < mapenv->mapextent.x2) {
sprintf(path,"%s%s%s",covpath,tiledir,spxname[pclass]);
/* 20 (below) is a fairly arbitrary cutoff of the number of */
/* primitives that make a spatial index search worth while. */
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)&&(fcrel.table[prim].nrows > 20)) {
primitive_rows = bounding_select(path,mapenv->mapextent,
library->dec_degrees);
}
}
}
if (primitive_rows.size == 0) {
/* Search through all the primitives */
primitive_rows=set_init(fcrel.table[prim].nrows+1);
set_on(primitive_rows);
}
if (strcmp(tiledir,"") != 0) {
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);
}
} else {
tile_features = set_init(fcrel.table[feature].nrows+1);
set_on(tile_features);
}
set_delete(0,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;
}
start = set_min(tile_features);
end = set_max(tile_features);
/* 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[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);
}
} 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);
}
p = ll_next(p);
}
}
if (primlist) ll_reset(primlist);
if (kbhit()) {
if (getch()==27) {
*status = 0;
break;
}
}
}
set_nuke(&primitive_rows);
set_nuke(&tile_features);
if (idx.fp) close_thematic_index(&idx);
*status = 1;
if (kbhit()) {
if (getch()==27) {
*status = 0;
break;
}
}
}
return primitives;
}
bool rspfVpfDatabaseHeaderTableValidator::isValid(rspfVpfTable& aTable)const
{
if(&aTable == NULL)
{
return false;
}
if(aTable.isClosed())
{
return false;
}
const vpf_table_type* data = aTable.getVpfTableData();
if(!data)
{
return false;
}
if(!data->fp)
{
return false;
}
long column = table_pos("ID", *data);
if(column < 0)
{
return false;
}
column = table_pos("VPF_VERSION", *data);
if(column < 0)
{
return false;
}
column = table_pos("DATABASE_NAME", *data);
if(column < 0)
{
return false;
}
column = table_pos("DATABASE_DESC", *data);
if(column < 0)
{
return false;
}
column = table_pos("MEDIA_STANDARD", *data);
if(column < 0)
{
return false;
}
column = table_pos("ORIGINATOR", *data);
if(column < 0)
{
return false;
}
column = table_pos("ADDRESSEE", *data);
if(column < 0)
{
return false;
}
column = table_pos("MEDIA_VOLUMES", *data);
if(column < 0)
{
return false;
}
column = table_pos("SEQ_NUMBERS", *data);
if(column < 0)
{
return false;
}
column = table_pos("NUM_DATA_SETS", *data);
if(column < 0)
{
return false;
}
column = table_pos("SECURITY_CLASS", *data);
if(column < 0)
{
return false;
}
column = table_pos("DOWNGRADING", *data);
if(column < 0)
{
return false;
}
column = table_pos("DOWNGRADE_DATE", *data);
if(column < 0)
{
return false;
}
column = table_pos("RELEASABILITY", *data);
if(column < 0)
{
return false;
}
column = table_pos("TRANSMITTAL_ID", *data);
if(column < 0)
{
return false;
}
column = table_pos("EDITION_NUMBER", *data);
if(column < 0)
{
return false;
}
column = table_pos("EDITION_DATE", *data);
if(column < 0)
{
return false;
}
return true;
}
/*************************************************************************
*
*N draw_face_row
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function draws the specified face from the given row of
* the given face table.
* It is complicated by the fact that it checks to see whether a
* face has wrapped around the screen due to projection effects.
* If so, it first adjusts the coordinates off the right edge of the
* screen to fill that portion of the face. Then, if the face
* wraps around to the other edge of the screen, it adjusts the
* coordinates to the left edge of the screen and refills to
* display that portion of the face.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* row <input>==(row_type) row of the specified face table.
* facetable <input>==(vpf_table_type) VPF face primitive table.
* ringtable <input>==(vpf_table_type) VPF ring primitive table.
* edgetable <input>==(vpf_table_type) VPF edge primitive table.
* fbr <input>==(vpf_table_type) VPF face bounding rectangle table.
* outline <input>==(color_type) outline color.
* c1 <input>==(color_type) 1st color in the fill pattern.
* c2 <input>==(color_type) 2nd color in the fill pattern.
* c3 <input>==(color_type) 3rd color in the fill pattern.
* c4 <input>==(color_type) 4th color in the fill pattern.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*************************************************************************/
void draw_face_row( row_type row,
vpf_table_type facetable,
vpf_table_type ringtable,
vpf_table_type edgetable,
vpf_table_type fbr,
color_type outline,
color_type c1,
color_type c2,
color_type c3,
color_type c4 )
{
ossim_int32 count;
int spx1,spy1,spx2,spy2, rowid,ring;
extent_type shade_box;
Pattern pattern;
face_rec_type face_rec;
int wrap, mbrx2;
row_type fbrrow;
int XMIN_,YMIN_,XMAX_,YMAX_;
rowid = table_pos( "ID", facetable );
ring = table_pos( "RING_PTR", facetable );
get_table_element( rowid, row, facetable, &(face_rec.id), &count );
get_table_element( ring, row, facetable, &(face_rec.ring), &count );
gpsetlinecolor(outline);
gpsetlinestyle(SOLID_LINE);
gpsetlinewidth(NORM_WIDTH);
wrap = 0;
if (gpgetdevice()==SCREEN) {
pattern = MakePattern(c1,c2,c3,c4);
/* Read bounding box */
fbrrow = read_row( face_rec.id, fbr );
XMIN_ = table_pos( "XMIN", fbr );
YMIN_ = table_pos( "YMIN", fbr );
XMAX_ = table_pos( "XMAX", fbr );
YMAX_ = table_pos( "YMAX", fbr );
get_table_element(XMIN_,fbrrow,fbr,&shade_box.x1,&count);
get_table_element(YMIN_,fbrrow,fbr,&shade_box.y1,&count);
get_table_element(XMAX_,fbrrow,fbr,&shade_box.x2,&count);
get_table_element(YMAX_,fbrrow,fbr,&shade_box.y2,&count);
free_row(fbrrow,fbr);
screen_bounds(shade_box.x1,shade_box.y1,
shade_box.x2,shade_box.y2,
&spx1,&spy1,&spx2,&spy2);
mbrx2 = spx2;
if (spx2<spx1) {
/* The face wraps around the screen */
/* (or at least wraps off the edge of the screen) */
wrap = gpgetmaxx();
if (spx2 < 0) wrap -= spx2;
/* Adjust the maximum screen value */
spx2 += wrap;
}
} else {
gpstartpoly();
}
draw_polygon( spx1,spy1,spx2,spy2, face_rec, ringtable,
edgetable, outline, pattern, wrap );
if (wrap && mbrx2 > 0) {
/* The polygon has wrapped around to the other side of the */
/* screen. Must redraw the part left off on the first pass. */
if (gpgetdevice()==SCREEN) {
spx1 -= wrap;
spx2 -= wrap;
} else {
gpstartpoly();
}
wrap *= -1;
draw_polygon( spx1,spy1,spx2,spy2, face_rec, ringtable,
edgetable, outline, pattern, wrap );
}
}