diff --git a/config/logviewer.cfg b/config/logviewer.cfg new file mode 100644 index 0000000000000000000000000000000000000000..68ceca62ea716bc247b4b560574604dbf7d1c9df --- /dev/null +++ b/config/logviewer.cfg @@ -0,0 +1,5 @@ +!include score.cfg + +log.viewers : rescuecore2.standard.view.StandardWorldModelViewer + +loadabletypes.inspect.dir: ./jars \ No newline at end of file diff --git a/config/score.cfg b/config/score.cfg new file mode 100644 index 0000000000000000000000000000000000000000..21e487ed6076ecee85cb06034c0ed757f08d4320 --- /dev/null +++ b/config/score.cfg @@ -0,0 +1,13 @@ +score.function: rescuecore2.standard.score.RSL21ScoreFunction + +score.standard.building-fire.heating: 0.66 +score.standard.building-fire.burning: 0.33 +score.standard.building-fire.inferno: 0.0 +score.standard.building-fire.water-damage: 0.90 +score.standard.building-fire.minor-damage: 0.75 +score.standard.building-fire.moderate-damage: 0.5 +score.standard.building-fire.severe-damage: 0.25 +score.standard.building-fire.burnt-out: 0 +score.standard.building-fire.absolute: false + +score.standard.health.absolute: false \ No newline at end of file diff --git a/docs/map-creation/images/both_way_road.png b/docs/map-creation/images/both_way_road.png new file mode 100644 index 0000000000000000000000000000000000000000..a691a9fdc906dc8677d1126fd98c6588be18a176 Binary files /dev/null and b/docs/map-creation/images/both_way_road.png differ diff --git a/docs/map-creation/images/building_list.png b/docs/map-creation/images/building_list.png new file mode 100644 index 0000000000000000000000000000000000000000..989906fc575e469a6be222adba5b7b0a820d7393 Binary files /dev/null and b/docs/map-creation/images/building_list.png differ diff --git a/docs/map-creation/images/building_setup.png b/docs/map-creation/images/building_setup.png new file mode 100644 index 0000000000000000000000000000000000000000..45e09d086b1d79266378832ecfdcb83b79049c03 Binary files /dev/null and b/docs/map-creation/images/building_setup.png differ diff --git a/docs/map-creation/images/converter_result.png b/docs/map-creation/images/converter_result.png new file mode 100644 index 0000000000000000000000000000000000000000..fb7c06bf914f1f0484511a3e44b8204a117bf432 Binary files /dev/null and b/docs/map-creation/images/converter_result.png differ diff --git a/docs/map-creation/images/converter_running.png b/docs/map-creation/images/converter_running.png new file mode 100644 index 0000000000000000000000000000000000000000..a0206cf9f6f56a2581ba399805c99b71aa61ff4d Binary files /dev/null and b/docs/map-creation/images/converter_running.png differ diff --git a/docs/map-creation/images/josm_editor.png b/docs/map-creation/images/josm_editor.png new file mode 100644 index 0000000000000000000000000000000000000000..3c8012f04a9e19f389d69c9048b320463da78bb3 Binary files /dev/null and b/docs/map-creation/images/josm_editor.png differ diff --git a/docs/map-creation/images/josm_map.png b/docs/map-creation/images/josm_map.png new file mode 100644 index 0000000000000000000000000000000000000000..7f1856226a48d936c36820f7be714a234fbaff5f Binary files /dev/null and b/docs/map-creation/images/josm_map.png differ diff --git a/docs/map-creation/images/line_building.png b/docs/map-creation/images/line_building.png new file mode 100644 index 0000000000000000000000000000000000000000..9a9c2821b269eeeb40f54e5540822882801cd463 Binary files /dev/null and b/docs/map-creation/images/line_building.png differ diff --git a/docs/map-creation/images/map_save.png b/docs/map-creation/images/map_save.png new file mode 100644 index 0000000000000000000000000000000000000000..edc9e662573addbdbe85a985e2b33f0873edd1d7 Binary files /dev/null and b/docs/map-creation/images/map_save.png differ diff --git a/docs/map-creation/images/map_usp.png b/docs/map-creation/images/map_usp.png new file mode 100644 index 0000000000000000000000000000000000000000..83163f26e01638d2f3cd2232e4a210cd8f17c697 Binary files /dev/null and b/docs/map-creation/images/map_usp.png differ diff --git a/docs/map-creation/images/osm_layout.png b/docs/map-creation/images/osm_layout.png new file mode 100644 index 0000000000000000000000000000000000000000..2b89898731a5ea1c95847c1f45e44b980fc9f5a1 Binary files /dev/null and b/docs/map-creation/images/osm_layout.png differ diff --git a/docs/map-creation/images/outermost_shape.png b/docs/map-creation/images/outermost_shape.png new file mode 100644 index 0000000000000000000000000000000000000000..029afd09c54d67d2d0140f8510650b5e9ee4b063 Binary files /dev/null and b/docs/map-creation/images/outermost_shape.png differ diff --git a/docs/map-creation/images/overlapping_buildings.png b/docs/map-creation/images/overlapping_buildings.png new file mode 100644 index 0000000000000000000000000000000000000000..bc27ae4a2657ce8f6480125db737eeb84dbc8bf5 Binary files /dev/null and b/docs/map-creation/images/overlapping_buildings.png differ diff --git a/docs/map-creation/images/road_list.png b/docs/map-creation/images/road_list.png new file mode 100644 index 0000000000000000000000000000000000000000..f5b2a94d110894fdf06610f6cef39b381ed6e2fa Binary files /dev/null and b/docs/map-creation/images/road_list.png differ diff --git a/docs/map-creation/images/road_setup_dialog.png b/docs/map-creation/images/road_setup_dialog.png new file mode 100644 index 0000000000000000000000000000000000000000..e8164c842ef60ddc69e3bfc2a9e68c599f814730 Binary files /dev/null and b/docs/map-creation/images/road_setup_dialog.png differ diff --git a/docs/map-creation/images/scenario_layout.png b/docs/map-creation/images/scenario_layout.png new file mode 100644 index 0000000000000000000000000000000000000000..95a93e3c236dd668c335c8c5f97a5349b019315d Binary files /dev/null and b/docs/map-creation/images/scenario_layout.png differ diff --git a/docs/map-creation/map-creation-manual.adoc b/docs/map-creation/map-creation-manual.adoc new file mode 100644 index 0000000000000000000000000000000000000000..10256eda6b91e977042fac40b9ea39cc1b54a676 --- /dev/null +++ b/docs/map-creation/map-creation-manual.adoc @@ -0,0 +1,252 @@ += RoboCup Rescue Map and Scenario Creation Manual +:author: RoboCup Rescue Simulation Team +:revnumber: 2.0 +:revdate: September 27, 2021 +:size: A4 +:reproducible: true +:encode: UTF-8 +:lang: en +:sectids!: +:sectnums: +:sectnumlevels: 4 +:toclevels: 3 +:outlinelevels: 3 +:xrefstyle: short +:imagesdir: images +:math: +:stem: latexmath +:source-highlighter: highlight.js +:bibtex-style: apa +:bibtex-order: alphabetical +:bibtex-format: asciidoc +:title-page: +:toc: left + +<<< + +[#purpose] +== Purpose +The RoboCup Rescue Simulator comes with some example maps that can be used to test and analyze a team of agents' performance. Although useful, these different maps do not represent all possible situations to evaluate a strategy or overall performance of a team of agents. Furthermore, teams would benefit to assess their performance in a larger number and variate of maps. Hence, it is useful to be able to create new maps for the RoboCup Rescue Simulator. + +This tutorial describes the procedure to create maps and scenarios compatible with the RoboCup Rescue Simulator. The tutorial illustrates the basic steps to create a map and scenario using the creation of the map of the University of São Paulo, Brazil as example. + +[#Tools] +== Tools + +[#openstreetmap] +=== OpenStreetMap + +https://www.openstreetmap.org[OpenStreetMap] (OSM) is a free worldwide map web platform developed collaboratively. OpenStreetMap provides free to use geographic information from many places around the world. It was created under the project _Planet OSM_ aimed to provide geographic information in XML format, containing description of Nodes, Ways, and Relations. A new version of the project is released every week in a single XML file (around 93GB compressed at September 5, 2020). The entire map, or the latest weekly changeset, can be downloaded at https://planet.openstreetmap.org/. <> shows the layout of a reduced `.osm` file. + +[#fig:osm_layout] +.OSM Layout +image::osm_layout.png[OSM Layout] + +[#gml] +=== Geographic Markup Language +https://www.iso.org/standard/75676.html[Geographic Markup Language] (GML) is a XML-­based grammar used to describe interchangeable geographic information. It was defined by the https://www.ogc.org/[Open Geospatial Consortium], and it is largely used for providing a rich set of markup primitives that allow the creation of application specific schemas, such as the definition of Buildings and Roads. The RoboCup Rescue Simulator uses the GML format for representing the entities in its maps. + +[#josm] +=== Java OpenStreetMap editor +https://josm.openstreetmap.de/[Java OpenStreetMap Editor] (JOSM) is an open Java-­based OpenStreetMap editor, an application originally developed by Immanuel Scholz and currently maintained by Dirk Stocker. JOSM can be used to download, edit, and convert maps from OSM to the GML format. The conversion requires a plugin that can be downloaded at https://github.com/roborescue/osm-converter[RCR-converter]. + +[#osm2gml] +=== `osm2gml` +The `osm2gml` enables the conversion from OSM to GML standard, transforming the XML file from one format to the other. The conversion process changes the features in the original map to make it compatible with the GML representation of the maps in the RoboCup Rescue Simulator. The `osm2gml` is part of the RoboCup Rescue Server project (see README at https://github.com/roborescue/rcrs-server[RoboCup Rescue Server]). + +[#creation_process] +== Map and scenario creation process +In a nutshell, the process of creating a map for the RoboCup Rescue Simulator is comprised of 3 basic steps: + +. Capture the map in a OSM file format (`.osm` extension) + +The JOSM editor is used to browse through the OSM worldwide map, select the wanted area of the map, and export the map area information as an `.osm` file. <> illustrates in detail how to perform these tasks. + +. Convert the OSM file into the GML file format + +The `osm2gml` tool is used to convert the OSM file into a GML file format. If the conversion fails, perform the map capture again using the JOSM. <> illustrates in detail how to use the `osm2gml` tool and some recurrent changes that must be made on the OSM map before converting it. + +. Create a valid RoboCup Rescue scenario for the map on the simulator + +To use the map on the RoboCup Rescue Simulator, a scenario has to be created setting the initial position of agents, special buildings like Ambulance Center, Fire Brigade, Police Station, and Refuges. <> illustrates in detail how to setup a scenario associated to a specific map. + +[#map_capturing] +=== Map capturing +The map capturing is performed using the JOSM tool and it is comprised of another 3 stages: install and run the JOSM tool <>, select and download locally a region of the map <>, and save it as an `.osm` file <>. + +[#josm_run] +==== Download and run JOSM +First, download the JOSM tool from the http://josm.openstreetmap.de/. There are multiple alternatives to download JOSM, i.e., Installer, Launcher, JAR file. The recommended alternative is the JAR file, which is compatible with any environment supporting Java 8+. Once downloaded, execute the JAR file as + +[source,shell] +---- +$ java -jar josm-tested.jar +---- + +<> illustrates the JOSM editor interface. + +[#fig:josm_editor] +.JOSM Editor +image::josm_editor.png[JOSM Editor] + +[#map_select] +==== Select and download the region of the map +On the toolbar, select the green arrow button to "Download Map from OSM Server" and a zoomed out map is shown (see <>). + +[#fig:josm_map] +.JOSM Zoomed Map +image::josm_map.png[JOSM Map] + +Manually zoom in until the region of interest is found. After finding the region of interest, select the specific area you want to download, and select the _Download_ button to download the selected region. <> shows the selected area corresponding to the University of São Paulo. + +[#fig:map_usp] +.JOSM University of São Paulo (USP) map selection +image::map_usp.png[University of São Paulo] + +[#map_save] +==== Save the OSM file +After downloading the area of the map from the OpenStreetMap server, JOSM will open the edit screen with the downloaded map on display. Before starting editing it, save the map using the `File` -­> `Save As..` menu options (see <>). + +[#fig:map_save] +.JOSM Downloaded University of São Paulo (USP) map +image::map_save.png[Downloaded University of São Paulo (USP) map] + +[#map_conversion] +=== Convert OSM map into GML map format +After saving the map in OSM format, there is the need to convert it into the GML format compatible with the RoboCup Rescue Simulator using the `osm2gml` tool. The OSM map, however, normally contains some kinds of shapes and streets that causes the conversion to fail, and some buildings and streets not marked as such, which makes them disappear in the conversion process. <> describe some of these problems and how to overcome them. + +[#adjust_osm] +==== Adjusting the OSM map +In order to make the map convertible to the GML format, some changes have to be made on the original OSM map. + +NOTE: The problems reported here are not exhaustive, but purely based on experience during the creation of the University of São Paulo map. Some of these problems may not show up in other map conversions and new problems may arise. + +[#buildings] +===== Buildings + +* Remove Buildings from outermost shapes + +Some of the buildings overlap with the outermost shape in the map. The converter interprets all buildings overlapping with the outermost shape as only one, the outermost one, eliminating all buildings. To prevent this situation, it is necessary to remove the outermost shape, allowing the buildings to be processed separately. In order to remove the outermost shape, click in one of its edges, then press `Delete`. <> illustrates the case of multiple buildings inside another shape. + +[#fig:outermost_shape] +.Outermost Shape +image::outermost_shape.png[Outermost Shape] + +* Making _Buildings_ as _Building_ + +Because most of the times shapes corresponding to _Buildings_ in the original OSM map are not marked as buildings, the converter does not generate a corresponding building at the resulting GML map. Hence, it is necessary to identify manually all the non-marked buildings in the OSM map. To set one shape as Building, select the shape then go to `Presets` -­> `Man Made` -­> `Man Made` -­> `Building` menu option. Then, select one of the Building type. <> shows the setup of a shape as building. + +[#fig:building_setup] +.Building Setup +image::building_setup.png[Building Setup] + +* Separate Overlapping Buildings + +The original map may contain shapes that overlap each other, either two buildings, or one building and a road, or two roads. The converter processes these overlapping during the conversion process, but sometimes it fails. The safest practice is to separate the overlapping shapes in your map before converting it. Select one of the shapes and drag and drop it to separate one from the other. <> illustrates an example of overlapping buildings. + +[#fig:overlapping_buildings] +.Overlapping Buildings +image::overlapping_buildings.png[Overlapping Buildings] + +[#roads] +===== Roads + +* Setup roads as both ways + +Most roads on the original map are set as only one way road, although some of them should be both ways roads (see <>). + +[#fig:both_way_road] +.Both Way Road +image::both_way_road.png[Both Way Road] + +To set roads as both ways, select it then go to `Presets` -­> `Highways` -> `Streets` and select the street type. A dialog will appear, before clicking `OK`, make sure the checkbox `Oneway` is not selected. <> illustrates the dialog for the option of "Unclassified" street. + +[#fig:road_setup_dialog] +.Road Setup Dialog +image::road_setup_dialog.png[Road Setup Dialog] + +* Remove roads from inside buildings + +The original OSM map may have some lines inside the buildings, which represent the path one can walk inside them. But sometimes these lines are interpreted by the converter as roads, and this can cause the conversion process to fail. To prevent this problem, it is necessary to remove these lines from inside the buildings. <> shows an example of lines inside a building. + +[#fig:line_building] +.Lines Inside the Building +image::line_building.png[Lines Inside the Building] + +[#running_converter] +==== Running the map converter +To convert the adjusted OSM map into the GML format, it is necessary to run the `osm2gml` converter. The run the converter, open a terminal window, navigate to the `rcrs-server` root directory and execute + +[source,shell] +---- +$ ./gradlew osm2gml --args=' ' +---- + +The `` is the path to the OSM map file and the `` is the destination GML map path. + +NOTE: Even after running all the checks in <>, there still may be some invalid entities in the map may cause the conversion to fail. Use the JOSM to fix those newly identified error in an iterative process. + +<> illustrates the converter application running, and <> shows the resulting map after the conversion. + +[#fig:converter_running] +.Converter `osm2gml` Running +image::converter_running.png[Converter `osm2gml` Running] + +[#fig:converter_result] +.Conversion Result +image::converter_result.png[Conversion Result] + +[#map_scenario] +=== Create a Scenario +Create a scenario means configuring the initial state of the entities in a map such as the initial location of agents, the locations of the centre agents, buildings on fire, etc. + +To illustrate the creation of a scenario, the University of São Paulo created in <> is used. + +[#map_directory] +==== Map directory +The maps and scenarios of the current maps in the RoboCup Rescue Simulator ae stored in the directory `rcrs-server/maps/gml/`. Inside each folder in this directory there are a `map.gml` and a `scenario.xml` file. The former represents the map in GML format, while the latter represents one scenario for that specific map. + +[#gml_layout] +==== GML map file layout +In order to create a scenario, it is necessary to understand the layout of the GML file. The GML file is separated into 4 important parts: the node list, +the edge list, the building list, and the road list. + +The edge list contains information of all the edges that are composed by the nodes in the node list. The buildings and roads are defined based on the edges. <> and <> show a example of the building and road lists on a GML map file. + +[#fig:building_list] +.GML Building List +image::building_list.png[GML Building List] + +[#fig:road_list] +.GML Road List +image::road_list.png[GML Road List] + +[#create_scenario] +==== Creating a scenario +The scenario file is also XML formatted file, and contains a list of the entities that compose the simulation initial state, including the starting fires, refuges, civilians, agents, etc. Each element of the xml file has two attributes. The first determines the type of entity being created (fire, refuge, +ambulance, ambulance centre, etc.) and the second determines where the location of the entity in the map at the beginning of the simulation. The location is a number that refers to the `id` of an entity in the GML file (either a Building or a Road). + +There are two tools that can assist in creating a scenario: Scenario Editor and Random Scenario. Please refer the https://roborescue.github.io/rcrs-docs/rcrs-server/manual.html[RoboCup Rescue Simulator Manual] for information of how to run these tools. + +<> shows a reduced representation of scenario file created for University of São Paulo map. + +[#fig:scenario_layout] +.Scenario Layout +image::scenario_layout.png[Scenario Layout] + +Some types of entities can be located only on Buildings, others only on Roads, and other yet in both. The following list shows the types of entities and where they can be located at. + +* Building +** fire +** refuge +** firestation +** ambulancecentre +** policeoffice +** gasstation +** ambulanceteam +** policeforce +** firebrigade +** civilian +* Road +** hydrant +** ambulanceteam +** policeforce +** firebrigade +** civilian \ No newline at end of file diff --git a/docs/map-creation/map-example.tar.gz b/docs/map-creation/map-example.tar.gz new file mode 100644 index 0000000000000000000000000000000000000000..555d9711b1780142eb50396a812b87b35cb8b66e Binary files /dev/null and b/docs/map-creation/map-example.tar.gz differ diff --git a/docs/map-creation/references.bib b/docs/map-creation/references.bib new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/docs/rcrs-competition/rcrs-competition-manual.adoc b/docs/rcrs-competition/rcrs-competition-manual.adoc new file mode 100644 index 0000000000000000000000000000000000000000..18322d1a28f37a51b65fd2616c12936159ecbc61 --- /dev/null +++ b/docs/rcrs-competition/rcrs-competition-manual.adoc @@ -0,0 +1,153 @@ += RoboCup Rescue Simulation Competition Manual +:author: RoboCup Rescue Simulation Team +:revnumber: 1.0 +:revdate: September 27, 2021 +:size: A4 +:reproducible: true +:encode: UTF-8 +:lang: en +:sectids!: +:sectnums: +:sectnumlevels: 3 +:toclevels: 3 +:outlinelevels: 3 +:xrefstyle: short +:imagesoutdir: images +:imagesdir: images +:math: +:stem: latexmath +:source-highlighter: highlight.js +:bibtex-file: rcrs-competition/references.bib +:bibtex-style: apa +:bibtex-order: alphabetical +:bibtex-format: asciidoc +:title-page: +:toc: left + +<<< + +[#purpose] +== Purpose +The manual describes the sequence of tasks to setup and run the RoboCup Rescue Simulation competition on a cluster of Linux computers. + +[#general-notes] +== General Notes +This manual assumes the RoboCup Rescue Simulation competition will run in a cluster of Linux machines. + +[#requirements] +=== Software Requirements + +* https://www.openssh.com/[OpenSSH] +* https://openjdk.java.net/[Java OpenJDK 11+] +* https://git-scm.com/[Git] +* https://gradle.org/[Gradle] +* Utilities like bash`, `xterm`, `tar`, `7zip`, `gzip`, etc. + + *Note:* If you are using Ubuntu, all of these utilities are present in the default software repositories. + +[#setup] +== Setup +The competition environment is composed of 5 Linux computers, one controller called `controller` and four simulation computer called `c1-1`, `c1-2`, `c1-3`, and `c1-4`. The `c1-1` runs the RoboCup Rescue Simulator, while each other computer `c1-2`, `c1-3`, and `c1-4` runs a specific type of agents (i.e., ambulance teams, fire brigades, and police forces). + +[#controller] +=== Installation +In Ubuntu, the installation proceeds according to the following commands. + +[source,shell] +.Installation on Ubuntu +---- +$ git clone https://github.com/roborescue/rcrs-server.git +$ cd rcrs-server +$ ./gradlew completeBuild +---- + +You can download the simulation server by cloning the `https://github.com/roborescue/rcrs-server` repository. Clone the simulator server using the command + +[source,shell] +---- +git clone https://github.com/roborescue/rcrs-server.git +---- + +General Notes: +Getting server access for the first time: +ssh-keygen +ssh-copy-id rescue@116.203.191.59 + +Login to the server: ssh -X rescue@116.203.191.59 +Validate display is connected by typing in the terminal: +“echo $DISPLAY” or “xcalc” +check.sh -> checks cluster connection + +To access the clusters: +Cluster 1: ssh c1-1 +Cluster 2: ssh c2-1 + +Teams names in the scripts: AIT, CSU, MRL, RI1 + +Preparing for competition day: +nano scripts/remote-control/config.sh -> to select the right day, ex: DAY = Day1, DAY = Final + +Copy maps to clusters: +Check map exists in /home/rescue/in_maps/submission_day/ +Copy map to /home/rescue/maps/ -> cp -r paris/ ../../maps/paris3 +./copyToServers.sh maps/ -> maps folder should contains maps directly, ex: maps/paris3 + +Check teams submitted their code: +Teams codes should be in /home/team_name/code/submission_day_time/ + +Copy new submitted code to clusters: +cd home/rescue/codeDir +rm -rf in/* +rm -rf out/* +./fetchCodes.sh -> nano before copying & validate the code version is correct, ex: 10 = day 1 first submission, 11 = day 1 2nd submission….etc +./prepare.sh teams_name (ex: RI1, MRL) +./uploadCodes.sh +cd .. -> go back to rescue folder +./copyToClients.sh code/ + +Run maps: +./run.sh [cluster_number] [map] [team_name] +Example: ./run.sh 1 berlin1 AIT +./cancelRun.sh (1 or 2) -> if there are any errors + +Generate logs: +nano scripts/evaluation/config.py -> make sure teams, maps per day & days are added properly +evalAll.sh -> if this doesn’t work then run evalLog for each team +evalLog.sh [path_to_gz_file] [map] [team_name] +Example: evalLog.sh logs/Day1/kernel/0624-104636-CSU-Yunlu-eindhoven1.gz eindhoven1 CSU + +== Notes + +evaluation = log execution +code = team code +codeDir = prepare team code +codeDir/in = team code + +./fetch Codes to fix copy +nn = variable + +./prepare.sh CS | AIT | RIO | MRL + +./updateCodes.sh + +./copyToClients.sh code/ = copy code to all machines +./check.sh = check all machine connections +./copyToServers.sh maps/ +* maps with the proper numbering + +=== Run the competition + +./run.sh [cluster number] [map name] [team name] + +./cancelRun.sh [cluster number] + +=== Update Web Interface +./evalAll.sh + +scripts/remote_control/config.sh +scripts/evaluation/config.py + +logs/Day1/kernel = Log of teams + +./evalLog.sh logs/Day1/kernel/ [map name] [team name] + +./gatherLogs.sh \ No newline at end of file diff --git a/docs/rcrs-competition/references.bib b/docs/rcrs-competition/references.bib new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/docs/rcrs-server/images/ambulance_centre.png b/docs/rcrs-server/images/ambulance_centre.png new file mode 100644 index 0000000000000000000000000000000000000000..ff49933cec37f3bc1ebc8a81f5d74b8fad475f00 Binary files /dev/null and b/docs/rcrs-server/images/ambulance_centre.png differ diff --git a/docs/rcrs-server/images/building_status.png b/docs/rcrs-server/images/building_status.png new file mode 100644 index 0000000000000000000000000000000000000000..6bfebf0e5d253ccdfa07f882a0ea4e6be070c2be Binary files /dev/null and b/docs/rcrs-server/images/building_status.png differ diff --git a/docs/rcrs-server/images/entities.png b/docs/rcrs-server/images/entities.png new file mode 100644 index 0000000000000000000000000000000000000000..5cdf66a4d676c4213c31163d45e27b3c06235c6e Binary files /dev/null and b/docs/rcrs-server/images/entities.png differ diff --git a/docs/rcrs-server/images/fire_station.png b/docs/rcrs-server/images/fire_station.png new file mode 100644 index 0000000000000000000000000000000000000000..c52a40b4240e012a20e10037bd446ef83b4e19b2 Binary files /dev/null and b/docs/rcrs-server/images/fire_station.png differ diff --git a/docs/rcrs-server/images/no_los.png b/docs/rcrs-server/images/no_los.png new file mode 100644 index 0000000000000000000000000000000000000000..1e854a7459a5bb18c5a3fec5dfe1dc8ccdbca2f5 Binary files /dev/null and b/docs/rcrs-server/images/no_los.png differ diff --git a/docs/rcrs-server/images/police_office.png b/docs/rcrs-server/images/police_office.png new file mode 100644 index 0000000000000000000000000000000000000000..cfd98e0a17b2282d077a1d7d572f6e61d7b3696f Binary files /dev/null and b/docs/rcrs-server/images/police_office.png differ diff --git a/docs/rcrs-server/images/refuge.png b/docs/rcrs-server/images/refuge.png new file mode 100644 index 0000000000000000000000000000000000000000..2b7cd2e0971b6a2c04c0f62330dab9dc1eadd97c Binary files /dev/null and b/docs/rcrs-server/images/refuge.png differ diff --git a/docs/rcrs-server/images/simulator_architecture.png b/docs/rcrs-server/images/simulator_architecture.png new file mode 100644 index 0000000000000000000000000000000000000000..d8e41bbed0e61d814091ca3b1e88346d448609ca Binary files /dev/null and b/docs/rcrs-server/images/simulator_architecture.png differ diff --git a/docs/rcrs-server/images/with_los.png b/docs/rcrs-server/images/with_los.png new file mode 100644 index 0000000000000000000000000000000000000000..6eb15d67ac3fc2daae4dd0da188480c0b3bcccf3 Binary files /dev/null and b/docs/rcrs-server/images/with_los.png differ diff --git a/docs/rcrs-server/rcrs-server-manual.adoc b/docs/rcrs-server/rcrs-server-manual.adoc new file mode 100644 index 0000000000000000000000000000000000000000..a9cb9da863779a009bdc626b827dea2cc42e4ae2 --- /dev/null +++ b/docs/rcrs-server/rcrs-server-manual.adoc @@ -0,0 +1,443 @@ += RoboCup Rescue Simulator Manual +:author: RoboCup Rescue Simulation Team +:revnumber: 1.5 +:revdate: September 27, 2021 +:size: A4 +:reproducible: true +:encode: UTF-8 +:lang: en +:sectids!: +:sectnums: +:sectnumlevels: 3 +:toclevels: 3 +:outlinelevels: 3 +:xrefstyle: short +:imagesdir: images +:math: +:stem: latexmath +:source-highlighter: highlight.js +:bibtex-style: apa +:bibtex-order: alphabetical +:bibtex-format: asciidoc +:title-page: +:toc: left + +<<< + +[#purpose] +== Purpose +The manual facilitates the understanding of the RoboCup Rescue Simulation server and helps people interested in participating in RoboCup Rescue Agent Simulation competitions. + +[#installation] +== Installation +This manual assumes the simulator will run in a Linux machine even though it is possible to run them in Microsoft Windows or Apple macOS. We recommend to use Linux because it is open-source and most of the distributions have a good support from the users' community. If you have never used Linux before and intend to, we recommend starting with a user-friendly distribution, such as https://www.ubuntu.com/[Ubuntu] or https://getfedora.org[Fedora]. + +[#requirements] +=== Software Requirements + +* https://openjdk.java.net/[Java OpenJDK 11+] +* https://git-scm.com/[Git] +* https://gradle.org/[Gradle] +* Utilities like `wget`, `bash`, `xterm`, `tar`, `gzip`, etc. + + *Note:* If you are using Ubuntu, all of these utilities are present in the default software repositories. + +[#download] +=== Download +You can download the simulation server by cloning the `https://github.com/roborescue/rcrs-server` repository. Clone the simulator server using the command + +[source,shell] +---- +git clone https://github.com/roborescue/rcrs-server.git +---- + +[#directories] +=== Directories +The `rcrs-server` contains multiple directories. The important directories of the server are: + +* `boot`: scripts to run the simulation server +** `boot/config/`: default configuration files +** `boot/logs/`: text log files +** `boot/records/`: JSON log files +* `build/`: compiled Java classes +* `docs/`: documentation +* `jars/`: simulator JAR files +* `lib/`: external libraries +* `maps/`: maps and scenarios +* `modules/`: simulator source code +* `oldsims/`: old simulator source code + +[#compiling] +=== Compiling +The simulation server has to be compiled on your machine to generate the required JAR files to run the simulator. Execute the steps below to compile the simulation server. + +. Change to the directory `rcrs-server` +.. If macOS, patch the file `boot/functions.sh` using command + + `sed -i -e "/readlink/s/^/#/" boot/functions.sh` +. Compile the simulator using the command `./gradlew completeBuild` +. Check the message at the end of the installation. If the installation is successfully completed, the message `BUILD SUCCESSFUL` is displayed; otherwise `BUILD FAILED` is displayed. + +[#example] +=== Example +In Ubuntu, the installation proceeds according to the following commands. + +[source,shell] +.Installation on Ubuntu +---- +$ git clone https://github.com/roborescue/rcrs-server.git +$ cd rcrs-server +$ ./gradlew completeBuild +---- + +The following message will be displayed if the installation is successfully completed. + +[source,text] +.Install Completion +---- +BUILD SUCCESSFUL in 2s +1 actionable task: 1 executed +---- + +[#running] +== Running +There are two modes of execution of the simulation server: *Precomputation* and *Normal*. + +[#precomputation_mode] +=== Precomputation Mode +In the precomputation mode, the simulator connects one agent of each type and allows them to write the computation results. + +The sequence of commands to run the simulation server in precomputation mode are: + +[source,shell] +.Running simulation server in precomputation mode +---- +$ cd rcrs-server +$ cd boot +$ bash start-precompute.sh +---- + +After running the simulation server, run the agents. Once the precomputation is completed, push _Control-C_ and type `sh kill.sh` to stop the simulation server of running. + +[source,shell] +.Stop running simulation server in precomputation mode +---- +Control-C +$ bash kill.sh +---- + +[#normal_mode] +=== Normal Mode +In the normal mode, the simulator connects all agents defined in the scenario and allows them to use the precomputation output. + +The sequence of commands to run the simulation server in normal mode are: + +[source,shell] +.Running simulation server in normal mode +---- +$ cd rcrs-server +$ cd boot +$ bash start-comprun.sh +---- + +After running the simulation server, run the agents. Once the simulation is completed, the server will stop automatically. + +[#parameters] +=== Parameter Options +The following parameters can be used to run the simulation server: + +* `-m MAPDIR` or `--map MAPDIR`, where `MAPDIR` is the path to the directory containing the map you want to run (default is `../maps/gml/test/map`). +* `-c CONFIGDIR` or `--config CONFIGDIR`, where `CONFIGDIR` is the directory containing the configuration associated with a map (default is `../maps/gml/test/config`). +* `-l LOGDIR` or `--log LOGDIR`, where `LOGDIR` is the directory where the log files will be stored (default is `./logs`). + +These parameters can be used at running a precomputaion and a normal simulation. You must use the same parameters for `MAPDIR` and `CONFIGDIR` to run a simulation server in precomputation and normal mode. An example of how to run the simulation server using these parameters is: + +[source,shell] +.Running Simulation Server with Options +$ bash start-precompute.sh -m ../maps/gml/kobe/map -l logs2 +(After completing precomputation) +Control-C +$ bash kill.sh +$ bash start-comprun.sh -m ../maps/gml/kobe/map -l logs2 + +[#tools] +== Tools +The simulation server comes with several tools to support the development of new maps and scenarios as well as replaying of the simulation. + +[#map-editor] +=== Map editor +Open a terminal window, navigate to the `rcrs-server` root directory and execute + +[source,shell] +---- +$ ./gradlew gmlEditor --args= +---- + +where `--args=` is optional. + +For example, +[source,shell] +---- +$ ./gradlew gmlEditor + +$ ./gradlew gmlEditor --args="../maps/gml/test/map" +---- + +[#scenario-editor] +=== Scenario Editor +Open a terminal window, navigate to the `rcrs-server` root directory and execute + +[source,shell] +---- +$ ./gradlew scenarioEditor --args= +---- + +where `--args=` is optional. + +For example, +[source,shell] +---- +$ ./gradlew scenarioEditor + +$ ./gradlew scenarioEditor --args="../maps/gml/test/map" +---- + +[#random-scenario] +=== Random Scenario +Open a terminal window, navigate to the `rcrs-server` root directory and execute + +[source,shell] +---- +$ ./gradlew randomScenario --args= +---- + +where `--args=` is optional. + +For example, +[source,shell] +---- +$ ./gradlew randomScenario + +$ ./gradlew randomScenario --args="../maps/gml/test/map -civ 10 100 -fb 1 50 -fs 0 1 -pf 1 50 -po 0 1 -at 1 50 -ac 0 1 -refuge 1 2 -fire 0 1" +---- + +[#log-viewer] +=== Log Viewer +Open a terminal window, navigate to the `rcrs-server` root directory and execute + +[source,shell] +---- +$ ./gradlew logViewer --args='-c config/logviewer.cfg ' +---- + +where `--args='-c config/logviewer.cfg '` is optional and `` defines the log file path. The default log file path is `logs/rescue.log`. + +[#osm2gml] +=== `osm2gml` +Open a terminal window, navigate to the `rcrs-server` root directory and execute + +[source,shell] +---- +$ ./gradlew osm2gml --args=' ' +---- + +The `` is the path to the OSM map file and the `` is the destination GML map path. + +[#design] +== Simulator Design +This section describes the simulator architecture and its main features as well as the entities composing a simulation scenario. + +[#architecture] +=== Architecture +The RoboCup Rescue Simulation server is composed of several simulators as listed in <>. + +[#table:simulators] +.List of Simulators +|=== +| Simulator | Description + +| Clear | Manage blockade removal +| Collapse | Manage buildings' structural damage and blockade creation +| Ignition | Randomly ignites fire on buildings during the simulation +| Fire | Manage the fire spread between buildings and extinction +| Traffic | Manage humans' movement +| Miscellaneous | Manage human damage and buriedness +|=== + +These simulators establish connections to the _kernel simulator_, responsible for coordinating the simulators' processes and centralizing the data they generate cite:[skinnerRamchurn2010]. These connections are illustrated in <>. + +[#fig:simulator_architecture] +.RoboCup Rescue Agent Simulation platform architecture +image::simulator_architecture.png[RoboCup Rescue Agent Simulation platform architecture, align="center"] + +The RoboCup Rescue simulator was designed to create a _partially observable_, _discrete-time_, _dynamic_, _stochastic_, _multiagent_ environment. In other words, in this environment: + +* the complete world current state cannot be known through a single agent's perception (even if the agent has an infinite range of sight, it still will not be able to see through a building's walls); +* time is divided in intervals, as opposed to continuous time; +* there are random elements that affect its state transition; +* there is more than one agent present, and one's actions may interfere with the others' performance. + +Time is divided in _timesteps_; during each timestep, the agent perceives the environment and reasons about what action it will perform. In each timestep, the following happens: +. The kernel updates all agents' perception (visual and communication) and waits for the agents' commands. +. The agents updates their world model and make their decisions, sending their commands to the kernel. +. The kernel sends the agents' commands to the simulators. +. The simulators process the agents' commands and send the changes suffered by the environment back to the kernel. +. The kernel sends the environment changes to the viewers. + +[#entities] +=== Entities +Several objects are represented in the simulator as depicted in <>. + +[#fig:entities] +.Entities of the simulator +image::entities.png[Entities of the simulator] + +[#blockades] +==== Blockades +Blockades obstruct the path of agents and civilians; they are represented as black polygons in roads. Blockades appear in the beginning of the simulation and are not produced after this. They must be removed by Police Forces. + +The properties constituting a blockade are: + +[horizontal] +position:: ID of the road to which the blockade belongs +repair cost:: cost to completely remove the blockade from the road +shape:: a rectangle which surrounds the whole blockade +X & Y:: coordinates of the blockade's centroid +apexes:: vector containing the apexes of the blockade + +[#area] +==== Area +Area entities represent buildings and roads. + +The properties constituting an area are: + +[horizontal] +blockades:: a list with the blockades in that area +edges:: a list with the edges that limit the area +neighbours:: a list of the areas that can be accessed from this area +X & Y:: coordinates representing the area in the map + +While both *Buildings* and *Roads* have the blockades attribute, blockades are valid only in *Roads*. + +[#buildings] +==== Buildings +Buildings represent all kinds of buildings in the simulator. There are special kinds of buildings like *Refuges*, *Ambulance Centres*, *Fire Stations*, and *Police Offices* that cannot catch on fire. <> shows the illustration of these special buildings, they will be described in later sections of this document. + +[#table:special_buildings] +[cols="2*^"] +.Special buildings +|=== +| image:refuge.png[Refuge] + +*Refuge* +| image:ambulance_centre.png[Ambulance Centre] + +*Ambulance Centre* +| image:fire_station.png[Fire Station] + +*Fire Station* +| image:police_office.png[Police Office] + +*Police Office* +|=== + +The properties constituting a building are: + +[horizontal] +brokenness:: how structurally damaged the building is; does not change during the simulation +fieryness:: the intensity of the fire and fire-related damage in the building + * __UNBURNT__ - not burnt at all + * __WATER_DAMAGE__ - not burnt at all, but has water damage + * __HEATING__ - on fire a bit + * __BURNING__ - on fire a bit more + * __INFERNO__ - on fire a lot + * __MINOR_DAMAGE__ - extinguished but minor damage + * __MODERATE_DAMAGE__ - extinguished but moderate damage + * __SEVERE_DAMAGE__ - extinguished but major damage + * __BURNT_OUT__ - completely burnt out +floors:: the number of floors the building has +ground area:: the area of each floor +ignition:: indicates if the simulator has lit this building on fire (*NOTE:* A building can catch on fire by being ignited by the simulator or by being close to a burning building; ignition will be set to "1" if the building was, at some point of the simulation, ignited by the simulator.) +importance:: unknown function; has equal values to all buildings +temperature:: temperature of the building; if it crosses a certain threshold, the building catches on fire +total area:: the total area of the building (*floors* x *ground area*) + +Regular buildings are represented as polygons of various colors, depending of their status, as shown in <>; the darker the color, the greater the structural fire or water damage. + +[#fig:building_status] +.Possible status of regular buildings +image::building_status.png[Building status,600] + +In the beginning of the simulation, broken buildings trap humans inside it under debris; these debris must be removed by *Ambulance Teams*, who then proceeds to rescue the human. + +A *Refuge* is a special kind of building: it represents a place destined to support the rescue activity, providing medical care for the wounded and water to the *Fire Brigades*. In the simulator, humans inside a refuge have their damage zeroed, which means they do not lose health while they stay there; damage will, however, resume when the human entity leaves the refuge. + +Also, *Fire Brigades* have their water supply replenished by a certain amount during each cycle while they are inside the refuge. + +[#roads] +==== Roads +Area entities representing roads have no new attributes besides those of *Area* entities. + +[#humans] +==== Humans +These are the entities representing humans. In the simulator, they can be *Civilians*, *Ambulance Teams*, *Fire Brigades*, or *Police Forces*. They are all represented by circles of different colors, and cannot move by themselves if they are dead or buried. + +The properties constituting a human are: + +[horizontal] +buriedness:: how deep the human is buried +damage:: how much HP the human loses per cycle; zeroes when a refuge is reached +direction:: direction to where the human is moving (inferred); the Y-axis positive half is zero, and the value increases until 129599 ((360 * 60 * 60) - 1) seconds anti-clockwise +HP:: health points of the human; if it reaches 0, the human dies +position:: ID of the entity where the human is; may be an Area entity or a human entity (if it is inside an ambulance) +position history:: a list of the entities the human has passed during the last cycle, in chronological order +stamina:: not implemented; would decrease each time the agent took an action and would be partially replenished at the beginning of each cycle +travel distance:: (unknown) +X & Y:: coordinates representing the human in the map + +The color of each human in the simulator is defined by its type and its health: the lower its health, the darker it is. Dead humans are represented by the black color. + +[#civilians] +==== Civilians +Civilians are human entities and they are not part of a rescue team; they are represented by the color green. Their standard behavior is to walk to the closest refuge on their on if they are not wounded or buried; otherwise, they will have to be transported by an *Ambulance Team*. + +[#agents] +=== Agents +These are the entities that will compose your rescue team; in other words, this is what you will program. Agents are divided in two types: *Platoon Agents* (<>) and *Centre Agents* (<>). + +[#platoon_agents] +==== Platoon agents +Platoon agents are able to interact with the simulated environment through perception and executing actions on it. They can also exchange messages with other agents by vocal or radio communication. They are comprised of three different categories: the *Ambulance Team*, *Fire Brigade*, and *Police Force*. + +[horizontal] +Ambulance Team:: is responsible for transporting rescued victims to a refuge. +Fire Brigade:: is responsible for unburying (i.e., rescuing) victims and extinguishing fires on buildings. They carry a certain amount of water in their tanks and they can replenish it in a refuge. +Police Force:: is responsible for removing blockades from the roads. When ordered to do so, they will clean a certain amount, specified in the repair cost parameter, from the target blockade at each cycle. However, differently from *Ambulance Teams* and *Fire Brigades*, having two *Police Forces* acting on the same blockade brings no advantage to the process: it will be as though there was only one *Police Force* acting on it. + +[#centre_agents] +==== Centre Agents +Centre agents are a type of agents whose only interaction with the world is through radio communication. There are three types of central agents: *Ambulance Centres*, *Fire Stations* and *Police Offices*, and they are represented as buildings. + +[#perception_commands] +=== Perception and Commands +The simulator has two perception modes: _standard_ and _line of sight_. + +The _line of sight_ perception simulates visual perception of the agent: a vision range and a number of rays are defined and the agent percepts anything that is reached by these rays. + +[#fig:no_los] +.No Light of Sight +image::no_los.png[No Light of Sight,450] + +[#fig:los] +.Include Light of Sight +image::with_los.png[Include Light of Sight,450] + +The set of currently visible entities for an agent is stored in a structure named _ChangeSet_; entities present in it are automatically updated in its world model; that is, if an agent perceives a blockade it did not know that was there before, this blockade is automatically added to its world model. The opposite, though does not happen: if the agent does not perceive a blockade any more, nothing in its world model changes, even if it knew that there was a blockade there before. In that case, the agent will still think that there is a blockade in that road, even though such blockade has already been cleared. Thus, it is up to the agent to figure this out and modify its world model accordingly. + +[#communication] +=== Communication +There are two forms of communication available in the simulator: _direct communication_ and _radio communication_. Direct communication, done with the command _speak_, is communication audible to humans within a radius from the emitter agent, as if the emitter shouted something. + +Radio communication is done with the command _tell_, and transmits information to all agents that are signed up to the channel on which it was broadcasted. Radio communication channels are present in limited number, each one with a limited bandwidth. + +In both types of communication, the message has to be coded into a string of bytes before being sent; the receptor must decode it once it receives the message. Both types might be susceptible to message _drop out_, where the message is not received by its targets; radio communication is also susceptible to message _failure_, where the message is received empty. + +:!sectnums: +[#references] +== References + +bibliography::[] \ No newline at end of file diff --git a/docs/rcrs-server/references.bib b/docs/rcrs-server/references.bib new file mode 100644 index 0000000000000000000000000000000000000000..64d38db9ea5dd71c2805971a010dee64f3aa7e48 --- /dev/null +++ b/docs/rcrs-server/references.bib @@ -0,0 +1,12 @@ +@InProceedings{skinnerRamchurn2010, + author = {Skinner, Cameron and Ramchurn, Sarvapali}, + title = {The RoboCup rescue simulation platform}, + booktitle = {Proceedings of the 9th International Conference on Autonomous Agents + and Multiagent Systems: volume 1 - Volume 1}, + year = {2010}, + series = {AAMAS '10}, + pages = {1647--1648}, + address = {Richland, SC}, + publisher = {International Foundation for Autonomous Agents and Multiagent Systems}, + location = {Toronto} +} \ No newline at end of file diff --git a/docs/resources/fonts/LibertinusSans-Bold.ttf b/docs/resources/fonts/LibertinusSans-Bold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..73259bf4fd5e11040a9f766c93f0c04d380d94df Binary files /dev/null and b/docs/resources/fonts/LibertinusSans-Bold.ttf differ diff --git a/docs/resources/fonts/LibertinusSans-Italic.ttf b/docs/resources/fonts/LibertinusSans-Italic.ttf new file mode 100644 index 0000000000000000000000000000000000000000..cc1733f3ca233fa25672d6552dd86f014ddbe781 Binary files /dev/null and b/docs/resources/fonts/LibertinusSans-Italic.ttf differ diff --git a/docs/resources/fonts/LibertinusSans-Regular.ttf b/docs/resources/fonts/LibertinusSans-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..37a65c88b50f50f055afef0ef26dcae679d43025 Binary files /dev/null and b/docs/resources/fonts/LibertinusSans-Regular.ttf differ diff --git a/docs/resources/fonts/LibertinusSerif-Bold.ttf b/docs/resources/fonts/LibertinusSerif-Bold.ttf new file mode 100644 index 0000000000000000000000000000000000000000..ea6758b0c1ed58afd909bc8c944d709a1c07447a Binary files /dev/null and b/docs/resources/fonts/LibertinusSerif-Bold.ttf differ diff --git a/docs/resources/fonts/LibertinusSerif-BoldItalic.ttf b/docs/resources/fonts/LibertinusSerif-BoldItalic.ttf new file mode 100644 index 0000000000000000000000000000000000000000..f27cf9601afa0a62029fbbb0cd786fc56dd3ac29 Binary files /dev/null and b/docs/resources/fonts/LibertinusSerif-BoldItalic.ttf differ diff --git a/docs/resources/fonts/LibertinusSerif-Italic.ttf b/docs/resources/fonts/LibertinusSerif-Italic.ttf new file mode 100644 index 0000000000000000000000000000000000000000..0ad1c8058f63c54ea6b6e533e97641c41c36c361 Binary files /dev/null and b/docs/resources/fonts/LibertinusSerif-Italic.ttf differ diff --git a/docs/resources/fonts/LibertinusSerif-Regular.ttf b/docs/resources/fonts/LibertinusSerif-Regular.ttf new file mode 100644 index 0000000000000000000000000000000000000000..bf12e6e12fea4d5cca7de12258843009217344b8 Binary files /dev/null and b/docs/resources/fonts/LibertinusSerif-Regular.ttf differ diff --git a/docs/resources/themes/manual.yml b/docs/resources/themes/manual.yml new file mode 100644 index 0000000000000000000000000000000000000000..bbae7b0d85d2050a8ac9d906542ad12b1565e0f7 --- /dev/null +++ b/docs/resources/themes/manual.yml @@ -0,0 +1,92 @@ +font: + catalog: + Libertinus-Serif: + normal: LibertinusSerif-Regular.ttf + italic: LibertinusSerif-Italic.ttf + bold: LibertinusSerif-Bold.ttf + bold_italic: LibertinusSerif-BoldItalic.ttf + Libertinus-Sans: + normal: LibertinusSans-Regular.ttf + italic: LibertinusSans-Italic.ttf + bold: LibertinusSans-Bold.ttf +page: + layout: portrait + margin: [2.5cm, 2.5cm, 2.5cm, 2.5cm] + size: A4 +base: + align: left + font-family: Libertinus-Serif + font-size: 10 + line-height: 1.25 +toc-title: + align: left +abstract-title: + align: left + font-size: 10 + font-style: bold +abstract: + font-size: 10 + font-style: italic + line-height: 1.4 + padding: [0cm, 0cm, 0cm, 0cm] +heading: + align: left + font-family: Libertinus-Sans + font-size: 12 + margin-top: 0cm + margin-bottom: 0.15cm +thematic-break: + border-color: #000000 + border-style: solid + border-width: 0.15 +code: + background-color: #f5f5f5 + border-color: #ffffff + font-size: 9 +image: + align: center +caption: + align: center + font-size: 10 +header: + border-color: #ffffff + border-style: solid + border-width: 0.25 + font-size: 10 + height: 1.5cm + padding: [0.5cm, 0cm, 0cm, 0cm] + recto: + right: + content: '' + left: + content: '' + center: + content: '' + verso: + right: + content: '' + left: + content: '' + center: + content: '' +footer: + border-color: #000000 + border-style: solid + border-width: 0.15 + font-size: 10 + height: 1.75cm + padding: [0.0cm, 0cm, 0cm, 0cm] + recto: + right: + content: '' + left: + content: '' + center: + content: '{page-number}' + verso: + right: + content: '' + left: + content: '' + center: + content: '{page-number}'