galaxis Namespace Reference

Namespaces
	autopilot
	camera
	control
	controllerSettings
	Errors
	lina
	map
	math
	motorSettings
	ros
	serviceStates
	servoSettings
	utils

Classes
struct	line_markings_reference_t
class	PolySpline
class	ROSHeartbeat

Typedefs
typedef std::vector< float >	polynom
typedef std::tuple< float, float >	interval

Functions
std::ostream &	operator<< (std::ostream &strm, polynom const &poly)
std::ostream &	operator<< (std::ostream &strm, interval const &interval)
float	calculate_error_between_polyspline_point (shared_ptr< PolySpline > p_polySpline, Eigen::Vector2f &p_point)
float	calculate_error_between_polyspline_point_square (shared_ptr< PolySpline > p_polySpline, Eigen::Vector2f const &p_point)
float	calculate_error_between_polyspline_poseseries (shared_ptr< PolySpline > p_polySplineSPtr, shared_ptr< galaxis::control::CarPoseSeries > p_poseSeriesSPtr, shared_ptr< line_markings_reference_t > p_lineMarkings, float cross_angle_weight, float cross_line_weight)
float	calculate_error_between_polyspline_point_square (shared_ptr< PolySpline > p_polySpline, Eigen::Vector2f &p_point)
float	calculate_error_between_polyspline_point (PolySpline p_polySpline, Eigen::Vector2f &p_point)

Typedef Documentation

interval

typedef std::tuple<float, float> galaxis::interval

Definition at line 21 of file poly.hpp.

polynom

typedef std::vector<float> galaxis::polynom

Definition at line 20 of file poly.hpp.

Function Documentation

calculate_error_between_polyspline_point() [1/2]

float galaxis::calculate_error_between_polyspline_point	(	PolySpline	p_polySpline,
		Eigen::Vector2f &	p_point
	)

Definition at line 126 of file poly.cpp.

                                                                                                  {
    // TODO: maxbe calc correct distance between polynom and
    // log_warning("poly.hpp: galaxis::utils::calculate_error_between_polyspline_point - correct distance implementation missing");
 
    float splinevalue = p_polySpline.evaluate(static_cast<float>(p_point[0]));
    float error       = p_point[1] - splinevalue;
 
    return error;
  }

References galaxis::PolySpline::evaluate().

Here is the call graph for this function:

calculate_error_between_polyspline_point() [2/2]

float galaxis::calculate_error_between_polyspline_point	(	shared_ptr< PolySpline >	p_polySpline,
		Eigen::Vector2f &	p_point
	)

Referenced by calculate_error_between_polyspline_poseseries().

Here is the caller graph for this function:

calculate_error_between_polyspline_point_square() [1/2]

float galaxis::calculate_error_between_polyspline_point_square	(	shared_ptr< PolySpline >	p_polySpline,
		Eigen::Vector2f &	p_point
	)

Definition at line 116 of file poly.cpp.

                                                                                                                     {
    // TODO: maxbe calc correct distance between polynom and
    // log_warning("poly.hpp: galaxis::utils::calculate_error_between_polyspline_point - correct distance implementation missing");
 
    float splinevalue = p_polySpline->evaluate(static_cast<float>(p_point[0]));
    float error       = p_point[1] - splinevalue;
 
    return error * error;
  }

calculate_error_between_polyspline_point_square() [2/2]

float galaxis::calculate_error_between_polyspline_point_square	(	shared_ptr< PolySpline >	p_polySpline,
		Eigen::Vector2f const &	p_point
	)

Referenced by calculate_error_between_polyspline_poseseries().

Here is the caller graph for this function:

calculate_error_between_polyspline_poseseries()

float galaxis::calculate_error_between_polyspline_poseseries	(	shared_ptr< PolySpline >	p_polySplineSPtr,
		shared_ptr< galaxis::control::CarPoseSeries >	p_poseSeriesSPtr,
		shared_ptr< line_markings_reference_t >	p_lineMarkings,
		float	cross_angle_weight,
		float	cross_line_weight
	)

Definition at line 136 of file poly.cpp.

                                                                                                         {
    float error = 0;
    // Compute regular error function based on y difference between polynom and series
    for(shared_ptr<CarPose> pose: *p_poseSeriesSPtr) {
      error += calculate_error_between_polyspline_point_square(p_polySplineSPtr, pose->position);
    }
 
  
    // // Compute Angle at each planning point between polynom and series
    // for(shared_ptr<CarPose> pose: *p_poseSeriesSPtr) {
      
    //   // We dont use the spline part of polyspline
    //   float poly_gradient = calculate_gradient(p_polySplineSPtr->m_polynomVec.at(0), pose->position[0]);
      
    //   // Convert gradient to orientation
    //   float poly_orientation = std::tanh(poly_gradient);
    //   float angle_error = poly_orientation - pose->orientation;
 
    //   error += cross_angle_weight * (angle_error * angle_error);
    // }
 
    if(p_lineMarkings != nullptr){
      for(shared_ptr<CarPose> pose: *p_poseSeriesSPtr) {
        //TODO: Check that the pose is in the well defined interval for the line polynoms (tend to be bad outside of the interval)
        if(p_lineMarkings->isRightEnabled) {
          float r_error = calculate_error_between_polyspline_point(p_lineMarkings->right, pose->position);
          
          if(r_error > 0){
            error += (r_error * r_error) * cross_line_weight;
          }
        }
 
        if(p_lineMarkings->isLeftEnabled) {
          float l_error = calculate_error_between_polyspline_point(p_lineMarkings->left, pose->position);
          
          if(l_error < 0){
            error += (l_error * l_error) * cross_line_weight;
          }
        }
      }
    }
 
    return error;
  }

References calculate_error_between_polyspline_point(), and calculate_error_between_polyspline_point_square().

Referenced by galaxis::control::TwoAndAHalfCarrots::calculate_best_yaw_rate().

Here is the call graph for this function:

Here is the caller graph for this function:

operator<<() [1/2]

std::ostream & galaxis::operator<<	(	std::ostream &	strm,
		interval const &	interval
	)

Definition at line 28 of file poly.cpp.

                                                                          {
  return strm << "[" << std::get<0>(interval) << ", " << std::get<1>(interval) << "]";
}

operator<<() [2/2]

std::ostream & galaxis::operator<<	(	std::ostream &	strm,
		polynom const &	poly
	)

Definition at line 11 of file poly.cpp.

                                                                     {
  std::string str = "";
 
  if(poly.size() >= 1) {
    str = std::to_string(poly[0]);
    str += "x^0";
  }
  for(unsigned int i = 1; i < poly.size(); ++i) {
    str += " + ";
    str += std::to_string(poly[i]);
    str += "x^";
    str += std::to_string(i);
  }
 
  return strm << str;
}