README.md

   1 # I am car
   2 Autonomous car architecture
   3
   4 # Build
   5 [CMake] is used for project build.
   6
   7 ##  Prerequisities
   8 - cmake
   9 - libjsoncpp-dev
  10 - libomp-dev
  11 - libsdl2-dev
  12 - freeglut3-dev
  13
  14 ## Commands
  15 ```bash
  16 mkdir build
  17 cd build
  18 cmake ../
  19 make
  20 ```
  21
  22 ## Compile Macros
  23 Macros that affects output binary may be used with the cmake commands as
  24 follows:
  25 ```
  26 cmake -DPLANNER=LaValle1998 ../
  27 make
  28 ```
  29
  30 The list of available macros with values:
  31 - `PLANNER`
  32         - `LaValle198` - RRT framework.
  33         - `Kuwata2008` - RRT with changing cost and steering to goal.
  34         - `Karaman2011` - RRT* framework.
  35 - `TMAX` - Specify the upper time bound in seconds.
  36
  37 Implemented Steering procedures:
  38 - `st1` - Steer directly to goal.
  39 - `st2` - Steer with maximum turning radius and direction in mind.
  40 - `st3` - Reeds and Shepp steer procedure.
  41 - `st4` - Very basic closed-loop simulator.
  42
  43 To disable *OpenMP*, add `-DCMAKE_DISABLE_FIND_PACKAGE_OpenMP=TRUE` to `cmake`
  44 command or to `build.sh` script.
  45
  46 [CMake]: https://cmake.org/
  47
  48 # Run
  49 The scenarios may be run and plot by the following example command from root:
  50 ```
  51 SC=lpar && cat $SC.json | ./build/go_car_go > traj.json &&
  52 python plot.py $SC.json traj.json
  53 ```
  54
  55 # Scenarios
  56 The `go_car_go` program expects json formatted on std input. The output is json
  57 formatted to std output.
  58
  59 - Street width min.: 2.75 (sometimes 2.5m).
  60
  61 ## Small cars (size 01)
  62 - Norm: `ČSN 73 6056 s účinností od 1.8. 1988`.
  63 - Perpendicular: 2.25 x 4.5m
  64 - Parallel: 2.0 x 5,5m
  65
  66 ## Large cars (size 02)
  67 - Perpendicular: 2.4 x 5.30m
  68 - Parallel: 2.2 x 6.5m
  69
  70 ## Parallel parking example (large cars)
  71 ```json
  72 {
  73         "init": [1.1, 6.5, 1.5707963267948966],
  74         "goal": [-1.1, 14.37, 1.5707963267948966],
  75         "obst": [
  76                 {
  77                         "segment": [
  78                                 [0, 0],
  79                                 [0, 13]
  80                         ]
  81                 },
  82                 {
  83                         "segment": [
  84                                 [0, 13],
  85                                 [-2.2, 13]
  86                         ]
  87                 },
  88                 {
  89                         "segment": [
  90                                 [-2.2, 13],
  91                                 [-2.2, 19.5]
  92                         ]
  93                 },
  94                 {
  95                         "segment": [
  96                                 [-2.2, 19.5],
  97                                 [0, 19.5]
  98                         ]
  99                 },
 100                 {
 101                         "segment": [
 102                                 [0, 19.5],
 103                                 [0, 26]
 104                         ]
 105                 },
 106                 {
 107                         "segment": [
 108                                 [2.75, 0],
 109                                 [2.75, 26]
 110                         ]
 111                 },
 112                 {
 113                         "segment": [
 114                                 [0, 0],
 115                                 [2.75, 0]
 116                         ]
 117                 },
 118                 {
 119                         "segment": [
 120                                 [0, 26],
 121                                 [2.75, 26]
 122                         ]
 123                 }
 124         ]
 125 }
 126 ```
 127
 128 ## Perpendicular parking example
 129 ```json
 130 {
 131         "init": [1.1, 6.5, 1.5707963267948966],
 132         "goal": [-0.37, 14.2, 3.141592653589793],
 133         "obst": [
 134                 {
 135                         "segment": [
 136                                 [0, 0],
 137                                 [0, 13]
 138                         ]
 139                 },
 140                 {
 141                         "segment": [
 142                                 [0, 13],
 143                                 [-5.3, 13]
 144                         ]
 145                 },
 146                 {
 147                         "segment": [
 148                                 [-5.3, 13],
 149                                 [-5.3, 15.4]
 150                         ]
 151                 },
 152                 {
 153                         "segment": [
 154                                 [-5.3, 15.4],
 155                                 [0, 15.4]
 156                         ]
 157                 },
 158                 {
 159                         "segment": [
 160                                 [0, 15.4],
 161                                 [0, 26]
 162                         ]
 163                 },
 164                 {
 165                         "segment": [
 166                                 [5.5, 0],
 167                                 [5.5, 26]
 168                         ]
 169                 },
 170                 {
 171                         "segment": [
 172                                 [0, 0],
 173                                 [5.5, 0]
 174                         ]
 175                 },
 176                 {
 177                         "segment": [
 178                                 [0, 26],
 179                                 [5.5, 26]
 180                         ]
 181                 }
 182         ]
 183 }
 184 ```
 185
 186 # BATCH TEST
 187         for i in {0..19}; do $( bash test.sh )&& mv log log_$i; done
 188         L=l; WHAT=par; for i in {0..19}; do mv log_${i}/*${L}${WHAT}* ${WHAT}/${L}${WHAT}_${i}.json; done
 189         L=r; WHAT=par; for i in {0..19}; do mv log_${i}/*${L}${WHAT}* ${WHAT}/${L}${WHAT}_${i}.json; done
 190         L=l; WHAT=per; for i in {0..19}; do mv log_${i}/*${L}${WHAT}* ${WHAT}/${L}${WHAT}_${i}.json; done
 191         L=r; WHAT=per; for i in {0..19}; do mv log_${i}/*${L}${WHAT}* ${WHAT}/${L}${WHAT}_${i}.json; done
 192
 193 # VISUAL TEST
 194 ```
 195 while ! timeout 2 ./bin/Kuwata2008st3co1 < lpar.json > traj.json; do
 196         kill $!
 197         mv traj.json t.json
 198         python plot.py lpar.json t.json &
 199 done
 200 ```