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;
		}
Example #2
0
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;
	}
}
Example #3
0
		ParametersMap UpdateProfileAction::getParametersMap() const
		{
			ParametersMap map;
			if(_profile.get()) map.insert(PARAMETER_PROFILE_ID, _profile->getKey());
			map.insert(PARAMETER_NAME, _name);
			return map;
		}
Example #4
0
		ParametersMap OrService::_getParametersMap() const
		{
			ParametersMap map;
			map.insert(PARAMETER_LEFT, _left);
			map.insert(PARAMETER_RIGHT, _right);
			return map;
		}
Example #5
0
		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));
		}
	}
Example #8
0
		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;
		}
Example #9
0
		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;
		}
Example #10
0
		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;
		}
Example #14
0
		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;
		}
Example #20
0
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();
}
Example #21
0
		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);
			}
Example #22
0
		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
			{
Example #23
0
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;
		}
Example #25
0
		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);
				}
			}
		}
Example #26
0
		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);
	}
}