Info.cpp

Go to the documentation of this file.

#include "Info.h"
 
#include <opencv2/core/core.hpp>
#include <opencv2/imgcodecs.hpp>
#include <opencv2/imgproc/imgproc.hpp>
 
#include <SimoxUtility/algorithm/string.h>
#include <SimoxUtility/filesystem/list_directory.h>
#include <SimoxUtility/json.h>
#include <SimoxUtility/shapes/AxisAlignedBoundingBox.h>
#include <SimoxUtility/shapes/OrientedBox.h>
 
#include <ArmarXCore/core/exceptions/local/ExpressionException.h>
#include <ArmarXCore/core/logging/Logging.h>
 
#include <RobotAPI/libraries/aron/common/aron_conversions.h>
 
#include <VisionX/libraries/armem_human/aron/Person.aron.generated.h>
#include <VisionX/libraries/armem_human/json_conversions.h>
 
namespace armarx::armem::human
{
    namespace fs = std::filesystem;
 
    Info::Info(const std::string& packageName,
               const path& absPackageDataDir,
               const path& relativePath,
               const std::string& id) :
        _packageName(packageName),
        _absPackageDataDir(absPackageDataDir),
        _relativePath(relativePath),
        _id(id)
    {
    }
 
    void
    Info::setLogError(bool enabled)
    {
        this->_logError = enabled;
    }
 
    std::string
    Info::package() const
    {
        return _packageName;
    }
 
    std::string
    Info::id() const
    {
        return _id;
    }
 
    Info::path
    Info::_relativeProfileDirectory() const
    {
        return _relativePath / _id;
    }
 
    PackagePath
    Info::file(const std::string& _extension, const std::string& suffix) const
    {
        std::string extension = _extension;
        if (extension.at(0) != '.')
        {
            extension = "." + extension;
        }
        std::string filename = /*_id + */ suffix + extension;
 
        PackagePath path(_packageName, _relativeProfileDirectory() / filename);
        return path;
    }
 
    PackagePath
    Info::sub_directory(const std::string& suffix) const
    {
        std::string name = /*_id +*/ suffix;
        return PackagePath(_packageName, _relativeProfileDirectory() / name);
    }
 
    PackagePath
    Info::profileJson() const
    {
        return file(".json", "profile");
    }
 
    PackagePath
    Info::faceImageDir() const
    {
        // return sub_directory("_faces-images");
        return sub_directory("faces-images");
    }
 
    std::vector<PackagePath>
    Info::faceImages(const std::vector<std::string>& extensions) const
    {
        const PackagePath directory = faceImageDir();
 
        if (not fs::is_directory(directory.toSystemPath()))
        {
            ARMARX_VERBOSE << "Face image directory does not exist: " << directory.toSystemPath();
            return {};
        }
 
        std::vector<PackagePath> imageFiles;
        bool local = false;
        for (const fs::path& path : simox::fs::list_directory(directory.toSystemPath(), local))
        {
            for (const std::string& ext : extensions)
            {
                if (fs::is_regular_file(path) and simox::alg::ends_with(path.string(), ext))
                {
                    PackagePath imageFile(_packageName,
                                          _relativeProfileDirectory() / "faces-images" /
                                              path.filename());
                    imageFiles.push_back(imageFile);
                }
            }
        }
        return imageFiles;
    }
 
    std::optional<Info::Person>
    Info::loadProfile(const bool loadFaceImages) const
    {
        nlohmann::json j;
        try
        {
            ARMARX_INFO << "Loading profile: " << QUOTED(profileJson().toSystemPath());
            j = nlohmann::read_json(profileJson().toSystemPath());
        }
        catch (const std::exception& e)
        {
            if (_logError)
            {
                ARMARX_ERROR << e.what();
            }
            return std::nullopt;
        }
 
        Person profile = j.get<Person>();
        if (loadFaceImages)
        {
            for (const PackagePath& imagePath : this->faceImages())
            {
                cv::Mat image =
                    cv::imread(imagePath.toSystemPath().string(), cv::ImreadModes::IMREAD_COLOR);
                cv::cvtColor(image, image, cv::ColorConversionCodes::COLOR_BGR2RGB);
 
                armarx::arondto::PackagePath packagePath;
                toAron(packagePath, imagePath);
 
                armarx::human::arondto::FaceImage faceImage;
                faceImage.filepath = packagePath;
                faceImage.image = image;
                toAron(profile.faceImages.emplace_back(), faceImage);
            }
        }
        return profile;
    }
 
    bool
    Info::checkPaths() const
    {
        namespace fs = std::filesystem;
        bool result = true;
 
        if (!fs::is_regular_file(profileJson().toSystemPath()))
        {
            if (_logError)
            {
                ARMARX_WARNING << "Expected simox object file for object " << *this << ": "
                               << profileJson().toSystemPath();
            }
            result = false;
        }
 
        return result;
    }
 
} // namespace armarx::armem::human
 
std::ostream&
armarx::armem::human::operator<<(std::ostream& os, const Info& rhs)
{
    return os << rhs.id();
}