ParametersMap VDVServersListService::run( std::ostream& stream, const Request& request ) const { ParametersMap map; if(_serverFilter.get()) { boost::shared_ptr<ParametersMap> serverPM(new ParametersMap); _serverFilter->toParametersMap(*serverPM, true); map.insert(TAG_SERVER, serverPM); } else { BOOST_FOREACH( const VDVServer::Registry::value_type& server, Env::GetOfficialEnv().getRegistry<VDVServer>() ){ boost::shared_ptr<ParametersMap> serverPM(new ParametersMap); server.second->toParametersMap(*serverPM, true); map.insert(TAG_SERVER, serverPM); } } return map; }
bool DataRecorder::init(const QString & path, bool recordInRAM) { UScopeMutex scope(memoryMutex_); if(!memory_) { ParametersMap customParameters; customParameters.insert(ParametersPair(Parameters::kMemRehearsalSimilarity(), "1.0")); // desactivate rehearsal customParameters.insert(ParametersPair(Parameters::kKpWordsPerImage(), "-1")); // desactivate keypoints extraction customParameters.insert(ParametersPair(Parameters::kMemBinDataKept(), "true")); // to keep images if(!recordInRAM) { customParameters.insert(ParametersPair(Parameters::kDbSqlite3InMemory(), "false")); } memory_ = new Memory(); if(!memory_->init(path.toStdString(), true, customParameters)) { delete memory_; memory_ = 0; UERROR("Error initializing the memory."); return false; } path_ = path; return true; } else { UERROR("Already initialized, close it first."); return false; } }
ParametersMap UpdateProfileAction::getParametersMap() const { ParametersMap map; if(_profile.get()) map.insert(PARAMETER_PROFILE_ID, _profile->getKey()); map.insert(PARAMETER_NAME, _name); return map; }
ParametersMap OrService::_getParametersMap() const { ParametersMap map; map.insert(PARAMETER_LEFT, _left); map.insert(PARAMETER_RIGHT, _right); return map; }
ParametersMap AndFunction::_getParametersMap() const { ParametersMap map; map.insert(PARAMETER_LEFT, _left); map.insert(PARAMETER_RIGHT, _right); return map; }
ParametersMap FreeDRTAreaUpdateAction::getParametersMap() const { ParametersMap map; if(_area.get()) { map.insert(PARAMETER_AREA_ID, _area->getKey()); } if(_name) { map.insert(PARAMETER_NAME, *_name); } if(_cities) { map.insert(PARAMETER_CITIES, FreeDRTAreaTableSync::SerializeCities(*_cities)); } if(_stopAreas) { map.insert(PARAMETER_STOP_AREAS, FreeDRTAreaTableSync::SerializeStopAreas(*_stopAreas)); } if(_line && _line->get()) { map.insert(PARAMETER_COMMERCIAL_LINE_ID, (*_line)->getKey()); } return map; }
MapOptimizer() : mapFrameId_("map"), odomFrameId_("odom"), globalOptimization_(true), optimizeFromLastNode_(false), mapToOdom_(rtabmap::Transform::getIdentity()), transformThread_(0) { ros::NodeHandle nh; ros::NodeHandle pnh("~"); double epsilon = 0.0; bool robust = true; bool slam2d =false; int strategy = 0; // 0=TORO, 1=g2o, 2=GTSAM int iterations = 100; bool ignoreVariance = false; pnh.param("map_frame_id", mapFrameId_, mapFrameId_); pnh.param("odom_frame_id", odomFrameId_, odomFrameId_); pnh.param("iterations", iterations, iterations); pnh.param("ignore_variance", ignoreVariance, ignoreVariance); pnh.param("global_optimization", globalOptimization_, globalOptimization_); pnh.param("optimize_from_last_node", optimizeFromLastNode_, optimizeFromLastNode_); pnh.param("epsilon", epsilon, epsilon); pnh.param("robust", robust, robust); pnh.param("slam_2d", slam2d, slam2d); pnh.param("strategy", strategy, strategy); UASSERT(iterations > 0); ParametersMap parameters; parameters.insert(ParametersPair(Parameters::kOptimizerStrategy(), uNumber2Str(strategy))); parameters.insert(ParametersPair(Parameters::kOptimizerEpsilon(), uNumber2Str(epsilon))); parameters.insert(ParametersPair(Parameters::kOptimizerIterations(), uNumber2Str(iterations))); parameters.insert(ParametersPair(Parameters::kOptimizerRobust(), uBool2Str(robust))); parameters.insert(ParametersPair(Parameters::kOptimizerSlam2D(), uBool2Str(slam2d))); parameters.insert(ParametersPair(Parameters::kOptimizerVarianceIgnored(), uBool2Str(ignoreVariance))); optimizer_ = Optimizer::create(parameters); double tfDelay = 0.05; // 20 Hz bool publishTf = true; pnh.param("publish_tf", publishTf, publishTf); pnh.param("tf_delay", tfDelay, tfDelay); mapDataTopic_ = nh.subscribe("mapData", 1, &MapOptimizer::mapDataReceivedCallback, this); mapDataPub_ = nh.advertise<rtabmap_ros::MapData>(nh.resolveName("mapData")+"_optimized", 1); mapGraphPub_ = nh.advertise<rtabmap_ros::MapGraph>(nh.resolveName("mapData")+"Graph_optimized", 1); if(publishTf) { ROS_INFO("map_optimizer will publish tf between frames \"%s\" and \"%s\"", mapFrameId_.c_str(), odomFrameId_.c_str()); ROS_INFO("map_optimizer: map_frame_id = %s", mapFrameId_.c_str()); ROS_INFO("map_optimizer: odom_frame_id = %s", odomFrameId_.c_str()); ROS_INFO("map_optimizer: tf_delay = %f", tfDelay); transformThread_ = new boost::thread(boost::bind(&MapOptimizer::publishLoop, this, tfDelay)); } }
ParametersMap MapRequest::_getParametersMap() const { ParametersMap map; map.insert(OUTPUT_PARAMETER, _output); map.insert(DATA_PARAMETER, _data); map.insert(MAP_PARAMETER, _query); map.insert(PARAMETER_USE_ENVIRONMENT, _useEnvironment); return map; }
ParametersMap AlarmAddLinkAction::getParametersMap() const { ParametersMap map; map.insert(PARAMETER_ALARM_ID, _alarm.get() ? _alarm->getKey() : RegistryKeyType(0)); map.insert(PARAMETER_RECIPIENT_KEY, _recipientKey); map.insert(PARAMETER_OBJECT_ID, _objectId); map.insert(PARAMETER_PARAMETER, _parameter); return map; }
ParametersMap DBLogPurgeAction::getParametersMap() const { ParametersMap map; if(_dbLog.get()) { map.insert(PARAMETER_LOG_KEY, _dbLog->getFactoryKey()); } map.insert(PARAMETER_END_DATE, _endDate); return map; }
ParametersMap HikingTrailStopRemoveAction::getParametersMap() const { ParametersMap map; if(_trail.get()) { map.insert(PARAMETER_TRAIL_ID, _trail->getKey()); map.insert(PARAMETER_RANK, _rank); } return map; }
ParametersMap TimetableRowGroupItemAddAction::getParametersMap() const { ParametersMap map; map.insert(PARAMETER_RANK, _rank); if(_rowGroup.get()) { map.insert(PARAMETER_ROWGROUP_ID, _rowGroup->getKey()); } return map; }
ParametersMap DisplayScreenRemovePhysicalStopAction::getParametersMap() const { ParametersMap map; if (_stop.get()) { map.insert(PARAMETER_PHYSICAL, _stop->getKey()); } if(_screen.get()) map.insert(PARAMETER_SCREEN_ID, _screen->getKey()); return map; }
ParametersMap SubStrFunction::_getParametersMap() const { ParametersMap map; map.insert(PARAMETER_TEXT, _text); map.insert(PARAMETER_FIRST, _first); if(_size) { map.insert(PARAMETER_LENGTH, *_size); } return map; }
ParametersMap TimetableSetPhysicalStopAction::getParametersMap() const { ParametersMap map; if(_timetable.get()) { map.insert(PARAMETER_TIMETABLE_ID, _timetable->getKey()); } if(_physicalStop.get()) { map.insert(PARAMETER_PHYSICAL_STOP_ID, _physicalStop->getKey()); } return map; }
ParametersMap DisplayScreenAddDisplayedPlaceAction::getParametersMap() const { ParametersMap map; if(_screen.get()) { map.insert(PARAMETER_SCREEN_ID, _screen->getKey()); } if(_place.get()) { map.insert(PARAMETER_PLACE, _place->getKey()); } return map; }
ParametersMap ServiceInformationsFunction::_getParametersMap() const { ParametersMap map; if(_service.get()) { map.insert(Request::PARAMETER_OBJECT_ID, _service->getKey()); } if(_stopPage.get()) { map.insert(PARAMETER_STOP_PAGE_ID, _stopPage->getKey()); } return map; }
ParametersMap DisplayScreenTransferDestinationAddAction::getParametersMap() const { ParametersMap map; if(_screen.get()) map.insert(PARAMETER_DISPLAY_SCREEN_ID, _screen->getKey()); if(_transferPlace.get()) map.insert(PARAMETER_TRANSFER_PLACE_ID, _transferPlace->getKey()); if(_destinationPlace && _destinationPlace->getCity()) { map.insert(PARAMETER_DESTINATION_PLACE_CITY_NAME, _destinationPlace->getCity()->getName()); map.insert(PARAMETER_DESTINATION_PLACE_NAME, _destinationPlace->getName()); } return map; }
ParametersMap HikingTrailStopAddAction::getParametersMap() const { ParametersMap map; if(_trail.get()) { map.insert(PARAMETER_TRAIL_ID, _trail->getKey()); if(_stop.get()) { map.insert(PARAMETER_CITY, _stop->getCity()->getName()); map.insert(PARAMETER_NAME, _stop->getName()); } map.insert(PARAMETER_RANK, _rank.value_or(0)); } return map; }
void DataRecorder::addData(const rtabmap::SensorData & data, const Transform & pose, const cv::Mat & covariance) { memoryMutex_.lock(); if(memory_) { if(memory_->getStMem().size() == 0 && data.id() > 0) { ParametersMap customParameters; customParameters.insert(ParametersPair(Parameters::kMemGenerateIds(), "false")); // use id from data memory_->parseParameters(customParameters); } //save to database UTimer time; memory_->update(data, pose, covariance); const Signature * s = memory_->getLastWorkingSignature(); totalSizeKB_ += (int)s->sensorData().imageCompressed().total()/1000; totalSizeKB_ += (int)s->sensorData().depthOrRightCompressed().total()/1000; totalSizeKB_ += (int)s->sensorData().laserScanCompressed().total()/1000; memory_->cleanup(); if(++count_ % 30) { memory_->emptyTrash(); } UDEBUG("Time to process a message = %f s", time.ticks()); } memoryMutex_.unlock(); }
ParametersMap TablesViewService::run( std::ostream& stream, const Request& request ) const { ParametersMap map; BOOST_FOREACH( const DBModule::TablesByIdMap::value_type& it, DBModule::GetTablesById() ) { boost::shared_ptr<ParametersMap> tablePM(new ParametersMap); tablePM->insert(ATTR_ID, static_cast<int>(it.first)); tablePM->insert(ATTR_NAME, it.second->getFormat().NAME); BOOST_FOREACH(const FieldsList::value_type& f, it.second->getFieldsList()) { boost::shared_ptr<ParametersMap> fieldPM(new ParametersMap); fieldPM->insert(ATTR_NAME, f.name); fieldPM->insert(ATTR_EXPORT_ON_FILE, f.exportOnFile); fieldPM->insert(ATTR_TYPE, f.type); tablePM->insert(TAG_FIELD, fieldPM); } map.insert(TAG_TABLE, tablePM); }
util::ParametersMap WebPageMenuFunction::run( std::ostream& stream, const Request& request ) const { // Root page const Webpage* currentPage(CMSModule::GetWebPage(request)); const Webpage* rootPage(_rootId ? _root : currentPage); // RSS header if(!_itemPage.get() && _outputFormat == VALUE_RSS) { StaticFunctionRequest<WebPageDisplayFunction> openRequest(request, false); openRequest.getFunction()->setPage(rootPage); stream << "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" << "<rss version=\"2.0\" xmlns:atom=\"http://www.w3.org/2005/Atom\">" << "<channel>" << "<title>" << rootPage->getName() << "</title>" << "<description><![CDATA[" << rootPage->get<Abstract>() << "]]></description>" << "<link>" << HTMLModule::HTMLEncode(openRequest.getURL(true, true)) << "</link>" << "<generator>SYNTHESE " << ServerModule::VERSION << "</generator>" ; if(!rootPage->get<ImageURL>().empty()) { stream << "<image><url>" << rootPage->get<ImageURL>() << "</url><title>" << rootPage->get<Title>() << "</title><link>" << HTMLModule::HTMLEncode(openRequest.getURL(true, true)) << "</link></image>" ; } stream << "<atom:link href=\"" << HTMLModule::HTMLEncode(openRequest.getURL(true, true)) << "\" rel=\"self\" type=\"application/rss+xml\" />"; } // Content ParametersMap pm; if(_rootSite) { BOOST_FOREACH(const Website::ChildrenType::value_type& it, _rootSite->getChildren()) { shared_ptr<ParametersMap> pagePM(new ParametersMap); _getMenuContentRecursive( stream, request, it.second, 0, currentPage, 0, true, *pagePM ); if(!pagePM->getMap().empty()) { pm.insert(TAG_PAGE, pagePM); } } } else {
ParametersMap RequestWithInterface::_getParametersMap() const { ParametersMap map; if (_interface.get()) map.insert(PARAMETER_INTERFACE, _interface->getKey()); return map; }
ParametersMap SYNTHESEInformationService::run( std::ostream& stream, const Request& request ) const { ParametersMap map; map.insert(ATTR_START_TIME, ServerModule::GetStartingTime()); return map; }
void InterSYNTHESEModule::_generateFakeImport() { if(!_slaveActive) { if(Env::GetOfficialEnv().getRegistry<Import>().contains(FAKE_IMPORT_ID)) { boost::shared_ptr<Import> import( Env::GetOfficialEnv().getRegistry<Import>().getEditable(FAKE_IMPORT_ID) ); import->unlink(); Env::GetOfficialEnv().getEditableRegistry<Import>().remove(FAKE_IMPORT_ID); } } else { boost::shared_ptr<Import> import; bool created(false); if(Env::GetOfficialEnv().getRegistry<Import>().contains(FAKE_IMPORT_ID)) { import = Env::GetOfficialEnv().getRegistry<Import>().getEditable(FAKE_IMPORT_ID); } else { import.reset(new Import(FAKE_IMPORT_ID)); import->set<Name>("Auto generated Inter-SYNTHESE import"); import->set<FileFormatKey>(InterSYNTHESEFileFormat::FACTORY_KEY); import->set<Active>(true); created = true; } // Import parameters ParametersMap pm; pm.insert(ConnectionImporter<InterSYNTHESEFileFormat>::PARAMETER_ADDRESS, _masterHost); pm.insert(ConnectionImporter<InterSYNTHESEFileFormat>::PARAMETER_PORT, _masterPort); pm.insert(InterSYNTHESEFileFormat::Importer_::PARAMETER_SLAVE_ID, _slaveId); import->set<synthese::Parameters>(pm); import->set<AutoImportDelay>(_syncWaitingTime); import->link(Env::GetOfficialEnv(), true); if(created) { Env::GetOfficialEnv().getEditableRegistry<Import>().add(import); } } }
ParametersMap DriverActivityAdmin::getParametersMap() const { ParametersMap m; if(_activity.get()) { m.insert(Request::PARAMETER_OBJECT_ID, _activity->get<Key>()); } return m; }
ParametersMap GenerateContinuousServiceAction::getParametersMap() const { ParametersMap map; if(_line.get()) { map.insert(PARAMETER_LINE, _line->getKey()); } return map; }
ParametersMap CalendarTemplateCleanAction::getParametersMap() const { ParametersMap map; if(_calendar.get()) { map.insert(PARAMETER_CALENDAR_ID, _calendar->getKey()); } return map; }
ParametersMap ServiceTimetableUpdateAction::getParametersMap() const { ParametersMap map; if(_service.get()) { map.insert(PARAMETER_SERVICE_ID, _service->getKey()); map.insert(PARAMETER_RANK, _rank); map.insert(PARAMETER_UPDATE_ARRIVAL, _updateArrival); if(!_shifting_delay.is_not_a_date_time()) { map.insert(PARAMETER_SHIFTING_DELAY, _shifting_delay.total_seconds() / 60); } else if(!_time.is_not_a_date_time()) { map.insert(PARAMETER_TIME, _time); } } return map; }
void Camera::setFeaturesExtracted(bool featuresExtracted, KeypointDetector::DetectorType detector, KeypointDescriptor::DescriptorType descriptor) { _featuresExtracted = featuresExtracted; if(detector != KeypointDetector::kDetectorUndef || descriptor != KeypointDescriptor::kDescriptorUndef) { ParametersMap pm; pm.insert(ParametersPair(Parameters::kKpDetectorStrategy(), uNumber2Str((int)detector))); this->parseParameters(pm); } }