diff --git a/build_mosaic.sh b/build_mosaic.sh
new file mode 100755
index 0000000..4ec725d
--- /dev/null
+++ b/build_mosaic.sh
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+filename="report_dummie.docx"
+weeks_ago="0"
+report_date="2022-12-12"
+
+# Parse de command line argumenten
+while [ "$#" -gt 0 ]; do
+    case "$1" in
+        --weeks_ago=*)
+            weeks_ago="${1#*=}"
+            ;;
+        *)
+            echo "Onbekende optie: $1"
+            exit 1
+            ;;
+    esac
+    shift
+done
+
+# Controleer of de vereiste argumenten zijn ingesteld
+if [ -z "$filename" ] || [ -z "$weeks_ago" ] || [ -z $report_date ]; then
+    echo "Missende argumenten. Gebruik: build_reports.sh --filename=hello.txt --weeks_ago=3 --report_date=2020-01-01"
+    exit 1
+fi
+
+
+echo "Weeks ago: $weeks_ago"
+cd /Users/mfolkerts/smartCane/r_app
+Rscript 2_CI_data_prep.R $weeks_ago
\ No newline at end of file
diff --git a/build_report.sh b/build_report.sh
index dd6da8f..2959f36 100755
--- a/build_report.sh
+++ b/build_report.sh
@@ -1,15 +1,51 @@
 #!/bin/bash
-## Runnen van Rmd bestand
-# -e betekent "evalueren" en -i specificeert de input file
-Rscript --version
-echo $PATH
+
+filename="report_dummie.docx"
+weeks_ago="0"
+report_date="2022-12-12"
+
+# Parse de command line argumenten
+while [ "$#" -gt 0 ]; do
+    case "$1" in
+        --filename=*)
+            filename="${1#*=}"
+            ;;
+        --weeks_ago=*)
+            weeks_ago="${1#*=}"
+            ;;
+        --report_date=*)
+            report_date="${1#*=}"
+            ;;
+        *)
+            echo "Onbekende optie: $1"
+            exit 1
+            ;;
+    esac
+    shift
+done
+
+# Controleer of de vereiste argumenten zijn ingesteld
+if [ -z "$filename" ] || [ -z "$weeks_ago" ] || [ -z $report_date ]; then
+    echo "Missende argumenten. Gebruik: build_reports.sh --filename=hello.txt --weeks_ago=3 --report_date=2020-01-01"
+    exit 1
+fi
+
+# Je script logica hier
+echo "Filename: $filename"
+echo "Weeks ago: $weeks_ago"
+echo "Report date: $report_date"
+
 #script_dir="$(dirname "$0")"
 #echo $script_dir;
 #/bin/ps aux | grep fontd
+#output_file="/Users/mfolkerts/smartCane/laravel_app/storage/app/chemba/$filename"
 
+#echo "Output file: $output_file"
 echo '\n'
 
 echo 'zx28tb' | /usr/bin/sudo -S launchctl load -w /System/Library/LaunchAgents/com.apple.fontd.useragent.plist
 cd /Users/mfolkerts/smartCane/r_app
-Rscript -e "rmarkdown::render('/Users/mfolkerts/smartCane/r_app/CI_Report_dashboard_planet.Rmd', 'all')"
-
+#Rscript -e "rmarkdown::render('/Users/mfolkerts/smartCane/r_app/CI_Report_dashboard_planet.Rmd', 'all')"
+#Rscript 1_harvest_data_EcoFarm_v2.R
+Rscript 2_CI_data_prep.R $weeks_ago
+Rscript -e "rmarkdown::render('CI_report_dashboard_planet.Rmd', output_file='$filename', params=list(ref='$ref', report_date='$report_date'))"
\ No newline at end of file
diff --git a/laravel_app/app/Jobs/ProjectMosiacGeneratorJob.php b/laravel_app/app/Jobs/ProjectMosiacGeneratorJob.php
new file mode 100644
index 0000000..f13ce40
--- /dev/null
+++ b/laravel_app/app/Jobs/ProjectMosiacGeneratorJob.php
@@ -0,0 +1,69 @@
+<?php
+
+namespace App\Jobs;
+
+use App\Models\Project;
+use App\Models\ProjectReport;
+use Illuminate\Bus\Queueable;
+use Illuminate\Contracts\Queue\ShouldBeUnique;
+use Illuminate\Contracts\Queue\ShouldQueue;
+use Illuminate\Foundation\Bus\Dispatchable;
+use Illuminate\Queue\InteractsWithQueue;
+use Illuminate\Queue\SerializesModels;
+use Symfony\Component\Process\Process;
+
+class ProjectMosiacGeneratorJob implements ShouldQueue
+{
+    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
+
+
+    public $year;
+    public $week;
+    public Project $project;
+    /**
+     * Create a new job instance.
+     */
+    public function __construct(Project $project, $year, $week)
+    {
+        $this->year = $year;
+        $this->week = $week;
+        //
+    }
+
+    /**
+     * Execute the job.
+     */
+    public function handle(): void
+    {
+        $weeksAgo = ProjectReport::weeksAgoForYearAndWeek($this->year, $this->week);
+
+        $projectFolder = base_path('../');
+
+        $command = [
+            sprintf('%sbuild_mosaic.sh', $projectFolder),
+            sprintf('--weeks_ago=%s', $weeksAgo),
+        ];
+
+
+        $process = new Process($command);
+        $process->setTimeout(120);
+        $currentPath = '/usr/gnu/bin:/usr/local/bin:/bin:/usr/bin/Users/mfolkerts/anaconda3/bin:/Library/Apple/usr/bin';
+
+        $process->setEnv(['PATH' => $currentPath.':/usr/local/Cellar/pandoc/3.1.8/bin/pandoc']);
+//        $process->setTimeout(36000); // stel een geschikte timeout in
+        $process->start();
+        try {
+            $myOutput = [];
+            $process->wait(function ($type, $buffer) use (&$myOutput) {
+//                $this->stream(to: 'processOutput', content: $buffer);
+                $myOutput[] = $buffer;
+                logger($buffer);
+            });
+            $this->processOutput = collect($myOutput)->join('\n');
+
+        } catch (ProcessFailedException $exception) {
+            echo $exception->getMessage();
+
+        }
+    }
+}
diff --git a/laravel_app/app/Livewire/Projects/MosaicManager.php b/laravel_app/app/Livewire/Projects/MosaicManager.php
new file mode 100644
index 0000000..e784de8
--- /dev/null
+++ b/laravel_app/app/Livewire/Projects/MosaicManager.php
@@ -0,0 +1,58 @@
+<?php
+
+namespace App\Livewire\Projects;
+
+use App\Jobs\ProjectMosiacGeneratorJob;
+use App\Models\Project;
+use Livewire\Component;
+
+class MosaicManager extends Component
+{
+    public $project;
+
+    public $formData = [
+        'week' => '',
+        'year' => '',
+    ];
+    public $showCreateModal = false;
+
+    public function mount(Project $project) {
+        $this->path = $project->download_path;
+    }
+
+    public function render()
+    {
+        return view('livewire.projects.mosaic-manager', [
+            'downloads' => $this->project
+        ]);
+    }
+
+    public function saveMosiac(){
+        $this->validate([
+            'formData.year' => 'required',
+            'formData.week' => 'required',
+        ]);
+
+        ProjectMosiacGeneratorJob::dispatch($this->project, $this->formData['year'], $this->formData['week']);
+
+        $this->showCreateModal = false;
+    }
+
+    public function openCreateMosiacsModal(){
+        $this->showCreateModal = true;
+    }
+
+    public function getDateRangeProperty()
+    {
+        if (empty($this->formData['week']) || strlen($this->formData['year']) !== 4) {
+            return '<span class="text-red-500">Invalid week or year</span>';
+        }
+        $begin = now()
+            ->setISODate($this->formData['year'], $this->formData['week'])
+            ->startOfWeek();
+        $end = now()
+            ->setISODate($this->formData['year'], $this->formData['week'])
+            ->endOfWeek();
+        return $begin->format('Y-m-d').' - '.$end->format('Y-m-d');
+    }
+}
diff --git a/laravel_app/app/Models/Project.php b/laravel_app/app/Models/Project.php
index e7e9b3d..30478d2 100644
--- a/laravel_app/app/Models/Project.php
+++ b/laravel_app/app/Models/Project.php
@@ -5,6 +5,7 @@
 use Illuminate\Database\Eloquent\Factories\HasFactory;
 use Illuminate\Database\Eloquent\Model;
 use Illuminate\Support\Carbon;
+use Illuminate\Support\Collection;
 use Illuminate\Support\Facades\Storage;
 use Illuminate\Support\Str;
 
@@ -143,7 +144,7 @@ public function allMosaicsPresent(Carbon $endDate)
         $mosaicsNotPresentInFilesystem = $this->getMosiacFilenameListByEndDate($endDate)
             ->filter(function ($filename) {
                 return !$this->getMosaicList()->contains(function ($mosaicFilename) use ($filename) {
-                    return Str::endsWith( $mosaicFilename, substr($filename, -16));
+                    return Str::endsWith($mosaicFilename, substr($filename, -16));
                 });
             });
         if ($mosaicsNotPresentInFilesystem->count() === 0) {
@@ -173,5 +174,52 @@ public function getMosiacFilenameListByEndDate(Carbon $endDate): \Illuminate\Sup
         return $result;
     }
 
+    public function getMosiacList()
+    {
+        return collect(Storage::files($this->getMosaicPath()))
+            ->filter(fn($file) => Str::endsWith($file, '.tif'))
+            ->sortByDesc(function ($file) {
+                $parts = explode('_', str_replace('.tif', '', $file));
+                $week = $parts[1];
+                $year = $parts[2];
+                return $year.sprintf('%02d', $week);
+            })
+            ->values();
+    }
 
+    public static function getAllDatesOfWeeksInYear($year, $weekNumber): Collection
+    {
+        $startOfWeek = Carbon::now()->setISODate($year, $weekNumber)->startOfWeek();
+        $dates = collect([]);
+
+        for ($day = 0; $day < 7; $day++) {
+            $dates->push((clone $startOfWeek)->addDays($day)->toDateString());
+        }
+
+        return $dates;
+    }
+
+    public function allMergedTiffsPresent(Collection $haystack, Collection $needles)
+    {
+        $needlesNotInHaystack = $needles->filter(function ($needle) use ($haystack) {
+            return !$haystack->contains(function ($item) use ($needle) {
+                return str_contains($item, $needle);
+            });
+        });
+
+        if ($needlesNotInHaystack->count() > 0) {
+            $message = sprintf(
+                'Missing merged tiffs: %s',
+                $needlesNotInHaystack->implode(', ')
+            );
+
+            throw new \Exception($message);
+        }
+        return true;
+    }
+
+    public function getMergedTiffList()
+    {
+        return collect([]);;
+    }
 }
diff --git a/laravel_app/app/Models/ProjectReport.php b/laravel_app/app/Models/ProjectReport.php
index 93a3917..fb74e73 100644
--- a/laravel_app/app/Models/ProjectReport.php
+++ b/laravel_app/app/Models/ProjectReport.php
@@ -29,7 +29,12 @@ public function project()
 
     public function weeksAgo()
     {
-        return now()->diffInWeeks(now()->setISODate($this->year, $this->week));
+        return $this->weeksAgoForYearAndWeek($this->year, $this->week);
+    }
+
+    public static function weeksAgoForYearAndWeek($year, $week)
+    {
+        return now()->diffInWeeks(now()->setISODate($year, $week));
     }
 
     public function getFileName()
diff --git a/laravel_app/app/Rules/AllMergedTiffsPresentRule.php b/laravel_app/app/Rules/AllMergedTiffsPresentRule.php
new file mode 100644
index 0000000..c81c437
--- /dev/null
+++ b/laravel_app/app/Rules/AllMergedTiffsPresentRule.php
@@ -0,0 +1,36 @@
+<?php
+
+namespace App\Rules;
+
+use Illuminate\Contracts\Validation\Rule;
+use App\Models\Project;
+use App\Models\ProjectReport;
+
+class AllMergedTiffsPresentRule implements Rule
+{
+    protected $project;
+    protected $errorMessage = '';
+
+    public function __construct(Project $project)
+    {
+        $this->project = $project;
+    }
+
+    public function passes($attribute, $value)
+    {
+        try {
+            return $this->project->allMergedTiffsPresent(
+                $this->project->getMergedTiffList(),
+                Project::getAllDatesOfWeeksInYear($value['year'], $value['week'])
+            );
+        } catch (\Exception $e) {
+            $this->errorMessage = $e->getMessage();
+            return false;
+        }
+    }
+
+    public function message()
+    {
+        return $this->errorMessage;
+    }
+}
diff --git a/laravel_app/resources/views/components/mosaic-create-modal.blade.php b/laravel_app/resources/views/components/mosaic-create-modal.blade.php
new file mode 100644
index 0000000..659a0dc
--- /dev/null
+++ b/laravel_app/resources/views/components/mosaic-create-modal.blade.php
@@ -0,0 +1,51 @@
+@props([
+    'formData',
+    /** @var \App\Livewire\Projects\MosaicManager */
+    'manager'
+])
+
+<x-modal wire:model.live="showCreateModal" {{ $attributes }} >
+    <x-form-modal submit="saveMosiac" wire:loading.class="opacity-50">
+        <x-slot name="title">
+            {{ __('Project') }}
+        </x-slot>
+
+        <x-slot name="description">
+            {{ __('Report generator for generating reports') }}
+        </x-slot>
+
+
+        <x-slot name="form">
+            <div class="col-span-6 sm:col-span-4">
+                <x-label for="year" value="{{ __('Year') }}"/>
+                <x-input id="year" type="text" class="mt-1 block w-full" wire:model.live="formData.year" autofocus/>
+                <x-input-error for="formData.year" class="mt-2"/>
+            </div><div class="col-span-6 sm:col-span-4">
+                <x-label for="week" value="{{ __('Week') }}"/>
+                <x-input id="week" type="text" class="mt-1 block w-full" wire:model.live="formData.week" autofocus/>
+                <x-input-error for="formData.week" class="mt-2"/>
+                <x-input-error for="formData" class="mt-2"/>
+            </div>
+            <div>
+                <span class="whitespace-nowrap">{!! $manager->dateRange !!}</span>
+            </div>
+        </x-slot>
+
+        <x-slot name="actions">
+            <x-action-message class="mr-3" on="saved">
+                {{ __('Saved.') }}
+            </x-action-message>
+
+            <x-secondary-button class="mr-3"
+                                type="button"
+                                x-on:click="$wire.showCreateModal = false"
+            >
+                {{ __('Cancel') }}
+            </x-secondary-button>
+            <x-button wire:loading.disabled>
+                {{ __('Save') }}
+            </x-button>
+
+        </x-slot>
+    </x-form-modal>
+</x-modal>
diff --git a/laravel_app/resources/views/livewire/projects/mosaic-manager.blade.php b/laravel_app/resources/views/livewire/projects/mosaic-manager.blade.php
new file mode 100644
index 0000000..6c14faa
--- /dev/null
+++ b/laravel_app/resources/views/livewire/projects/mosaic-manager.blade.php
@@ -0,0 +1,52 @@
+<div>
+    <div class="px-4 sm:px-6 lg:px-8">
+        <div class="sm:flex sm:items-center">
+            <div class="sm:flex-auto">
+                <h1 class="text-base font-semibold leading-6 text-gray-900">Reports</h1>
+                <p class="mt-2 text-sm text-gray-700"></p>
+            </div>
+            <div class="mt-4 sm:ml-16 sm:mt-0 sm:flex-none">
+                <x-button wire:click="openCreateMosiacsModal"
+                          class="block rounded-md bg-indigo-600 px-3 py-2 text-center text-sm font-semibold text-white shadow-sm hover:bg-indigo-500 focus-visible:outline focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-indigo-600">
+                    Create Mosaic
+                </x-button>
+            </div>
+        </div>
+        <div class="mt-8 flow-root">
+            <div class="-mx-4 -my-2 overflow-x-auto sm:-mx-6 lg:-mx-8">
+                <div class="inline-block min-w-full py-2 align-middle">
+                    <table class="min-w-full divide-y divide-gray-300">
+                        <thead>
+                        <tr>
+                            <th scope="col"
+                                class="py-3.5 pl-4 pr-3 text-left text-sm font-semibold text-gray-900 sm:pl-6 lg:pl-8">
+                                Name
+                            </th>
+                            <th scope="col" class="px-3 py-3.5 text-left text-sm font-semibold text-gray-900">
+                                Status
+                            </th>
+                            <th scope="col" class="relative py-3.5 pl-3 pr-4 sm:pr-6 lg:pr-8">
+                                <span class="sr-only">Edit</span>
+                            </th>
+                        </tr>
+                        </thead>
+                        <tbody class="divide-y divide-gray-200 bg-white">
+                        @foreach($project->getMosaicList() as $mosaic)
+                            <tr>
+                            <td class="whitespace-nowrap py-4 pl-4 pr-3 text-sm font-medium text-gray-900 sm:pl-6 lg:pl-8">{{ $project->name }}</td>
+                            <td class="whitespace-nowrap px-3 py-4 text-sm text-gray-500">
+                            {{ $mosaic }}
+                            </td>
+                            <td class="relative whitespace-nowrap py-4 pl-3 pr-4 text-right text-sm font-medium sm:pr-6 lg:pr-8">
+
+                            </td>
+                            </tr>
+                        @endforeach
+                        </tbody>
+                    </table>
+                </div>
+            </div>
+        </div>
+    </div>
+    <x-mosaic-create-modal :manager="$this"/>
+</div>
diff --git a/laravel_app/resources/views/livewire/projects/report-manager.blade.php b/laravel_app/resources/views/livewire/projects/report-manager.blade.php
index 680fb08..6cc00fb 100644
--- a/laravel_app/resources/views/livewire/projects/report-manager.blade.php
+++ b/laravel_app/resources/views/livewire/projects/report-manager.blade.php
@@ -1,6 +1,4 @@
 <div>
-
-
     <div class="px-4 sm:px-6 lg:px-8">
         <div class="sm:flex sm:items-center">
             <div class="sm:flex-auto">
diff --git a/laravel_app/resources/views/projects/show.blade.php b/laravel_app/resources/views/projects/show.blade.php
index 4d946fa..57fef0c 100644
--- a/laravel_app/resources/views/projects/show.blade.php
+++ b/laravel_app/resources/views/projects/show.blade.php
@@ -12,6 +12,11 @@
                     :class="$tab.isSelected ? 'border-gray-200 bg-white' : 'border-transparent'"
                     class="inline-flex rounded-l-md border-t border-l border-b px-5 py-2.5"
             >{{ __('Downloads') }}</button>
+            <button x-tabs:tab type="button"
+                    data-tab-name="mosaics"
+                    :class="$tab.isSelected ? 'border-gray-200 bg-white' : 'border-transparent'"
+                    class="inline-flex rounded-l-md border-t border-l border-b px-5 py-2.5"
+            >{{ __('Mosaic') }}</button>
             <button x-tabs:tab type="button"
                     data-tab-name="mailing"
                     :class="$tab.isSelected ? 'border-gray-200 bg-white' : 'border-transparent'"
@@ -28,7 +33,9 @@ class="inline-flex rounded-l-md border-t border-l border-b px-5 py-2.5"
             <section x-tabs:panel class="p-8">
                 <livewire:projects.download-manager :project="$project" />
             </section>
-
+            <section x-tabs:panel class="p-8">
+                <livewire:projects.mosaic-manager :project="$project" />
+            </section>
             <section x-tabs:panel class="p-8">
                 <livewire:projects.mailing-manager :project="$project" />
             </section>
diff --git a/laravel_app/tests/Unit/Rules/AllMergedTiffsPresentRuleTest.php b/laravel_app/tests/Unit/Rules/AllMergedTiffsPresentRuleTest.php
new file mode 100644
index 0000000..d2bdf0a
--- /dev/null
+++ b/laravel_app/tests/Unit/Rules/AllMergedTiffsPresentRuleTest.php
@@ -0,0 +1,94 @@
+<?php
+
+namespace Tests\Unit\Rules;
+
+use App\Models\Project;
+
+use App\Rules\AllMergedTiffsPresentRule;
+use Illuminate\Foundation\Testing\RefreshDatabase;
+use Illuminate\Support\Carbon;
+use Mockery;
+use Tests\TestCase;
+
+class AllMergedTiffsPresentRuleTest extends TestCase
+{
+    use RefreshDatabase;
+
+    protected function setUp(): void
+    {
+        parent::setUp(); // TODO: Change the autogenerated stub
+    }
+
+    /**
+     * @test
+     */
+    public function validatesCorrectValue()
+    {
+        $project = Project::create([
+            'name'           => 'Test project',
+            'mail_template'  => 'Test mail template',
+            'mail_subject'   => 'Test mail subject',
+            'mail_frequency' => 'Test mail frequency',
+            'mail_day'       => 'Friday',
+            'download_path'  => 'test_project',
+        ]);
+
+        $projectMock = Mockery::mock($project)->makePartial();
+
+        $projectMock->shouldReceive('getMergedTiffList')->andReturn(
+            collect([
+                "chemba/merged_tiff/2021-01-04.tif",
+                "chemba/merged_tiff/2021-01-05.tif",
+                "chemba/merged_tiff/2021-01-06.tif",
+                "chemba/merged_tiff/2021-01-07.tif",
+                "chemba/merged_tiff/2021-01-08.tif",
+                "chemba/merged_tiff/2021-01-09.tif",
+                "chemba/merged_tiff/2021-01-10.tif",
+            ]));
+
+        $rule = new AllMergedTiffsPresentRule($projectMock);
+
+        $this->assertTrue($rule->passes(
+            'attribute',
+            ['year' => '2021', 'week' => '1']
+        ));
+    }
+
+    public function testInvalidatesIncorrectValue()
+    {
+        $project = Project::create([
+            'name'           => 'Test project',
+            'mail_template'  => 'Test mail template',
+            'mail_subject'   => 'Test mail subject',
+            'mail_frequency' => 'Test mail frequency',
+            'mail_day'       => 'Friday',
+            'download_path'  => 'test_project',
+        ]);
+
+        $projectMock = Mockery::mock($project)->makePartial();
+
+        $projectMock->shouldReceive('getMergedTiffList')->andReturn(
+            collect([
+//                "chemba/merged_tiff/2021-01-04.tif",
+                "chemba/merged_tiff/2021-01-05.tif",
+                "chemba/merged_tiff/2021-01-06.tif",
+                "chemba/merged_tiff/2021-01-07.tif",
+                "chemba/merged_tiff/2021-01-08.tif",
+                "chemba/merged_tiff/2021-01-09.tif",
+                "chemba/merged_tiff/2021-01-10.tif",
+            ]));
+
+
+        $rule = new AllMergedTiffsPresentRule($projectMock);
+
+        $this->assertFalse($rule->passes(
+            'attribute',
+            ['year' => '2021', 'week' => '1']
+        ));
+        $this->assertEquals(
+            'Missing merged tiffs: 2021-01-04',
+            $rule->message()
+        );
+    }
+
+}
diff --git a/python_app/Chemba_download.ipynb b/python_app/Chemba_download.ipynb
index 1679b90..4490d36 100644
--- a/python_app/Chemba_download.ipynb
+++ b/python_app/Chemba_download.ipynb
@@ -335,6 +335,8 @@
     "  # Adjust the number of days needed\n",
     "\n",
     "end = datetime.date.today()\n",
+    "#end = datetime.datetime(2023, 11, 10)\n",
+    "#start = datetime.datetime(2023, 10, 19)\n",
     "start = end - datetime.timedelta(days=days_needed - 1)\n",
     "\n",
     "slots = [(start + datetime.timedelta(days=i)).strftime('%Y-%m-%d') for i in range(days_needed)]\n",
diff --git a/r_app/2_CI_data_prep.R b/r_app/2_CI_data_prep.R
index 1b9d8d7..2a3c6be 100644
--- a/r_app/2_CI_data_prep.R
+++ b/r_app/2_CI_data_prep.R
@@ -11,7 +11,21 @@ library(exactextractr)
 
 library(CIprep)
 
+# Vang alle command line argumenten op
+args <- commandArgs(trailingOnly = TRUE)
 
+# Controleer of er ten minste één argument is doorgegeven
+if (length(args) == 0) {
+  stop("Geen argumenten doorgegeven aan het script")
+}
+
+# Converteer het eerste argument naar een numerieke waarde
+weeks_ago <- as.numeric(args[1])
+
+# Controleer of weeks_ago een geldig getal is
+if (is.na(weeks_ago)) {
+  stop("Het argument is geen geldig getal")
+}
 
 laravel_storage_dir <- here("../laravel_app/storage/app")
 #preparing directories
@@ -38,13 +52,13 @@ dir.create(merged_final)
 
 
 # Creating weekly mosaic
-dates <- date_list(0)
+dates <- date_list(weeks_ago)
+head(dates)
+print(planet_tif_folder)
 
 #load pivot geojson
 pivot_sf_q <- st_read(here( "pivot_20210625.geojson")) %>% dplyr::select(pivot, pivot_quadrant) %>% vect()
 
-#load and filter raster files
-raster_files <- list.files(planet_tif_folder,full.names = T, pattern = ".tif") #use pattern = '.tif$' or something else if you have multiple files in this folder
 filtered_files  <- map(dates$days_filter, ~ raster_files[grepl(pattern = .x, x = raster_files)]) %>%
   compact() %>%
   flatten_chr()
diff --git a/r_app/CI_report_dashboard_planet.Rmd b/r_app/CI_report_dashboard_planet.Rmd
index 5f696d2..bd781c4 100644
--- a/r_app/CI_report_dashboard_planet.Rmd
+++ b/r_app/CI_report_dashboard_planet.Rmd
@@ -2,6 +2,8 @@
 # title: paste0("CI report week ", week, " - all pivots from ", last_tuesday, " to ", today)
 params:
   ref: word-styles-reference-03.docx
+  output_file: "CI_report.docx"
+  report_date: "2023-12-12"
 output:
   word_document:
     reference_docx: !expr file.path("word-styles-reference-03.docx")
@@ -11,6 +13,12 @@ editor_options:
 ---
 
 ```{r setup, include=FALSE}
+#set de filename van de output
+knitr::opts_chunk$set(echo = TRUE)
+output_file <- params$output_file
+report_date <- params$report_date
+
+
 # Activeer de renv omgeving
 renv::activate()
 
@@ -50,12 +58,13 @@ s2_dir <- "C:/Users/timon/Resilience BV/4002 CMD App - General/4002 CMD Team/400
 
 ```{r week, message=FALSE, warning=FALSE, include=FALSE}
 # week <- 5
-# today = "2023-10-08"
-# week <- week(today)
+#today = "2023-12-12"
+today <- as.character(report_date)
+week <- week(today)
  #today = "2022-08-18"
 
-today = as.character(Sys.Date())
-week = lubridate::week(Sys.time())
+#today = as.character(Sys.Date())
+#week = lubridate::week(Sys.time())
 ## week = 26
 title_var <- paste0("CI dashboard week ", week, " - all pivots dashboard using 3x3 meter resolution")
 ```
@@ -97,7 +106,6 @@ last_week_dif_raster <- ((CI - CI_m1) / CI_m1) * 100
 last_week_dif_raster_abs <- (CI - CI_m1)
 two_week_dif_raster_abs <- (CI - CI_m2)
 
-
 AllPivots0 <-st_read(here(data_dir, "pivot_20210625.geojson"))
 joined_spans <-st_read(here(data_dir, "spans2.geojson")) %>% st_transform(crs(AllPivots0))
 
diff --git a/r_app/Rplots.pdf b/r_app/Rplots.pdf
index 72e81a3..b804666 100644
Binary files a/r_app/Rplots.pdf and b/r_app/Rplots.pdf differ
diff --git a/renv/.gitignore b/renv/.gitignore
new file mode 100644
index 0000000..0ec0cbb
--- /dev/null
+++ b/renv/.gitignore
@@ -0,0 +1,7 @@
+library/
+local/
+cellar/
+lock/
+python/
+sandbox/
+staging/
diff --git a/renv/activate.R b/renv/activate.R
new file mode 100644
index 0000000..cb5401f
--- /dev/null
+++ b/renv/activate.R
@@ -0,0 +1,1180 @@
+
+local({
+
+  # the requested version of renv
+  version <- "1.0.3"
+  attr(version, "sha") <- NULL
+
+  # the project directory
+  project <- getwd()
+
+  # use start-up diagnostics if enabled
+  diagnostics <- Sys.getenv("RENV_STARTUP_DIAGNOSTICS", unset = "FALSE")
+  if (diagnostics) {
+    start <- Sys.time()
+    profile <- tempfile("renv-startup-", fileext = ".Rprof")
+    utils::Rprof(profile)
+    on.exit({
+      utils::Rprof(NULL)
+      elapsed <- signif(difftime(Sys.time(), start, units = "auto"), digits = 2L)
+      writeLines(sprintf("- renv took %s to run the autoloader.", format(elapsed)))
+      writeLines(sprintf("- Profile: %s", profile))
+      print(utils::summaryRprof(profile))
+    }, add = TRUE)
+  }
+
+  # figure out whether the autoloader is enabled
+  enabled <- local({
+
+    # first, check config option
+    override <- getOption("renv.config.autoloader.enabled")
+    if (!is.null(override))
+      return(override)
+
+    # next, check environment variables
+    # TODO: prefer using the configuration one in the future
+    envvars <- c(
+      "RENV_CONFIG_AUTOLOADER_ENABLED",
+      "RENV_AUTOLOADER_ENABLED",
+      "RENV_ACTIVATE_PROJECT"
+    )
+
+    for (envvar in envvars) {
+      envval <- Sys.getenv(envvar, unset = NA)
+      if (!is.na(envval))
+        return(tolower(envval) %in% c("true", "t", "1"))
+    }
+
+    # enable by default
+    TRUE
+
+  })
+
+  if (!enabled)
+    return(FALSE)
+
+  # avoid recursion
+  if (identical(getOption("renv.autoloader.running"), TRUE)) {
+    warning("ignoring recursive attempt to run renv autoloader")
+    return(invisible(TRUE))
+  }
+
+  # signal that we're loading renv during R startup
+  options(renv.autoloader.running = TRUE)
+  on.exit(options(renv.autoloader.running = NULL), add = TRUE)
+
+  # signal that we've consented to use renv
+  options(renv.consent = TRUE)
+
+  # load the 'utils' package eagerly -- this ensures that renv shims, which
+  # mask 'utils' packages, will come first on the search path
+  library(utils, lib.loc = .Library)
+
+  # unload renv if it's already been loaded
+  if ("renv" %in% loadedNamespaces())
+    unloadNamespace("renv")
+
+  # load bootstrap tools   
+  `%||%` <- function(x, y) {
+    if (is.null(x)) y else x
+  }
+  
+  catf <- function(fmt, ..., appendLF = TRUE) {
+  
+    quiet <- getOption("renv.bootstrap.quiet", default = FALSE)
+    if (quiet)
+      return(invisible())
+  
+    msg <- sprintf(fmt, ...)
+    cat(msg, file = stdout(), sep = if (appendLF) "\n" else "")
+  
+    invisible(msg)
+  
+  }
+  
+  header <- function(label,
+                     ...,
+                     prefix = "#",
+                     suffix = "-",
+                     n = min(getOption("width"), 78))
+  {
+    label <- sprintf(label, ...)
+    n <- max(n - nchar(label) - nchar(prefix) - 2L, 8L)
+    if (n <= 0)
+      return(paste(prefix, label))
+  
+    tail <- paste(rep.int(suffix, n), collapse = "")
+    paste0(prefix, " ", label, " ", tail)
+  
+  }
+  
+  startswith <- function(string, prefix) {
+    substring(string, 1, nchar(prefix)) == prefix
+  }
+  
+  bootstrap <- function(version, library) {
+  
+    friendly <- renv_bootstrap_version_friendly(version)
+    section <- header(sprintf("Bootstrapping renv %s", friendly))
+    catf(section)
+  
+    # attempt to download renv
+    catf("- Downloading renv ... ", appendLF = FALSE)
+    withCallingHandlers(
+      tarball <- renv_bootstrap_download(version),
+      error = function(err) {
+        catf("FAILED")
+        stop("failed to download:\n", conditionMessage(err))
+      }
+    )
+    catf("OK")
+    on.exit(unlink(tarball), add = TRUE)
+  
+    # now attempt to install
+    catf("- Installing renv  ... ", appendLF = FALSE)
+    withCallingHandlers(
+      status <- renv_bootstrap_install(version, tarball, library),
+      error = function(err) {
+        catf("FAILED")
+        stop("failed to install:\n", conditionMessage(err))
+      }
+    )
+    catf("OK")
+  
+    # add empty line to break up bootstrapping from normal output
+    catf("")
+  
+    return(invisible())
+  }
+  
+  renv_bootstrap_tests_running <- function() {
+    getOption("renv.tests.running", default = FALSE)
+  }
+  
+  renv_bootstrap_repos <- function() {
+  
+    # get CRAN repository
+    cran <- getOption("renv.repos.cran", "https://cloud.r-project.org")
+  
+    # check for repos override
+    repos <- Sys.getenv("RENV_CONFIG_REPOS_OVERRIDE", unset = NA)
+    if (!is.na(repos)) {
+  
+      # check for RSPM; if set, use a fallback repository for renv
+      rspm <- Sys.getenv("RSPM", unset = NA)
+      if (identical(rspm, repos))
+        repos <- c(RSPM = rspm, CRAN = cran)
+  
+      return(repos)
+  
+    }
+  
+    # check for lockfile repositories
+    repos <- tryCatch(renv_bootstrap_repos_lockfile(), error = identity)
+    if (!inherits(repos, "error") && length(repos))
+      return(repos)
+  
+    # retrieve current repos
+    repos <- getOption("repos")
+  
+    # ensure @CRAN@ entries are resolved
+    repos[repos == "@CRAN@"] <- cran
+  
+    # add in renv.bootstrap.repos if set
+    default <- c(FALLBACK = "https://cloud.r-project.org")
+    extra <- getOption("renv.bootstrap.repos", default = default)
+    repos <- c(repos, extra)
+  
+    # remove duplicates that might've snuck in
+    dupes <- duplicated(repos) | duplicated(names(repos))
+    repos[!dupes]
+  
+  }
+  
+  renv_bootstrap_repos_lockfile <- function() {
+  
+    lockpath <- Sys.getenv("RENV_PATHS_LOCKFILE", unset = "renv.lock")
+    if (!file.exists(lockpath))
+      return(NULL)
+  
+    lockfile <- tryCatch(renv_json_read(lockpath), error = identity)
+    if (inherits(lockfile, "error")) {
+      warning(lockfile)
+      return(NULL)
+    }
+  
+    repos <- lockfile$R$Repositories
+    if (length(repos) == 0)
+      return(NULL)
+  
+    keys <- vapply(repos, `[[`, "Name", FUN.VALUE = character(1))
+    vals <- vapply(repos, `[[`, "URL", FUN.VALUE = character(1))
+    names(vals) <- keys
+  
+    return(vals)
+  
+  }
+  
+  renv_bootstrap_download <- function(version) {
+  
+    sha <- attr(version, "sha", exact = TRUE)
+  
+    methods <- if (!is.null(sha)) {
+  
+      # attempting to bootstrap a development version of renv
+      c(
+        function() renv_bootstrap_download_tarball(sha),
+        function() renv_bootstrap_download_github(sha)
+      )
+  
+    } else {
+  
+      # attempting to bootstrap a release version of renv
+      c(
+        function() renv_bootstrap_download_tarball(version),
+        function() renv_bootstrap_download_cran_latest(version),
+        function() renv_bootstrap_download_cran_archive(version)
+      )
+  
+    }
+  
+    for (method in methods) {
+      path <- tryCatch(method(), error = identity)
+      if (is.character(path) && file.exists(path))
+        return(path)
+    }
+  
+    stop("All download methods failed")
+  
+  }
+  
+  renv_bootstrap_download_impl <- function(url, destfile) {
+  
+    mode <- "wb"
+  
+    # https://bugs.r-project.org/bugzilla/show_bug.cgi?id=17715
+    fixup <-
+      Sys.info()[["sysname"]] == "Windows" &&
+      substring(url, 1L, 5L) == "file:"
+  
+    if (fixup)
+      mode <- "w+b"
+  
+    args <- list(
+      url      = url,
+      destfile = destfile,
+      mode     = mode,
+      quiet    = TRUE
+    )
+  
+    if ("headers" %in% names(formals(utils::download.file)))
+      args$headers <- renv_bootstrap_download_custom_headers(url)
+  
+    do.call(utils::download.file, args)
+  
+  }
+  
+  renv_bootstrap_download_custom_headers <- function(url) {
+  
+    headers <- getOption("renv.download.headers")
+    if (is.null(headers))
+      return(character())
+  
+    if (!is.function(headers))
+      stopf("'renv.download.headers' is not a function")
+  
+    headers <- headers(url)
+    if (length(headers) == 0L)
+      return(character())
+  
+    if (is.list(headers))
+      headers <- unlist(headers, recursive = FALSE, use.names = TRUE)
+  
+    ok <-
+      is.character(headers) &&
+      is.character(names(headers)) &&
+      all(nzchar(names(headers)))
+  
+    if (!ok)
+      stop("invocation of 'renv.download.headers' did not return a named character vector")
+  
+    headers
+  
+  }
+  
+  renv_bootstrap_download_cran_latest <- function(version) {
+  
+    spec <- renv_bootstrap_download_cran_latest_find(version)
+    type  <- spec$type
+    repos <- spec$repos
+  
+    baseurl <- utils::contrib.url(repos = repos, type = type)
+    ext <- if (identical(type, "source"))
+      ".tar.gz"
+    else if (Sys.info()[["sysname"]] == "Windows")
+      ".zip"
+    else
+      ".tgz"
+    name <- sprintf("renv_%s%s", version, ext)
+    url <- paste(baseurl, name, sep = "/")
+  
+    destfile <- file.path(tempdir(), name)
+    status <- tryCatch(
+      renv_bootstrap_download_impl(url, destfile),
+      condition = identity
+    )
+  
+    if (inherits(status, "condition"))
+      return(FALSE)
+  
+    # report success and return
+    destfile
+  
+  }
+  
+  renv_bootstrap_download_cran_latest_find <- function(version) {
+  
+    # check whether binaries are supported on this system
+    binary <-
+      getOption("renv.bootstrap.binary", default = TRUE) &&
+      !identical(.Platform$pkgType, "source") &&
+      !identical(getOption("pkgType"), "source") &&
+      Sys.info()[["sysname"]] %in% c("Darwin", "Windows")
+  
+    types <- c(if (binary) "binary", "source")
+  
+    # iterate over types + repositories
+    for (type in types) {
+      for (repos in renv_bootstrap_repos()) {
+  
+        # retrieve package database
+        db <- tryCatch(
+          as.data.frame(
+            utils::available.packages(type = type, repos = repos),
+            stringsAsFactors = FALSE
+          ),
+          error = identity
+        )
+  
+        if (inherits(db, "error"))
+          next
+  
+        # check for compatible entry
+        entry <- db[db$Package %in% "renv" & db$Version %in% version, ]
+        if (nrow(entry) == 0)
+          next
+  
+        # found it; return spec to caller
+        spec <- list(entry = entry, type = type, repos = repos)
+        return(spec)
+  
+      }
+    }
+  
+    # if we got here, we failed to find renv
+    fmt <- "renv %s is not available from your declared package repositories"
+    stop(sprintf(fmt, version))
+  
+  }
+  
+  renv_bootstrap_download_cran_archive <- function(version) {
+  
+    name <- sprintf("renv_%s.tar.gz", version)
+    repos <- renv_bootstrap_repos()
+    urls <- file.path(repos, "src/contrib/Archive/renv", name)
+    destfile <- file.path(tempdir(), name)
+  
+    for (url in urls) {
+  
+      status <- tryCatch(
+        renv_bootstrap_download_impl(url, destfile),
+        condition = identity
+      )
+  
+      if (identical(status, 0L))
+        return(destfile)
+  
+    }
+  
+    return(FALSE)
+  
+  }
+  
+  renv_bootstrap_download_tarball <- function(version) {
+  
+    # if the user has provided the path to a tarball via
+    # an environment variable, then use it
+    tarball <- Sys.getenv("RENV_BOOTSTRAP_TARBALL", unset = NA)
+    if (is.na(tarball))
+      return()
+  
+    # allow directories
+    if (dir.exists(tarball)) {
+      name <- sprintf("renv_%s.tar.gz", version)
+      tarball <- file.path(tarball, name)
+    }
+  
+    # bail if it doesn't exist
+    if (!file.exists(tarball)) {
+  
+      # let the user know we weren't able to honour their request
+      fmt <- "- RENV_BOOTSTRAP_TARBALL is set (%s) but does not exist."
+      msg <- sprintf(fmt, tarball)
+      warning(msg)
+  
+      # bail
+      return()
+  
+    }
+  
+    catf("- Using local tarball '%s'.", tarball)
+    tarball
+  
+  }
+  
+  renv_bootstrap_download_github <- function(version) {
+  
+    enabled <- Sys.getenv("RENV_BOOTSTRAP_FROM_GITHUB", unset = "TRUE")
+    if (!identical(enabled, "TRUE"))
+      return(FALSE)
+  
+    # prepare download options
+    pat <- Sys.getenv("GITHUB_PAT")
+    if (nzchar(Sys.which("curl")) && nzchar(pat)) {
+      fmt <- "--location --fail --header \"Authorization: token %s\""
+      extra <- sprintf(fmt, pat)
+      saved <- options("download.file.method", "download.file.extra")
+      options(download.file.method = "curl", download.file.extra = extra)
+      on.exit(do.call(base::options, saved), add = TRUE)
+    } else if (nzchar(Sys.which("wget")) && nzchar(pat)) {
+      fmt <- "--header=\"Authorization: token %s\""
+      extra <- sprintf(fmt, pat)
+      saved <- options("download.file.method", "download.file.extra")
+      options(download.file.method = "wget", download.file.extra = extra)
+      on.exit(do.call(base::options, saved), add = TRUE)
+    }
+  
+    url <- file.path("https://api.github.com/repos/rstudio/renv/tarball", version)
+    name <- sprintf("renv_%s.tar.gz", version)
+    destfile <- file.path(tempdir(), name)
+  
+    status <- tryCatch(
+      renv_bootstrap_download_impl(url, destfile),
+      condition = identity
+    )
+  
+    if (!identical(status, 0L))
+      return(FALSE)
+  
+    renv_bootstrap_download_augment(destfile)
+  
+    return(destfile)
+  
+  }
+  
+  # Add Sha to DESCRIPTION. This is stop gap until #890, after which we
+  # can use renv::install() to fully capture metadata.
+  renv_bootstrap_download_augment <- function(destfile) {
+    sha <- renv_bootstrap_git_extract_sha1_tar(destfile)
+    if (is.null(sha)) {
+      return()
+    }
+  
+    # Untar
+    tempdir <- tempfile("renv-github-")
+    on.exit(unlink(tempdir, recursive = TRUE), add = TRUE)
+    untar(destfile, exdir = tempdir)
+    pkgdir <- dir(tempdir, full.names = TRUE)[[1]]
+  
+    # Modify description
+    desc_path <- file.path(pkgdir, "DESCRIPTION")
+    desc_lines <- readLines(desc_path)
+    remotes_fields <- c(
+      "RemoteType: github",
+      "RemoteHost: api.github.com",
+      "RemoteRepo: renv",
+      "RemoteUsername: rstudio",
+      "RemotePkgRef: rstudio/renv",
+      paste("RemoteRef: ", sha),
+      paste("RemoteSha: ", sha)
+    )
+    writeLines(c(desc_lines[desc_lines != ""], remotes_fields), con = desc_path)
+  
+    # Re-tar
+    local({
+      old <- setwd(tempdir)
+      on.exit(setwd(old), add = TRUE)
+  
+      tar(destfile, compression = "gzip")
+    })
+    invisible()
+  }
+  
+  # Extract the commit hash from a git archive. Git archives include the SHA1
+  # hash as the comment field of the tarball pax extended header
+  # (see https://www.kernel.org/pub/software/scm/git/docs/git-archive.html)
+  # For GitHub archives this should be the first header after the default one
+  # (512 byte) header.
+  renv_bootstrap_git_extract_sha1_tar <- function(bundle) {
+  
+    # open the bundle for reading
+    # We use gzcon for everything because (from ?gzcon)
+    # > Reading from a connection which does not supply a 'gzip' magic
+    # > header is equivalent to reading from the original connection
+    conn <- gzcon(file(bundle, open = "rb", raw = TRUE))
+    on.exit(close(conn))
+  
+    # The default pax header is 512 bytes long and the first pax extended header
+    # with the comment should be 51 bytes long
+    # `52 comment=` (11 chars) + 40 byte SHA1 hash
+    len <- 0x200 + 0x33
+    res <- rawToChar(readBin(conn, "raw", n = len)[0x201:len])
+  
+    if (grepl("^52 comment=", res)) {
+      sub("52 comment=", "", res)
+    } else {
+      NULL
+    }
+  }
+  
+  renv_bootstrap_install <- function(version, tarball, library) {
+  
+    # attempt to install it into project library
+    dir.create(library, showWarnings = FALSE, recursive = TRUE)
+    output <- renv_bootstrap_install_impl(library, tarball)
+  
+    # check for successful install
+    status <- attr(output, "status")
+    if (is.null(status) || identical(status, 0L))
+      return(status)
+  
+    # an error occurred; report it
+    header <- "installation of renv failed"
+    lines <- paste(rep.int("=", nchar(header)), collapse = "")
+    text <- paste(c(header, lines, output), collapse = "\n")
+    stop(text)
+  
+  }
+  
+  renv_bootstrap_install_impl <- function(library, tarball) {
+  
+    # invoke using system2 so we can capture and report output
+    bin <- R.home("bin")
+    exe <- if (Sys.info()[["sysname"]] == "Windows") "R.exe" else "R"
+    R <- file.path(bin, exe)
+  
+    args <- c(
+      "--vanilla", "CMD", "INSTALL", "--no-multiarch",
+      "-l", shQuote(path.expand(library)),
+      shQuote(path.expand(tarball))
+    )
+  
+    system2(R, args, stdout = TRUE, stderr = TRUE)
+  
+  }
+  
+  renv_bootstrap_platform_prefix <- function() {
+  
+    # construct version prefix
+    version <- paste(R.version$major, R.version$minor, sep = ".")
+    prefix <- paste("R", numeric_version(version)[1, 1:2], sep = "-")
+  
+    # include SVN revision for development versions of R
+    # (to avoid sharing platform-specific artefacts with released versions of R)
+    devel <-
+      identical(R.version[["status"]],   "Under development (unstable)") ||
+      identical(R.version[["nickname"]], "Unsuffered Consequences")
+  
+    if (devel)
+      prefix <- paste(prefix, R.version[["svn rev"]], sep = "-r")
+  
+    # build list of path components
+    components <- c(prefix, R.version$platform)
+  
+    # include prefix if provided by user
+    prefix <- renv_bootstrap_platform_prefix_impl()
+    if (!is.na(prefix) && nzchar(prefix))
+      components <- c(prefix, components)
+  
+    # build prefix
+    paste(components, collapse = "/")
+  
+  }
+  
+  renv_bootstrap_platform_prefix_impl <- function() {
+  
+    # if an explicit prefix has been supplied, use it
+    prefix <- Sys.getenv("RENV_PATHS_PREFIX", unset = NA)
+    if (!is.na(prefix))
+      return(prefix)
+  
+    # if the user has requested an automatic prefix, generate it
+    auto <- Sys.getenv("RENV_PATHS_PREFIX_AUTO", unset = NA)
+    if (auto %in% c("TRUE", "True", "true", "1"))
+      return(renv_bootstrap_platform_prefix_auto())
+  
+    # empty string on failure
+    ""
+  
+  }
+  
+  renv_bootstrap_platform_prefix_auto <- function() {
+  
+    prefix <- tryCatch(renv_bootstrap_platform_os(), error = identity)
+    if (inherits(prefix, "error") || prefix %in% "unknown") {
+  
+      msg <- paste(
+        "failed to infer current operating system",
+        "please file a bug report at https://github.com/rstudio/renv/issues",
+        sep = "; "
+      )
+  
+      warning(msg)
+  
+    }
+  
+    prefix
+  
+  }
+  
+  renv_bootstrap_platform_os <- function() {
+  
+    sysinfo <- Sys.info()
+    sysname <- sysinfo[["sysname"]]
+  
+    # handle Windows + macOS up front
+    if (sysname == "Windows")
+      return("windows")
+    else if (sysname == "Darwin")
+      return("macos")
+  
+    # check for os-release files
+    for (file in c("/etc/os-release", "/usr/lib/os-release"))
+      if (file.exists(file))
+        return(renv_bootstrap_platform_os_via_os_release(file, sysinfo))
+  
+    # check for redhat-release files
+    if (file.exists("/etc/redhat-release"))
+      return(renv_bootstrap_platform_os_via_redhat_release())
+  
+    "unknown"
+  
+  }
+  
+  renv_bootstrap_platform_os_via_os_release <- function(file, sysinfo) {
+  
+    # read /etc/os-release
+    release <- utils::read.table(
+      file             = file,
+      sep              = "=",
+      quote            = c("\"", "'"),
+      col.names        = c("Key", "Value"),
+      comment.char     = "#",
+      stringsAsFactors = FALSE
+    )
+  
+    vars <- as.list(release$Value)
+    names(vars) <- release$Key
+  
+    # get os name
+    os <- tolower(sysinfo[["sysname"]])
+  
+    # read id
+    id <- "unknown"
+    for (field in c("ID", "ID_LIKE")) {
+      if (field %in% names(vars) && nzchar(vars[[field]])) {
+        id <- vars[[field]]
+        break
+      }
+    }
+  
+    # read version
+    version <- "unknown"
+    for (field in c("UBUNTU_CODENAME", "VERSION_CODENAME", "VERSION_ID", "BUILD_ID")) {
+      if (field %in% names(vars) && nzchar(vars[[field]])) {
+        version <- vars[[field]]
+        break
+      }
+    }
+  
+    # join together
+    paste(c(os, id, version), collapse = "-")
+  
+  }
+  
+  renv_bootstrap_platform_os_via_redhat_release <- function() {
+  
+    # read /etc/redhat-release
+    contents <- readLines("/etc/redhat-release", warn = FALSE)
+  
+    # infer id
+    id <- if (grepl("centos", contents, ignore.case = TRUE))
+      "centos"
+    else if (grepl("redhat", contents, ignore.case = TRUE))
+      "redhat"
+    else
+      "unknown"
+  
+    # try to find a version component (very hacky)
+    version <- "unknown"
+  
+    parts <- strsplit(contents, "[[:space:]]")[[1L]]
+    for (part in parts) {
+  
+      nv <- tryCatch(numeric_version(part), error = identity)
+      if (inherits(nv, "error"))
+        next
+  
+      version <- nv[1, 1]
+      break
+  
+    }
+  
+    paste(c("linux", id, version), collapse = "-")
+  
+  }
+  
+  renv_bootstrap_library_root_name <- function(project) {
+  
+    # use project name as-is if requested
+    asis <- Sys.getenv("RENV_PATHS_LIBRARY_ROOT_ASIS", unset = "FALSE")
+    if (asis)
+      return(basename(project))
+  
+    # otherwise, disambiguate based on project's path
+    id <- substring(renv_bootstrap_hash_text(project), 1L, 8L)
+    paste(basename(project), id, sep = "-")
+  
+  }
+  
+  renv_bootstrap_library_root <- function(project) {
+  
+    prefix <- renv_bootstrap_profile_prefix()
+  
+    path <- Sys.getenv("RENV_PATHS_LIBRARY", unset = NA)
+    if (!is.na(path))
+      return(paste(c(path, prefix), collapse = "/"))
+  
+    path <- renv_bootstrap_library_root_impl(project)
+    if (!is.null(path)) {
+      name <- renv_bootstrap_library_root_name(project)
+      return(paste(c(path, prefix, name), collapse = "/"))
+    }
+  
+    renv_bootstrap_paths_renv("library", project = project)
+  
+  }
+  
+  renv_bootstrap_library_root_impl <- function(project) {
+  
+    root <- Sys.getenv("RENV_PATHS_LIBRARY_ROOT", unset = NA)
+    if (!is.na(root))
+      return(root)
+  
+    type <- renv_bootstrap_project_type(project)
+    if (identical(type, "package")) {
+      userdir <- renv_bootstrap_user_dir()
+      return(file.path(userdir, "library"))
+    }
+  
+  }
+  
+  renv_bootstrap_validate_version <- function(version, description = NULL) {
+  
+    # resolve description file
+    #
+    # avoid passing lib.loc to `packageDescription()` below, since R will
+    # use the loaded version of the package by default anyhow. note that
+    # this function should only be called after 'renv' is loaded
+    # https://github.com/rstudio/renv/issues/1625
+    description <- description %||% packageDescription("renv")
+  
+    # check whether requested version 'version' matches loaded version of renv
+    sha <- attr(version, "sha", exact = TRUE)
+    valid <- if (!is.null(sha))
+      renv_bootstrap_validate_version_dev(sha, description)
+    else
+      renv_bootstrap_validate_version_release(version, description)
+  
+    if (valid)
+      return(TRUE)
+  
+    # the loaded version of renv doesn't match the requested version;
+    # give the user instructions on how to proceed
+    remote <- if (!is.null(description[["RemoteSha"]])) {
+      paste("rstudio/renv", description[["RemoteSha"]], sep = "@")
+    } else {
+      paste("renv", description[["Version"]], sep = "@")
+    }
+  
+    # display both loaded version + sha if available
+    friendly <- renv_bootstrap_version_friendly(
+      version = description[["Version"]],
+      sha     = description[["RemoteSha"]]
+    )
+  
+    fmt <- paste(
+      "renv %1$s was loaded from project library, but this project is configured to use renv %2$s.",
+      "- Use `renv::record(\"%3$s\")` to record renv %1$s in the lockfile.",
+      "- Use `renv::restore(packages = \"renv\")` to install renv %2$s into the project library.",
+      sep = "\n"
+    )
+    catf(fmt, friendly, renv_bootstrap_version_friendly(version), remote)
+  
+    FALSE
+  
+  }
+  
+  renv_bootstrap_validate_version_dev <- function(version, description) {
+    expected <- description[["RemoteSha"]]
+    is.character(expected) && startswith(expected, version)
+  }
+  
+  renv_bootstrap_validate_version_release <- function(version, description) {
+    expected <- description[["Version"]]
+    is.character(expected) && identical(expected, version)
+  }
+  
+  renv_bootstrap_hash_text <- function(text) {
+  
+    hashfile <- tempfile("renv-hash-")
+    on.exit(unlink(hashfile), add = TRUE)
+  
+    writeLines(text, con = hashfile)
+    tools::md5sum(hashfile)
+  
+  }
+  
+  renv_bootstrap_load <- function(project, libpath, version) {
+  
+    # try to load renv from the project library
+    if (!requireNamespace("renv", lib.loc = libpath, quietly = TRUE))
+      return(FALSE)
+  
+    # warn if the version of renv loaded does not match
+    renv_bootstrap_validate_version(version)
+  
+    # execute renv load hooks, if any
+    hooks <- getHook("renv::autoload")
+    for (hook in hooks)
+      if (is.function(hook))
+        tryCatch(hook(), error = warnify)
+  
+    # load the project
+    renv::load(project)
+  
+    TRUE
+  
+  }
+  
+  renv_bootstrap_profile_load <- function(project) {
+  
+    # if RENV_PROFILE is already set, just use that
+    profile <- Sys.getenv("RENV_PROFILE", unset = NA)
+    if (!is.na(profile) && nzchar(profile))
+      return(profile)
+  
+    # check for a profile file (nothing to do if it doesn't exist)
+    path <- renv_bootstrap_paths_renv("profile", profile = FALSE, project = project)
+    if (!file.exists(path))
+      return(NULL)
+  
+    # read the profile, and set it if it exists
+    contents <- readLines(path, warn = FALSE)
+    if (length(contents) == 0L)
+      return(NULL)
+  
+    # set RENV_PROFILE
+    profile <- contents[[1L]]
+    if (!profile %in% c("", "default"))
+      Sys.setenv(RENV_PROFILE = profile)
+  
+    profile
+  
+  }
+  
+  renv_bootstrap_profile_prefix <- function() {
+    profile <- renv_bootstrap_profile_get()
+    if (!is.null(profile))
+      return(file.path("profiles", profile, "renv"))
+  }
+  
+  renv_bootstrap_profile_get <- function() {
+    profile <- Sys.getenv("RENV_PROFILE", unset = "")
+    renv_bootstrap_profile_normalize(profile)
+  }
+  
+  renv_bootstrap_profile_set <- function(profile) {
+    profile <- renv_bootstrap_profile_normalize(profile)
+    if (is.null(profile))
+      Sys.unsetenv("RENV_PROFILE")
+    else
+      Sys.setenv(RENV_PROFILE = profile)
+  }
+  
+  renv_bootstrap_profile_normalize <- function(profile) {
+  
+    if (is.null(profile) || profile %in% c("", "default"))
+      return(NULL)
+  
+    profile
+  
+  }
+  
+  renv_bootstrap_path_absolute <- function(path) {
+  
+    substr(path, 1L, 1L) %in% c("~", "/", "\\") || (
+      substr(path, 1L, 1L) %in% c(letters, LETTERS) &&
+      substr(path, 2L, 3L) %in% c(":/", ":\\")
+    )
+  
+  }
+  
+  renv_bootstrap_paths_renv <- function(..., profile = TRUE, project = NULL) {
+    renv <- Sys.getenv("RENV_PATHS_RENV", unset = "renv")
+    root <- if (renv_bootstrap_path_absolute(renv)) NULL else project
+    prefix <- if (profile) renv_bootstrap_profile_prefix()
+    components <- c(root, renv, prefix, ...)
+    paste(components, collapse = "/")
+  }
+  
+  renv_bootstrap_project_type <- function(path) {
+  
+    descpath <- file.path(path, "DESCRIPTION")
+    if (!file.exists(descpath))
+      return("unknown")
+  
+    desc <- tryCatch(
+      read.dcf(descpath, all = TRUE),
+      error = identity
+    )
+  
+    if (inherits(desc, "error"))
+      return("unknown")
+  
+    type <- desc$Type
+    if (!is.null(type))
+      return(tolower(type))
+  
+    package <- desc$Package
+    if (!is.null(package))
+      return("package")
+  
+    "unknown"
+  
+  }
+  
+  renv_bootstrap_user_dir <- function() {
+    dir <- renv_bootstrap_user_dir_impl()
+    path.expand(chartr("\\", "/", dir))
+  }
+  
+  renv_bootstrap_user_dir_impl <- function() {
+  
+    # use local override if set
+    override <- getOption("renv.userdir.override")
+    if (!is.null(override))
+      return(override)
+  
+    # use R_user_dir if available
+    tools <- asNamespace("tools")
+    if (is.function(tools$R_user_dir))
+      return(tools$R_user_dir("renv", "cache"))
+  
+    # try using our own backfill for older versions of R
+    envvars <- c("R_USER_CACHE_DIR", "XDG_CACHE_HOME")
+    for (envvar in envvars) {
+      root <- Sys.getenv(envvar, unset = NA)
+      if (!is.na(root))
+        return(file.path(root, "R/renv"))
+    }
+  
+    # use platform-specific default fallbacks
+    if (Sys.info()[["sysname"]] == "Windows")
+      file.path(Sys.getenv("LOCALAPPDATA"), "R/cache/R/renv")
+    else if (Sys.info()[["sysname"]] == "Darwin")
+      "~/Library/Caches/org.R-project.R/R/renv"
+    else
+      "~/.cache/R/renv"
+  
+  }
+  
+  renv_bootstrap_version_friendly <- function(version, shafmt = NULL, sha = NULL) {
+    sha <- sha %||% attr(version, "sha", exact = TRUE)
+    parts <- c(version, sprintf(shafmt %||% " [sha: %s]", substring(sha, 1L, 7L)))
+    paste(parts, collapse = "")
+  }
+  
+  renv_bootstrap_exec <- function(project, libpath, version) {
+    if (!renv_bootstrap_load(project, libpath, version))
+      renv_bootstrap_run(version, libpath)
+  }
+  
+  renv_bootstrap_run <- function(version, libpath) {
+  
+    # perform bootstrap
+    bootstrap(version, libpath)
+  
+    # exit early if we're just testing bootstrap
+    if (!is.na(Sys.getenv("RENV_BOOTSTRAP_INSTALL_ONLY", unset = NA)))
+      return(TRUE)
+  
+    # try again to load
+    if (requireNamespace("renv", lib.loc = libpath, quietly = TRUE)) {
+      return(renv::load(project = getwd()))
+    }
+  
+    # failed to download or load renv; warn the user
+    msg <- c(
+      "Failed to find an renv installation: the project will not be loaded.",
+      "Use `renv::activate()` to re-initialize the project."
+    )
+  
+    warning(paste(msg, collapse = "\n"), call. = FALSE)
+  
+  }
+  
+  renv_json_read <- function(file = NULL, text = NULL) {
+  
+    jlerr <- NULL
+  
+    # if jsonlite is loaded, use that instead
+    if ("jsonlite" %in% loadedNamespaces()) {
+  
+      json <- catch(renv_json_read_jsonlite(file, text))
+      if (!inherits(json, "error"))
+        return(json)
+  
+      jlerr <- json
+  
+    }
+  
+    # otherwise, fall back to the default JSON reader
+    json <- catch(renv_json_read_default(file, text))
+    if (!inherits(json, "error"))
+      return(json)
+  
+    # report an error
+    if (!is.null(jlerr))
+      stop(jlerr)
+    else
+      stop(json)
+  
+  }
+  
+  renv_json_read_jsonlite <- function(file = NULL, text = NULL) {
+    text <- paste(text %||% read(file), collapse = "\n")
+    jsonlite::fromJSON(txt = text, simplifyVector = FALSE)
+  }
+  
+  renv_json_read_default <- function(file = NULL, text = NULL) {
+  
+    # find strings in the JSON
+    text <- paste(text %||% read(file), collapse = "\n")
+    pattern <- '["](?:(?:\\\\.)|(?:[^"\\\\]))*?["]'
+    locs <- gregexpr(pattern, text, perl = TRUE)[[1]]
+  
+    # if any are found, replace them with placeholders
+    replaced <- text
+    strings <- character()
+    replacements <- character()
+  
+    if (!identical(c(locs), -1L)) {
+  
+      # get the string values
+      starts <- locs
+      ends <- locs + attr(locs, "match.length") - 1L
+      strings <- substring(text, starts, ends)
+  
+      # only keep those requiring escaping
+      strings <- grep("[[\\]{}:]", strings, perl = TRUE, value = TRUE)
+  
+      # compute replacements
+      replacements <- sprintf('"\032%i\032"', seq_along(strings))
+  
+      # replace the strings
+      mapply(function(string, replacement) {
+        replaced <<- sub(string, replacement, replaced, fixed = TRUE)
+      }, strings, replacements)
+  
+    }
+  
+    # transform the JSON into something the R parser understands
+    transformed <- replaced
+    transformed <- gsub("{}", "`names<-`(list(), character())", transformed, fixed = TRUE)
+    transformed <- gsub("[[{]", "list(", transformed, perl = TRUE)
+    transformed <- gsub("[]}]", ")", transformed, perl = TRUE)
+    transformed <- gsub(":", "=", transformed, fixed = TRUE)
+    text <- paste(transformed, collapse = "\n")
+  
+    # parse it
+    json <- parse(text = text, keep.source = FALSE, srcfile = NULL)[[1L]]
+  
+    # construct map between source strings, replaced strings
+    map <- as.character(parse(text = strings))
+    names(map) <- as.character(parse(text = replacements))
+  
+    # convert to list
+    map <- as.list(map)
+  
+    # remap strings in object
+    remapped <- renv_json_remap(json, map)
+  
+    # evaluate
+    eval(remapped, envir = baseenv())
+  
+  }
+  
+  renv_json_remap <- function(json, map) {
+  
+    # fix names
+    if (!is.null(names(json))) {
+      lhs <- match(names(json), names(map), nomatch = 0L)
+      rhs <- match(names(map), names(json), nomatch = 0L)
+      names(json)[rhs] <- map[lhs]
+    }
+  
+    # fix values
+    if (is.character(json))
+      return(map[[json]] %||% json)
+  
+    # handle true, false, null
+    if (is.name(json)) {
+      text <- as.character(json)
+      if (text == "true")
+        return(TRUE)
+      else if (text == "false")
+        return(FALSE)
+      else if (text == "null")
+        return(NULL)
+    }
+  
+    # recurse
+    if (is.recursive(json)) {
+      for (i in seq_along(json)) {
+        json[i] <- list(renv_json_remap(json[[i]], map))
+      }
+    }
+  
+    json
+  
+  }
+
+  # load the renv profile, if any
+  renv_bootstrap_profile_load(project)
+
+  # construct path to library root
+  root <- renv_bootstrap_library_root(project)
+
+  # construct library prefix for platform
+  prefix <- renv_bootstrap_platform_prefix()
+
+  # construct full libpath
+  libpath <- file.path(root, prefix)
+
+  # run bootstrap code
+  renv_bootstrap_exec(project, libpath, version)
+
+  invisible()
+
+})
diff --git a/runcane.sh b/runcane.sh
index 6ad7265..09b9323 100755
--- a/runcane.sh
+++ b/runcane.sh
@@ -1,4 +1,7 @@
 #!/bin/bash
+
+output_file=${1:-"standaard_naam.html"}
+ref=${2:-"word-styles-reference-03.docx"}
 # Directory waar de virtuele omgeving zal worden aangemaakt
 #VENV_DIR="./python_app/myenv"
 
@@ -18,5 +21,6 @@ Rscript 2_CI_data_prep.R
 #
 ## Runnen van Rmd bestand
 # -e betekent "evalueren" en -i specificeert de input file
-Rscript -e "rmarkdown::render('CI_report_dashboard_planet.Rmd', 'all')"
+#Rscript -e "rmarkdown::render('CI_report_dashboard_planet.Rmd', 'all')"
+Rscript -e "rmarkdown::render('CI_report_dashboard_planet.Rmd', output_file='$output_file', params=list(ref='$ref'))"
 cd ..
diff --git a/runpython.sh b/runpython.sh
index 8a9212e..2654b48 100755
--- a/runpython.sh
+++ b/runpython.sh
@@ -1,7 +1,7 @@
 #!/bin/bash
 
 # Standaardwaarde voor days
-days=28
+days=7
 
 # Loop door alle argumenten
 for arg in "$@"