Adding Windows build instructions and refactoring READMEs

PhRosenberger · ClemensLinnhoff · commit 2400c7232868 · 2021-06-18T14:35:15.000+02:00
Signed-off-by: PhRosenberger &lt;philipp.rosenberger@tu-darmstadt.de&gt;
diff --git a/.gitignore b/.gitignore
@@ -1,4 +1,7 @@
-.idea
-cmake-build-debug
-cmake-build-release
-
+cmake*
+build*
+.vscode/
+.editorconfig
+out/
+.idea/
+.vs/
diff --git a/README.md b/README.md
@@ -1,75 +1,45 @@
-# OSI Sensor Model Packaging FMU Framework with Example Strategies
+# Modular OSI Sensor Model Packaging FMU Framework with Example Strategies
 
 <img align="right" src="https://gitlab.com/tuda-fzd/perception-sensor-modeling/object-based-generic-perception-object-model/uploads/17c84e9ec0acf0fac2e35855f038ad0b/fzdlogo.jpg" width="100" />
 This is the OSMP FMU Framework provided with example strategies and profiles.
 <br>
 <img src="https://gitlab.com/tuda-fzd/perception-sensor-modeling/fzd-osmp-model-framework/uploads/172e7820150fb48818bce2c57ce66f85/OSMP_Model_Framework.png" width="800" />
 
 The framework is based on adaptions of OSI Sensor Model Packaging (OSMP) to load individual code modules called strategies and get parameters from profiles into the strategies.
-OSMP specifies ways in which models (like e.g. environmental effect models, sensor models and logical models) using the [Open Simulation Interface (OSI)](https://github.com/OpenSimulationInterface/open-simulation-interface) are to be packaged for their use in simulation environments using FMI 2.0.
+OSMP specifies ways in which models using the [Open Simulation Interface (OSI)](https://github.com/OpenSimulationInterface/open-simulation-interface) are to be packaged for their use in simulation environments using [FMI 2.0](https://fmi-standard.org).
 
-## Important
-
-This work is based on the [`OSMPDummySensor`](https://github.com/OpenSimulationInterface/osi-sensor-model-packaging/tree/master/examples/OSMPDummySensor) example from the [Open Simulation Inferface Sensor Model Packaging project](https://github.com/OpenSimulationInterface/osi-sensor-model-packaging).
+The actual logic of the model is packed in so called strategies.
+This is where the magic happens.
+The `apply()` function of the strategy is called by the `do_calc()` function of the Framework.
+There are two exemplary strategies delivered with this framework:
 
-Before modifying files, carefully read the files [COPYING](COPYING) and [CONTRIBUTING.md](CONTRIBUTING.md).
+1. Example strategy: It simply logs some input data to show that it is running.
+2. CSV output gt objects strategy: It outputs a .csv file to `CSV_PATH` set via `CMakeLists.txt` containing moving objects from the received ground truth.
 
-### Usage
+## Configuration
 
-The actual logic of the model is packed in so called strategies.
-The `apply()` function of a strategy is called by the `do_calc()` function of the OSMP Framework.
+### Model name
 
-When building and installing, the framework will build an fmu package into `_FMU_INSTALL_DIR_`, which can be used with a simulation tool like CarMaker, dSpace ASM or others.
+The model's name (in this case "FrameworkDemoModel") used for CMake-projects and the FMU at the end is defined in file `model_name.conf` located at `src/model`.
 
-## Build Instructions for Ubuntu 18.04 / 20.04
+### Install path
 
-When building and installing, the framework will build an FMU package, which can be used with a simulation tool like CarMaker, dSpace ASM or others.
+When building and installing, the framework will build an FMU package into `FMU_INSTALL_DIR`, which can be used with a simulation tool that supports OSI and fills the required fields listed below.
 
-### Install Dependencies
+### VariableNamingConvention
 
-1. Install cmake 3.12: e.g. with
-   ```bash
-   $ git clone https://github.com/Kitware/CMake
-   $ sudo apt install libssl-dev
-   $ cd CMake
-   $ ./bootstrap
-   $ make -j
-   $ sudo make install
-   ```
-2. Install protobuf 3.0.0:
-   * Check your version via `protoc --version`. It should output: `libprotoc 3.0.0`
-   * If needed, you can install it via `sudo apt-get install libprotobuf-dev protobuf-compiler`
-   * or from source:
-     * Download it from https://github.com/protocolbuffers/protobuf/releases/tag/v3.0.0 and extract the archive.
-     * Try to run `./autogen.sh`, if it failes, download the gmock-1.7.0.zip from https://pkgs.fedoraproject.org/repo/pkgs/gmock/gmock-1.7.0.zip/073b984d8798ea1594f5e44d85b20d66/gmock-1.7.0.zip, extract it into the protobuf folder and rename the gmock-1.7.0 folter to gmock.
-     * Proceed with the install with
-     ```bash
-     $ make
-     $ sudo make install
-     $ sudo ldconfig # refresh shared library cache.
-     ```
+The parameter variableNamingConvention for the FMU specified within the modelDescription.xml is taken from file `variableNamingConvention.conf` located at `src/osmp`.
+Possible values are "flat" or "structured".
 
-### Clone with Submodules, Build, and Install
+### Profiles for Parameterization
 
-1. Clone this repository <ins>with submodules</ins>:
-    ```bash
-    $ git clone https://gitlab.com/tuda-fzd/perception-sensor-modeling/reflection-based-lidar-object-model.git --recurse-submodules
-    ```
-    or alternatively initialize submodules after cloning:
-    ```
-    $ git submodule update --init
-    ```
-2. Build the model by executing in the extracted project root directory:
-    ```bash
-    $ mkdir cmake-build
-    $ cd cmake-build
-    # If FMU_INSTALL_DIR is not set, CMAKE_BINARY_DIR is used
-    $ cmake -DCMAKE_BUILD_TYPE=Release -DFMU_INSTALL_DIR:PATH=/opt/osifmu ..
-    $ make -j N_JOBS
-    ```
-3. Take FMU from `FMU_INSTALL_DIR`
+The profiles are parameterized in the files `profile_*.hpp.in`.
+The parameters are declared in the files `profile.hpp.in`.
+The profiles can be extended by the strategies with additional parameters and values in their respective folders.
 
-    (Please note that sources are not packed into the FMU at the moment.)
+The profile to be loaded for simulation is set via a model parameter defined in the `modelDescription.xml` of the FMU.
+The first name in `src/model/profiles/profile_list.conf` is taken as default.
+If you would like to have a different one or if your simulation master does not support the configuration of model parameters, you have to adapt the *start* value of the parameter `profile` in `src/osmp/modelDescription.in.xml`.
 
 ## How to use (= extend) this framework
 
@@ -126,7 +96,7 @@ Have a look at the existing strategies to get an idea about how easy it is to in
    /* TODO add further profiles and profile generators here */
    #include <model/profiles/profile_NAME.hpp>
    
-   bool CFZDSensorModel::try_load_profile(const std::string &name) {
+   bool CFrameworkPackaging::try_load_profile(const std::string &name) {
       if (name == "NAME") {
          profile = model::profile::NAME::generate();
          return true;
@@ -137,10 +107,75 @@ Have a look at the existing strategies to get an idea about how easy it is to in
    }
    ```
 
-**Note:**
-The profile to be loaded is set via a model parameter defined in the `modelDescription.xml` of the FMU.
-It can be set by the FMU master.
-If it is not set by the FMU master, the first name in `src/model/profiles/profile_list.conf` is simply taken as default.
+## Build Instructions in Windows 10
+
+### Install Dependencies in Windows 10
+
+1. Install cmake from https://github.com/Kitware/CMake/releases/download/v3.20.3/cmake-3.20.3-windows-x86_64.msi
+2. Install protobuf for [MSYS-2020](install_protobuf_Win64_MSYS-2020.md) or [Visual Studio 2017](install_protobuf_Win64_VS2017.md)
+
+### Clone with Submodules, Build, and Install in Windows 10
+
+1. Clone this repository <ins>with submodules</ins>:
+   ```bash
+   $ git clone https://gitlab.com/tuda-fzd/perception-sensor-modeling/modular-osmp-framework.git --recurse-submodules
+   ```
+2. Build the model in [MSYS-2020](install_model_Win64_MSYS-2020.md) or [Visual Studio 2017](install_model_Win64_VS2017.md)
+3. Take FMU from `FMU_INSTALL_DIR`
+
+    (Please note that sources are not packed into the FMU at the moment.)
+
+## Build Instructions in Ubuntu 18.04 / 20.04
+
+### Install Dependencies in Ubuntu 18.04 / 20.04
+
+1. Install cmake 3.12
+   * as told in [these install instructions](install_cmake_ubuntu_3-12.md)
+2. Install protobuf 3.0.0:
+   * Check your version via `protoc --version`. It should output: `libprotoc 3.0.0`
+   * If needed, you can install it via `sudo apt-get install libprotobuf-dev protobuf-compiler`
+   * or from source:
+     * Download it from https://github.com/protocolbuffers/protobuf/releases/tag/v3.0.0 and extract the archive.
+     * Try to run `./autogen.sh`, if it failes, download the gmock-1.7.0.zip from https://pkgs.fedoraproject.org/repo/pkgs/gmock/gmock-1.7.0.zip/073b984d8798ea1594f5e44d85b20d66/gmock-1.7.0.zip, extract it into the protobuf folder and rename the gmock-1.7.0 folter to gmock.
+     * Proceed with the install with
+     ```bash
+     $ make
+     $ sudo make install
+     $ sudo ldconfig # refresh shared library cache.
+     ```
+3. <ins>For ROS-Output-Strategies:</ins> Install ROS melodic (Ubuntu 18.04) / noetic (Ubuntu 20.04)
+   * **Ubuntu 18.04: ROS melodic** <br> http://wiki.ros.org/melodic/Installation/Ubuntu (go with `desktop-full`)
+   * **Ubuntu 20.04: ROS noetic** <br> http://wiki.ros.org/noetic/Installation/Ubuntu (go with `desktop-full`)
+
+### Clone with Submodules, Build, and Install in Ubuntu 18.04 / 20.04
+
+1. Clone this repository <ins>with submodules</ins>:
+    ```bash
+    $ git clone https://gitlab.com/tuda-fzd/perception-sensor-modeling/modular-osmp-framework.git --recurse-submodules
+    ```
+2. <ins>For ROS-Output-Strategies:</ins> Change CMakeLists.txt in every ROS-Strategy according to ROS-version
+   * In `src/model/strategies/ros-.../CMakeLists.txt` change the two lines
+     - **Ubuntu 18.04: ROS melodic**
+       ```CMake
+       list(APPEND CMAKE_PREFIX_PATH /opt/ros/melodic/)
+       set(PYTHONPATH /opt/ros/melodic/lib/python2.7/dist-packages)
+       ```
+     - **Ubuntu 20.04: ROS noetic**
+       ```CMake
+       list(APPEND CMAKE_PREFIX_PATH /opt/ros/noetic/)
+       set(PYTHONPATH /opt/ros/melodic/lib/python3/dist-packages)
+       ```
+3. Build the model by executing in the extracted project root directory:
+    ```bash
+    $ mkdir cmake-build
+    $ cd cmake-build
+    # If FMU_INSTALL_DIR is not set, CMAKE_BINARY_DIR is used
+    $ cmake -DCMAKE_BUILD_TYPE=Release -DFMU_INSTALL_DIR:PATH=/tmp ..
+    $ make -j N_JOBS
+    ```
+4. Take FMU from `FMU_INSTALL_DIR`
+
+    (Please note that sources are not packed into the FMU at the moment.)
 
 ## Licensing
 
diff --git a/install_cmake_ubuntu_3-12.md b/install_cmake_ubuntu_3-12.md
@@ -0,0 +1,43 @@
+#### Download and compile:
+```bash
+$ wget http://www.cmake.org/files/v3.12/cmake-3.12.1.tar.gz
+$ tar -xvzf cmake-3.12.1.tar.gz
+$ cd cmake-3.12.1/
+$ ./configure
+$ make
+```
+
+Make's install command installs cmake by default in /usr/local/bin/cmake, shared files are installed into /usr/local/share/cmake-3.10.
+
+Now it's time to create a backup, in case you need to roll back to the old version:
+```bash
+$ /usr/bin/cmake --version
+cmake version 3.10.1
+
+CMake suite maintained and supported by Kitware (kitware.com/cmake). 
+
+$ sudo cp -p /usr/bin/cmake{,.3.10.1}
+
+$ ll /usr/bin/cmake*
+-rwxr-xr-x 1 root root 16509675 Dez 22  2017 /usr/local/bin/cmake
+-rwxr-xr-x 1 root root 16509675 Dez 22  2017 /usr/local/bin/cmake.3.10.1
+```
+
+To install (copy) the binary and libraries to the new destination, run:
+```bash
+$ sudo make install
+```
+
+If you haven't already installed a newer cmake installation, run the following command to tell Ubuntu that the cmake command is now being replaced by an alternative installation:
+```bash
+$ sudo update-alternatives --install /usr/bin/cmake cmake /usr/local/bin/cmake 1 --force
+```
+
+If you already have a custom cmake version installed (in my case I still had the 3.10.1 version active), the update-alternatives command is not necessary.
+The make install command will replace the existing binary in /usr/local/bin/cmake. This can be verified using:
+```bash
+$ cmake --version
+cmake version 3.12.1
+
+CMake suite maintained and supported by Kitware (kitware.com/cmake).
+```
diff --git a/install_model_Win64_MSYS-2020.md b/install_model_Win64_MSYS-2020.md
@@ -0,0 +1,20 @@
+Build the model by running the following bash script in MSYS-2020:
+   ```bash
+   #!/bin/bash
+   export CC="gcc -std=c++17 -s"
+   export CXX="g++ -std=c++17 -s"
+   mkdir -p build-MSYS && cd build-MSYS && rm -r *
+   mkdir -p install-osi
+   "C:/Program Files/CMake/bin/cmake.exe" \
+      -G "MSYS Makefiles" \
+      -DCMAKE_BUILD_TYPE=Release \
+      -DCMAKE_INSTALL_PREFIX=install-osi \
+      -DFMU_INSTALL_DIR:PATH=C:/tmp \
+      -DPROTOBUF_PROTOC_EXECUTABLE=C:/protobuf-3.3/bin/protoc.exe \
+      -DPROTOBUF_FOUND=C:/protobuf-3.3 \
+      -DProtobuf_INCLUDE_DIR=C:/protobuf-3.3/include \
+      -DPROTOBUF_LIBRARY=C:/protobuf-3.3/lib/libprotobuf.a \
+      ..
+   make -j12
+   make install
+   ```
diff --git a/install_model_Win64_VS2017.md b/install_model_Win64_VS2017.md
@@ -0,0 +1,30 @@
+# Install protobuf for Win64 and Visual Studio 2017
+
+1. Create and run Shell-Script (e.g. with cmd.exe):
+    ```bash
+    #!/bin/bash
+    mkdir -p build-VS2017 && cd build-VS2017 && rm -r *
+    mkdir -p install-osi
+    "C:/Program Files/CMake/bin/cmake.exe" \
+        -G "Visual Studio 15 2017" \
+        -DCMAKE_BUILD_TYPE=Debug \
+        -DCMAKE_INSTALL_PREFIX=install-osi \
+        -DFMU_INSTALL_DIR:PATH=C:/tmp \
+        -DCMAKE_GENERATOR_PLATFORM:INTERNAL=x64 \
+        -DCMAKE_SHARED_LINKER_FLAGS:STRING=/machine:x64 \
+        -DCMAKE_STATIC_LINKER_FLAGS:STRING=/machine:x64 \
+        -DCMAKE_EXE_LINKER_FLAGS:STRING=/machine:x64 \
+        -DCMAKE_MODULE_LINKER_FLAGS:STRING=/machine:x64 \
+        -DProtobuf_INCLUDE_DIR=C:/protobuf-3.14/include \
+        -DPROTOBUF_PROTOC_EXECUTABLE=C:/protobuf-3.14/bin/protoc.exe \
+        -DProtobuf_LIBRARY_DEBUG=C:/protobuf-3.14/lib/libprotobufd.lib \
+        -DProtobuf_LIBRARY_RELEASE=C:/protobuf-3.14/lib/libprotobuf.lib \
+        -DProtobuf_LITE_LIBRARY_DEBUG=C:/protobuf-3.14/lib/libprotobuf-lited.lib \
+        -DProtobuf_LITE_LIBRARY_RELEASE=C:/protobuf-3.14/lib/libprotobuf-lite.lib \
+        -DProtobuf_PROTOC_LIBRARY_DEBUG=C:/protobuf-3.14/lib/libprotocd.lib \
+        -DProtobuf_PROTOC_LIBRARY_RELEASE=C:/protobuf-3.14/lib/libprotoc.lib \
+        ..
+    ```
+3. Open FrameworkDemoModel.sln located in build-dir from above with **Visual Studio 2017**
+4. Build Solution for *Release* AND for *Debug*
+5. Build INSTALL for *Release* AND for *Debug*
diff --git a/install_protobuf_Win64_MSYS-2020.md b/install_protobuf_Win64_MSYS-2020.md
@@ -0,0 +1,16 @@
+# Install protobuf for Win64 and MSYS-2020
+
+Create and run Shell-Script with **MSYS-2020**:
+```bash
+#!/bin/bash
+# Protobuf 3.3.0
+cd C:/tmp
+curl -LO https://github.com/protocolbuffers/protobuf/releases/download/v3.3.0/protobuf-cpp-3.3.0.zip
+unzip -qq protobuf-cpp-3.3.0.zip
+cd protobuf-3.3.0
+export CC="gcc -std=c++17 -s"
+export CXX="g++ -std=c++17 -s"
+mkdir -p build-dir && cd build-dir && rm -r *
+../configure --prefix=C:/protobuf-3.3 --disable-shared
+make -j12 && make install
+```
diff --git a/install_protobuf_Win64_VS2017.md b/install_protobuf_Win64_VS2017.md
@@ -0,0 +1,32 @@
+# Install protobuf for Win64 and Visual Studio 2017
+
+1. Create and run Shell-Script (e.g. with cmd.exe):
+    ```bash
+    #!/bin/bash
+    # Protobuf 3.14.0
+    cd C:/tmp
+    curl -LO https://github.com/protocolbuffers/protobuf/releases/download/v3.14.0/protobuf-cpp-3.14.0.zip
+    unzip -qq protobuf-cpp-3.14.0.zip
+    cd protobuf-3.14.0/cmake
+    mkdir -p build-dir && cd build-dir && rm -r *
+    "C:/Program Files/CMake/bin/cmake.exe" \
+        -G "Visual Studio 15 2017" \
+        -DCMAKE_INSTALL_PREFIX:PATH=C:/protobuf-3.14 \
+        -DCMAKE_SHARED_LINKER_FLAGS:STRING=/machine:x64 \
+        -DCMAKE_STATIC_LINKER_FLAGS:STRING=/machine:x64 \
+        -DCMAKE_EXE_LINKER_FLAGS:STRING=/machine:x64 \
+        -DCMAKE_MODULE_LINKER_FLAGS:STRING=/machine:x64 \
+        -DCMAKE_GENERATOR_PLATFORM:INTERNAL=x64 \
+        -Dprotobuf_WITH_ZLIB:BOOL=OFF \
+        -Dprotobuf_BUILD_TESTS:BOOL=OFF \
+        ..
+    ```
+2. Run extract_includes.bat located in build-dir from above
+3. Open protobuf.sln located in build-dir from above with **Visual Studio 2017**
+4. Change Properties->C/C++->Code Generation of **all** solutions for Configuration *Release* AND *Debug*<br>
+   - Runtime Library for *Release* must be set to "Multi-threaded DLL (/MD)":<br>
+     <img src="https://gitlab.com/tuda-fzd/perception-sensor-modeling/reflection-based-lidar-object-model/uploads/38c646d7442362bbbbce936d67a26836/ASM_protobuf_runtime_library_release.png"  width="800"><br><br>
+   - Runtime Library for *Debug* must be set to "Multi-threaded Debug DLL (/MDd)":<br>
+     <img src="https://gitlab.com/tuda-fzd/perception-sensor-modeling/reflection-based-lidar-object-model/uploads/be2f9e3f0cda9da9bb4686805379b37e/ASM_protobuf_runtime_library_debug.png"  width="800">
+5. Build Solution for *Release* AND for *Debug*
+6. Build INSTALL for *Release* AND for *Debug*
diff --git a/lib/README.md b/lib/README.md
@@ -1,3 +1,3 @@
-# FZD OSMP Framework - *lib* Folder
+# Modular OSMP Framework - *lib* Folder
 
-The lib folder contains libraries used for the entire model. At the moment only OSI and FMI are included, but you can add other libraries for your model, e.g. as git submodules.
+The lib folder contains libraries used for the entire model. At the moment OSI, FMI and Eigen are included, but you can add other libraries for your model, e.g. as git submodules.
diff --git a/src/README.md b/src/README.md
@@ -1,4 +1,4 @@
-# FZD OSMP Framework - src Folder
+# Modular OSMP Framework - src Folder
 
 The src folder is subdevided into *model* and *osmp*.
 
diff --git a/src/model/README.md b/src/model/README.md
@@ -1,4 +1,4 @@
-# FZD OSMP Framework - *model* Folder
+# Modular OSMP Framework - *model* Folder
 
 The *model* folder contains the actual model logic and is subdevided into *include*, *profiles* and *strategies*. It also contains the *model_name.conf*. In this file the name of the model can be set. This will define the name of the overall fmu package as well as the name inside the model description.
 
diff --git a/src/model/include/README.md b/src/model/include/README.md
@@ -1,3 +1,3 @@
-# FZD OSMP Framework - *include* Folder
+# Modular OSMP Framework - *include* Folder
 
 The include folder does not have to be changed by the user. It contains the definition of the strategy class and defines framework in which the strategies are called.
diff --git a/src/model/profiles/README.md b/src/model/profiles/README.md
@@ -1,4 +1,4 @@
-# FZD OSMP Framework - *profiles* Folder
+# Modular OSMP Framework - *profiles* Folder
 
 The *profiles* folder contains the parts of the parameter profiles, that are strategy-independent.
 
diff --git a/src/model/profiles/profile_list.hpp b/src/model/profiles/profile_list.hpp
@@ -24,7 +24,7 @@
 /* TODO add further profiles and profile generators here */
 #include <model/profiles/profile_example.hpp>
 
-bool CFZDSensorModel::try_load_profile(const std::string &name) {
+bool CFrameworkPackaging::try_load_profile(const std::string &name) {
     if (name == "example") {
         profile = model::profile::example::generate();
         return true;
diff --git a/src/model/strategies/README.md b/src/model/strategies/README.md
@@ -1,5 +1,5 @@
-# FZD OSMP Framework - *strategies* Folder
+# Modular OSMP Framework - *strategies* Folder
 
 The strategies folder contains individual folders for every strategy. Inside the modular strategies the actual model code is written. So every strategy is contained in their own folder with their own includes, src and CMakeLists.
 
-The *sequence.conf* defines, in which order the strategies are called by the framework. The indicidual strategies are listed in lines in this file. In this example only the "empty-strategy" is called.
+The *sequence.conf* defines, in which order the strategies are called by the framework. The individual strategies are listed in lines in this file. In this example first the "empty-strategy" is called, then the "csv-output-gtobjects-strategy".
diff --git a/src/model/strategies/example-strategy/README.md b/src/model/strategies/example-strategy/README.md
diff --git a/src/osmp/CMakeLists.txt b/src/osmp/CMakeLists.txt
diff --git a/src/osmp/FrameworkPackaging.cpp b/src/osmp/FrameworkPackaging.cpp
diff --git a/src/osmp/FrameworkPackaging.h b/src/osmp/FrameworkPackaging.h
diff --git a/src/osmp/README.md b/src/osmp/README.md
diff --git a/src/osmp/modelDescription.in.xml b/src/osmp/modelDescription.in.xml
diff --git a/src/osmp/variableNamingConvention.conf b/src/osmp/variableNamingConvention.conf

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-# FZD OSMP Framework - src Folder`
	`1`	`+# Modular OSMP Framework - src Folder`
`2`	`2`
`3`	`3`	`The src folder is subdevided into model and osmp.`
`4`	`4`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-# FZD OSMP Framework - model Folder`
	`1`	`+# Modular OSMP Framework - model Folder`
`2`	`2`
`3`	`3`	`The model folder contains the actual model logic and is subdevided into include, profiles and strategies. It also contains the model_name.conf. In this file the name of the model can be set. This will define the name of the overall fmu package as well as the name inside the model description.`
`4`	`4`
Original file line number	Diff line number	Diff line change
`@@ -1,3 +1,3 @@`
`1`		`-# FZD OSMP Framework - include Folder`
	`1`	`+# Modular OSMP Framework - include Folder`
`2`	`2`
`3`	`3`	`The include folder does not have to be changed by the user. It contains the definition of the strategy class and defines framework in which the strategies are called.`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-# FZD OSMP Framework - profiles Folder`
	`1`	`+# Modular OSMP Framework - profiles Folder`
`2`	`2`
`3`	`3`	`The profiles folder contains the parts of the parameter profiles, that are strategy-independent.`
`4`	`4`