Keep underscore prefix for private members conv.

diff --git a/incl/bcar.hh b/incl/bcar.hh
index 0d239c57179e8538242b782032b8f33252a5f53d..7302855583bf25002b4921c69eb9d94a022c5574 100644 (file)
--- a/incl/bcar.hh
+++ b/incl/bcar.hh
@@ -21,8 +21,8 @@ class Line;
 
 class Point {
 private:
-       double x_ = 0.0;
-       double y_ = 0.0;
+       double _x = 0.0;
+       double _y = 0.0;
 public:
        Point();
        Point(double x, double y);
@@ -92,10 +92,10 @@ public:
 
 class Line {
 private:
-       Point b_;
-       Point e_;
-       Point i1_;
-       Point i2_;
+       Point _b;
+       Point _e;
+       Point _i1;
+       Point _i2;
 public:
        Line(Point const& fp, Point const& lp);
 
@@ -147,7 +147,7 @@ public:
 /*! Store coordinates `x`, `y`, and heading `h`. */
 class Pose : public virtual Point {
 private:
-       double h_ = 0.0;
+       double _h = 0.0;
 public:
        using Point::Point;
        Pose(double x, double y, double h);
@@ -171,8 +171,8 @@ public:
 
 class PoseRange : public virtual Pose {
 private:
-       Pose bp_;
-       Pose ep_;
+       Pose _bp;
+       Pose _ep;
        void set_xyh();
 public:
        PoseRange(Pose bp, Pose ep);
@@ -200,11 +200,11 @@ public:
  */
 class CarSize {
 private:
-       double curb_to_curb_ = 10.802166641822163;
-       double width_ = 1.945; // including mirrors
-       double wheelbase_ = 2.588;
-       double distance_to_front_ = 3.427;
-       double length_ = 4.084;
+       double _curb_to_curb = 10.802166641822163;
+       double _width = 1.945; // including mirrors
+       double _wheelbase = 2.588;
+       double _distance_to_front = 3.427;
+       double _length = 4.084;
        double _front_track = 1.511;
 public:
        /*! Get curb-to-curb distance. */
@@ -251,10 +251,10 @@ public:
         * Please, note that the method returns really _minimum turning radius_,
         * which is the distance from the rear axle center to the center of
         * left or right rotation given by the kinematics constrants, i.e.
-        * _wheelbase_ and _curb-to-curb_ distance.
+        * _wheelbase and _curb-to-curb_ distance.
         *
-        * Sometimes _minimum turning radius_ is not radius, not minimum, or not
-        * turning. In this method, _minimum turning radius_ is minimum turning
+        * Sometimes _minimum turning _radius is not radius, not minimum, or not
+        * turning. In this method, _minimum turning _radius is minimum turning
         * radius.
         */
        double mtr() const;
@@ -296,8 +296,8 @@ public:
 /*! Store car motion. */
 class CarMove {
 private:
-       double speed_ = 0.0;
-       double steer_ = 0.0;
+       double _speed = 0.0;
+       double _steer = 0.0;
 public:
        /*! Get speed. */
        double sp() const;

diff --git a/incl/pslot.hh b/incl/pslot.hh
index 33a119997dc02a9c55ca74cab78788488a1cb555..843d9f920cb47a5b2d701da78d3bfae03a216629 100644 (file)
--- a/incl/pslot.hh
+++ b/incl/pslot.hh
@@ -22,15 +22,15 @@ namespace bcar {
  */
 class ParkingSlot {
 private:
-       double offset_ = 0.001; // to avoid collision during init
-       double parking_speed_ = -0.1;
-       unsigned int max_cusp_ = 10;
-       double delta_angle_to_slot_ = 0.001;
-       Point border_[4];
-       Line entry_;
-       Line rear_;
-       Line curb_;
-       Line front_;
+       double _offset = 0.001; // to avoid collision during init
+       double _parking_speed = -0.1;
+       unsigned int _max_cusp = 10;
+       double _delta_angle_to_slot = 0.001;
+       Point _border[4];
+       Line _entry;
+       Line _rear;
+       Line _curb;
+       Line _front;
 public:
        std::vector<std::vector<BicycleCar>> _entries;
        /*! \brief Set parking slot.
@@ -155,7 +155,7 @@ public:
 
        /*! \brief Recompute zero slot's `PoseRange` entry for `this`.
         *
-        * The _zero_ slot is the `ParkingSlot(Point(0.0, 0.0), 0.0, W, L);`.
+        * The _zero slot_ is the `ParkingSlot(Point(0.0, 0.0), 0.0, W, L);`.
         *
         * \param p Computed `PoseRange` entry.
         */

diff --git a/src/bcar.cc b/src/bcar.cc
index 060ed153103859da28b3b5f3258a79174831e450..b5446e037569fd99d5c275871c5365cb02811f82 100644 (file)
--- a/src/bcar.cc
+++ b/src/bcar.cc
@@ -13,32 +13,32 @@ Point::Point()
 {
 }
 
-Point::Point(double x, double y) : x_(x), y_(y)
+Point::Point(double x, double y) : _x(x), _y(y)
 {
 }
 
 double
 Point::x() const
 {
-       return this->x_;
+       return this->_x;
 }
 
 void
 Point::x(double x)
 {
-       this->x_ = x;
+       this->_x = x;
 }
 
 double
 Point::y() const
 {
-       return this->y_;
+       return this->_y;
 }
 
 void
 Point::y(double y)
 {
-       this->y_ = y;
+       this->_y = y;
 }
 
 double
@@ -92,8 +92,8 @@ Point::on_right_side_of(Line const& li) const
        auto y1 = li.b().y();
        auto x2 = li.e().x();
        auto y2 = li.e().y();
-       auto x3 = this->x_;
-       auto y3 = this->y_;
+       auto x3 = this->_x;
+       auto y3 = this->_y;
        if (sgn((x3 - x1) * (y2 - y1) - (y3 - y1) * (x2 - x1)) < 0.0) {
                return false;
        } else {
@@ -104,8 +104,8 @@ Point::on_right_side_of(Line const& li) const
 void
 Point::translate(Point const& p)
 {
-       this->x_ += p.x();
-       this->y_ += p.y();
+       this->_x += p.x();
+       this->_y += p.y();
 }
 
 void
@@ -125,16 +125,16 @@ void
 Point::reflect(Line const& li)
 {
        this->rotate(li.b(), -li.h());
-       this->y_ -= li.b().y();
-       this->y_ *= -1.0;
-       this->y_ += li.b().y();
+       this->_y -= li.b().y();
+       this->_y *= -1.0;
+       this->_y += li.b().y();
        this->rotate(li.b(), li.h());
 }
 
 double
 Point::edist(Point const& p) const
 {
-       return sqrt(pow(p.x() - this->x_, 2.0) + pow(p.y() - this->y_, 2.0));
+       return sqrt(pow(p.x() - this->_x, 2.0) + pow(p.y() - this->_y, 2.0));
 }
 
 bool
@@ -150,48 +150,48 @@ operator<<(std::ostream& out, Point const& p)
        return out;
 }
 
-Line::Line(Point const& b, Point const& e): b_(b), e_(e)
+Line::Line(Point const& b, Point const& e): _b(b), _e(e)
 {
 }
 
 Point
 Line::b() const&
 {
-       return this->b_;
+       return this->_b;
 }
 
 Point
 Line::e() const&
 {
-       return this->e_;
+       return this->_e;
 }
 
 Point
 Line::m() const
 {
-       return Point((this->b_.x() + this->e_.x()) / 2.0,
-               (this->b_.y() + this->e_.y()) / 2.0);
+       return Point((this->_b.x() + this->_e.x()) / 2.0,
+               (this->_b.y() + this->_e.y()) / 2.0);
 }
 
 Point
 Line::i1() const&
 {
-       return this->i1_;
+       return this->_i1;
 }
 
 Point
 Line::i2() const&
 {
-       return this->i2_;
+       return this->_i2;
 }
 
 bool
 Line::intersects_with(Line const& li)
 {
-       auto x1 = this->b_.x();
-       auto y1 = this->b_.y();
-       auto x2 = this->e_.x();
-       auto y2 = this->e_.y();
+       auto x1 = this->_b.x();
+       auto y1 = this->_b.y();
+       auto x2 = this->_e.x();
+       auto y2 = this->_e.y();
        auto x3 = li.b().x();
        auto y3 = li.b().y();
        auto x4 = li.e().x();
@@ -208,18 +208,18 @@ Line::intersects_with(Line const& li)
        if (t < 0.0 || t > 1.0 || u < 0.0 || u > 1.0) {
                return false;
        }
-       this->i1_.x(x1 + t * (x2 - x1));
-       this->i1_.y(y1 + t * (y2 - y1));
+       this->_i1.x(x1 + t * (x2 - x1));
+       this->_i1.y(y1 + t * (y2 - y1));
        return true;
 }
 
 bool
 Line::intersects_with(Point const& c, double const r)
 {
-       auto x1 = this->b_.x();
-       auto y1 = this->b_.y();
-       auto x2 = this->e_.x();
-       auto y2 = this->e_.y();
+       auto x1 = this->_b.x();
+       auto y1 = this->_b.y();
+       auto x2 = this->_e.x();
+       auto y2 = this->_e.y();
        auto cx = c.x();
        auto cy = c.y();
        x2 -= cx;
@@ -245,40 +245,40 @@ Line::intersects_with(Point const& c, double const r)
        iy1 += cy;
        double iy2 = (-D*dx - std::abs(dy)*sqrt(r*r * dr*dr - D*D)) / (dr*dr);
        iy2 += cy;
-       this->i1_.x(ix1);
-       this->i1_.y(iy1);
-       this->i2_.x(ix2);
-       this->i2_.y(iy2);
+       this->_i1.x(ix1);
+       this->_i1.y(iy1);
+       this->_i2.x(ix2);
+       this->_i2.y(iy2);
        return true;
 }
 
 double
 Line::len() const
 {
-       return this->b_.edist(this->e_);
+       return this->_b.edist(this->_e);
 }
 
 double
 Line::h() const
 {
-       return atan2(this->e_.y() - this->b_.y(), this->e_.x() - this->b_.x());
+       return atan2(this->_e.y() - this->_b.y(), this->_e.x() - this->_b.x());
 }
 
 std::ostream&
 operator<<(std::ostream& out, Line const& li)
 {
-       out << "[" << li.b_ << "," << li.e_ << "]";
+       out << "[" << li._b << "," << li._e << "]";
        return out;
 }
 
-Pose::Pose(double x, double y, double h) : Point(x, y), h_(h)
+Pose::Pose(double x, double y, double h) : Point(x, y), _h(h)
 {
 }
 
 double
 Pose::h() const
 {
-       return this->h_;
+       return this->_h;
 }
 
 void
@@ -290,7 +290,7 @@ Pose::h(double h)
        while (h > +M_PI) {
                h -= 2 * M_PI;
        }
-       this->h_ = h;
+       this->_h = h;
 }
 
 void
@@ -333,15 +333,15 @@ void
 PoseRange::set_xyh()
 {
        double clen = 10.0;
-       double bpbx = this->bp_.x() - clen * cos(this->bp_.h());
-       double bpby = this->bp_.y() - clen * sin(this->bp_.h());
-       double bpfx = this->bp_.x() + clen * cos(this->bp_.h());
-       double bpfy = this->bp_.y() + clen * sin(this->bp_.h());
+       double bpbx = this->_bp.x() - clen * cos(this->_bp.h());
+       double bpby = this->_bp.y() - clen * sin(this->_bp.h());
+       double bpfx = this->_bp.x() + clen * cos(this->_bp.h());
+       double bpfy = this->_bp.y() + clen * sin(this->_bp.h());
        Line li1(Point(bpbx, bpby), Point(bpfx, bpfy));
-       double epbx = this->ep_.x() - clen * cos(this->ep_.h());
-       double epby = this->ep_.y() - clen * sin(this->ep_.h());
-       double epfx = this->ep_.x() + clen * cos(this->ep_.h());
-       double epfy = this->ep_.y() + clen * sin(this->ep_.h());
+       double epbx = this->_ep.x() - clen * cos(this->_ep.h());
+       double epby = this->_ep.y() - clen * sin(this->_ep.h());
+       double epfx = this->_ep.x() + clen * cos(this->_ep.h());
+       double epfy = this->_ep.y() + clen * sin(this->_ep.h());
        Line li2(Point(epbx, epby), Point(epfx, epfy));
        li1.intersects_with(li2);
        this->x(li1.i1().x());
@@ -350,19 +350,19 @@ PoseRange::set_xyh()
        while (bh < 0.0) {
                bh += 2.0 * M_PI;
        }
-       this->bp_.h(bh);
+       this->_bp.h(bh);
        double eh = this->e();
        while (eh < 0.0) {
                eh += 2.0 * M_PI;
        }
-       this->ep_.h(eh);
+       this->_ep.h(eh);
        this->h((this->b() + this->e()) / 2.0);
 }
 
-PoseRange::PoseRange(Pose bp, Pose ep) : bp_(bp), ep_(ep)
+PoseRange::PoseRange(Pose bp, Pose ep) : _bp(bp), _ep(ep)
 {
-       if (this->bp_ == this->ep_) {
-               this->set_pose(this->ep_);
+       if (this->_bp == this->_ep) {
+               this->set_pose(this->_ep);
        } else {
                this->set_xyh();
        }
@@ -376,48 +376,48 @@ PoseRange::PoseRange(double x, double y, double b, double e)
 Pose
 PoseRange::bp() const
 {
-       return this->bp_;
+       return this->_bp;
 }
 
 Pose
 PoseRange::ep() const
 {
-       return this->ep_;
+       return this->_ep;
 }
 
 double
 PoseRange::b() const
 {
-       return std::min(this->bp_.h(), this->ep_.h());
+       return std::min(this->_bp.h(), this->_ep.h());
 }
 
 double
 PoseRange::e() const
 {
-       return std::max(this->bp_.h(), this->ep_.h());
+       return std::max(this->_bp.h(), this->_ep.h());
 }
 
 void
 PoseRange::translate(Point const& p)
 {
-       this->bp_.translate(p);
-       this->ep_.translate(p);
+       this->_bp.translate(p);
+       this->_ep.translate(p);
        this->set_xyh();
 }
 
 void
 PoseRange::rotate(Point const& c, double const angl)
 {
-       this->bp_.rotate(c, angl);
-       this->ep_.rotate(c, angl);
+       this->_bp.rotate(c, angl);
+       this->_ep.rotate(c, angl);
        this->set_xyh();
 }
 
 void
 PoseRange::reflect(Line const& li)
 {
-       this->bp_.reflect(li);
-       this->ep_.reflect(li);
+       this->_bp.reflect(li);
+       this->_ep.reflect(li);
        this->set_xyh();
 }
 
@@ -432,61 +432,61 @@ operator<<(std::ostream& out, PoseRange const& p)
 double
 CarSize::ctc() const
 {
-       return this->curb_to_curb_;
+       return this->_curb_to_curb;
 }
 
 void
 CarSize::ctc(double ctc)
 {
-       this->curb_to_curb_ = ctc;
+       this->_curb_to_curb = ctc;
 }
 
 double
 CarSize::wb() const
 {
-       return this->wheelbase_;
+       return this->_wheelbase;
 }
 
 void
 CarSize::wb(double wb)
 {
-       this->wheelbase_ = wb;
+       this->_wheelbase = wb;
 }
 
 double
 CarSize::w() const
 {
-       return this->width_;
+       return this->_width;
 }
 
 void
 CarSize::w(double w)
 {
-       this->width_ = w;
+       this->_width = w;
 }
 
 double
 CarSize::len() const
 {
-       return this->length_;
+       return this->_length;
 }
 
 void
 CarSize::len(double len)
 {
-       this->length_ = len;
+       this->_length = len;
 }
 
 double
 CarSize::df() const
 {
-       return this->distance_to_front_;
+       return this->_distance_to_front;
 }
 
 void
 CarSize::df(double df)
 {
-       this->distance_to_front_ = df;
+       this->_distance_to_front = df;
 }
 
 double
@@ -552,25 +552,25 @@ CarSize::perfect_parking_slot_len() const
 double
 CarMove::sp() const
 {
-       return this->speed_;
+       return this->_speed;
 }
 
 void
 CarMove::sp(double sp)
 {
-       this->speed_ = sp;
+       this->_speed = sp;
 }
 
 double
 CarMove::st() const
 {
-       return this->steer_;
+       return this->_steer;
 }
 
 void
 CarMove::st(double st)
 {
-       this->steer_ = st;
+       this->_steer = st;
 }
 
 bool

diff --git a/src/pslot.cc b/src/pslot.cc
index 1a0f32385f2c012076851c36a3eb35fe7c223f81..1d84e28ab1593aa5f5a84e21b91d3e97784dbd07 100644 (file)
--- a/src/pslot.cc
+++ b/src/pslot.cc
@@ -11,88 +11,88 @@
 namespace bcar {
 
 ParkingSlot::ParkingSlot(Point p, double h, double W, double L) :
-               border_{p,
+               _border{p,
                        Point(p.x() + W * cos(h - M_PI / 2.0),
                                p.y() + W * sin(h - M_PI / 2.0)),
                        Point(p.x() + W * cos(h - M_PI / 2.0) + L * cos(h),
                                p.y() + W * sin(h - M_PI / 2.0) + L * sin(h)),
                        Point(p.x() + L * cos(h), p.y() + L * sin(h))},
-               entry_(border_[0], border_[3]),
-               rear_(border_[0], border_[1]),
-               curb_(border_[1], border_[2]),
-               front_(border_[2], border_[3])
+               _entry(_border[0], _border[3]),
+               _rear(_border[0], _border[1]),
+               _curb(_border[1], _border[2]),
+               _front(_border[2], _border[3])
 {
 }
 
 ParkingSlot::ParkingSlot(double lrx, double lry, double rrx, double rry,
                double rfx, double rfy, double lfx, double lfy) :
-                       border_{Point(lrx, lry), Point(rrx, rry),
+                       _border{Point(lrx, lry), Point(rrx, rry),
                                Point(rfx, rfy), Point(lfx, lfy)},
-                       entry_(border_[0], border_[3]),
-                       rear_(border_[0], border_[1]),
-                       curb_(border_[1], border_[2]),
-                       front_(border_[2], border_[3])
+                       _entry(_border[0], _border[3]),
+                       _rear(_border[0], _border[1]),
+                       _curb(_border[1], _border[2]),
+                       _front(_border[2], _border[3])
 {
 }
 
 double
 ParkingSlot::len() const
 {
-       return this->entry_.len();
+       return this->_entry.len();
 }
 
 double
 ParkingSlot::w() const
 {
-       return this->rear_.len();
+       return this->_rear.len();
 }
 
 double
 ParkingSlot::lfx() const
 {
-       return this->border_[3].x();
+       return this->_border[3].x();
 }
 
 double
 ParkingSlot::lfy() const
 {
-       return this->border_[3].y();
+       return this->_border[3].y();
 }
 
 double
 ParkingSlot::lrx() const
 {
-       return this->border_[0].x();
+       return this->_border[0].x();
 }
 
 double
 ParkingSlot::lry() const
 {
-       return this->border_[0].y();
+       return this->_border[0].y();
 }
 
 double
 ParkingSlot::rrx() const
 {
-       return this->border_[1].x();
+       return this->_border[1].x();
 }
 
 double
 ParkingSlot::rry() const
 {
-       return this->border_[1].y();
+       return this->_border[1].y();
 }
 
 double
 ParkingSlot::rfx() const
 {
-       return this->border_[2].x();
+       return this->_border[2].x();
 }
 
 double
 ParkingSlot::rfy() const
 {
-       return this->border_[2].y();
+       return this->_border[2].y();
 }
 
 double
@@ -128,79 +128,79 @@ ParkingSlot::rf() const
 Line
 ParkingSlot::entry() const
 {
-       return this->entry_;
+       return this->_entry;
 }
 
 Line
 ParkingSlot::rear() const
 {
-       return this->rear_;
+       return this->_rear;
 }
 
 Line
 ParkingSlot::curb() const
 {
-       return this->curb_;
+       return this->_curb;
 }
 
 Line
 ParkingSlot::front() const
 {
-       return this->front_;
+       return this->_front;
 }
 
 void
 ParkingSlot::set_parking_speed(double s)
 {
-       this->parking_speed_ = s;
+       this->_parking_speed = s;
 }
 
 unsigned int
 ParkingSlot::get_max_cusp() const
 {
-       return this->max_cusp_;
+       return this->_max_cusp;
 }
 
 void
 ParkingSlot::set_max_cusp(unsigned int m)
 {
-       this->max_cusp_ = m;
+       this->_max_cusp = m;
 }
 
 void
 ParkingSlot::set_delta_angle_to_slot(double d)
 {
-       this->delta_angle_to_slot_ = d;
+       this->_delta_angle_to_slot = d;
 }
 
 bool
 ParkingSlot::parallel() const
 {
-       return this->entry_.len() > this->rear_.len();
+       return this->_entry.len() > this->_rear.len();
 }
 
 bool
 ParkingSlot::right() const
 {
-       return this->border_[1].on_right_side_of(this->entry_);
+       return this->_border[1].on_right_side_of(this->_entry);
 }
 
 void
 ParkingSlot::swap_side()
 {
-       this->border_[1].rotate(this->border_[0], M_PI);
-       this->border_[2].rotate(this->border_[3], M_PI);
-       this->entry_ = Line(this->border_[0], this->border_[3]);
-       this->rear_ = Line(this->border_[0], this->border_[1]);
-       this->curb_ = Line(this->border_[1], this->border_[2]);
-       this->front_ = Line(this->border_[2], this->border_[3]);
+       this->_border[1].rotate(this->_border[0], M_PI);
+       this->_border[2].rotate(this->_border[3], M_PI);
+       this->_entry = Line(this->_border[0], this->_border[3]);
+       this->_rear = Line(this->_border[0], this->_border[1]);
+       this->_curb = Line(this->_border[1], this->_border[2]);
+       this->_front = Line(this->_border[2], this->_border[3]);
 }
 
 bool
 ParkingSlot::parked(BicycleCar const& c) const
 {
-       auto b_len = sizeof(this->border_) / sizeof(this->border_[0]);
-       std::vector<Point> b(this->border_, this->border_ + b_len);
+       auto b_len = sizeof(this->_border) / sizeof(this->_border[0]);
+       std::vector<Point> b(this->_border, this->_border + b_len);
        return c.lf().inside_of(b) && c.lr().inside_of(b)
                && c.rr().inside_of(b) && c.rf().inside_of(b);
 }
@@ -208,18 +208,18 @@ ParkingSlot::parked(BicycleCar const& c) const
 bool
 ParkingSlot::collide(BicycleCar const& c) const
 {
-       return c.left().intersects_with(this->rear_)
-               || c.left().intersects_with(this->curb_)
-               || c.left().intersects_with(this->front_)
-               || c.rear().intersects_with(this->rear_)
-               || c.rear().intersects_with(this->curb_)
-               || c.rear().intersects_with(this->front_)
-               || c.right().intersects_with(this->rear_)
-               || c.right().intersects_with(this->curb_)
-               || c.right().intersects_with(this->front_)
-               || c.front().intersects_with(this->rear_)
-               || c.front().intersects_with(this->curb_)
-               || c.front().intersects_with(this->front_);
+       return c.left().intersects_with(this->_rear)
+               || c.left().intersects_with(this->_curb)
+               || c.left().intersects_with(this->_front)
+               || c.rear().intersects_with(this->_rear)
+               || c.rear().intersects_with(this->_curb)
+               || c.rear().intersects_with(this->_front)
+               || c.right().intersects_with(this->_rear)
+               || c.right().intersects_with(this->_curb)
+               || c.right().intersects_with(this->_front)
+               || c.front().intersects_with(this->_rear)
+               || c.front().intersects_with(this->_curb)
+               || c.front().intersects_with(this->_front);
 }
 
 std::vector<BicycleCar>
@@ -230,13 +230,13 @@ ParkingSlot::drive_in_slot(BicycleCar c)
        assert(c.len() < this->len());
        assert(c.w() < this->w());
        std::vector<BicycleCar> path;
-       path.reserve(this->max_cusp_ + 2);
+       path.reserve(this->_max_cusp + 2);
        path.push_back(c);
        unsigned int cusp = 0;
-       while (cusp < this->max_cusp_ + 1) {
+       while (cusp < this->_max_cusp + 1) {
                if (this->parked(c)) {
-                       if (cusp < this->max_cusp_) {
-                               this->max_cusp_ = cusp;
+                       if (cusp < this->_max_cusp) {
+                               this->_max_cusp = cusp;
                        }
                        path.push_back(c);
                        return path;
@@ -270,15 +270,15 @@ ParkingSlot::drive_of_slot(BicycleCar c)
        assert(c.w() < this->w());
        assert(this->parked(c));
        std::vector<BicycleCar> path;
-       path.reserve(this->max_cusp_ + 2);
+       path.reserve(this->_max_cusp + 2);
        path.push_back(c);
        unsigned int cusp = 0;
-       auto b_len = sizeof(this->border_) / sizeof(this->border_[0]);
-       std::vector<Point> b(this->border_, this->border_ + b_len);
-       while (cusp < this->max_cusp_ + 1) {
+       auto b_len = sizeof(this->_border) / sizeof(this->_border[0]);
+       std::vector<Point> b(this->_border, this->_border + b_len);
+       while (cusp < this->_max_cusp + 1) {
                if (!c.lf().inside_of(b) && !c.rf().inside_of(b)) {
-                       if (cusp < this->max_cusp_) {
-                               this->max_cusp_ = cusp;
+                       if (cusp < this->_max_cusp) {
+                               this->_max_cusp = cusp;
                        }
                        path.push_back(c);
                        return path;
@@ -318,32 +318,32 @@ ParkingSlot::fe(BicycleCar c)
                double gd = 0.0;
                double dd = 0.0;
                double radi = 0.0;
-               if (this->parking_speed_ < 0) {
+               if (this->_parking_speed < 0) {
                        gd = c.df();
-                       c.h(this->rear_.h() + M_PI);
+                       c.h(this->_rear.h() + M_PI);
                        c.sp(1.0);
                        radi = c.iradi();
                } else {
                        gd = c.dr();
-                       c.h(this->rear_.h());
+                       c.h(this->_rear.h());
                        c.sp(-1.0);
                        radi = c.ofradi();
                }
-               c.x(this->entry_.m().x() + gd * cos(this->rear_.h()));
-               c.y(this->entry_.m().y() + gd * sin(this->rear_.h()));
+               c.x(this->_entry.m().x() + gd * cos(this->_rear.h()));
+               c.y(this->_entry.m().y() + gd * sin(this->_rear.h()));
                Point cc(0.0, 0.0);
                if (this->right()) {
                        cc = c.ccl();
                } else {
                        cc = c.ccr();
                }
-               this->rear_.intersects_with(cc, radi);
-               dd = std::min(this->border_[0].edist(this->rear_.i1()),
-                       this->border_[0].edist(this->rear_.i2()));
+               this->_rear.intersects_with(cc, radi);
+               dd = std::min(this->_border[0].edist(this->_rear.i1()),
+                       this->_border[0].edist(this->_rear.i2()));
                c.st(0.0);
                c.sp(c.sp() * dd);
                c.next();
-               c.sp(this->parking_speed_);
+               c.sp(this->_parking_speed);
                return PoseRange(c.x(), c.y(), c.h(), c.h());
        }
        bool swapped = false;
@@ -352,19 +352,19 @@ ParkingSlot::fe(BicycleCar c)
                swapped = true;
        }
        c.h(this->h());
-       double clen = -this->offset_ + this->len() - c.df();
+       double clen = -this->_offset + this->len() - c.df();
        double cw = c.w() / 2.0;
        c.x(this->lrx() + clen * cos(c.h()) + cw * cos(c.h() + M_PI / 2.0));
        c.y(this->lry() + clen * sin(c.h()) + cw * sin(c.h() + M_PI / 2.0));
        c.set_max_steer();
-       assert(this->parking_speed_ < 0.0);
-       c.sp(this->parking_speed_);
+       assert(this->_parking_speed < 0.0);
+       c.sp(this->_parking_speed);
        auto const rc = c.rf();
-       this->curb_.intersects_with(rc, c.len());
+       this->_curb.intersects_with(rc, c.len());
        double max_to_slot;
        auto const& rr = c.rr();
-       auto const& i1 = this->curb_.i1();
-       auto const& i2 = this->curb_.i2();
+       auto const& i1 = this->_curb.i1();
+       auto const& i2 = this->_curb.i2();
        if (rr.edist(i1) < rr.edist(i2)) {
                max_to_slot = rr.min_angle_between(rc, i1);
        } else {
@@ -373,8 +373,8 @@ ParkingSlot::fe(BicycleCar c)
        std::vector<BicycleCar> starts;
        double a_to_slot = 0.0;
        while (a_to_slot < max_to_slot) {
-               a_to_slot += this->delta_angle_to_slot_;
-               c.rotate(rc, this->delta_angle_to_slot_);
+               a_to_slot += this->_delta_angle_to_slot;
+               c.rotate(rc, this->_delta_angle_to_slot);
                starts.push_back(c);
        }
        for (auto s: starts) {
@@ -395,7 +395,7 @@ ParkingSlot::fe(BicycleCar c)
        PoseRange p(c1, c2);
        if (swapped) {
                this->swap_side();
-               p.reflect(this->entry_);
+               p.reflect(this->_entry);
        }
        return p;
 }
@@ -404,9 +404,9 @@ PoseRange
 ParkingSlot::recompute_entry(PoseRange p)
 {
        p.rotate(Point(0.0, 0.0), this->h());
-       p.translate(this->border_[0]);
+       p.translate(this->_border[0]);
        if (!this->right()) {
-               p.reflect(this->entry_);
+               p.reflect(this->_entry);
        }
        return p;
 }
@@ -415,10 +415,10 @@ std::ostream&
 operator<<(std::ostream& o, ParkingSlot const& s)
 {
        o << "[";
-       o << s.border_[0] << ",";
-       o << s.border_[1] << ",";
-       o << s.border_[2] << ",";
-       o << s.border_[3];
+       o << s._border[0] << ",";
+       o << s._border[1] << ",";
+       o << s._border[2] << ",";
+       o << s._border[3];
        o << "]";
        return o;
 }