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);
  }
}
Beispiel #11
0
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;
}
Beispiel #12
0
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;
}
Beispiel #16
0
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);
}