ProjSector.h

Go to the documentation of this file.

/*
* Copyright 2017 Autodesk, Inc. All rights reserved.
* Use of this software is subject to the terms of the Autodesk license agreement and any attachments or Appendices thereto provided at the time of installation or download,
* or which otherwise accompanies this software in either electronic or hard copy form, or which is signed by you and accepted by Autodesk.
*/

#pragma once

#include "navgenproj/ProjGeometry.h"
#include "navgenproj/ProjClientInput.h"
#include "navgenproj/ProjSeedPoint.h"
#include "navgenproj/ProjTagVolume.h"
#include "navgenproj/ProjTypes.h"
#include "gwnavruntime/base/kyguid.h"
#include <memory>
#include <string>

namespace Kaim
{

class ProjSector
{
    KY_CLASS_WITHOUT_COPY(ProjSector)
public:
    ProjSector(ProjConfig& config)
      : m_projConfig(config)
      , m_guid(KyGuid::GetInvalidGuid())
      , m_doBuild(true)
      , m_doSaveClientInput(true)
      , m_doGenerateColData(false)
      , m_mirroredPos(KyInt32MAXVAL, KyInt32MAXVAL)
    {
    }

    void SetName(const char* name)                    { m_name.assign(name); }
    void SetGuid(const Kaim::KyGuid& guid)            { m_guid = guid; }
    void SetDoBuild(bool doBuild)                     { m_doBuild = doBuild; }
    void SetDoSaveClientInput(bool doSaveClientInput) { m_doSaveClientInput = doSaveClientInput; }
    void SetDoGenerateColData(bool doGenerateColData) { m_doGenerateColData = doGenerateColData; }
    void SetCellBox(const Kaim::CellBox& cellBox)     { m_cellBox = cellBox; }

    void AddObjFilePath(const char* fileName)
    {
        ProjGeometry geometry;
        geometry.SetFileName(fileName);
        m_geometries.push_back(geometry);
    }

    void AddClientInputFilePath(const char* fileName)
    {
        m_clientInputs.push_back(ProjClientInput(fileName));
    }

    void AddSeedPoint(float x, float y, float z)
    {
        ProjSeedPoint seedPoint;
        seedPoint.m_pos = Kaim::Vec3f(x, y, z);
        m_seedPoints.push_back(seedPoint);
    }

    KyResult AddTagVolume(const Vec3f* polylinePoints, int pointArraySize, const Kaim::DynamicNavTag& navTag, float minAltitude, float maxAltitude)
    {
        std::unique_ptr<ProjTagVolume> projTagVolume(new ProjTagVolume(&m_projConfig.m_coordSystem));
        if (projTagVolume->m_tagVolume.InitInClientCoordinates(polylinePoints, pointArraySize, minAltitude, maxAltitude, navTag, m_projConfig.m_coordSystem) == KY_ERROR)
            return KY_ERROR;

        m_tagVolumes.push_back(std::move(projTagVolume));
        return KY_SUCCESS;
    }

    int         GetGeometryFileCount() const { return (int)m_geometries.size(); }
    std::string GetGeometryFileName(int index) { return m_geometries[index].m_fileName; }

    int         GetClientInputFileCount() const { return (int)m_clientInputs.size(); }
    std::string GetClientInputFileName(int index) { return m_clientInputs[index].m_fileName; }

    void Write(XmlNode node) const
    {
        node.WriteChild("name", m_name);
        node.WriteChild("guid", m_guid);

        node.WriteChild("doBuild", m_doBuild);
        node.WriteChild("doSaveClientInput", m_doSaveClientInput);
        node.WriteChild("doGenerateColData", m_doGenerateColData);

        if (m_cellBox.IsValid())
            node.WriteChild("cellBox", m_cellBox);

        node.WriteChild("produceInputMask", m_produceInputMask);

        // Write geometries
        if (m_geometries.size() > 0)
        {
            XmlNode n = node.CreateChild("geometries");
            for (const auto& e : m_geometries)
                n.WriteChild("geometry", e);
        }

        // Write clientInputs
        if (m_clientInputs.size() > 0)
        {
            XmlNode n = node.CreateChild("clientInputs");
            for (const auto& e : m_clientInputs)
                n.WriteChild("clientInput", e);
        }

        // Write seedPoints
        if (m_seedPoints.size() > 0)
        {
            XmlNode n = node.CreateChild("seedPoints");
            for (const auto& e : m_seedPoints)
                n.WriteChild("seedPoint", e);
        }

        // Write tagVolumes
        if (m_tagVolumes.size() > 0)
        {
            XmlNode tagVolumesNode = node.CreateChild("tagVolumes");
            for (const auto& e : m_tagVolumes)
                Kaim::Write(tagVolumesNode.CreateChild("tagVolume"), *e);
        }
    }

    bool Read(XmlNode node)
    {
        for (XmlNode child = node.FirstChild(); child; child = child.NextSibling())
        {
            if (child.IsElement() == false)
                continue;

            KY_READ_CHILD_VALUE(child, "name", m_name);
            KY_READ_CHILD_VALUE(child, "guid", m_guid);

            KY_READ_CHILD_VALUE(child, "doBuild", m_doBuild);
            KY_READ_CHILD_VALUE(child, "doSaveClientInput", m_doSaveClientInput);
            KY_READ_CHILD_VALUE(child, "doGenerateColData", m_doGenerateColData);

            KY_READ_CHILD_VALUE(child, "cellBox", m_cellBox);

            KY_READ_CHILD_VALUE(child, "produceInputMask", m_produceInputMask);

            KY_READ_CHILD_FUNC(child, "geometries", ReadGeometries(child));
            KY_READ_CHILD_FUNC(child, "clientInputs", ReadClientInputs(child));

            KY_READ_CHILD_FUNC(child, "seedpoints", ReadSeedPoints(child));
            KY_READ_CHILD_FUNC(child, "tagVolumes", ReadTagVolumes(child));

            KY_LOG_WARNING(("[NavGenProj] unknown child <%s> in node <%s>", child.GetName(), node.GetName()));
        }
        return true;
    }


public: // internal

    bool ReadGeometries(XmlNode node)
    {
        for (XmlNode child = node.FirstChild(); child; child = child.NextSibling())
        {
            if (child.HasName("geometry") == false)
                return false;

            ProjGeometry geometry;
            if (child.ReadNode(geometry) == false)
                return false;

            m_geometries.push_back(geometry);
        }
        return true;
    }

    bool ReadClientInputs(XmlNode node)
    {
        for (XmlNode child = node.FirstChild(); child; child = child.NextSibling())
        {
            if (child.HasName("clientInput") == false)
                return false;

            ProjClientInput projClientInput;
            if (child.ReadNode(projClientInput) == false)
                return false;

            m_clientInputs.push_back(projClientInput);
        }
        return true;
    }

    bool ReadSeedPoints(XmlNode node)
    {
        for (XmlNode child = node.FirstChild(); child; child = child.NextSibling())
        {
            if (child.HasName("seedpoint") == false)
                return false;

            ProjSeedPoint projSeedPoint;
            if (Kaim::Read(child, projSeedPoint) == false)
                return false;

            m_seedPoints.push_back(projSeedPoint);
        }
        return true;
    }

    bool ReadTagVolumes(XmlNode node)
    {
        for (XmlNode child = node.FirstChild(); child; child = child.NextSibling())
        {
            if (child.HasName("tagVolume") == false)
                return false;

            std::unique_ptr<ProjTagVolume> projTagVolume(new ProjTagVolume(&m_projConfig.m_coordSystem));
            if (child.ReadNode(*projTagVolume) == false)
                return false;

            m_tagVolumes.push_back(std::move(projTagVolume));
        }
        return true;
    }

public:
    ProjConfig& m_projConfig;
    std::string m_name;
    Kaim::KyGuid m_guid;
    bool m_doBuild;
    bool m_doSaveClientInput;
    bool m_doGenerateColData;
    ProjProduceInputMask m_produceInputMask;
    std::vector<ProjGeometry> m_geometries;
    std::vector<ProjClientInput> m_clientInputs;
    std::vector<ProjSeedPoint> m_seedPoints;
    std::vector<std::unique_ptr<ProjTagVolume>> m_tagVolumes;
    Kaim::CellBox m_cellBox;
    Vec2i m_mirroredPos;
};

inline bool Read(XmlNode node, ProjSector& value) { return value.Read(node); }
inline void Write(XmlNode node, const ProjSector& value) { value.Write(node); }


}