psi_action.h

Go to the documentation of this file.

/* $Id: psi_action.h 12743 2012-07-25 23:52:02Z jguan1 $ */
/* {{{=========================================================================== *
   |
   |  Copyright (c) 1994-2011 by Kobus Barnard (author)
   |
   |  Personal and educational use of this code is granted, provided that this
   |  header is kept intact, and that the authorship is not misrepresented, that
   |  its use is acknowledged in publications, and relevant papers are cited.
   |
   |  For other use contact the author (kobus AT cs DOT arizona DOT edu).
   |
   |  Please note that the code in this file has not necessarily been adequately
   |  tested. Naturally, there is no guarantee of performance, support, or fitness
   |  for any particular task. Nonetheless, I am interested in hearing about
   |  problems that you encounter.
   |
   |  Author:  Kyle Simek
 * =========================================================================== }}}*/

// vim: tabstop=4 shiftwidth=4 foldmethod=marker

#ifndef PSI_VERSION_1_ACTION_H
#define PSI_VERSION_1_ACTION_H

#include <l_cpp/l_exception.h>
#include <string>
#include <vector>
#include <psi_cpp/psi_units.h>
#include <people_tracking_cpp/pt_entity.h>

#include <boost/function.hpp>
namespace kjb
{
namespace psi
{

enum Action_type {NULL_ACTION, WALK_ACTION, WALK_IN_ARC_ACTION, WALK_THROUGH_POINTS_ACTION, 
                    FOLLOW_ACTION};

// get information about an action
const std::string& get_name(Action_type t);
Unit_type get_units(Action_type a, size_t i);

Action_type action_name_to_type(const std::string& name);

struct Action
{
    Action()  :
        parent_type(pt::NUM_ENTITY_TYPES),
        parent_index(-1)
    {
    }

    Action_type type;
    std::vector<double> parameters;

    // these two fields are for actions that depend on another entity's state
    int parent_type;
    int parent_index;
};

struct Action_descriptor
{
    Action_descriptor() {}

    Action_descriptor(
            Action_type type_,
            std::string name_,
            size_t num_params_,
            std::vector<std::string> param_names_,
            std::vector<Unit_type> param_units_, 
            boost::function1<double, const Action&> get_duration_,
            bool fixed_length_,
            bool is_relative_,
            boost::function1<bool, const Action&> validator_) :
        type(type_),
        name(name_),
        num_params(num_params_),
        param_names(param_names_),
        param_units(param_units_),
        get_duration(get_duration_),
        fixed_length(fixed_length_),
        is_relative(is_relative_),
        validator(validator_)
    { }


    Action_type type;
    std::string name;
    size_t num_params;
    std::vector<std::string> param_names;
    std::vector<Unit_type> param_units;

    boost::function1<double, const Action&> get_duration;

    bool fixed_length;

    bool is_relative;

    boost::function1<bool, const Action&> validator;
};

double get_action_duration(const Action& action);

void validate(const Action& a);

Action make_walk_through_points_action
(
    const std::vector<std::vector<double> >& points
);

inline Action make_follow_action
(
    double duration,
    size_t parent_type,
    size_t parent_index,
    double time_behind 
)
{
    Action result;
    result.type = FOLLOW_ACTION;
    result.parent_type = parent_type;
    result.parent_index = parent_index;

    result.parameters.resize(2);
    result.parameters[0] = duration;
    result.parameters[1] = time_behind;
    return result;
}


inline Action make_walk_action(double duration, double speed)
{
    Action result;
    result.type = WALK_ACTION;
    result.parameters.resize(2);

    result.parameters[0] = duration;
    result.parameters[1] = speed;

    return result;
}

inline Action make_walk_in_arc_action
(
    double duration, 
    double speed,
    double angular_speed
)
{
    Action result;
    result.type = WALK_IN_ARC_ACTION;
    result.parameters.resize(3);

    result.parameters[0] = duration;
    result.parameters[1] = speed;
    result.parameters[2] = angular_speed;

    return result;
}

inline Action make_null_action(double duration)
{
    Action result;
    result.type = NULL_ACTION;
    result.parameters.resize(1);
    result.parameters[0] = duration;

    return result;
}

 /*----------------------------------------------------------------------*/
 /*                             Utility Functions                        */
 /*----------------------------------------------------------------------*/

inline size_t get_num_waypoints(size_t param_size)
{
    return (param_size - 1) / 3;
}

inline size_t to_x_index(size_t i)
{
    return (1 + (3 * i + 0));
}

inline size_t to_z_index(size_t i)
{
    return (1 + (3 * i + 1));
}

inline size_t to_time_index(size_t i)
{
    return (1 + (3 * i + 2));
}

std::ostream& operator<<(std::ostream& ost, const Action& action);

std::istream& operator>>(std::istream& ist, Action& action);

Action parse_cli_action(const std::string& str);


} // namespace psi
} // namespace kjb
#endif