Map2DLocation.h

Go to the documentation of this file.

/*
 * Copyright (C) 2006-2020 Istituto Italiano di Tecnologia (IIT)
 * All rights reserved.
 *
 * This software may be modified and distributed under the terms of the
 * BSD-3-Clause license. See the accompanying LICENSE file for details.
 */
 
#ifndef YARP_DEV_MAP2DLOCATION_H
#define YARP_DEV_MAP2DLOCATION_H
 
#include <sstream>
#include <string>
 
//#include <yarp/math/Vec2D.h>
#include <yarp/dev/api.h>
#include <yarp/dev/NavTypes.h>
#include <yarp/dev/Map2DLocationData.h>
 
namespace yarp
{
    namespace dev
    {
        namespace Nav2D
        {
            struct YARP_dev_API Map2DLocation : public Map2DLocationData
            {
                Map2DLocation(const std::string& map_name, const double& inX, const double& inY, const double& inT)
                {
                    map_id = map_name;
                    x = inX;
                    y = inY;
                    theta = inT;
                }
 
                Map2DLocation(const std::string& map_name, yarp::dev::Nav2D::XYWorld location)
                {
                    map_id = map_name;
                    x = location.x;
                    y = location.y;
                    theta = 0;
                }
 
                Map2DLocation()
                {
                    map_id = "";
                    x = 0;
                    y = 0;
                    theta = 0;
                }
 
                std::string toString() const
                {
                    std::ostringstream stringStream;
                    stringStream.precision(-1);
                    stringStream.width(-1);
                    stringStream << std::string("map_id:") << map_id << std::string(" x:") << x << std::string(" y:") << y << std::string(" theta:") << theta;
                    return stringStream.str();
                }
 
                inline bool operator!=(const Map2DLocation& r) const
                {
                    if (
                        map_id != r.map_id ||
                        x != r.x ||
                        y != r.y ||
                        theta != r.theta
                        )
                    {
                        return true;
                    }
                    return false;
                }
 
                inline bool operator==(const Map2DLocation& r) const
                {
                    if (
                        map_id == r.map_id &&
                        x == r.x      &&
                        y == r.y      &&
                        theta == r.theta
                        )
                    {
                        return true;
                    }
                    return false;
                }
 
                bool is_near_to(const Map2DLocation& other_loc, double linear_tolerance, double angular_tolerance) const;
 
                bool read(yarp::os::idl::WireReader& reader) override { return Map2DLocationData::read(reader); }
                bool write(const yarp::os::idl::WireWriter& writer) const override { return Map2DLocationData::write(writer); }
                bool read(yarp::os::ConnectionReader& reader) override { return Map2DLocationData::read(reader); }
                bool write(yarp::os::ConnectionWriter& writer) const override { return Map2DLocationData::write(writer); }
            };
        }
    }
}
 
#endif // YARP_DEV_MAP2DLOCATION_H