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 ```
  23 {
  24         "init": [0, 0, 0],
  25         "goal": [9, 9, 0],
  26         "obst": [
  27                 {
  28                         "segment": [
  29                                 [3, 3],
  30                                 [7, 3]
  31                         ]
  32                 },
  33                 {
  34                         "segment": [
  35                                 [7, 3],
  36                                 [7, 7]
  37                         ]
  38                 },
  39                 {
  40                         "segment": [
  41                                 [7, 7],
  42                                 [3, 7]
  43                         ]
  44                 },
  45                 {
  46                         "segment": [
  47                                 [3, 7],
  48                                 [3, 3]
  49                         ]
  50                 }
  51         ]
  52 }
  53 ```
  54
  55
  56 # Scenarios
  57 The `go_car_go` program expects json formatted on std input. The output is json
  58 formatted to std output.
  59
  60 - Street width min.: 2.75 (sometimes 2.5m).
  61
  62 ## Small cars (size 01)
  63 - Norm: `ČSN 73 6056 s účinností od 1.8. 1988`.
  64 - Perpendicular: 2.25 x 4.5m
  65 - Parallel: 2.0 x 5,5m
  66
  67 ## Large cars (size 02)
  68 - Perpendicular: 2.4 x 5.30m
  69 - Parallel: 2.2 x 6.5m
  70
  71 ## Parallel parking example (large cars)
  72 ```json
  73 {
  74         "init": [1.1, 6.5, 1.5707963267948966],
  75         "goal": [-1.1, 14.37, 1.5707963267948966],
  76         "obst": [
  77                 {
  78                         "segment": [
  79                                 [0, 0],
  80                                 [0, 13]
  81                         ]
  82                 },
  83                 {
  84                         "segment": [
  85                                 [0, 13],
  86                                 [-2.2, 13]
  87                         ]
  88                 },
  89                 {
  90                         "segment": [
  91                                 [-2.2, 13],
  92                                 [-2.2, 19.5]
  93                         ]
  94                 },
  95                 {
  96                         "segment": [
  97                                 [-2.2, 19.5],
  98                                 [0, 19.5]
  99                         ]
 100                 },
 101                 {
 102                         "segment": [
 103                                 [0, 19.5],
 104                                 [0, 26]
 105                         ]
 106                 },
 107                 {
 108                         "segment": [
 109                                 [2.75, 0],
 110                                 [2.75, 26]
 111                         ]
 112                 },
 113                 {
 114                         "segment": [
 115                                 [0, 0],
 116                                 [2.75, 0]
 117                         ]
 118                 },
 119                 {
 120                         "segment": [
 121                                 [0, 26],
 122                                 [2.75, 26]
 123                         ]
 124                 }
 125         ]
 126 }
 127 ```
 128
 129 ## Perpendicular parking example
 130 ```json
 131 {
 132         "init": [1.1, 6.5, 1.5707963267948966],
 133         "goal": [-0.37, 14.2, 3.141592653589793],
 134         "obst": [
 135                 {
 136                         "segment": [
 137                                 [0, 0],
 138                                 [0, 13]
 139                         ]
 140                 },
 141                 {
 142                         "segment": [
 143                                 [0, 13],
 144                                 [-5.3, 13]
 145                         ]
 146                 },
 147                 {
 148                         "segment": [
 149                                 [-5.3, 13],
 150                                 [-5.3, 15.4]
 151                         ]
 152                 },
 153                 {
 154                         "segment": [
 155                                 [-5.3, 15.4],
 156                                 [0, 15.4]
 157                         ]
 158                 },
 159                 {
 160                         "segment": [
 161                                 [0, 15.4],
 162                                 [0, 26]
 163                         ]
 164                 },
 165                 {
 166                         "segment": [
 167                                 [5.5, 0],
 168                                 [5.5, 26]
 169                         ]
 170                 },
 171                 {
 172                         "segment": [
 173                                 [0, 0],
 174                                 [5.5, 0]
 175                         ]
 176                 },
 177                 {
 178                         "segment": [
 179                                 [0, 26],
 180                                 [5.5, 26]
 181                         ]
 182                 }
 183         ]
 184 }
 185 ```