PFWaypointCollection.h

Go to the documentation of this file.

//    Copyright (C) 2006-2011 Dylan Blair
//
//    email: dblair@alumni.cs.utexas.edu
//
//    This library is free software; you can redistribute it and/or
//    modify it under the terms of the GNU Lesser General Public
//    License as published by the Free Software Foundation; either
//    version 2.1 of the License, or (at your option) any later version.
//
//    This library 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
//    Lesser General Public License for more details.
//
//    You should have received a copy of the GNU Lesser General Public
//    License along with this library; if not, write to the Free Software
//    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

#ifndef PF_WAYPOINT_COLLECTION_H
#define PF_WAYPOINT_COLLECTION_H

#include "../Math_LIB/MPath.h"
#include "../CD_LIB/CDGrid.h"

namespace OpenSkyNet {
    namespace PF {
        class WaypointCollection {
        public:
            struct lessThan {
                bool operator()(const Math::Point<int>& p1_, const Math::Point<int>& p2_) const {
                    if (p1_.x() < p2_.x()) return true;
                    else if (p1_.x() > p2_.x()) return false;
                    else if (p1_.y() < p2_.y()) return true;
                    else if (p1_.y() > p2_.y()) return false;
                    else if (p1_.z() < p2_.z()) return true;
                    else if (p1_.z() > p2_.z()) return false;
                    return false;
                }
            };
            struct WhoGoesWhereDef {
                std::set<Math::Point<int>, lessThan> _drivBins;
                std::set<Math::Point<int>, lessThan> _targBins;
                std::vector<Math::Point<> > _pathPoints;
            protected:
                bool findBin(const Math::Point<int>& bin_, const std::set<Math::Point<int>, lessThan>& bins_) const;
            public:
                inline bool findDrivBin(const Math::Point<int>& drivBin_) const {
                    return findBin(drivBin_,_drivBins);
                }
                inline bool findTargBin(const Math::Point<int>& targBin_) const {
                    return findBin(targBin_,_targBins);
                }
            };
            std::vector<WhoGoesWhereDef*> _defs;
        private:
            Math::Point<> _initMaxCorner;
            Math::Point<> _maxCorner;
            Math::Point<> _size;
            Math::Point<Utils::uint> _axisDivisions;
            Math::Point<> _binSize;
        public:
            void loadWPC(const char* wPC_);

            inline Math::Point<int> getWPCBin(const Math::Point<>& pos_) const {
                return Math::Point<int>(static_cast<int>(floor((_maxCorner.x() - pos_.x())/_binSize.x())),
                    static_cast<int>(floor((_maxCorner.y() - pos_.y())/_binSize.y())),
                    static_cast<int>(floor((_maxCorner.z() - pos_.z())/_binSize.z())));
            }

            inline bool getWPCBin(const Math::Point<>& pos_, Math::Point<int>& wPCBin_) const {
                wPCBin_ = getWPCBin(pos_);

                if ((((((wPCBin_.x() < 0) || (wPCBin_.y() < 0)) || (wPCBin_.z() < 0)) || 
                    (wPCBin_.x() >= static_cast<int>(_axisDivisions.x()))) || 
                    (wPCBin_.y() >= static_cast<int>(_axisDivisions.y()))) || 
                    (wPCBin_.z() >= static_cast<int>(_axisDivisions.z())))
                    return false;
                return true;
            }

            inline Math::Point<int> getNearestWPCBin(const Math::Point<>& pos_) const {
                Math::Point<int> wPCBin(getWPCBin(pos_));
                wPCBin.x() = wPCBin.x() < 0 ? 0 : wPCBin.x();
                wPCBin.y() = wPCBin.y() < 0 ? 0 : wPCBin.y();
                wPCBin.z() = wPCBin.z() < 0 ? 0 : wPCBin.z();

                return Math::Point<int>(static_cast<Utils::uint>(wPCBin.x()) >= _axisDivisions.x() ? _axisDivisions.x()-1 : wPCBin.x(), 
                                        static_cast<Utils::uint>(wPCBin.y()) >= _axisDivisions.y() ? _axisDivisions.y()-1 : wPCBin.y(), 
                                        static_cast<Utils::uint>(wPCBin.z()) >= _axisDivisions.z() ? _axisDivisions.z()-1 : wPCBin.z());
            }

            inline Math::Point<int> getWPCBin(const Math::Point<int>& gridBin_, const CD::Grid* grid_) const {
                Math::Point<> gridBinCenter(grid_->getMaxCorner() - grid_->getBinSize()/2.0f);
                gridBinCenter -= grid_->getBinSize()*gridBin_;
                return getWPCBin(gridBinCenter);
            }

            inline bool getWPCBin(const Math::Point<int>& gridBin_, const CD::Grid* grid_, Math::Point<int>& wPCBin_) const {
                wPCBin_ = getWPCBin(gridBin_,grid_);

                if ((((((wPCBin_.x() < 0) || (wPCBin_.y() < 0)) || (wPCBin_.z() < 0)) || 
                        (wPCBin_.x() >= static_cast<int>(_axisDivisions.x()))) || 
                        (wPCBin_.y() >= static_cast<int>(_axisDivisions.y()))) || 
                        (wPCBin_.z() >= static_cast<int>(_axisDivisions.z())))
                        return false;
                return true;
            }

            inline Math::Point<int> getNearestWPCBin(const Math::Point<int>& gridBin_, const CD::Grid* grid_) const {
                Math::Point<int> wPCBin(getWPCBin(gridBin_,grid_));
                wPCBin.x() = wPCBin.x() < 0 ? 0 : wPCBin.x();
                wPCBin.y() = wPCBin.y() < 0 ? 0 : wPCBin.y();
                wPCBin.z() = wPCBin.z() < 0 ? 0 : wPCBin.z();

                return Math::Point<int>(static_cast<Utils::uint>(wPCBin.x()) >= _axisDivisions.x() ? _axisDivisions.x()-1 : wPCBin.x(), 
                                        static_cast<Utils::uint>(wPCBin.y()) >= _axisDivisions.y() ? _axisDivisions.y()-1 : wPCBin.y(), 
                                        static_cast<Utils::uint>(wPCBin.z()) >= _axisDivisions.z() ? _axisDivisions.z()-1 : wPCBin.z());
            }

            int getWGWDIndex(Math::Point<int>& drivBin_, Math::Point<int>& targBin_, const CD::Grid* grid_) const;

            int getWGWDIndex(const Math::Point<>& drivPos_, const Math::Point<>& targPos_) const;

            void getPath(int wGWDIndex_, const Math::Point<>& drivPos_, const Math::Point<>& targPos_, Math::Path& path_) const;

            inline const Math::Point<>& getMaxCorner() const { return _maxCorner; }

            inline void translate(const Math::Point<>& delta_) { _maxCorner += delta_; }

            inline const Math::Point<>& getSize() const { return _size; }

            inline const Math::Point<Utils::uint>& getAxisDivs() const { return _axisDivisions; }

            inline const Math::Point<>& getBinSize() const { return _binSize; }
        };
    }
}

#endif //PF_WAYPOINT_COLLECTION_H