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
  11 ## Commands
  12 ```bash
  13 mkdir build
  14 cd build
  15 cmake ../
  16 make
  17 ```
  18
  19 [CMake]: https://cmake.org/
  20
  21 # Run
  22 The scenarios may be run and plot by the following example command from root:
  23 ```
  24 SC=lpar && cat $SC.json | ./build/go_car_go > traj.json &&
  25 python plot.py $SC.json traj.json
  26 ```
  27
  28 # Scenarios
  29 The `go_car_go` program expects json formatted on std input. The output is json
  30 formatted to std output.
  31
  32 - Street width min.: 2.75 (sometimes 2.5m).
  33
  34 ## Small cars (size 01)
  35 - Norm: `ČSN 73 6056 s účinností od 1.8. 1988`.
  36 - Perpendicular: 2.25 x 4.5m
  37 - Parallel: 2.0 x 5,5m
  38
  39 ## Large cars (size 02)
  40 - Perpendicular: 2.4 x 5.30m
  41 - Parallel: 2.2 x 6.5m
  42
  43 ## Parallel parking example (large cars)
  44 ```json
  45 {
  46         "init": [1.1, 6.5, 1.5707963267948966],
  47         "goal": [-1.1, 14.37, 1.5707963267948966],
  48         "obst": [
  49                 {
  50                         "segment": [
  51                                 [0, 0],
  52                                 [0, 13]
  53                         ]
  54                 },
  55                 {
  56                         "segment": [
  57                                 [0, 13],
  58                                 [-2.2, 13]
  59                         ]
  60                 },
  61                 {
  62                         "segment": [
  63                                 [-2.2, 13],
  64                                 [-2.2, 19.5]
  65                         ]
  66                 },
  67                 {
  68                         "segment": [
  69                                 [-2.2, 19.5],
  70                                 [0, 19.5]
  71                         ]
  72                 },
  73                 {
  74                         "segment": [
  75                                 [0, 19.5],
  76                                 [0, 26]
  77                         ]
  78                 },
  79                 {
  80                         "segment": [
  81                                 [2.75, 0],
  82                                 [2.75, 26]
  83                         ]
  84                 },
  85                 {
  86                         "segment": [
  87                                 [0, 0],
  88                                 [2.75, 0]
  89                         ]
  90                 },
  91                 {
  92                         "segment": [
  93                                 [0, 26],
  94                                 [2.75, 26]
  95                         ]
  96                 }
  97         ]
  98 }
  99 ```
 100
 101 ## Perpendicular parking example
 102 ```json
 103 {
 104         "init": [1.1, 6.5, 1.5707963267948966],
 105         "goal": [-0.37, 14.2, 3.141592653589793],
 106         "obst": [
 107                 {
 108                         "segment": [
 109                                 [0, 0],
 110                                 [0, 13]
 111                         ]
 112                 },
 113                 {
 114                         "segment": [
 115                                 [0, 13],
 116                                 [-5.3, 13]
 117                         ]
 118                 },
 119                 {
 120                         "segment": [
 121                                 [-5.3, 13],
 122                                 [-5.3, 15.4]
 123                         ]
 124                 },
 125                 {
 126                         "segment": [
 127                                 [-5.3, 15.4],
 128                                 [0, 15.4]
 129                         ]
 130                 },
 131                 {
 132                         "segment": [
 133                                 [0, 15.4],
 134                                 [0, 26]
 135                         ]
 136                 },
 137                 {
 138                         "segment": [
 139                                 [5.5, 0],
 140                                 [5.5, 26]
 141                         ]
 142                 },
 143                 {
 144                         "segment": [
 145                                 [0, 0],
 146                                 [5.5, 0]
 147                         ]
 148                 },
 149                 {
 150                         "segment": [
 151                                 [0, 26],
 152                                 [5.5, 26]
 153                         ]
 154                 }
 155         ]
 156 }
 157 ```