bool Remove_group::init( std::string& parameters, GsTL_project* proj, Error_messages_handler* errors ){ std::vector< std::string > params = String_Op::decompose_string( parameters, Actions::separator, Actions::unique ); if( params.size() != 2 ) { errors->report( "Must have 2 parameters, name of the grid and name the group to be removed" ); return false; } // Get the grid SmartPtr<Named_interface> ni = Root::instance()->interface( gridModels_manager + "/" + params[0] ); Geostat_grid* grid = dynamic_cast<Geostat_grid*>( ni.raw_ptr() ); if(!grid) { errors->report( "The grid "+params[0]+" does not exist" ); return false; } GsTLGridPropertyGroup* group = grid->get_group(params[1]); if(!group) { errors->report( "The group "+params[1]+" does not exist" ); return false; } grid->remove_group(params[1]); return true; }
void New_region_from_property_dialog::populate_categories(){ if( !isCategorical_ ) return; QString grid_name = selected_grid(); QString prop_name = selected_property(); if(grid_name.isEmpty() || prop_name.isEmpty()) return; SmartPtr< Named_interface > ni = Root::instance()->interface( gridModels_manager + "/" + grid_name.toStdString() ); Geostat_grid* grid = dynamic_cast<Geostat_grid*>(ni.raw_ptr()); Grid_categorical_property *prop = grid->categorical_property(prop_name.toStdString()); if(!prop) return; const CategoricalPropertyDefinition* cat_def = prop->get_category_definition(); const CategoricalPropertyDefinitionName* cat_def_name = dynamic_cast<const CategoricalPropertyDefinitionName*>(cat_def); if( cat_def_name ) { cat_selector_->show_categories( cat_def_name->name().c_str() ); } else { cat_selector_->show_default_categories( prop->get_number_of_category() ); } }
bool New_property_group::init( std::string& parameters, GsTL_project* proj, Error_messages_handler* errors ){ std::vector< std::string > params = String_Op::decompose_string( parameters, Actions::separator, Actions::unique ); if( params.size() < 2 ) { errors->report( "Must have at least 2 parameters, name of the grid and name the group" ); return false; } // Get the grid std::string grid_name = params[0]; SmartPtr<Named_interface> ni = Root::instance()->interface( gridModels_manager + "/" + grid_name); Geostat_grid* grid = dynamic_cast<Geostat_grid*>( ni.raw_ptr() ); if(!grid) { errors->report( "The grid "+params[0]+" does not exist" ); return false; } GsTLGridPropertyGroup* group = grid->get_group(params[1]); if(group) { errors->report( "The goup "+params[1]+" already exist; hence cannot be created" ); return false; } std::string type = ""; if( params.size() == 3 ) { if( params[2] == "General" ) type = ""; else type = params[2]; } group = grid->add_group(params[1],type); if(!group) { errors->report( "The goup "+params[1]+" could no be created; possibly type undefined" ); return false; } for(int i=3; i< params.size(); i++) { Grid_continuous_property* prop = grid->property(params[i]); if(prop == NULL) { errors->report( "The property "+params[i]+" does not exist" ); return false; } } for(int i=3; i< params.size(); i++) { group->add_property(grid->property(params[i])); } proj->update(); return true; }
bool Rename_property_item_action::execute(GsTL_object_item* item) { Grid_continuous_property* prop = dynamic_cast<Grid_continuous_property*>(item); if(prop == 0) return false; std::string old_name = prop->name(); Rename_dialog rename_diag("Property",old_name.c_str(), dynamic_cast<QWidget*>(this->parent())); int r = rename_diag.exec(); if (r==1) { Geostat_grid* grid = dynamic_cast<Geostat_grid*>(item->parent()->parent()); if(grid == 0) return false; return grid->reNameProperty(old_name, rename_diag.new_name().toStdString() ); } else return false; }
Grid_continuous_property* QPplot_control_panel::get_property( const PropertySelector* object_selector ) { std::string grid_name( qstring2string(object_selector->selectedGrid()) ); if( grid_name.empty() ) return 0; Geostat_grid* grid = dynamic_cast<Geostat_grid*>( Root::instance()->interface( gridModels_manager + "/" + grid_name ).raw_ptr() ); appli_assert( grid ); std::string prop_name( qstring2string(object_selector->selectedProperty()) ); Grid_continuous_property* prop = grid->property( prop_name ); appli_assert( prop ); return prop; }
Grid_region* Scatterplot_control_panel::get_region( const GridSelector* object_selector ) { std::string grid_name( object_selector->selectedGrid().toStdString() ); std::string region_name( object_selector->selectedRegion().toStdString() ); if( grid_name.empty() || region_name.empty() ) return 0; Geostat_grid* grid = dynamic_cast<Geostat_grid*>( Root::instance()->interface( gridModels_manager + "/" + grid_name ).raw_ptr() ); appli_assert( grid ); Grid_region* region = grid->region( region_name ); appli_assert( region ); return region; }
GsTLGridProperty* Histogram_control_panel::get_property( const PropertySelector* object_selector ) { if( object_selector->selectedGrid().isEmpty() || object_selector->selectedProperty().isEmpty() ) return 0; std::string grid_name( object_selector->selectedGrid().latin1() ); Geostat_grid* grid = dynamic_cast<Geostat_grid*>( Root::instance()->interface( gridModels_manager + "/" + grid_name ).raw_ptr() ); appli_assert( grid ); std::string prop_name( object_selector->selectedProperty().latin1() ); GsTLGridProperty* prop = grid->property( prop_name ); appli_assert( prop ); return prop; }
void New_region_from_property_dialog::set_filter_type(){ QString grid_name = selected_grid(); QString prop_name = selected_property(); if(grid_name.isEmpty() || prop_name.isEmpty()) return; SmartPtr< Named_interface > ni = Root::instance()->interface( gridModels_manager + "/" + grid_name.toStdString() ); Geostat_grid* grid = dynamic_cast<Geostat_grid*>(ni.raw_ptr()); Grid_categorical_property *prop = grid->categorical_property(prop_name.toStdString()); if(prop) { min_max_box_->setHidden(true); category_box_->setVisible(true); isCategorical_ = true; } else { category_box_->setHidden(true); min_max_box_->setVisible(true); isCategorical_ = false; } }
bool Remove_properties_from_group::init( std::string& parameters, GsTL_project* proj, Error_messages_handler* errors ){ std::vector< std::string > params = String_Op::decompose_string( parameters, Actions::separator, Actions::unique ); if( params.size() < 3 ) { errors->report( "Must have at least 3 parameters, name of the grid and name the group and at least one property" ); return false; } // Get the grid SmartPtr<Named_interface> ni = Root::instance()->interface( gridModels_manager + "/" + params[0] ); Geostat_grid* grid = dynamic_cast<Geostat_grid*>( ni.raw_ptr() ); if(!grid) { errors->report( "The grid "+params[0]+" does not exist" ); return false; } GsTLGridPropertyGroup* group = grid->get_group(params[1]); if(!group) { errors->report( "The goup "+params[1]+" does not exist" ); return false; } for(int i=2; i< params.size(); i++) { Grid_continuous_property* prop = grid->property(params[i]); if(prop == NULL) { errors->report( "The property "+params[i]+" does not exist" ); return false; } } for(int i=2; i< params.size(); i++) { if( group->is_member_property( params[i] ) ) group->remove_property(grid->property(params[i])); } return true; }
void Save_grid_dialog::gridChanged(const QString & s) { SmartPtr<Named_interface> grid_ni = Root::instance()->interface( gridModels_manager + "/" + s.toStdString() ); Geostat_grid* grid = dynamic_cast<Geostat_grid*>( grid_ni.raw_ptr() ); appli_assert( grid ); std::list<std::string> pn = grid->property_list(); propList_->clear(); for (std::list<std::string>::iterator it = pn.begin(); it != pn.end(); ++it){ QListWidgetItem * nitem = new QListWidgetItem(it->c_str(), propList_); propList_->addItem(nitem); nitem->setSelected(true); } if (dynamic_cast<Reduced_grid*>(grid)) { masked_as_regular_frame_->setVisible(true); } else{ masked_as_regular_frame_->setVisible(false); } }
bool Show_histogram::init( std::string& parameters, GsTL_project* proj, Error_messages_handler* errors ) { std::vector< std::string > params = String_Op::decompose_string( parameters, Actions::separator, Actions::unique ); if( params.size() < 2 ) { // TL modified errors->report( "Usage: ShowHistogram grid prop [#bins " "logscaling_flag cdf_flag]" ); return false; } SmartPtr<Named_interface> grid_ni = Root::instance()->interface( gridModels_manager + "/" + params[0] ); Geostat_grid* grid = dynamic_cast<Geostat_grid*>( grid_ni.raw_ptr() ); if( !grid ) { std::ostringstream message; message << "No grid called \"" << params[0] << "\" was found"; errors->report( message.str() ); return false; } GsTLGridProperty* prop = grid->property( params[1] ); if( !prop ) { std::ostringstream message; message << "Grid \"" << params[0] << "\" has no property called \"" << params[1] << "\""; errors->report( message.str() ); return false; } //TL modified bool cdf_flag = true; if (params.size() == 5) { if (params[4] == "0") { appli_message("Turning off cdf"); cdf_flag = false; } } Histogram_gui* histog = new Histogram_gui( proj, 0 ); if (cdf_flag) histog->changeCurve("pdf+cdf"); else histog->changeCurve("pdf"); histog->get_data_from( prop ); // check if other options were input if( params.size() >= 3 ) { int bins = String_Op::to_number<int>( params[2] ); histog->update_bins( bins ); if( params.size() >= 4 ) { bool logscale = String_Op::to_number<bool>( params[3] ); histog->set_x_axis_logscale( logscale ); } } histog->show(); return true; }
bool Save_histogram::init( std::string& parameters, GsTL_project* proj, Error_messages_handler* errors ) { std::vector< std::string > params = String_Op::decompose_string( parameters, Actions::separator, Actions::unique ); // TL modified if( params.size() < 3 ) { errors->report( "Usage: SaveHistogram grid prop file [format #bins " "logscaling_flag show_stats_flag show_grid_flag cdf_flag]" ); return false; } SmartPtr<Named_interface> grid_ni = Root::instance()->interface( gridModels_manager + "/" + params[0] ); Geostat_grid* grid = dynamic_cast<Geostat_grid*>( grid_ni.raw_ptr() ); if( !grid ) { std::ostringstream message; message << "No grid called \"" << params[0] << "\" was found"; errors->report( message.str() ); return false; } GsTLGridProperty* prop = grid->property( params[1] ); if( !prop ) { std::ostringstream message; message << "Grid \"" << params[0] << "\" has no property called \"" << params[1] << "\""; errors->report( message.str() ); return false; } // check if we can write to the requested file QFile file( params[2].c_str() ); if( !file.open( IO_WriteOnly ) ) { std::ostringstream message; message << "Can't open file " << params[2]; errors->report( message.str() ); return false; } file.close(); //TL modified bool cdf_flag = true; if (params.size() == 9) { if (params[8] == "0") { appli_message("Turning off cdf"); cdf_flag = false; } } Histogram_gui* histog = new Histogram_gui( proj, 0 ); //TL modified if (cdf_flag) histog->changeCurve("pdf+cdf"); else histog->changeCurve("pdf"); histog->get_data_from( prop ); std::string format = "PNG"; bool show_stats = true; bool show_grid = false; // check if other options were input if( params.size() >= 4 ) { format = params[3] ; } if( params.size() >= 5 ) { int bins = String_Op::to_number<int>( params[4] ); histog->update_bins( bins ); } if( params.size() >= 6 ) { bool logscale = String_Op::to_number<bool>( params[5] ); histog->set_x_axis_logscale( logscale ); } if( params.size() >= 7 ) { show_stats = String_Op::to_number<bool>( params[6] ); } if( params.size() >= 8 ) { show_grid = String_Op::to_number<bool>( params[7] ); } histog->show(); histog->save_as_image( params[2].c_str(), format.c_str(), show_stats, show_grid ); histog->hide(); delete histog; return true; }
void ExternalResponseInputFilter::exec() { std::cout << "Executing External Response Input Filter" << std::endl; // First Parse The XML file QDomDocument doc("ExternalResponses"); QFile file(QString::fromStdString(this->filename)); if (!file.open(QIODevice::ReadOnly)) { std::cerr << "Failed to open response file" << std::endl; return; } if (!doc.setContent(&file)) { std::cerr << "Failed to parse response file" << std::endl; file.close(); return; } QDomElement root = doc.documentElement(); if (root.tagName()!= "Responses") { std::cerr << "Failed to find root" << std::endl; return; } QDomNode n = root.firstChild(); while (!n.isNull()) { QDomElement e = n.toElement(); if (!e.isNull()) { if (e.tagName() == "Response") { // Check to make sure grid exists QString gridStr = e.attribute("grid"); // Check to make sure property exists QString propStr = e.attribute("property"); // Check to make sure name exists, it not create it QString nameStr = e.attribute("name"); // Read type of data this response is storing QString typeStr = e.attribute("type"); // If we have a time series, we store both time and values if (typeStr == "time-series") { std::vector<float> time; std::vector<float> value; // Grab child node QDomNode subNode = e.firstChild(); while (!subNode.isNull()) { // Convert node to element QDomElement subNodeElem = subNode.toElement(); // Read raw text QString rawText = subNodeElem.text(); // Break raw text up into seperate values seperated by ; istringstream seperatedString(rawText.toStdString()); while (seperatedString) { std::string s; if (!getline(seperatedString,s,';')) break; else { // Convert from string to float istringstream os(s); float d; os >> d; if (subNodeElem.nodeName() == "Time") { time.push_back(d); } else if (subNodeElem.nodeName() == "Value") value.push_back(d); else break; } } subNode = subNode.nextSibling(); } // Ensure number of time and values are the same if (time.size() != value.size()) std::cerr << "ERROR: time and values do not align" << std::endl; // GENERATE NEW METRIC DATA HERE // Need: Pointer to property // -QDomElement metaDataXml // which has <algorithm name = "whatever"> // and <Name value = "whatever"> // Find pointer to appropiate property // Obtain smart point to current grid SmartPtr<Named_interface> grid_ni = Root::instance()->interface(gridModels_manager + "/" + gridStr.toStdString()); if (grid_ni.raw_ptr() == 0) { std::cerr << "Grid not found" << std::endl; file.close(); return; } Geostat_grid* grid = dynamic_cast<Geostat_grid*> (grid_ni.raw_ptr()); // Grab GsTLGridProperty from Grid GsTLGridProperty* currentProperty = grid->select_property(propStr.toStdString()); // Generate the required metaDataXml QDomDocument doc("metaDataXml"); QDomElement metaDataXml = doc.createElement("metaRoot"); doc.appendChild(metaDataXml); QDomElement algoXml = doc.createElement("algorithm"); algoXml.setAttribute("name",nameStr); metaDataXml.appendChild(algoXml); QDomElement nameXml = doc.createElement("Name"); nameXml.setAttribute("value",nameStr); metaDataXml.appendChild(nameXml); SmartPtr<Named_interface> ni = Root::instance()->interface( metricData_manager + "/metricRegistrar"); MetricDataManager* mDataRegistrar = dynamic_cast<MetricDataManager*>(ni.raw_ptr()); MetricTimeSeriesData *metric = new MetricTimeSeriesData(currentProperty, metaDataXml,value,time); mDataRegistrar->registerMetricData(gridStr.toStdString(), propStr.toStdString(), metric ); // Move onto next response time.clear(); value.clear(); } else if (typeStr == "vector") { std::vector<float> value; // Grab child node QDomNode subNode = e.firstChild(); while (!subNode.isNull()) { // Convert node to element QDomElement subNodeElem = subNode.toElement(); // Read raw text QString rawText = subNodeElem.text(); // Break raw text up into seperate values seperated by ; istringstream seperatedString(rawText.toStdString()); while (seperatedString) { std::string s; if (!getline(seperatedString,s,';')) break; else { // Convert from string to float istringstream os(s); float d; os >> d; if (subNodeElem.nodeName() == "Value") value.push_back(d); else break; } } subNode = subNode.nextSibling(); } // GENERATE NEW METRIC DATA HERE // Need: Pointer to property // -QDomElement metaDataXml // which has <algorithm name = "whatever"> // and <Name value = "whatever"> // Find pointer to appropiate property // Obtain smart point to current grid SmartPtr<Named_interface> grid_ni = Root::instance()->interface(gridModels_manager + "/" + gridStr.toStdString()); if (grid_ni.raw_ptr() == 0) { std::cerr << "Grid not found" << std::endl; file.close(); return; } Geostat_grid* grid = dynamic_cast<Geostat_grid*> (grid_ni.raw_ptr()); // Grab GsTLGridProperty from Grid GsTLGridProperty* currentProperty = grid->select_property(propStr.toStdString()); // Generate the required metaDataXml QDomDocument doc("metaDataXml"); QDomElement metaDataXml = doc.createElement("metaRoot"); doc.appendChild(metaDataXml); QDomElement algoXml = doc.createElement("algorithm"); algoXml.setAttribute("name",nameStr); metaDataXml.appendChild(algoXml); QDomElement nameXml = doc.createElement("Name"); nameXml.setAttribute("value",nameStr); metaDataXml.appendChild(nameXml); SmartPtr<Named_interface> ni = Root::instance()->interface( metricData_manager + "/metricRegistrar"); MetricDataManager* mDataRegistrar = dynamic_cast<MetricDataManager*>(ni.raw_ptr()); MetricVectorData *metric = new MetricVectorData(currentProperty, metaDataXml,value); mDataRegistrar->registerMetricData(gridStr.toStdString(), propStr.toStdString(), metric ); // Move onto next response value.clear(); }
/* Convert_continuous_to_categorical_property grid_name::prop1::[prop2::] * will copy convert the property from continuous to categorical */ bool Convert_continuous_to_categorical_property:: init( std::string& parameters, GsTL_project* proj, Error_messages_handler* errors ) { std::vector< std::string > params = String_Op::decompose_string( parameters, Actions::separator, Actions::unique ); if( params.size() <2 ) { errors->report( "some parameters are missing, Needs at least two parameters (grid + property)" ); return false; } SmartPtr<Named_interface> grid_ni = Root::instance()->interface( gridModels_manager + "/" + params[0] ); Geostat_grid* grid = dynamic_cast<Geostat_grid*>( grid_ni.raw_ptr() ); if( !grid ) { std::ostringstream message; message << "No grid called \"" << params[0] << "\" was found"; errors->report( message.str() ); return false; } for(int i=1; i<params.size(); ++i) { Grid_categorical_property* cprop = grid->categorical_property(params[i]); if(cprop) continue; Grid_continuous_property* prop = grid->property(params[i]); if(prop == 0) continue; std::set<int> cat_codes; std::string prop_name = prop->name()+" - categorical"; cprop = grid->add_categorical_property(prop_name); while(!cprop) { prop_name.append("_0"); cprop = grid->add_categorical_property(prop_name); } for(int nodeid=0; nodeid < prop->size(); ++nodeid) { if( prop->is_informed(nodeid)) { int code = static_cast<int>(prop->get_value(nodeid)); cprop->set_value(code,nodeid); cat_codes.insert(code); } } // Check is sequential coding bool is_sequential_coding = false; std::set<int>::iterator it = cat_codes.begin(); if( *it == 0 ) { std::advance(it, cat_codes.size()-1); if( *it == cat_codes.size()-1 ) { is_sequential_coding = true; } } if( !is_sequential_coding ) { // Need to build a categorical definition CategoricalPropertyDefinitionName* cat_def = 0; std::string catdef_name = grid->name()+"-"+prop->name(); while(!cat_def) { SmartPtr<Named_interface> ni = Root::instance()->new_interface( "categoricaldefinition://"+catdef_name,categoricalDefinition_manager +"/"+catdef_name ); cat_def = dynamic_cast<CategoricalPropertyDefinitionName*>(ni.raw_ptr()); if(!cat_def) catdef_name.append("_0"); } std::set<int>::iterator it_cat_codes = cat_codes.begin(); for(; it_cat_codes != cat_codes.end(); ++it_cat_codes) { cat_def->add_category(*it_cat_codes, QString("Code %1").arg(*it_cat_codes).toStdString() ); } cprop->set_category_definition( cat_def ); } } proj->update( params[0] ); return true; }
/* Convert_continuous_to_categorical_property grid_name::prop1::[prop2::] * will copy convert the property from continuous to categorical */ bool Convert_categorical_property_to_sequential_coding:: init( std::string& parameters, GsTL_project* proj, Error_messages_handler* errors ) { std::vector< std::string > params = String_Op::decompose_string( parameters, Actions::separator, Actions::unique ); if( params.size() != 2 ) { errors->report( "Some parameters are missing, needs two paramters (grid and categorical property)" ); return false; } SmartPtr<Named_interface> grid_ni = Root::instance()->interface( gridModels_manager + "/" + params[0] ); Geostat_grid* grid = dynamic_cast<Geostat_grid*>( grid_ni.raw_ptr() ); if( !grid ) { std::ostringstream message; message << "No grid called \"" << params[0] << "\" was found"; errors->report( message.str() ); return false; } Grid_categorical_property* cprop = grid->categorical_property(params[1]); if(cprop->get_category_definition()->is_sequential_coding()) return true; const CategoricalPropertyDefinitionName* cdef = dynamic_cast<const CategoricalPropertyDefinitionName*>(cprop->get_category_definition()); if(!cdef) { errors->report( "Error with the categorical definition" ); return false; } std::vector<int> current_codes = cdef->category_codes(); int ncat = cdef->number_of_category(); std::string sequential_catdef_name = cdef->name() + " - Sequential"; // Check if the categorical definition exist SmartPtr<Named_interface> ni = Root::instance()->interface( categoricalDefinition_manager+"/"+sequential_catdef_name ); CategoricalPropertyDefinitionName* cat_def = dynamic_cast<CategoricalPropertyDefinitionName*>(ni.raw_ptr()); while(!cat_def) { sequential_catdef_name.append(" "+cprop->name()); SmartPtr<Named_interface> ni = Root::instance()->new_interface( "categoricaldefinition://"+sequential_catdef_name,categoricalDefinition_manager +"/"+sequential_catdef_name ); cat_def = dynamic_cast<CategoricalPropertyDefinitionName*>(ni.raw_ptr()); if(cat_def) { for(int i=0; i< ncat; ++i) { QString new_cat_name = QString("%1 (code:%2)").arg(cdef->get_category_name(current_codes[i]).c_str()).arg(current_codes[i]); cat_def->add_category(i, new_cat_name.toStdString() ); } } } //Get the new value std::map<int,int> map_codes; for(int i=0; i< current_codes.size(); ++i ) { map_codes[current_codes[i]] = i; } std::string prop_name = cprop->name()+" sequential"; Grid_categorical_property* seq_cprop = grid->add_categorical_property(cprop->name()+" sequential",cdef->name()); while(!seq_cprop) { prop_name.append("_0"); seq_cprop = grid->add_categorical_property(prop_name); } for(int i=0; i < cprop->size(); ++i) { if( !cprop->is_informed(i) ) continue; int code = cprop->get_value(i); std::map<int,int>::const_iterator it = map_codes.find(code); if( it == map_codes.end() ) continue; seq_cprop->set_value(static_cast<Grid_continuous_property::property_type>(it->second),i); } seq_cprop->set_category_definition(cat_def); proj->update( params[0] ); return true; }
bool Save_scatterplot::init( std::string& parameters, GsTL_project* proj, Error_messages_handler* errors ) { std::vector< std::string > params = String_Op::decompose_string( parameters, Actions::separator, Actions::unique ); if( params.size() < 4 ) { errors->report( "Usage: SaveScatterplot grid prop1 prop2 file [format " "stats_flag grid_flag logY logX]" ); return false; } SmartPtr<Named_interface> grid_ni = Root::instance()->interface( gridModels_manager + "/" + params[0] ); Geostat_grid* grid = dynamic_cast<Geostat_grid*>( grid_ni.raw_ptr() ); if( !grid ) { std::ostringstream message; message << "No grid called \"" << params[0] << "\" was found"; errors->report( message.str() ); return false; } GsTLGridProperty* prop1 = grid->property( params[1] ); GsTLGridProperty* prop2 = grid->property( params[2] ); if( !prop1 || !prop2 ) { std::ostringstream message; message << "Grid \"" << params[0] << "\" has no property called \"" ; if (!prop1 ) message << params[1] << "\" "; if (!prop2 ) message << params[2] << "\" "; errors->report( message.str() ); return false; } // check if we can write to the requested file QFile file( params[3].c_str() ); if( !file.open( IO_WriteOnly ) ) { std::ostringstream message; message << "Can't open file " << params[3]; errors->report( message.str() ); return false; } file.close(); Scatterplot_gui* scplot = new Scatterplot_gui( proj, 0 ); scplot->get_var1_data_from( prop1 ); scplot->get_var2_data_from( prop2 ); std::string format = "PNG"; bool show_stats = true; bool show_grid = false; // check if other options were input if( params.size() >= 5 ) { format = params[4] ; } if( params.size() >= 6 ) { show_stats = String_Op::to_number<bool>( params[5] ); } if( params.size() >= 7 ) { show_grid = String_Op::to_number<bool>( params[6] ); } if( params.size() >= 8 ) { bool ylog = String_Op::to_number<bool>( params[7] ); scplot->set_y_axis_logscale( ylog ); } if( params.size() >= 8 ) { bool xlog = String_Op::to_number<bool>( params[7] ); scplot->set_x_axis_logscale( xlog ); } scplot->show(); scplot->save_as_image( params[3].c_str(), format.c_str(), show_stats, show_grid ); scplot->hide(); delete scplot; return true; }
void Project_ItemModel::begin_add_item(std::string type_hierarchy,std::string type_name){ QStringList types = QString(type_hierarchy.c_str()).split("/"); QStringList names = QString(type_name.c_str()).split("/"); if(types.isEmpty() || names.isEmpty() || types.size() != names.size()) return; QModelIndex insert_parent_index; int position; // can either add a grid, a group, a property (in the all_group and/or in a specific group) or a region QModelIndex root_index = this->root_index(); if(types.size() == 1) { // Adding a grid, always at the end insert_parent_index = root_index; position = rootItem_->childCount(); } else { QString grid_name = names.at(0); Geostat_grid* grid = dynamic_cast<Geostat_grid*>( Root::instance()->interface( gridModels_manager + "/" + grid_name.toStdString() ).raw_ptr() ); if(grid == 0) return; GsTL_root_item *root_item = dynamic_cast<GsTL_root_item*>(rootItem_); GsTL_grid_item * grid_item = new GsTL_grid_item(root_item->project(), grid, grid_name, rootItem_ ); QModelIndex grid_index = root_index.child(grid_item->row(),0); if(types.size() == 2) { // adding a group or a property if(types.at(1) == "group") { insert_parent_index = grid_index; std::string new_group_name = names.at(1).toStdString(); std::list<std::string> group_names = grid->get_group_names(); std::list<std::string>::iterator it = group_names.begin(); for(int i=0 ; it != group_names.end() ; ++it) { if( *it > new_group_name ) { position = i; break; } } } else if(types.at(1) == "property") { insert_parent_index = grid_index.child(0,0); //Need to add it to the all property group and the specific group std::string new_prop_name = names.at(1).toStdString(); std::list<std::string> props = grid->property_list(); std::list<std::string>::const_iterator it_prop = props.begin(); for(int i=0;it_prop != props.end(); ++it_prop, ++i) { if(*it_prop > new_prop_name) { position = i; break; } } } } } this->beginInsertRows(insert_parent_index,position, position); }