int GRASS_LIB_EXPORT QgsGrassGisLib::G__gisinit( const char * version, const char * programName )
{
Q_UNUSED( version );
// We use this function also to init our fake lib
QgsDebugMsg( QString( "version = %1 programName = %2" ).arg( version ).arg( programName ) );
// Init providers path
int argc = 1;
char **argv = new char*[1];
argv[0] = qstrdup( programName );
// unfortunately it seems impossible to get QGIS prefix
// QCoreApplication::applicationDirPath() returns $GISBASE/lib on Linux
#if 0
QDir dir( QCoreApplication::applicationDirPath() );
dir.cdUp();
QString prefixPath = dir.absolutePath();
#endif
//QCoreApplication app( argc, argv ); // to init paths
QgsApplication app( argc, argv, false ); // to init paths
// TODO: WCS (network) fails with: "QTimer can only be used with threads started
// with QThread" because QCoreApplication::exec() was not called, but
// QCoreApplication::exec() goes to loop. We need to start QThread somehow.
// QGIS_PREFIX_PATH should be loaded by QgsApplication
//QString prefixPath = getenv( "QGIS_PREFIX_PATH" );
//if ( prefixPath.isEmpty() )
//{
// fatal( "Cannot get QGIS_PREFIX_PATH" );
//}
//QgsApplication::setPrefixPath( prefixPath, true );
QgsDebugMsg( "Plugin path: " + QgsApplication::pluginPath() );
QgsProviderRegistry::instance( QgsApplication::pluginPath() );
QgsDebugMsg( "qgisSettingsDirPath = " + app.qgisSettingsDirPath() );
G_set_error_routine( &errorRoutine );
G_set_gisrc_mode( G_GISRC_MODE_MEMORY );
G_setenv( "OVERWRITE", "1" ); // avoid checking if map exists
G_suppress_masking();
#if GRASS_VERSION_MAJOR<6 || (GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR <= 4)
G__init_null_patterns();
#endif
// Read projection if set
//mCrs.createFromOgcWmsCrs( "EPSG:900913" );
QString crsStr = getenv( "QGIS_GRASS_CRS" );
QgsDebugMsg( "Setting CRS to " + crsStr );
if ( !crsStr.isEmpty() )
{
if ( !mCrs.createFromProj4( crsStr ) )
{
fatal( "Cannot create CRS from QGIS_GRASS_CRS: " + crsStr );
}
//TODO: createFromProj4 used to save to the user database any new CRS
// this behavior was changed in order to separate creation and saving.
// Not sure if it necessary to save it here, should be checked by someone
// familiar with the code (should also give a more descriptive name to the generated CRS)
if ( mCrs.srsid() == 0 )
{
QString myName = QString( " * %1 (%2)" )
.arg( QObject::tr( "Generated CRS", "A CRS automatically generated from layer info get this prefix for description" ) )
.arg( mCrs.toProj4() );
mCrs.saveAsUserCRS( myName );
}
}
mDistanceArea.setSourceCrs( mCrs.srsid() );
// Read region fron environment variable
// QGIS_GRASS_REGION=west,south,east,north,cols,rows
#if 0
QString regionStr = getenv( "QGIS_GRASS_REGION" );
QStringList regionList = regionStr.split( "," );
if ( regionList.size() != 6 )
{
fatal( "Cannot read region from QGIS_GRASS_REGION environment variable" );
}
double xMin, yMin, xMax, yMax;
int cols, rows;
bool xMinOk, yMinOk, xMaxOk, yMaxOk, colsOk, rowsOk;
xMin = regionList.value( 0 ).toDouble( &xMinOk );
yMin = regionList.value( 1 ).toDouble( &yMinOk );
xMax = regionList.value( 2 ).toDouble( &xMaxOk );
yMax = regionList.value( 3 ).toDouble( &yMaxOk );
cols = regionList.value( 4 ).toInt( &colsOk );
rows = regionList.value( 5 ).toInt( &rowsOk );
if ( !xMinOk || !yMinOk || !xMaxOk || !yMaxOk || !colsOk || !rowsOk )
{
fatal( "Cannot parse QGIS_GRASS_REGION" );
}
struct Cell_head window;
window.west = xMin;
window.south = yMin;
window.east = xMax;
window.north = yMax;
window.rows = rows;
window.cols = cols;
char* err = G_adjust_Cell_head( &window, 1, 1 );
if ( err )
{
fatal( QString( err ) );
}
G_set_window( &window );
#endif
QString regionStr = getenv( "GRASS_REGION" );
if ( regionStr.isEmpty() )
{
fatal( "GRASS_REGION environment variable not set" );
}
QgsDebugMsg( "Getting region via true lib from GRASS_REGION: " + regionStr );
// GRASS true lib reads GRASS_REGION environment variable
G_get_window( &mWindow );
mExtent = QgsRectangle( mWindow.west, mWindow.south, mWindow.east, mWindow.north );
mRows = mWindow.rows;
mColumns = mWindow.cols;
mXRes = mExtent.width() / mColumns;
mYRes = mExtent.height() / mColumns;
QgsDebugMsg( "End" );
return 0;
}
void GRASS_EXPORT QgsGrass::init( void )
{
// Warning!!!
// G_set_error_routine() once called from plugin
// is not valid in provider -> call it always
// Set error function
G_set_error_routine( &error_routine );
if ( initialized )
return;
QSettings settings;
// Is it active mode ?
if ( getenv( "GISRC" ) )
{
active = true;
// Store default values
defaultGisdbase = G_gisdbase();
defaultLocation = G_location();
defaultMapset = G_mapset();
}
else
{
active = false;
}
// Don't use GISRC file and read/write GRASS variables (from location G_VAR_GISRC) to memory only.
G_set_gisrc_mode( G_GISRC_MODE_MEMORY );
// Init GRASS libraries (required)
G_no_gisinit(); // Doesn't check write permissions for mapset compare to G_gisinit("libgrass++");
// I think that mask should not be used in QGIS as it can only confuses people,
// anyway, I don't think anybody is using MASK
G_suppress_masking();
// Set program name
G_set_program_name( "QGIS" );
// Require GISBASE to be set. This should point to the location of
// the GRASS installation. The GRASS libraries use it to know
// where to look for things.
// Look first to see if GISBASE env var is already set.
// This is set when QGIS is run from within GRASS
// or when set explicitly by the user.
// This value should always take precedence.
#if WIN32
QString gisBase = getenv( "WINGISBASE" ) ? getenv( "WINGISBASE" ) : getenv( "GISBASE" );
gisBase = shortPath( gisBase );
#else
QString gisBase = getenv( "GISBASE" );
#endif
QgsDebugMsg( QString( "GRASS gisBase from GISBASE env var is: %1" ).arg( gisBase ) );
if ( !isValidGrassBaseDir( gisBase ) )
{
// Look for gisbase in QSettings
gisBase = settings.value( "/GRASS/gisbase", "" ).toString();
QgsDebugMsg( QString( "GRASS gisBase from QSettings is: %1" ).arg( gisBase ) );
}
if ( !isValidGrassBaseDir( gisBase ) )
{
// Erase gisbase from settings because it does not exists
settings.setValue( "/GRASS/gisbase", "" );
#ifdef WIN32
// Use the applicationDirPath()/grass
gisBase = shortPath( QCoreApplication::applicationDirPath() + "/grass" );
QgsDebugMsg( QString( "GRASS gisBase = %1" ).arg( gisBase ) );
#else
// Use the location specified --with-grass during configure
gisBase = GRASS_BASE;
QgsDebugMsg( QString( "GRASS gisBase from configure is: %1" ).arg( gisBase ) );
#endif
}
bool userGisbase = false;
bool valid = false;
while ( !( valid = isValidGrassBaseDir( gisBase ) ) )
{
// ask user if he wants to specify GISBASE
QMessageBox::StandardButton res = QMessageBox::warning( 0, QObject::tr( "GRASS plugin" ),
QObject::tr( "QGIS couldn't find your GRASS installation.\n"
"Would you like to specify path (GISBASE) to your GRASS installation?" ),
QMessageBox::Ok | QMessageBox::Cancel );
if ( res != QMessageBox::Ok )
{
userGisbase = false;
break;
}
// XXX Need to subclass this and add explantory message above to left side
userGisbase = true;
// For Mac, GISBASE folder may be inside GRASS bundle. Use Qt file dialog
// since Mac native dialog doesn't allow user to browse inside bundles.
gisBase = QFileDialog::getExistingDirectory(
0, QObject::tr( "Choose GRASS installation path (GISBASE)" ), gisBase,
QFileDialog::DontUseNativeDialog );
if ( gisBase == QString::null )
{
// User pressed cancel. No GRASS for you!
userGisbase = false;
break;
}
#if defined(WIN32)
gisBase = shortPath( gisBase );
#endif
}
if ( !valid )
{
// warn user
QMessageBox::information( 0, QObject::tr( "GRASS plugin" ),
QObject::tr( "GRASS data won't be available if GISBASE is not specified." ) );
}
if ( userGisbase )
{
settings.setValue( "/GRASS/gisbase", gisBase );
}
QgsDebugMsg( QString( "Valid GRASS gisBase is: %1" ).arg( gisBase ) );
putEnv( "GISBASE", gisBase );
// Add path to GRASS modules
#ifdef WIN32
QString sep = ";";
#else
QString sep = ":";
#endif
QString path = gisBase + "/bin";
path.append( sep + gisBase + "/scripts" );
path.append( sep + QgsApplication::pkgDataPath() + "/grass/scripts/" );
// On windows the GRASS libraries are in
// QgsApplication::prefixPath(), we have to add them
// to PATH to enable running of GRASS modules
// and database drivers
#ifdef WIN32
// It seems that QgsApplication::prefixPath()
// is not initialized at this point
path.append( sep + shortPath( QCoreApplication::applicationDirPath() ) );
// Add path to MSYS bin
// Warning: MSYS sh.exe will translate this path to '/bin'
if ( QFileInfo( QCoreApplication::applicationDirPath() + "/msys/bin/" ).isDir() )
path.append( sep + shortPath( QCoreApplication::applicationDirPath() + "/msys/bin/" ) );
#endif
QString p = getenv( "PATH" );
path.append( sep + p );
QgsDebugMsg( QString( "set PATH: %1" ).arg( path ) );
putEnv( "PATH", path );
// Set PYTHONPATH
QString pythonpath = gisBase + "/etc/python";
QString pp = getenv( "PYTHONPATH" );
pythonpath.append( sep + pp );
QgsDebugMsg( QString( "set PYTHONPATH: %1" ).arg( pythonpath ) );
putEnv( "PYTHONPATH", pythonpath );
// Set GRASS_PAGER if not set, it is necessary for some
// modules printing to terminal, e.g. g.list
// We use 'cat' because 'more' is not present in MSYS (Win)
// and it doesn't work well in built in shell (Unix/Mac)
// and 'less' is not user friendly (for example user must press
// 'q' to quit which is definitely difficult for normal user)
// Also scroling can be don in scrollable window in both
// MSYS terminal and built in shell.
if ( !getenv( "GRASS_PAGER" ) )
{
QString pager;
QStringList pagers;
//pagers << "more" << "less" << "cat"; // se notes above
pagers << "cat";
for ( int i = 0; i < pagers.size(); i++ )
{
int state;
QProcess p;
p.start( pagers.at( i ) );
p.waitForStarted();
state = p.state();
p.write( "\004" ); // Ctrl-D
p.closeWriteChannel();
p.waitForFinished( 1000 );
p.kill();
if ( state == QProcess::Running )
{
pager = pagers.at( i );
break;
}
}
if ( pager.length() > 0 )
{
putEnv( "GRASS_PAGER", pager );
}
}
initialized = 1;
}
int main( int argc, char **argv )
{
struct GModule *module;
struct Option *info_opt, *rast_opt, *vect_opt, *coor_opt, *north_opt, *south_opt, *east_opt, *west_opt, *rows_opt, *cols_opt;
struct Cell_head window;
/* Initialize the GIS calls */
G_gisinit( argv[0] );
module = G_define_module();
module->description = ( "Get info about locations,mapsets,maps" );
info_opt = G_define_option();
info_opt->key = "info";
info_opt->type = TYPE_STRING;
info_opt->description = "info key";
info_opt->options = "proj,window,size,query,info,colors,stats";
rast_opt = G_define_standard_option( G_OPT_R_INPUT );
rast_opt->key = "rast";
rast_opt->required = NO;
vect_opt = G_define_standard_option( G_OPT_V_INPUT );
vect_opt->key = "vect";
vect_opt->required = NO;
coor_opt = G_define_option();
coor_opt->key = "coor";
coor_opt->type = TYPE_DOUBLE;
coor_opt->multiple = YES;
north_opt = G_define_option();
north_opt->key = "north";
north_opt->type = TYPE_STRING;
south_opt = G_define_option();
south_opt->key = "south";
south_opt->type = TYPE_STRING;
east_opt = G_define_option();
east_opt->key = "east";
east_opt->type = TYPE_STRING;
west_opt = G_define_option();
west_opt->key = "west";
west_opt->type = TYPE_STRING;
rows_opt = G_define_option();
rows_opt->key = "rows";
rows_opt->type = TYPE_INTEGER;
cols_opt = G_define_option();
cols_opt->key = "cols";
cols_opt->type = TYPE_INTEGER;
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
if ( strcmp( "proj", info_opt->answer ) == 0 )
{
G_get_window( &window );
/* code from g.proj */
if ( window.proj != PROJECTION_XY )
{
struct Key_Value *projinfo, *projunits;
char *wkt;
projinfo = G_get_projinfo();
projunits = G_get_projunits();
wkt = GPJ_grass_to_wkt( projinfo, projunits, 0, 0 );
fprintf( stdout, "%s", wkt );
}
}
else if ( strcmp( "window", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%f,%f,%f,%f", window.west, window.south, window.east, window.north );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
// raster width and height
else if ( strcmp( "size", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
G_get_cellhd( rast_opt->answer, "", &window );
fprintf( stdout, "%d,%d", window.cols, window.rows );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
// raster information
else if ( strcmp( "info", info_opt->answer ) == 0 )
{
struct FPRange range;
double zmin, zmax;
// Data type
RASTER_MAP_TYPE raster_type = G_raster_map_type( rast_opt->answer, "" );
fprintf( stdout, "TYPE:%d\n", raster_type );
// Statistics
if ( G_read_fp_range( rast_opt->answer, "", &range ) < 0 )
{
G_fatal_error(( "Unable to read range file" ) );
}
G_get_fp_range_min_max( &range, &zmin, &zmax );
fprintf( stdout, "MIN_VALUE:%.17e\n", zmin );
fprintf( stdout, "MAX_VALUE:%.17e\n", zmax );
}
else if ( strcmp( "colors", info_opt->answer ) == 0 )
{
// Color table
struct Colors colors;
int i, ccount;
if ( G_read_colors( rast_opt->answer, "", &colors ) == 1 )
{
//int maxcolor;
//CELL min, max;
//G_get_color_range ( &min, &max, &colors);
ccount = G_colors_count( &colors );
for ( i = ccount - 1; i >= 0; i-- )
{
DCELL val1, val2;
unsigned char r1, g1, b1, r2, g2, b2;
G_get_f_color_rule( &val1, &r1, &g1, &b1, &val2, &r2, &g2, &b2, &colors, i );
fprintf( stdout, "%.17e %.17e %d %d %d %d %d %d\n", val1, val2, r1, g1, b1, r2, g2, b2 );
}
}
}
else if ( strcmp( "query", info_opt->answer ) == 0 )
{
double x, y;
int row, col;
//x = atof( coor_opt->answers[0] );
//y = atof( coor_opt->answers[1] );
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
char buff[101];
G_get_cellhd( rast_opt->answer, "", &window );
G_set_window( &window );
G_suppress_masking(); // must be after G_set_window()
fd = G_open_cell_old( rast_opt->answer, "" );
// wait for coords from stdin
while ( fgets( buff, 100, stdin ) != 0 )
{
if ( sscanf( buff, "%lf%lf", &x, &y ) != 2 )
{
fprintf( stdout, "value:error\n" );
}
else
{
col = ( int ) G_easting_to_col( x, &window );
row = ( int ) G_northing_to_row( y, &window );
if ( col == window.cols )
col--;
if ( row == window.rows )
row--;
if ( col < 0 || col > window.cols || row < 0 || row > window.rows )
{
//fprintf( stdout, "value:out\n" );
fprintf( stdout, "value:nan\n" );
}
else
{
void *ptr;
double val;
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
if ( rast_type == CELL_TYPE )
{
#if GRASS_VERSION_MAJOR < 7
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
#else
G_get_c_raster_row( fd, cell, row );
#endif
val = cell[col];
ptr = &( cell[col] );
}
else
{
#if GRASS_VERSION_MAJOR < 7
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
#else
G_get_d_raster_row( fd, dcell, row );
#endif
val = dcell[col];
ptr = &( dcell[col] );
}
if ( G_is_null_value( ptr, rast_type ) )
{
fprintf( stdout, "value:nan\n" );
}
else
{
fprintf( stdout, "value:%f\n", val );
}
}
}
fflush( stdout );
}
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
else if ( strcmp( "stats", info_opt->answer ) == 0 )
{
if ( rast_opt->answer )
{
int fd;
RASTER_MAP_TYPE rast_type;
DCELL *dcell;
CELL *cell;
int ncols, nrows;
int row, col;
void *ptr;
double val;
double min = DBL_MAX;
double max = -DBL_MAX;
double sum = 0; // sum of values
int count = 0; // count of non null values
double mean = 0;
double squares_sum = 0; // sum of squares
double stdev = 0; // standard deviation
G_get_cellhd( rast_opt->answer, "", &window );
window.north = atof( north_opt->answer );
window.south = atof( south_opt->answer );
window.east = atof( east_opt->answer );
window.west = atof( west_opt->answer );
window.rows = ( int ) atoi( rows_opt->answer );
window.cols = ( int ) atoi( cols_opt->answer );
G_set_window( &window );
G_suppress_masking(); // must be after G_set_window()
fd = G_open_cell_old( rast_opt->answer, "" );
ncols = G_window_cols();
nrows = G_window_rows();
#if defined(GRASS_VERSION_MAJOR) && defined(GRASS_VERSION_MINOR) && \
( ( GRASS_VERSION_MAJOR == 6 && GRASS_VERSION_MINOR > 2 ) || GRASS_VERSION_MAJOR > 6 )
rast_type = G_get_raster_map_type( fd );
#else
rast_type = G_raster_map_type( rast_opt->answer, "" );
#endif
cell = G_allocate_c_raster_buf();
dcell = G_allocate_d_raster_buf();
// Calc stats is very slow for large rasters -> prefer optimization for speed over
// code length and readability (which is not currently true)
for ( row = 0; row < nrows; row++ )
{
if ( rast_type == CELL_TYPE )
{
#if GRASS_VERSION_MAJOR < 7
if ( G_get_c_raster_row( fd, cell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
#else
G_get_c_raster_row( fd, cell, row );
#endif
}
else
{
#if GRASS_VERSION_MAJOR < 7
if ( G_get_d_raster_row( fd, dcell, row ) < 0 )
{
G_fatal_error(( "Unable to read raster map <%s> row %d" ),
rast_opt->answer, row );
}
#else
G_get_d_raster_row( fd, dcell, row );
#endif
}
for ( col = 0; col < ncols; col++ )
{
if ( rast_type == CELL_TYPE )
{
val = cell[col];
ptr = &( cell[col] );
}
else
{
val = dcell[col];
ptr = &( dcell[col] );
}
if ( ! G_is_null_value( ptr, rast_type ) )
{
if ( val < min ) min = val;
if ( val > max ) max = val;
sum += val;
count++;
squares_sum += pow( val, 2 );
}
}
}
mean = count > 0 ? sum / count : 0;
squares_sum -= count * pow( mean, 2 );
stdev = sqrt( squares_sum / ( count - 1 ) );
fprintf( stdout, "MIN:%.17e\n", min );
fprintf( stdout, "MAX:%.17e\n", max );
fprintf( stdout, "SUM:%.17e\n", sum );
fprintf( stdout, "MEAN:%.17e\n", mean );
fprintf( stdout, "COUNT:%d\n", count );
fprintf( stdout, "STDEV:%.17e\n", stdev );
fprintf( stdout, "SQSUM:%.17e\n", squares_sum );
G_close_cell( fd );
}
else if ( vect_opt->answer )
{
G_fatal_error( "Not yet supported" );
}
}
exit( EXIT_SUCCESS );
}
int main( int argc, char **argv )
{
char *mapset = 0;
char *name = 0;
struct GModule *module;
struct Option *map;
struct Option *win;
struct Option *format;
struct Cell_head window;
RASTER_MAP_TYPE raster_type;
/* Initialize the GIS calls */
G_gisinit( argv[0] );
module = G_define_module();
module->description = ( "Output raster map layers in a format suitable for display in QGIS" );
map = G_define_standard_option( G_OPT_R_MAP );
map->description = ( "Raster map to be displayed" );
format = G_define_option();
format->key = "format";
format->type = TYPE_STRING;
format->description = "format";
format->options = "color,value";
win = G_define_option();
win->key = "window";
win->type = TYPE_DOUBLE;
win->multiple = YES;
win->description = "xmin,ymin,xmax,ymax,ncols,nrows";
if ( G_parser( argc, argv ) )
exit( EXIT_FAILURE );
name = map->answer;
/* Make sure map is available */
#if GRASS_VERSION_MAJOR < 7
mapset = G_find_cell2( name, "" );
if ( !mapset )
G_fatal_error( ( "Raster map <%s> not found" ), name );
#else
mapset = "";
#endif
/* It can happen that GRASS data set is 'corrupted' and zone differs in WIND and
* cellhd, and G_open_cell_old fails, so it is better to read window from map */
/* G_get_window( &window ); */
G_get_cellhd( name, mapset, &window );
window.west = atof( win->answers[0] );
window.south = atof( win->answers[1] );
window.east = atof( win->answers[2] );
window.north = atof( win->answers[3] );
window.cols = atoi( win->answers[4] );
window.rows = atoi( win->answers[5] );
G_adjust_Cell_head( &window, 1, 1 );
G_set_window( &window );
G_suppress_masking(); // must be after G_set_window()
raster_type = G_raster_map_type( name, "" );
display( name, mapset, raster_type, format->answer );
exit( EXIT_SUCCESS );
}
int main(int argc, char *argv[])
{
char mapset[GMAPSET_MAX];
char name[GNAME_MAX];
char *camera;
struct GModule *module;
struct Option *group_opt, *map_opt, *target_map_opt;
struct Cell_head cellhd;
int ok;
int nfiles;
/* must run in a term window */
G_putenv("GRASS_UI_TERM", "1");
G_gisinit(argv[0]);
module = G_define_module();
module->keywords = _("imagery, orthorectify");
module->description = _("Creates control points on an image "
"to be ortho-rectified.");
group_opt = G_define_option();
group_opt->key = "group";
group_opt->type = TYPE_STRING;
group_opt->required = YES;
group_opt->multiple = NO;
group_opt->description = _("Name of imagery group");
map_opt = G_define_standard_option(G_OPT_R_MAP);
map_opt->required = NO;
map_opt->description = _("Name of image to be rectified which will "
"be initially drawn on screen");
target_map_opt = G_define_standard_option(G_OPT_R_MAP);
target_map_opt->key = "target";
target_map_opt->required = NO;
target_map_opt->description = _("Name of a map from target mapset which "
"will be initially drawn on screen");
if (G_parser(argc, argv))
exit(EXIT_FAILURE);
G_suppress_masking(); /* need to do this for target location */
camera = (char *)G_malloc(40 * sizeof(char));
strcpy(name, group_opt->answer);
interrupt_char = G_intr_char();
tempfile1 = G_tempfile();
tempfile2 = G_tempfile();
tempfile_dot = G_tempfile();
tempfile_dot2 = G_tempfile();
tempfile_win = G_tempfile();
tempfile_win2 = G_tempfile();
cell_list = G_tempfile();
vect_list = G_tempfile();
group_list = G_tempfile();
digit_points = G_tempfile();
if (R_open_driver() != 0)
G_fatal_error(_("No graphics device selected"));
/* get group ref */
strcpy(group.name, name);
if (!I_find_group(group.name))
G_fatal_error(_("Group [%s] not found"), group.name);
/* get the group ref */
I_get_group_ref(group.name, &group.group_ref);
nfiles = group.group_ref.nfiles;
/* write block files to block list file */
prepare_group_list();
/** look for camera info for this group**/
G_suppress_warnings(1);
if (!I_get_group_camera(group.name, camera))
G_fatal_error(_("No camera reference file selected for group [%s]"),
group.name);
if (!I_get_cam_info(camera, &group.camera_ref))
G_fatal_error(_("Bad format in camera file for group [%s]"),
group.name);
G_suppress_warnings(0);
/* get initial camera exposure station, if any */
if (!(ok = I_find_initial(group.name)))
G_warning(_("No initial camera exposure station for group [%s]"),
group.name);
if (ok && (!I_get_init_info(group.name, &group.camera_exp)) )
G_warning(_("Bad format in initial camera exposure station for group [%s]"),
group.name);
/* get target info and environment */
G_suppress_warnings(1);
get_target();
find_target_files();
G_suppress_warnings(0);
/* read group reference points, if any */
G_suppress_warnings(1);
if (!I_get_ref_points(group.name, &group.photo_points)) {
G_suppress_warnings(0);
if (group.photo_points.count == 0)
G_fatal_error(_("No photo points for group [%s]"), group.name);
else if (group.ref_equation_stat == 0)
G_fatal_error(_("Poorly placed photo points for group [%s]"),
group.name);
}
G_suppress_warnings(0);
/* determine transformation equation */
Compute_ref_equation();
/* read group control points, format: image x,y,cfl; target E,N,Z */
G_suppress_warnings(1);
if (!I_get_con_points(group.name, &group.control_points))
group.control_points.count = 0;
G_suppress_warnings(0);
/* compute image coordinates of photo control points */
/********
I_convert_con_points (group.name, &group.control_points,
&group.control_points, group.E12, group.N12);
********/
/* determine transformation equation */
G_message(_("Computing equations ..."));
if (group.control_points.count > 0)
Compute_ortho_equation();
/* signal (SIGINT, SIG_IGN); */
/* signal (SIGQUIT, SIG_IGN); */
select_current_env();
Init_graphics();
display_title(VIEW_MAP1);
select_target_env();
display_title(VIEW_MAP2);
select_current_env();
Begin_curses();
G_set_error_routine(error);
/*
#ifdef SIGTSTP
signal (SIGTSTP, SIG_IGN);
#endif
*/
/* Set image to be rectified */
if (map_opt->answer) {
char *ms;
ms = G_find_cell(map_opt->answer, "");
if (ms == NULL) {
G_fatal_error(_("Raster map <%s> not found"), map_opt->answer);
}
strcpy(name, map_opt->answer);
strcpy(mapset, ms);
if (G_get_cellhd(name, mapset, &cellhd) < 0) {
G_fatal_error(_("Unable to read raster header of <%s>"), map_opt->answer);
}
}
else {
/* ask user for group file to be displayed */
do {
if (!choose_groupfile(name, mapset))
quit(EXIT_SUCCESS);
/* display this file in "map1" */
} while (G_get_cellhd(name, mapset, &cellhd) < 0);
}
G_adjust_window_to_box(&cellhd, &VIEW_MAP1->cell.head, VIEW_MAP1->nrows,
VIEW_MAP1->ncols);
Configure_view(VIEW_MAP1, name, mapset, cellhd.ns_res, cellhd.ew_res);
drawcell(VIEW_MAP1);
/* Set target map if specified */
if (target_map_opt->answer) {
char *ms;
select_target_env();
ms = G_find_cell(target_map_opt->answer, "");
if (ms == NULL) {
G_fatal_error(_("Raster map <%s> not found"),
target_map_opt->answer);
}
strcpy(name, target_map_opt->answer);
strcpy(mapset, ms);
if (G_get_cellhd(name, mapset, &cellhd) < 0) {
G_fatal_error(_("Unable to read raster header of <%s>"),
target_map_opt->answer);
}
G_adjust_window_to_box(&cellhd, &VIEW_MAP2->cell.head,
VIEW_MAP2->nrows, VIEW_MAP2->ncols);
Configure_view(VIEW_MAP2, name, mapset, cellhd.ns_res, cellhd.ew_res);
drawcell(VIEW_MAP2);
from_flag = 1;
from_keyboard = 0;
from_screen = 1;
}
display_conz_points(1);
Curses_clear_window(PROMPT_WINDOW);
/* determine initial input method. */
setup_digitizer();
if (use_digitizer) {
from_digitizer = 1;
from_keyboard = 0;
from_flag = 1;
}
/* go do the work */
driver();
quit(EXIT_SUCCESS);
}