NavGenProjSector.h

Go to the documentation of this file.

/*
* Copyright 2015 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.
*/


// primary contact: MAMU - secondary contact: NOBODY
#ifndef GwNavGen_NavGenProjSector_H
#define GwNavGen_NavGenProjSector_H

#include "tinyxml.h"
#include <string>
#include "NavGenProj.h"
#include "gwnavruntime/base/kyguid.h"
#include "NavGenProjGeometry.h"
#include "NavGenProjClientInput.h"
#include "NavGenProjTagVolume.h"

namespace Kaim
{


class NavGenProjSector
{
public:
    NavGenProjSector(NavGenProjConfig& config)
        : m_doBuild(true)
        , m_doSaveClientInput(true)
        , m_doGenerateColData(false)
        , m_navGenProjConfig(config)
        , m_mirroredPos(KyInt32MAXVAL, KyInt32MAXVAL)
        , m_guid(KyGuid::GetInvalidGuid())
    {}

    ~NavGenProjSector()
    {
        for (unsigned int i = 0; i < m_geometries.size(); ++i)
            delete m_geometries[i];
        m_geometries.clear();

        for (unsigned int i = 0; i < m_clientInputs.size(); ++i)
            delete m_clientInputs[i];
        m_clientInputs.clear();

        for (unsigned int i = 0; i < m_tagVolumes.size(); ++i)
            delete m_tagVolumes[i];
        m_tagVolumes.clear();
    }

    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; }

    NavGenProjGeometry* AddObjFilePath(const char* fileName)
    {
        NavGenProjGeometry* geometry = new NavGenProjGeometry();
        geometry->SetFileName(fileName);
        m_geometries.push_back(geometry);
        return geometry;
    }

    NavGenProjClientInput* AddClientInputFilePath(const char* fileName)
    {
        NavGenProjClientInput* input = new NavGenProjClientInput();
        input->SetFileName(fileName);
        m_clientInputs.push_back(input);
        return input;
    }

    void AddSeedPoint(float x, float y, float z)
    {
        NavGenProjSeedPoint seedPoint;
        seedPoint.m_seedPoint = 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)
    {
        NavGenProjTagVolume* navGenTagVolume = new NavGenProjTagVolume(&m_navGenProjConfig.m_coordSystem);
        if (navGenTagVolume->m_tagVolume.InitInClientCoordinates(
            polylinePoints, pointArraySize, minAltitude, maxAltitude, 
            navTag, m_navGenProjConfig.m_coordSystem) == KY_ERROR)
        {
            delete navGenTagVolume;
            return KY_ERROR;
        }

        m_tagVolumes.push_back(navGenTagVolume);
        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; }

    bool Write(TiXmlNode* folderNode)
    {
        TiXmlElement* sectorNode = new TiXmlElement("sector");
        folderNode->LinkEndChild(sectorNode);
        return WriteContent(sectorNode);
    }


    bool Read(TiXmlNode* node)
    {
        for (TiXmlNode* child = node->FirstChild(); child != 0; child = child->NextSibling())
        {
            NavGenProj::GetParam(child, "name", m_name);

            std::string guidAsString;
            if (NavGenProj::GetParam(child, "guid", guidAsString) == true)
                m_guid.InitFromString(guidAsString.c_str());

            NavGenProj::GetParam(child, "doBuild", m_doBuild);
            NavGenProj::GetParam(child, "doSaveClientInput", m_doSaveClientInput);
            NavGenProj::GetParam(child, "doGenerateColData", m_doGenerateColData);
            
            if (strcmp(child->Value(), "geometries") == 0)
            {
                ReadGeometries(child);
            }

            if (strcmp(child->Value(), "clientInputs") == 0)
            {
                ReadClientInputs(child);
            }

            if (strcmp(child->Value(), "cellBox") == 0)
            {
                ReadCellBox(child);
            }

            if (strcmp(child->Value(), "seedpoints") == 0)
            {
                ReadSeedPoints(child);
            }

            if (strcmp(child->Value(), "tagVolumes") == 0)
            {
                ReadTagVolumes(child);
            }
        }
        return true;
    }


public: // internal
    
    bool ReadGeometry(TiXmlNode* node)
    {
        NavGenProjGeometry* geometry = new NavGenProjGeometry();
        if (geometry->Read(node))
        {
            m_geometries.push_back(geometry);
            return true;
        }
        else
        {
            delete geometry;
            return false;
        }
    }

    void ReadGeometries(TiXmlNode* node)
    {
        for (TiXmlNode* child = node->FirstChild(); child != 0; child = child->NextSibling())
        {
            if (strcmp(child->Value(), "geometry") == 0)
            {
                ReadGeometry(child);
            }
        }
    }

    bool ReadClientInput(TiXmlNode* node)
    {
        NavGenProjClientInput* input = new NavGenProjClientInput();
        if (input->Read(node))
        {
            m_clientInputs.push_back(input);
            return true;
        }
        else
        {
            delete input;
            return false;
        }
    }

    void ReadClientInputs(TiXmlNode* node)
    {
        TiXmlNode* child;
        for (child = node->FirstChild(); child != 0; child = child->NextSibling())
        {
            if (strcmp(child->Value(), "clientInput") == 0)
            {
                ReadClientInput(child);
            }
        }
    }

    void ReadCellBox(TiXmlNode* node)
    {
        m_cellBox.Clear();
        Kaim::CellPos min, max;
        bool foundMin = false;
        bool foundMax = false;
        for (TiXmlNode* child = node->FirstChild(); child != 0; child = child->NextSibling())
        {
            foundMin |= NavGenProj::GetParam(child, "min", min);
            foundMax |= NavGenProj::GetParam(child, "max", max);
        }
        if (foundMax && foundMin)
            m_cellBox.SetSafe(min, max);
    }

    void ReadSeedPoints(TiXmlNode* seedpointsNode)
    {
        for (TiXmlNode* pChild = seedpointsNode->FirstChild(); pChild != 0; pChild = pChild->NextSibling())
        {
            if (pChild->Type() != TiXmlNode::ELEMENT)
                continue;

            if (strcmp(pChild->Value(), "seedpoint") == 0)
            {
                NavGenProjSeedPoint seedPoint;
                if (seedPoint.Read(pChild))
                    m_seedPoints.push_back(seedPoint);
            }
        }
    }

    void ReadTagVolumes(TiXmlNode* tagVolumesNode)
    {
        for (TiXmlNode* pChild = tagVolumesNode->FirstChild(); pChild != 0; pChild = pChild->NextSibling())
        {
            if (pChild->Type() != TiXmlNode::ELEMENT)
                continue;

            if (strcmp(pChild->Value(), "tagVolume") == 0)
            {
                NavGenProjTagVolume* navGenProjTagVolume = new NavGenProjTagVolume(&m_navGenProjConfig.m_coordSystem);
                if (navGenProjTagVolume->Read(pChild))
                    m_tagVolumes.push_back(navGenProjTagVolume);
                else
                    delete navGenProjTagVolume;
            }
        }
    }

    void WriteCellBox(TiXmlNode* node)
    {
        // Get geometry folder node
        TiXmlNode* cellBoxFolderNode = NavGenProj::GetOrCreateFolderNode(node, "cellBox");

        // Min
        TiXmlElement* minNode = new TiXmlElement("min");
        minNode->SetAttribute("x", m_cellBox.m_min.x);
        minNode->SetAttribute("y", m_cellBox.m_min.y);
        cellBoxFolderNode->LinkEndChild(minNode);

        // Max
        TiXmlElement* maxNode = new TiXmlElement("max");
        maxNode->SetAttribute("x", m_cellBox.m_max.x);
        maxNode->SetAttribute("y", m_cellBox.m_max.y);
        cellBoxFolderNode->LinkEndChild(maxNode);
    }

    bool WriteContent(TiXmlNode* sectorNode)
    {
        NavGenProj::SetParam(sectorNode, "name", m_name);

        char guidString[37];
        m_guid.ToString(guidString);
        NavGenProj::SetParam(sectorNode, "guid", std::string(guidString));

        NavGenProj::SetParam(sectorNode, "doBuild", m_doBuild);
        NavGenProj::SetParam(sectorNode, "doSaveClientInput", m_doSaveClientInput);
        NavGenProj::SetParam(sectorNode, "doGenerateColData", m_doGenerateColData);

        if (m_cellBox.IsValid())
            WriteCellBox(sectorNode);

        // Write geometries
        for (int i = 0; i < (int)m_geometries.size(); i++)
        {
            if (m_geometries[i]->Write(sectorNode) == false)
                return KY_ERROR;
        }

        // Write clientInputs
        for (int i = 0; i < (int)m_clientInputs.size(); i++)
        {
            if (m_clientInputs[i]->Write(sectorNode) == false)
                return KY_ERROR;
        }

        // Write seedPoints
        for (int i = 0; i < (int)m_seedPoints.size(); i++)
        {
            if (m_seedPoints[i].Write(sectorNode) == false)
                return KY_ERROR;
        }

        // Write tagVolumes
        for (int i = 0; i < (int)m_tagVolumes.size(); i++)
        {
            if (m_tagVolumes[i]->Write(sectorNode) == false)
                return KY_ERROR;
        }

        return true;
    }

public:
    NavGenProjConfig& m_navGenProjConfig;
    std::string m_name;
    Kaim::KyGuid m_guid;
    bool m_doBuild;
    bool m_doSaveClientInput;
    bool m_doGenerateColData;
    std::vector<NavGenProjGeometry*>    m_geometries;
    std::vector<NavGenProjClientInput*> m_clientInputs;
    std::vector<NavGenProjSeedPoint>    m_seedPoints;
    std::vector<NavGenProjTagVolume*>   m_tagVolumes;
    Kaim::CellBox m_cellBox;
    Vec2i m_mirroredPos;
};


}


#endif