utilities.h

Go to the documentation of this file.

/*
  Copyright (C) 2018 by the authors of the World Builder code.

  This file is part of the World Builder.

   This program 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 of the License, or
   (at your option) any later version.

   This program 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 program.  If not, see <https://www.gnu.org/licenses/>.
*/

#ifndef _world_builder_utilities_h
#define _world_builder_utilities_h

#include <vector>

#include <boost/property_tree/json_parser.hpp>

#include <world_builder/point.h>
#include <world_builder/coordinate_system.h>
#include <world_builder/coordinate_systems/interface.h>

using boost::property_tree::ptree;

namespace WorldBuilder
{

  namespace CoordinateSystems
  {
    class Interface;
  }
  namespace Utilities
  {

    bool
    polygon_contains_point(const std::vector<Point<2> > &point_list,
                           const Point<2> &point);

    double
    signed_distance_to_polygon(const std::vector<Point<2> > &point_list_,
                               const Point<2> &point_);


    /*
    * A class that represents a point in a chosen coordinate system.
    */
    class NaturalCoordinate
    {
      public:
        NaturalCoordinate(const std::array<double,3> &position,
                          const ::WorldBuilder::CoordinateSystems::Interface &coordinate_system);

        NaturalCoordinate(const Point<3> &position,
                          const ::WorldBuilder::CoordinateSystems::Interface &coordinate_system);

        const std::array<double,3> &get_coordinates();

        const std::array<double,2> get_surface_coordinates() const;

        double get_depth_coordinate() const;

      private:
        CoordinateSystem coordinate_system;

        std::array<double,3> coordinates;
    };

    std::array<double,3>
    cartesian_to_spherical_coordinates(const Point<3> &position);

    Point<3>
    spherical_to_cartesian_coordinates(const std::array<double,3> &scoord);

    std::array<double,3>
    cartesian_to_ellipsoidal_coordinates(const Point<3> &position,
                                         const double semi_major_axis_a,
                                         const double eccentricity);

    Point<3>
    ellipsoidal_to_cartesian_coordinates(const std::array<double,3> &phi_theta_d,
                                         const double semi_major_axis_a,
                                         const double eccentricity);

    CoordinateSystem
    string_to_coordinate_system (const std::string &);


    template<int dim>
    const std::array<double,dim> convert_point_to_array(const Point<dim> &point);

    double
    string_to_double(const std::string &string);

    double
    string_to_int(const std::string &string);


    double
    string_to_unsigned_int(const std::string &string);

    boost::optional<std::string>
    get_from_ptree(const ptree &tree,
                   const std::string &path,
                   const std::string &key,
                   const bool required = true,
                   const std::string &path_separator = ".");


    boost::optional<std::string>
    get_from_ptree_abs(const ptree &tree,
                       const std::string &path,
                       const std::string &key,
                       const bool required = true,
                       const std::string &path_separator = ".");

    //std::string
    //escape_string(std::string &original);

    std::string indent(int level);

    std::stringstream print_tree (const ptree &pt, int level);
  }
}


#endif