constants.h

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    VisionX::ArmarXObjects::armem_images
 * @author     Rainer Kartmann ( rainer dot kartmann at kit dot edu )
 * @date       2021
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
 
#pragma once
 
// STD/STL
#include <map>
#include <string>
 
// Simox
#include <SimoxUtility/algorithm/string.h>
 
// RobotAPI
#include <RobotAPI/libraries/aron/core/data/variant/forward_declarations.h>
 
// PCL
#include <pcl/point_types.h>
 
// VisionX
#include <VisionX/interface/core/DataTypes.h>
 
// Aron
#include <VisionX/libraries/armem/vision/pointcloud/core/aron/PointCloudXYZ.aron.generated.h>
#include <VisionX/libraries/armem/vision/pointcloud/core/aron/PointCloudXYZL.aron.generated.h>
#include <VisionX/libraries/armem/vision/pointcloud/core/aron/PointCloudXYZRGBA.aron.generated.h>
#include <VisionX/libraries/armem/vision/pointcloud/core/aron/PointCloudXYZRGBL.aron.generated.h>
 
namespace visionx::armem::pointcloud
{
    namespace util
    {
        template <class T1, class T2>
        std::map<T2, T1>
        InvertMap(const std::map<T1, T2>& m)
        {
            std::map<T2, T1> ret;
            for (const auto& [key, val] : m)
            {
                ret.emplace(val, key);
            }
            return ret;
        }
 
        template <class T>
        std::map<T, std::string>
        InvertMap(const std::map<std::string, T>& m)
        {
            return InvertMap<std::string, T>(m);
        }
 
        template <class T>
        std::map<std::string, T>
        InvertMap(const std::map<T, std::string>& m)
        {
            return InvertMap<T, std::string>(m);
        }
    } // namespace util
 
    enum class PointType
    {
        PointXYZ,
        PointXYZL,
        PointXYZRGBA,
        PointXYZRGBL
    };
 
    const constexpr char* POINT_XYZ_SLUG = "PointXYZ";
    const constexpr char* POINT_XYZL_SLUG = "PointXYZL";
    const constexpr char* POINT_XYZRGBA_SLUG = "PointXYZRGBA";
    const constexpr char* POINT_XYZRGBL_SLUG = "PointXYZRGBL";
 
    std::map<PointType, std::string> PointType2String = {
        {PointType::PointXYZ, simox::alg::to_lower(std::string(POINT_XYZ_SLUG))},
        {PointType::PointXYZL, simox::alg::to_lower(std::string(POINT_XYZL_SLUG))},
        {PointType::PointXYZRGBA, simox::alg::to_lower(std::string(POINT_XYZRGBA_SLUG))},
        {PointType::PointXYZRGBL, simox::alg::to_lower(std::string(POINT_XYZRGBL_SLUG))}};
 
    std::map<std::string, PointType> String2PointType = util::InvertMap(PointType2String);
 
 
} // namespace visionx::armem::pointcloud