int main() { const int grid_size = 10; // Build grid with locally varying mean Cartesian_grid* lvm_grid = new Cartesian_grid( grid_size, grid_size, 1 ); GsTLGridProperty* prop = lvm_grid->add_property( "trend", typeid( float ) ); for( int i=0; i< grid_size*grid_size/2 ; i++ ) { prop->set_value( 0.0, i ); } for( int i=grid_size*grid_size/2; i< grid_size*grid_size ; i++ ) { prop->set_value( 10.0, i ); } Colocated_neighborhood* coloc_neigh = dynamic_cast<Colocated_neighborhood*>( lvm_grid->colocated_neighborhood( "trend" ) ); // Build kriging grid Cartesian_grid* krig_grid = new Cartesian_grid( grid_size, grid_size, 1 ); GsTLGridProperty* krig_prop = krig_grid->add_property( string("krig"), typeid( float ) ); krig_grid->select_property( "krig"); // Build harddata grid const int pointset_size = 4; Point_set* harddata = new Point_set( pointset_size ); std::vector<GsTLPoint> locations; locations.push_back( GsTLPoint( 0,0,0 ) ); locations.push_back( GsTLPoint( 1,5,0 ) ); locations.push_back( GsTLPoint( 8,8,0 ) ); locations.push_back( GsTLPoint( 5,2,0 ) ); harddata->point_locations( locations ); GsTLGridProperty* hard_prop = harddata->add_property( "poro" ); for( int i=0; i<pointset_size; i++ ) { hard_prop->set_value( i, i ); } harddata->select_property( "poro" ); // Set up covariance Covariance<GsTLPoint> cov; cov.nugget(0.1); cov.add_structure( "Spherical" ); cov.sill( 0, 0.9 ); cov.set_geometry( 0, 10,10,10, 0,0,0 ); Grid_initializer initializer; initializer.assign( krig_grid, krig_prop, harddata, "poro" ); for( int i=0; i< krig_prop->size(); i++ ) { if( krig_prop->is_harddata( i ) ) cout << "value at " << i << ": " << krig_prop->get_value( i ) << endl; } krig_grid->select_property( "krig"); Neighborhood* neighborhood = krig_grid->neighborhood( 20, 20, 1, 0,0,0, &cov, true ); typedef GsTLPoint Location; typedef std::vector<double>::const_iterator weight_iterator; typedef SKConstraints_impl< Neighborhood, Location > SKConstraints; typedef SK_local_mean_combiner<weight_iterator, Neighborhood, Colocated_neighborhood> LVM_combiner; typedef Kriging_constraints< Neighborhood, Location > KrigingConstraints; typedef Kriging_combiner< weight_iterator, Neighborhood > KrigingCombiner; LVM_combiner combiner( *coloc_neigh ); SKConstraints constraints; // initialize the algo Kriging algo; algo.simul_grid_ = krig_grid; algo.property_name_ = "krig"; algo.harddata_grid_ = 0; algo.neighborhood_ = neighborhood; algo.covar_ = cov; algo.combiner_ = new KrigingCombiner( &combiner ); algo.Kconstraints_ = new KrigingConstraints( &constraints ); // Run and output the results algo.execute(); ofstream ofile( "result.out" ); if( !ofile ) { cerr << "can't create file result.out" << endl; return 1; } GsTLGridProperty* prop1 = krig_grid->select_property( "krig" ); ofile << "kriging" << endl << "1" << endl << "krig" << endl ; for( int i=0; i< prop1->size(); i++ ) { if( prop1->is_informed( i ) ) ofile << prop1->get_value( i ) << endl; else ofile << "-99" << endl; } }
Geostat_grid* Simulacre_input_filter::read_pointset( QDataStream& stream, std::string* errors ) { char* name; stream >> name; std::string grid_name( name ); Q_INT32 version; stream >> version; if( version < 100 ) { errors->append( "file too old" ); return 0; } Q_UINT32 size; stream >> size; // create a new point set of the correct size std::ostringstream ostr; ostr << size; std::string final_grid_name; SmartPtr<Named_interface> ni = Root::instance()->new_interface( "point_set://" + ostr.str(), gridModels_manager + "/" + grid_name, &final_grid_name ); Point_set* grid = dynamic_cast<Point_set*>( ni.raw_ptr() ); // get the property names Q_UINT32 properties_count; stream >> properties_count; std::vector< char* > prop_names( properties_count ); for( unsigned int i = 0; i < properties_count; i++ ) stream >> prop_names[i]; // read the coordinates of the points std::vector<Point_set::location_type > coords; for( unsigned int k = 0; k < size; k ++ ) { float x,y,z; stream >> x >> y >> z; coords.push_back( Point_set::location_type( x,y,z) ); } grid->point_locations( coords ); // read all the properties for( unsigned int j = 0; j < properties_count; j++ ) { std::string prop_name( prop_names[j] ); GsTLGridProperty* prop = grid->add_property( prop_name ); for( GsTLInt k = 0; k < size ; k++ ) { float val; stream >> val; prop->set_value( val, k ); } } for( unsigned int l = 0; l < properties_count; l++ ) { delete [] prop_names[l]; } delete [] name; return grid; }
Geostat_grid* Csv_poinset_infilter::read( std::ifstream& infile ) { QByteArray tmp = dialog_->name().simplified().toLatin1(); std::string name( tmp.constData() ); int X_col_id = dialog_->X_column_index(); int Y_col_id = dialog_->Y_column_index(); int Z_col_id = dialog_->Z_column_index(); if( X_col_id == Y_col_id || X_col_id == Z_col_id || Y_col_id == Z_col_id ) { GsTLcerr << "The same column was selected for multiple coordinates \n" << gstlIO::end; return 0; } bool use_no_data_value = dialog_->use_no_data_value(); float no_data_value = GsTLGridProperty::no_data_value; if( dialog_->use_no_data_value() ) { no_data_value = dialog_->no_data_value(); } std::string str; std::getline(infile, str); QString qstr(str.c_str()); QStringList property_names = qstr.split(","); bool is_x_provided = dialog_->X_column_name() != "None"; bool is_y_provided = dialog_->Y_column_name() != "None"; bool is_z_provided = dialog_->Z_column_name() != "None"; if(is_x_provided) property_names.removeOne(dialog_->X_column_name()); if(is_y_provided) property_names.removeOne(dialog_->Y_column_name()); if(is_z_provided) property_names.removeOne(dialog_->Z_column_name()); std::vector< std::vector< QString > > property_values( property_names.size() ); std::vector< Point_set::location_type > point_locations; // For a csv file no data value is indicated by an empty field e.g. {34,,5.5} while( std::getline(infile, str) ) { qstr = str.c_str(); QStringList fields = qstr.split(","); Point_set::location_type loc; if(is_x_provided) loc[0] = fields[X_col_id].toDouble(); if(is_y_provided) loc[1] = fields[Y_col_id].toDouble(); if(is_z_provided) loc[2] = fields[Z_col_id].toDouble(); point_locations.push_back(loc); unsigned int i=0; for(unsigned int j=0;j<fields.size();j++) { if(j==0) i=0; if(j != X_col_id && j != Y_col_id && j != Z_col_id) { property_values[i].push_back(fields[j]); i++; } } } // done reading file //---------------------------- int point_set_size = point_locations.size(); appli_message( "read " << point_set_size << " points" ); // We now have a vector containing all the locations and another one with // all the property values. // Create a pointset, initialize it with the data we collected, and we're done // ask manager to get a new pointset and initialize it SmartPtr<Named_interface> ni = Root::instance()->interface( gridModels_manager + "/" + name ); if( ni.raw_ptr() != 0 ) { GsTLcerr << "object " << name << " already exists\n" << gstlIO::end; return 0; } std::string size_str = String_Op::to_string( point_set_size ); ni = Root::instance()->new_interface( "point_set://" + size_str, gridModels_manager + "/" + name ); Point_set* pset = dynamic_cast<Point_set*>( ni.raw_ptr() ); appli_assert( pset != 0 ); pset->point_locations( point_locations ); for( unsigned int k= 0; k < property_names.size(); k++ ) { // Need to find out if property is categorical unsigned int check_size = std::min(30,static_cast<int>(property_values[k].size())); bool is_categ = false; for(unsigned int i=0; i<check_size ; i++ ) { bool ok; property_values[k][i].toFloat(&ok); if(!ok) { is_categ = true; break; } } if(!is_categ) { GsTLGridProperty* prop = pset->add_property( property_names[k].toStdString() ); for( int l=0; l < point_set_size; l++ ) { float val = property_values[k][l].toFloat(); if(use_no_data_value && val == no_data_value) val = GsTLGridProperty::no_data_value; prop->set_value( val, l ); } } else { //Create categorical definition // by default it is named: grid-propertyName std::string catdef_name = name+"-"+property_names[k].toStdString(); ni = Root::instance()->new_interface( "categoricaldefinition://"+catdef_name,categoricalDefinition_manager +"/"+catdef_name ); CategoricalPropertyDefinitionName* cat_def = dynamic_cast<CategoricalPropertyDefinitionName*>(ni.raw_ptr()); for( int i=0; i < point_set_size; i++ ) { cat_def->add_category(property_values[k][i].toStdString()); } GsTLGridCategoricalProperty* prop = pset->add_categorical_property( property_names[k].toStdString(),cat_def->name() ); // prop->set_category_definition(cat_def->name()); QString no_data_value_str = QString().arg( no_data_value); for( int i=0; i < point_set_size; i++ ) { QString val = property_values[k][i]; if(use_no_data_value && val == no_data_value_str) { prop->set_value( GsTLGridProperty::no_data_value, i ); } else prop->set_value( val.toStdString(), i ); } } } return pset; }