diff --git a/.github/Dockerfile b/.github/Dockerfile deleted file mode 100644 index c5f5ff3..0000000 --- a/.github/Dockerfile +++ /dev/null @@ -1,18 +0,0 @@ -# syntax=docker/dockerfile:1 - -FROM python:3.10-slim -MAINTAINER Leonid Kostrykin - -RUN pip install --no-cache-dir --upgrade pip -RUN pip install --no-cache-dir pybind11 -RUN pip install --no-cache-dir ipykernel -RUN pip install --no-cache-dir jupyterlab - -COPY CarnaPy-*.whl /tmp/carnapy/ -RUN python -m pip install --force-reinstall /tmp/carnapy/*.whl -RUN rm -rf /tmp/carnapy - -COPY examples /data - -EXPOSE 8890 -CMD cd /data; jupyter lab --allow-root --port 8890 --no-browser --ip='*' diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 5c35719..76859d0 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -1,90 +1,133 @@ -name: Build CarnaPy and Docker image +name: Build and Test on: - push: - branches: - - 'master' - - 'dev**' - tags: - - '**' + workflow_call: + inputs: + python-version: + required: true + type: string jobs: - build_carnapy: - name: Build CarnaPy + build: + name: Build runs-on: ubuntu-latest steps: - - - name: Git checkout - uses: actions/checkout@v2 - - - name: Setup Miniconda - uses: conda-incubator/setup-miniconda@v2 + - name: Git checkout + uses: actions/checkout@v4 + + - name: Setup Miniconda + uses: conda-incubator/setup-miniconda@v3 with: - miniconda-version: 'latest' - python-version: '3.10' - channels: conda-forge, defaults - use-only-tar-bz2: true # IMPORTANT: This needs to be set for caching to work properly! + miniconda-version: latest auto-update-conda: true - auto-activate-base: true - - - name: Set environment variables - run: echo "CONDA_PREFIX=$CONDA" >> $GITHUB_ENV - - - name: Build dist - run: sh linux_build.sh - - - name: Collect artifact data + + - name: Patch required Python version + run: | + sed -i "s|python .\+|python ==${{ inputs.python-version }}|g" environment.yml + cat environment.yml + + - name: Create and validate conda environment + shell: bash run: | - mkdir /tmp/dist - cp /usr/local/lib/libCarna-*.so /tmp/dist - rm /tmp/dist/libCarna-*d.so - cp $(find /home/runner/work -name '*.whl') /tmp/dist/ - - - name: Build and upload artifact - uses: actions/upload-artifact@v3 + conda env create -f environment.yml --prefix ./.env + eval "$(conda shell.bash hook)" + conda activate ./.env + python -V + python -c "import sys; v = sys.version_info; assert f'{v.major}.{v.minor}' == '${{ inputs.python-version }}'" + + - name: Extract libcarna version + id: meta + shell: bash + run: | + eval "$(conda shell.bash hook)" + conda activate ./.env + export libcarna_version=$(conda list --json |jq -rj '[ .[] | select( .name == "libcarna" ) ][0].version') + echo "libcarna_version=$libcarna_version" >> "$GITHUB_OUTPUT" + + - name: Build dist + shell: bash + run: ./linux_build.bash + + - name: Upload wheel + uses: actions/upload-artifact@v4 with: - name: dist + name: dist-${{ inputs.python-version }} path: | - /tmp/dist + dist + + outputs: + libcarna_version: ${{ steps.meta.outputs.libcarna_version }} - build_docker: - name: Build Docker image - needs: build_carnapy + test: + needs: build + name: Test runs-on: ubuntu-latest steps: - - - name: Git checkout - uses: actions/checkout@v2 - - - name: Download artifact - uses: actions/download-artifact@v3 + - name: Git checkout + uses: actions/checkout@v4 + + - name: Install dependencies + run: | + sudo apt-get update -y -qq + sudo apt-get install -y -qq libegl1 + + - name: Download artifact + uses: actions/download-artifact@v4 with: - name: dist - - - name: Inspect working directory - run: tree . - - - name: Set up QEMU - uses: docker/setup-qemu-action@v3 - - - name: Set up Docker Buildx - uses: docker/setup-buildx-action@v3 - - - name: Login to Docker Hub - uses: docker/login-action@v3 + name: dist-${{ inputs.python-version }} + + - name: Setup Miniconda + uses: conda-incubator/setup-miniconda@v3 with: - username: ${{ secrets.DOCKERHUB_USERNAME }} - password: ${{ secrets.DOCKERHUB_TOKEN }} - - - name: Setup repository name - id: setup_repository_name + miniconda-version: latest + auto-update-conda: true + + - name: Create and validate conda environment + shell: bash + run: | + conda create --prefix ./.env -c conda-forge -c bioconda \ + python==${{ inputs.python-version }} \ + libcarna==${{ needs.build.outputs.libcarna_version }} \ + pip + eval "$(conda shell.bash hook)" + conda activate ./.env + python -V + python -c "import sys; v = sys.version_info; assert f'{v.major}.{v.minor}' == '${{ inputs.python-version }}'" + + - name: Install wheel + run: | + eval "$(conda shell.bash hook)" + conda activate ./.env + pip install libcarna_python-*.whl + + - name: Test installation run: | - echo "docker_repository=${GITHUB_REPOSITORY,,}" >> $GITHUB_OUTPUT - - - name: Build and push - uses: docker/build-push-action@v5 + eval "$(conda shell.bash hook)" + conda activate ./.env + python -c "import libcarna; assert libcarna.libcarna_version == '${{ needs.build.outputs.libcarna_version }}'" + + - name: Install dependencies for tests and examples + run: | + eval "$(conda shell.bash hook)" + conda activate ./.env + pip install -r test/requirements.txt + pip install -r docs/requirements.txt + + - name: Run tests + run: | + eval "$(conda shell.bash hook)" + conda activate ./.env + cd test + mkdir test + mv results test/results + python -m unittest -vv + env: + LIBCARNA_PYTHON_LOGGING: true + + - name: Upload failed test output + uses: actions/upload-artifact@v4 + if: failure() with: - file: .github/Dockerfile - context: . - push: true - tags: ${{ steps.setup_repository_name.outputs.docker_repository }}:${{ github.ref_name }} + name: test-output-${{ inputs.python-version }} + path: | + test/test/results/actual \ No newline at end of file diff --git a/.github/workflows/build_all.yml b/.github/workflows/build_all.yml new file mode 100644 index 0000000..30e83f1 --- /dev/null +++ b/.github/workflows/build_all.yml @@ -0,0 +1,28 @@ +name: Build and Test + +on: + workflow_dispatch: + + push: + branches: [ 'master', 'develop' ] + paths-ignore: + - 'docs/**' + - '.git*' + - 'LICENSE' + - 'LICENSE-*' + - 'README.md' + + pull_request: + branches-ignore: [ 'master' ] + +jobs: + build_and_test: + name: Build and Test ${{ matrix.python-version }} + strategy: + fail-fast: false + matrix: + python-version: ['3.10', '3.11', '3.12'] + uses: ./.github/workflows/build.yml + secrets: inherit + with: + python-version: ${{ matrix.python-version }} \ No newline at end of file diff --git a/.gitignore b/.gitignore index 3fd797b..20dccfb 100644 --- a/.gitignore +++ b/.gitignore @@ -1,6 +1,11 @@ +/.env +/condaenv.* /build +/docs/build /dist -/CarnaPy.egg-info -/misc/conda-recipe/carnapy +/LibCarna_Python.egg-info +/.libcarna-dev .ipynb_checkpoints *.swp +*.pyc +*.DS_Store \ No newline at end of file diff --git a/.readthedocs.yaml b/.readthedocs.yaml new file mode 100644 index 0000000..e639019 --- /dev/null +++ b/.readthedocs.yaml @@ -0,0 +1,27 @@ +# Read the Docs configuration file +# See https://docs.readthedocs.io/en/stable/config-file/v2.html for details + +# Required +version: 2 + +# Set the OS, Python version, and other tools you might need +build: + os: ubuntu-24.04 + tools: + python: "3.12" + +# Build documentation in the "docs/" directory with Sphinx +sphinx: + fail_on_warning: true + configuration: docs/conf.py + +# Install dependencies +conda: + environment: environment.yml + +# Install our python package and other dependencies +python: + install: + - requirements: docs/requirements.txt + - method: pip + path: . \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..84c50c5 --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,114 @@ +{ + "python.analysis.extraPaths": [ + "./build/make_release" + ], + "search.exclude": { + "docs/examples": true, + "docs/build": true + }, + "files.readonlyInclude": { + "build/**": true, + }, + "[git-commit]": { + "editor.rulers": [50] + }, + "editor.rulers": [ + 119 + ], + "files.associations": { + "any": "cpp", + "array": "cpp", + "atomic": "cpp", + "barrier": "cpp", + "bit": "cpp", + "bitset": "cpp", + "cctype": "cpp", + "cfenv": "cpp", + "charconv": "cpp", + "chrono": "cpp", + "cinttypes": "cpp", + "clocale": "cpp", + "cmath": "cpp", + "codecvt": "cpp", + "compare": "cpp", + "complex": "cpp", + "concepts": "cpp", + "condition_variable": "cpp", + "coroutine": "cpp", + "csetjmp": "cpp", + "csignal": "cpp", + "cstdarg": "cpp", + "cstddef": "cpp", + "cstdint": "cpp", + "cstdio": "cpp", + "cstdlib": "cpp", + "cstring": "cpp", + "ctime": "cpp", + "cuchar": "cpp", + "cwchar": "cpp", + "cwctype": "cpp", + "deque": "cpp", + "forward_list": "cpp", + "list": "cpp", + "map": "cpp", + "set": "cpp", + "string": "cpp", + "unordered_map": "cpp", + "unordered_set": "cpp", + "vector": "cpp", + "exception": "cpp", + "expected": "cpp", + "algorithm": "cpp", + "functional": "cpp", + "iterator": "cpp", + "memory": "cpp", + "memory_resource": "cpp", + "netfwd": "cpp", + "numeric": "cpp", + "optional": "cpp", + "random": "cpp", + "ratio": "cpp", + "regex": "cpp", + "source_location": "cpp", + "string_view": "cpp", + "system_error": "cpp", + "tuple": "cpp", + "type_traits": "cpp", + "utility": "cpp", + "rope": "cpp", + "slist": "cpp", + "format": "cpp", + "fstream": "cpp", + "future": "cpp", + "initializer_list": "cpp", + "iomanip": "cpp", + "iosfwd": "cpp", + "iostream": "cpp", + "istream": "cpp", + "latch": "cpp", + "limits": "cpp", + "mutex": "cpp", + "new": "cpp", + "numbers": "cpp", + "ostream": "cpp", + "ranges": "cpp", + "scoped_allocator": "cpp", + "semaphore": "cpp", + "shared_mutex": "cpp", + "span": "cpp", + "spanstream": "cpp", + "sstream": "cpp", + "stacktrace": "cpp", + "stdexcept": "cpp", + "stdfloat": "cpp", + "stop_token": "cpp", + "streambuf": "cpp", + "syncstream": "cpp", + "thread": "cpp", + "typeindex": "cpp", + "typeinfo": "cpp", + "valarray": "cpp", + "variant": "cpp", + "*.py.in": "python" + } +} \ No newline at end of file diff --git a/CMakeLists.txt b/CMakeLists.txt index e7d7a6c..ea0bb89 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,27 +1,28 @@ -cmake_minimum_required(VERSION 3.0.2) -project(CarnaPy) -include(FindPackageHandleStandardArgs) +cmake_minimum_required( VERSION 3.5 ) +project( LibCarna-Python ) +set( PYTHON_MODULE_NAME "libcarna" ) +include( FindPackageHandleStandardArgs ) -set(CMAKE_CXX_STANDARD 14) -set(CMAKE_CXX_STANDARD_REQUIRED ON) -set(CMAKE_INTERPROCEDURAL_OPTIMIZATION FALSE) +set( CMAKE_CXX_STANDARD 14 ) +set( CMAKE_CXX_STANDARD_REQUIRED ON ) +set( CMAKE_INTERPROCEDURAL_OPTIMIZATION FALSE ) ############################################ -set(FULL_VERSION ${MAJOR_VERSION}.${MINOR_VERSION}.${PATCH_VERSION}) -set(TARGET_NAME ${PROJECT_NAME}-${FULL_VERSION}) -string(TOUPPER ${PROJECT_NAME} PROJECT_NAME_CAPS) +set( FULL_VERSION ${MAJOR_VERSION}.${MINOR_VERSION}.${PATCH_VERSION} ) +set( TARGET_NAME ${PROJECT_NAME}-${FULL_VERSION} ) +string( TOUPPER ${PROJECT_NAME} PROJECT_NAME_CAPS ) +string( REGEX REPLACE "-" "_" PROJECT_NAME_CAPS ${PROJECT_NAME_CAPS} ) -set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/carna) -set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/carna) -set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/carna) +set( CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${PYTHON_MODULE_NAME} ) +set( CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${PYTHON_MODULE_NAME} ) +set( CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/${PYTHON_MODULE_NAME} ) ############################################ # Set default options for this build ############################################ -option(BUILD_DOC "Build and install the API documentation" OFF) -option(BUILD_TEST "Build the unit tests" OFF) +option( BUILD_TEST "Build the test suite" OFF ) ############################################ # Macro that sets variable to default value @@ -30,108 +31,106 @@ option(BUILD_TEST "Build the unit tests" OFF) macro( option_default_to var_name default_val var_type doc_string ) if( NOT DEFINED ${var_name} ) - set(${var_name} ${default_val}) + set( ${var_name} ${default_val} ) endif() - set(${var_name} ${${var_name}} CACHE ${var_type} ${doc_string} FORCE) + set( ${var_name} ${${var_name}} CACHE ${var_type} ${doc_string} FORCE ) endmacro() ############################################ # Locate Find.cmake scripts ############################################ -list(APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/misc/CMake-Modules) +list( APPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/misc/CMake-Modules ) +list( PREPEND CMAKE_MODULE_PATH ${CMAKE_CURRENT_SOURCE_DIR}/.libcarna-dev ) ############################################ # Define default paths for the installation ############################################ # set default library and header destinations (relative to CMAKE_INSTALL_PREFIX) -option_default_to(INSTALL_LIBRARY_DIR "${TARGET_NAME}/carna" String "Installation directory for libraries") -option_default_to(INSTALL_DOC_DIR "share/doc/${PROJECT_NAME}" String "Installation directory for API documentation") +option_default_to( INSTALL_LIBRARY_DIR "${PROJECT_NAME}" String "Installation directory for libraries" ) ############################################ # Normalize installation paths # (get rid of Windows-style delimiters) ############################################ -file(TO_CMAKE_PATH ${INSTALL_LIBRARY_DIR} INSTALL_LIBRARY_DIR) +file( TO_CMAKE_PATH ${INSTALL_LIBRARY_DIR} INSTALL_LIBRARY_DIR ) ############################################ # Find required dependencies ############################################ # EGL -find_package(OpenGL REQUIRED COMPONENTS OpenGL EGL) -include_directories(${OPENGL_EGL_INCLUDE_DIRS}) +find_package( OpenGL REQUIRED COMPONENTS EGL ) +include_directories( ${OPENGL_EGL_INCLUDE_DIRS} ) # pybind11 -find_package(pybind11 REQUIRED) +find_package( pybind11 REQUIRED ) # Eigen find_package( Eigen3 REQUIRED ) include_directories( ${EIGEN3_INCLUDE_DIR} ) -# Carna -find_package( Carna ${REQUIRED_VERSION_CARNA} REQUIRED ) -include_directories( ${CARNA_INCLUDE_DIR} ) -set(CARNA_VERSION ${FOUND_VERSION}) +# LibCarna +find_package( LibCarna ${REQUIRED_VERSION_LIBCARNA} REQUIRED COMPONENTS release ) +include_directories( ${LibCarna_INCLUDE_DIR} ) +set( LIBCARNA_VERSION ${FOUND_VERSION} ) ############################################ configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/misc/__init__.py.in - ${CMAKE_CURRENT_BINARY_DIR}/carna/__init__.py @ONLY) + ${CMAKE_CURRENT_BINARY_DIR}/${PYTHON_MODULE_NAME}/__init__.py @ONLY ) -configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/misc/py.py - ${CMAKE_CURRENT_BINARY_DIR}/carna/py.py COPYONLY) +file( GLOB PYTHON_AUX_FILES "${CMAKE_CURRENT_SOURCE_DIR}/misc/libcarna/*.py" ) +file( COPY ${PYTHON_AUX_FILES} DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/${PYTHON_MODULE_NAME}" ) -#configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/src/doc/Doxyfile.in -# ${CMAKE_CURRENT_SOURCE_DIR}/src/doc/Doxyfile @ONLY) +file( GLOB LICENSES "${LibCarna_LICENSE_DIR}/LICENSE*" ) +file( COPY ${LICENSES} DESTINATION "${CMAKE_CURRENT_BINARY_DIR}/licenses/" ) ############################################ # Project ############################################ -include_directories(${CMAKE_PROJECT_DIR}include) -include_directories(${CMAKE_PROJECT_DIR}src/include) +include_directories( ${CMAKE_PROJECT_DIR}src/include ) set( MODULES base egl presets helpers ) -set( PRIVATE_QOBJECT_HEADERS - "" -) -set( PRIVATE_HEADERS - ${PRIVATE_QOBJECT_HEADERS} - ) set( SRC - "" - ) -set( FORMS - "" - ) -set( RESOURCES - "" - ) -set( DOC_SRC - "" -# src/doc/Doxyfile.in -# src/doc/doc_extra.css -# src/doc/doc_main.dox -# src/doc/doc_version_log.dox + src/egl/EGLContext.cpp + src/py/log.cpp + src/py/Surface.cpp + src/py/base.cpp + src/py/egl.cpp + src/py/presets.cpp + src/py/helpers.cpp ) ############################################ -#include_directories( ${CMAKE_CURRENT_BINARY_DIR} ) +# Write unity build file ############################################ -set(EXTRA_SOURCES_egl src/egl/Context.cpp) -foreach( MODULE ${MODULES} ) - pybind11_add_module(${MODULE} src/py/${MODULE}.cpp ${EXTRA_SOURCES_${MODULE}}) - target_compile_options(${MODULE} PRIVATE -fvisibility=default -fno-lto) +set( UNITY_BUILD_FILE ${CMAKE_CURRENT_BINARY_DIR}/${TARGET_NAME}-unitybuild.cpp ) - SET_TARGET_PROPERTIES(${MODULE} PROPERTIES PREFIX "") +file( REMOVE ${UNITY_BUILD_FILE} ) +file( WRITE ${UNITY_BUILD_FILE} "// This file is automatically generated by CMake.\n\n" ) +foreach( SOURCE_FILE ${SRC} ) + file( APPEND ${UNITY_BUILD_FILE} "#include \"${CMAKE_CURRENT_SOURCE_DIR}/${SOURCE_FILE}\"\n" ) +endforeach( SOURCE_FILE ) + +############################################ +# Add sources +############################################ + +foreach( MODULE ${MODULES} ) + string( TOUPPER ${MODULE} MODULE_CAPS ) + pybind11_add_module( ${MODULE} ${UNITY_BUILD_FILE} ) + target_compile_options( ${MODULE} PRIVATE -fvisibility=default -fno-lto ) + target_compile_definitions( ${MODULE} PRIVATE ) + SET_TARGET_PROPERTIES( ${MODULE} PROPERTIES PREFIX "" ) endforeach( MODULE ) add_definitions( -D${PROJECT_NAME_CAPS}_EXPORT -DNOMINMAX ) @@ -147,25 +146,25 @@ foreach( MODULE ${MODULES} ) ${MODULE} PRIVATE ${OPENGL_LIBRARIES} - ${CARNA_LIBRARIES} + ${LibCarna_LIBRARIES} OpenGL::EGL ) - endforeach( MODULE ) ############################################ # Define installation routines ############################################ -install(TARGETS ${MODULES} - RUNTIME DESTINATION ${INSTALL_LIBRARY_DIR} - ARCHIVE DESTINATION ${INSTALL_LIBRARY_DIR} - LIBRARY DESTINATION ${INSTALL_LIBRARY_DIR}) +install( TARGETS ${MODULES} + RUNTIME DESTINATION ${INSTALL_LIBRARY_DIR} + ARCHIVE DESTINATION ${INSTALL_LIBRARY_DIR} + LIBRARY DESTINATION ${INSTALL_LIBRARY_DIR} +) -install(FILES - ${CMAKE_CURRENT_BINARY_DIR}/carna/__init__.py - ${CMAKE_CURRENT_BINARY_DIR}/carna/py.py - DESTINATION ${INSTALL_LIBRARY_DIR}) +install( FILES + ${CMAKE_CURRENT_BINARY_DIR}/${PYTHON_MODULE_NAME}/__init__.py + DESTINATION ${INSTALL_LIBRARY_DIR} +) ############################################ # Process unit tests @@ -174,14 +173,3 @@ install(FILES if( BUILD_TEST ) add_subdirectory( test ) endif() - -############################################ -# Doxygen API documentation -############################################ - -#if( BUILD_DOC ) -# add_subdirectory( src/doc ) -#endif() - -############################################ - diff --git a/LICENSE b/LICENSE index dfa7050..e5f02d9 100644 --- a/LICENSE +++ b/LICENSE @@ -1,29 +1,21 @@ -Copyright (c) 2021 by Leonid Kostrykin (leonid.kostrykin@bioquant.uni-heidelberg.de) +MIT License -All rights reserved. +Copyright (c) 2025 Leonid Kostrykin -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: -* Redistributions of source code must retain the above copyright notice, this - list of conditions and the following disclaimer. - -* Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - -* Neither the name of Carna nor CarnaPy or the names of its - contributors may be used to endorse or promote products derived from - this software without specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" -AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE -IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE -DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, -OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. \ No newline at end of file diff --git a/README.md b/README.md index 1991099..8e1d7bf 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,11 @@ -CarnaPy -======== +LibCarna-Python +=============== -The aim of this package is to provide real-time 3D visualization in Python for specifically, but not limited to, biomedical data. The library is based on [Carna](https://github.com/kostrykin/Carna). +The aim of this package is to provide real-time 3D visualization in Python for specifically, but not limited to, biomedical data. The library is based on [LibCarna](https://github.com/kostrykin/LibCarna). See [examples/kalinin2018.ipynb](examples/kalinin2018.ipynb) for an example. -[![Build CarnaPy and Docker image](https://github.com/kostrykin/CarnaPy/actions/workflows/build.yml/badge.svg)](https://github.com/kostrykin/CarnaPy/actions/workflows/build.yml) -![Docker Image Version (latest semver)](https://img.shields.io/docker/v/kostrykin/carnapy?label=DockerHub%3A) +[![Build LibCarnaPy and Docker image](https://github.com/kostrykin/LibCarnaPy/actions/workflows/build.yml/badge.svg)](https://github.com/kostrykin/LibCarnaPy/actions/workflows/build.yml) [![Anaconda-Server Badge](https://img.shields.io/badge/Install%20with-conda-%2387c305)](https://anaconda.org/kostrykin/carnapy) [![Anaconda-Server Badge](https://img.shields.io/conda/v/kostrykin/carnapy.svg?label=Version)](https://anaconda.org/kostrykin/carnapy) [![Anaconda-Server Badge](https://img.shields.io/conda/pn/kostrykin/carnapy.svg?label=Platforms)](https://anaconda.org/kostrykin/carnapy) @@ -23,7 +22,7 @@ See [examples/kalinin2018.ipynb](examples/kalinin2018.ipynb) for an example. ## 1. Limitations * Only 8bit and 16bit volume data are supported at the moment. -* DRR renderings are not exposed to Python yet. +* Only a subset of rendering stages is exposed to Python yet. * Build process is currently limited to Linux-based systems. --- @@ -33,33 +32,23 @@ Using the library requires the following dependencies: * [numpy](https://numpy.org/) ≥ 1.16 * EGL driver support * OpenGL 3.3 -* Python ≥ 3.7 +* Python ≥ 3.10 The following dependencies must be satisfied for the build process: -* [Carna](https://github.com/kostrykin/Carna) ≥ 3.1 +* [LibCarna](https://github.com/kostrykin/LibCarna) ≥ 3.4 * [Eigen](http://eigen.tuxfamily.org/) ≥ 3.0.5 -* [libboost-iostreams](https://www.boost.org/doc/libs/1_76_0/libs/iostreams/doc/index.html) * [pybind11](https://github.com/pybind/pybind11) * EGL development files -In addition, the following dependencies are required to run the test suite: -* [matplotlib](https://matplotlib.org/) -* [scipy](https://www.scipy.org/) +See environment.yml for further dependencies for testing and running. --- ## 3. Installation -The easiest way to install and use the library is to use one of the binary [Conda](https://docs.anaconda.com/anaconda/install/) packages: +The easiest way to install and use the library is to use one of the binary [Conda](https://www.anaconda.com/docs/getting-started/miniconda) packages: ```bash -conda install -c kostrykin carnapy -``` - -Conda packages are available for Python 3.7–3.9. - -Or you can use the Docker image which comes with Jupyter Lab: -```bash -docker run --rm --gpus all -p 8890:8890 -t -i kostrykin/carnapy: +conda install bioconda::libcarna-python ``` --- @@ -67,11 +56,19 @@ docker run --rm --gpus all -p 8890:8890 -t -i kostrykin/carnapy: There is a build script for Ubuntu Linux which builds a wheel file: ```bash -sh linux_build.sh +LIBCARNA_PYTHON_BUILD_DOCS=ON LIBCARNA_PYTHON_BUILD_TEST=ON ./linux_build.bash ``` Adaption to other distribution should be self-explanatory. After building the wheel file, it can be installed using: ```bash -python -m pip install --force-reinstall $(find . -name 'CarnaPy*.whl') +python -m pip install --force-reinstall $(find . -name 'LibCarna_Python*.whl') ``` + +To build against a development version of LibCarna, install it locally, +```bash +LIBCARNA_SRC_PREFIX="../LibCarna" ./install_libcarna_dev.bash +``` +where you make `LIBCARNA_SRC_PREFIX` point to the source directory. + +This will create a local directory `.libcarna-dev`. The build process will give precedence to LibCarna from this directory over other versions. Simply remove `.libcarna-dev` to stop building agaisnt the development version of LibCarna. diff --git a/docs/_static/custom.css b/docs/_static/custom.css new file mode 100644 index 0000000..3bb5863 --- /dev/null +++ b/docs/_static/custom.css @@ -0,0 +1,19 @@ +img.logo { + margin-bottom: 1rem; + margin-left: -0.9rem; +} + +h1.logo { + font-size: 1.4rem; + white-space: nowrap; +} + +section > dl { + margin-bottom: 1rem; + padding-top: 1rem; + border-top: 1px solid #ccc; +} + +section > dl > dd > dl { + margin-top: 15px; +} \ No newline at end of file diff --git a/docs/conf.py b/docs/conf.py new file mode 100644 index 0000000..056a7ec --- /dev/null +++ b/docs/conf.py @@ -0,0 +1,23 @@ +project = 'libcarna-python' +copyright = '2021-2025 Leonid Kostrykin' +author = 'Leonid Kostrykin' + +extensions = [ + 'sphinx.ext.autodoc', + 'sphinx.ext.autosummary', + 'sphinx.ext.napoleon', + 'nbsphinx', +] + +html_logo = 'logo.png' +html_static_path = ['_static'] +html_css_files = ['custom.css'] + +import os +import sys + +LIBCARNA_PYTHON_PATH = os.environ.get('LIBCARNA_PYTHON_PATH') +sys.path.append(LIBCARNA_PYTHON_PATH) +os.environ['PYTHONPATH'] = LIBCARNA_PYTHON_PATH + ':' + os.environ.get('PYTHONPATH', '') + +nbsphinx_execute = 'always' \ No newline at end of file diff --git a/docs/examples b/docs/examples new file mode 120000 index 0000000..a6573af --- /dev/null +++ b/docs/examples @@ -0,0 +1 @@ +../examples \ No newline at end of file diff --git a/docs/index.rst b/docs/index.rst new file mode 100644 index 0000000..15827e6 --- /dev/null +++ b/docs/index.rst @@ -0,0 +1,28 @@ +libcarna-python +=============== + +These are the Python bindings for the LibCarna library. The documentation of the original LibCarna library can be found at: +https://kostrykin.github.io/LibCarna/html. + +Examples +-------- + +.. toctree:: + + examples/introduction + examples/cells + examples/cthead + +API +--- + +.. toctree:: + :maxdepth: 1 + + libcarna + libcarna.base + libcarna.base.math + libcarna.data + libcarna.egl + libcarna.helpers + libcarna.presets \ No newline at end of file diff --git a/docs/libcarna.base.math.rst b/docs/libcarna.base.math.rst new file mode 100644 index 0000000..b3cdace --- /dev/null +++ b/docs/libcarna.base.math.rst @@ -0,0 +1,8 @@ +libcarna.base.math +================== + +.. automodule:: libcarna.base.math + :imported-members: + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/libcarna.base.rst b/docs/libcarna.base.rst new file mode 100644 index 0000000..95bcb26 --- /dev/null +++ b/docs/libcarna.base.rst @@ -0,0 +1,8 @@ +libcarna.base +============= + +.. automodule:: libcarna.base + :imported-members: + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/libcarna.data.rst b/docs/libcarna.data.rst new file mode 100644 index 0000000..39c141e --- /dev/null +++ b/docs/libcarna.data.rst @@ -0,0 +1,8 @@ +libcarna.data +============= + +.. automodule:: libcarna.data + :imported-members: + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/libcarna.egl.rst b/docs/libcarna.egl.rst new file mode 100644 index 0000000..ce8e781 --- /dev/null +++ b/docs/libcarna.egl.rst @@ -0,0 +1,8 @@ +libcarna.egl +============ + +.. automodule:: libcarna.egl + :imported-members: + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/libcarna.helpers.rst b/docs/libcarna.helpers.rst new file mode 100644 index 0000000..0fa9a18 --- /dev/null +++ b/docs/libcarna.helpers.rst @@ -0,0 +1,8 @@ +libcarna.helpers +================ + +.. automodule:: libcarna.helpers + :imported-members: + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/libcarna.presets.rst b/docs/libcarna.presets.rst new file mode 100644 index 0000000..f95e8ea --- /dev/null +++ b/docs/libcarna.presets.rst @@ -0,0 +1,8 @@ +libcarna.presets +================ + +.. automodule:: libcarna.presets + :imported-members: + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/libcarna.rst b/docs/libcarna.rst new file mode 100644 index 0000000..be22c4c --- /dev/null +++ b/docs/libcarna.rst @@ -0,0 +1,21 @@ +libcarna +======== + +Geometry Types +-------------- + +Each scene might contain multiple types of renderable objects. At least one could distinguish between polygonal and +volumetric objects. Planes are certainly a third type: They are neither polygonal because they are infinitely extended, +nor are they volumetric. It is up to the user to choose a more fine-grained taxonomy if required. Note that each +renderer expects to be told which *geometry type* it should render. For example, by using two +:class:`libcarna.cutting_planes` renderers with different values for their *geometry type*, one could render multiple +cutting planes with different windowing settings. + +API +--- + +.. automodule:: libcarna + :imported-members: + :members: + :undoc-members: + :show-inheritance: \ No newline at end of file diff --git a/docs/logo.png b/docs/logo.png new file mode 100644 index 0000000..a79b6a5 Binary files /dev/null and b/docs/logo.png differ diff --git a/docs/requirements.txt b/docs/requirements.txt new file mode 100644 index 0000000..9d9afa9 --- /dev/null +++ b/docs/requirements.txt @@ -0,0 +1,6 @@ +sphinx==8.1.3 +nbsphinx==0.9.7 +ipykernel~=6.29 +pandoc==2.4 +snowballstemmer<3 +matplotlib \ No newline at end of file diff --git a/environment.yml b/environment.yml new file mode 100644 index 0000000..ad6eafd --- /dev/null +++ b/environment.yml @@ -0,0 +1,35 @@ +name: libcarna-python-dev +channels: + - conda-forge + - bioconda +dependencies: + - python ~=3.12 + + # --------------------------------------------------------------------------- + # Build dependencies + + - pybind11 <3 + - libgl-devel + - libegl-devel + - libopengl-devel + - libglu + - cxx-compiler + - make + - cmake + - eigen >=3.0.5 + - libxcrypt # requied for Python 3.10 + - pyyaml + - setuptools + + # --------------------------------------------------------------------------- + # Runtime dependencies (general) + + - libcarna ==3.4.0 + - matplotlib-base # for `_colormap_helper` + - numpngw ==0.1.4 # writes APNG + - scikit-video ==1.1.11 # API for ffmpeg + - ffmpeg # writes h264 + - scipy # for `libcarna.data` and `libcarna.normalize_hounsfield_units` + - scikit-image # for `libcarna.data` + - tifffile # for `libcarna.data` + - pooch # for `libcarna.data` \ No newline at end of file diff --git a/examples/cells.ipynb b/examples/cells.ipynb new file mode 100644 index 0000000..43da89c --- /dev/null +++ b/examples/cells.ipynb @@ -0,0 +1,956 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3cdf478e", + "metadata": {}, + "source": [ + "# Cell Nuclei\n", + "\n", + "In this example, we will use a cellular image from the Allen Cell WTC-11 hiPSC Single-Cell Image Dataset ([Viana et al. 2023](https://doi.org/10.1038/s41586-022-05563-7))." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "59e8a2c3", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:25.120269Z", + "iopub.status.busy": "2025-05-13T11:30:25.120166Z", + "iopub.status.idle": "2025-05-13T11:30:25.533939Z", + "shell.execute_reply": "2025-05-13T11:30:25.533481Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "import libcarna\n", + "import numpy as np\n", + "import scipy.ndimage as ndi" + ] + }, + { + "cell_type": "markdown", + "id": "a3157707", + "metadata": {}, + "source": [ + "Get the data:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "97c2c4ed", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:25.535447Z", + "iopub.status.busy": "2025-05-13T11:30:25.535270Z", + "iopub.status.idle": "2025-05-13T11:30:25.596255Z", + "shell.execute_reply": "2025-05-13T11:30:25.595909Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((60, 256, 256), dtype('uint16'))" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = libcarna.data.nuclei()\n", + "data.shape, data.dtype" + ] + }, + { + "cell_type": "markdown", + "id": "fff4fac6", + "metadata": {}, + "source": [ + "The data is 60 × 256 × 256 pixels (uint16).\n", + "\n", + "## Maximum Intensity Projection\n", + "\n", + "In the code below, we use `normals=True` on the `volume` node; albeit this doesn't make any difference for the *Maximum\n", + "Intensity Projection* (MIP), it is benefitial for other rendering modes, [discussed below](#Direct-Volume-Rendering)." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ed16156a", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:25.597390Z", + "iopub.status.busy": "2025-05-13T11:30:25.597224Z", + "iopub.status.idle": "2025-05-13T11:30:26.469406Z", + "shell.execute_reply": "2025-05-13T11:30:26.469030Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + " 66k\n", + " \n", + "
\n", + "\n", + "
\n", + " 49k\n", + " \n", + "
\n", + "\n", + "
\n", + " 33k\n", + " \n", + "
\n", + "\n", + "
\n", + " 16k\n", + " \n", + "
\n", + "\n", + "
\n", + " 0\n", + " \n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "GEOMETRY_TYPE_VOLUME = 1\n", + "\n", + "# Create and configure frame renderer\n", + "mip = libcarna.mip(GEOMETRY_TYPE_VOLUME, cmap='jet', sr=500)\n", + "r = libcarna.renderer(600, 450, [mip])\n", + "\n", + "# Create and configure scene\n", + "root = libcarna.node()\n", + "\n", + "volume = libcarna.volume(\n", + " GEOMETRY_TYPE_VOLUME,\n", + " data,\n", + " parent=root,\n", + " spacing=(1, 0.5, 0.5),\n", + ").rotate('x', -35).rotate('y', 90)\n", + "\n", + "camera = libcarna.camera(\n", + " parent=root,\n", + ").frustum(fov=90, z_near=1, z_far=500).translate(z=100)\n", + "\n", + "# Render\n", + "libcarna.imshow(r.render(camera), mip.cmap.bar(volume))" + ] + }, + { + "cell_type": "markdown", + "id": "465034ee", + "metadata": {}, + "source": [ + "In the MIP, it can easily be seen that there is one mitotic nucleus in the image.\n", + "\n", + "For an even better visual perception of the 3D data, it is best viewed from different angles, that can be achieved with\n", + "as a subtle animation:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "d35452de", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:26.472115Z", + "iopub.status.busy": "2025-05-13T11:30:26.471993Z", + "iopub.status.idle": "2025-05-13T11:30:26.889987Z", + "shell.execute_reply": "2025-05-13T11:30:26.889554Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + " 66k\n", + " \n", + "
\n", + "\n", + "
\n", + " 49k\n", + " \n", + "
\n", + "\n", + "
\n", + " 33k\n", + " \n", + "
\n", + "\n", + "
\n", + " 16k\n", + " \n", + "
\n", + "\n", + "
\n", + " 0\n", + " \n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Render as animation\n", + "libcarna.imshow(\n", + " libcarna.animate(\n", + " libcarna.animate.swing_local(camera, amplitude=22),\n", + " n_frames=50,\n", + " ).render(r, camera),\n", + " mip.cmap.bar(volume),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "17ab03b3", + "metadata": {}, + "source": [ + "This makes the camera swing by 22° to the left and to the right." + ] + }, + { + "cell_type": "markdown", + "id": "ab9dc2e1", + "metadata": {}, + "source": [ + "## Direct Volume Rendering\n", + "\n", + "In a *Direct Volume Rendering* (DVR), surfaces are rendered by simulation of the absorption of light. This simulation\n", + "is most realstic, when the spatial orientation of the surfaces can be taken into account, which requires that the\n", + "normals of the volume have been computed (this is why we used `normals=True` when we created the `volume` node)." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "c33d38bc", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:26.894851Z", + "iopub.status.busy": "2025-05-13T11:30:26.894647Z", + "iopub.status.idle": "2025-05-13T11:30:26.899321Z", + "shell.execute_reply": "2025-05-13T11:30:26.898913Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "dvr = libcarna.dvr(GEOMETRY_TYPE_VOLUME, sr=500)" + ] + }, + { + "cell_type": "markdown", + "id": "0db629af", + "metadata": {}, + "source": [ + "We again use the `jet` colormap, that, as we have seen in the MIP, employs blueish colors for the nuclear envelope, and\n", + "reddish colors for the chromatin. In addition, we use a linear `ramp` function for the colormap, because we want the\n", + "space between the nuclei to be translucent:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "ea6ed2dd", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:26.901128Z", + "iopub.status.busy": "2025-05-13T11:30:26.900781Z", + "iopub.status.idle": "2025-05-13T11:30:27.319418Z", + "shell.execute_reply": "2025-05-13T11:30:27.318973Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + " 66k\n", + " \n", + "
\n", + "\n", + "
\n", + " 49k\n", + " \n", + "
\n", + "\n", + "
\n", + " 33k\n", + " \n", + "
\n", + "\n", + "
\n", + " 16k\n", + " \n", + "
\n", + "\n", + "
\n", + " 0\n", + " \n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dvr.cmap('jet', ramp=(0.15, 0.25))\n", + "\n", + "libcarna.imshow(\n", + " libcarna.animate(\n", + " libcarna.animate.swing_local(camera, amplitude=22),\n", + " n_frames=50,\n", + " ).render(\n", + " libcarna.renderer(600, 450, [dvr]),\n", + " camera,\n", + " ),\n", + " dvr.cmap.bar(volume),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "74821fb1", + "metadata": {}, + "source": [ + "The DVR of the nuclei in the image allows for a very natural perception of the 3D scene. On the downside, the mitotic\n", + "nucleus is harder to identify. This is because the chromatin from the inside of the nucleus (should be reddish due to\n", + "our colormap) is fully occluded by the nuclear envelope (blueish).\n", + "\n", + "We can overlay a DVR of the nuclear envelope with a MIP for the chromatin:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "b00a9d85", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:27.322333Z", + "iopub.status.busy": "2025-05-13T11:30:27.322209Z", + "iopub.status.idle": "2025-05-13T11:30:27.855893Z", + "shell.execute_reply": "2025-05-13T11:30:27.855442Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + " 66k\n", + " \n", + "
\n", + "\n", + "
\n", + " 49k\n", + " \n", + "
\n", + "\n", + "
\n", + " 33k\n", + " \n", + "
\n", + "\n", + "
\n", + " 16k\n", + " \n", + "
\n", + "\n", + "
\n", + " 0\n", + " \n", + "
\n", + "
\n", + "
\n", + " MIP\n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mip = libcarna.mip(GEOMETRY_TYPE_VOLUME, sr=500)\n", + "mip.cmap('jet', ramp=(0.5, 0.7))\n", + "\n", + "libcarna.imshow(\n", + " libcarna.animate(\n", + " libcarna.animate.swing_local(camera, amplitude=22),\n", + " n_frames=50,\n", + " ).render(\n", + " libcarna.renderer(600, 450, [dvr.replicate(), mip]),\n", + " camera,\n", + " ),\n", + " dvr.cmap.bar(volume, label='DVR', tick_labels=False),\n", + " mip.cmap.bar(volume, label='MIP'),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "8d5f0cf4", + "metadata": {}, + "source": [ + "Note that we use `dvr.replicate()` when adding the previously defined DVR to the renderer. This is because each\n", + "rendering stage can only be added to one renderer, hence, we replicate it this time. Of course, we could have used the\n", + "`dvr.replicate()` method the first time that we added the DVR to a renderer, too, but this is not mandatory. All\n", + "rendering stages provide such a method.\n", + "\n", + "## Pointwise Annotations\n", + "\n", + "Visual validation of detections, for example, requires visualization of those detections within the spatial context of\n", + "the original image data. Since LibCarna permits combining different renderers with great flexibility, there is nothing\n", + "in the way of rendering some opaque markers on top of the DVR.\n", + "\n", + "First, lets detect the chromatin spots in the 3D image:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "9931ba22", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:27.859332Z", + "iopub.status.busy": "2025-05-13T11:30:27.858992Z", + "iopub.status.idle": "2025-05-13T11:30:28.082316Z", + "shell.execute_reply": "2025-05-13T11:30:28.081718Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "data_denoised = ndi.gaussian_filter(data, 1)\n", + "data_max = ndi.maximum_filter(data_denoised, size=5)\n", + "detections = np.where(\n", + " np.logical_and(\n", + " data_denoised == data_max,\n", + " data_denoised >= 30_000,\n", + " )\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "f61c72df", + "metadata": {}, + "source": [ + "We now visualize the detected chromatin spots by marking each detection with a red ball. By using `parent=volume`, we\n", + "attach those markers to the `volume` node. To correctly position the markers, we take advantage of the\n", + "`transform_from_voxels_into` method of the `volume`, that maps the voxel coordinates of the original data to the\n", + "coordinates of the `volume` node:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "537cfdd2", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:28.084053Z", + "iopub.status.busy": "2025-05-13T11:30:28.083694Z", + "iopub.status.idle": "2025-05-13T11:30:28.472777Z", + "shell.execute_reply": "2025-05-13T11:30:28.472296Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "GEOMETRY_TYPE_OPAQUE = 2\n", + "\n", + "ball = libcarna.meshes.create_ball(5)\n", + "red = libcarna.material('solid', color=libcarna.color.RED)\n", + "\n", + "for xyz in zip(*detections):\n", + " libcarna.geometry(\n", + " GEOMETRY_TYPE_OPAQUE,\n", + " parent=volume,\n", + " mesh=ball,\n", + " material=red,\n", + " ).translate(\n", + " *volume.transform_from_voxels_into(volume).point(xyz)\n", + " )\n", + "\n", + "libcarna.imshow(\n", + " libcarna.animate(\n", + " libcarna.animate.swing_local(camera, amplitude=22),\n", + " n_frames=50,\n", + " ).render(\n", + " libcarna.renderer(600, 450, [\n", + " dvr.replicate(),\n", + " libcarna.opaque_renderer(GEOMETRY_TYPE_OPAQUE),\n", + " ]),\n", + " camera,\n", + " ),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "bd7785f1", + "metadata": {}, + "source": [ + "## Mask Visualization\n", + "\n", + "Segmentation is the identification of image regions that correspond to individual objects. To first obtain a\n", + "segmentation of the image, we apply an intensity threshold, followed by a connected component analysis to identify the\n", + "individual nuclei:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "417a2589", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:28.475480Z", + "iopub.status.busy": "2025-05-13T11:30:28.475278Z", + "iopub.status.idle": "2025-05-13T11:30:28.500487Z", + "shell.execute_reply": "2025-05-13T11:30:28.499892Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "data_seg = ndi.label(data_denoised > 10_000)[0]" + ] + }, + { + "cell_type": "markdown", + "id": "df9688f5", + "metadata": {}, + "source": [ + "The `data_seg` array is a *labeled mask*, where 0 corresponds to the image background, and each spatially connected\n", + "component of nuclei has a unique *label* (intensity value).\n", + "\n", + "We can now use the *Mask Renderer* to visualize the segmentation results by rendering their outlines on top of the DVR:" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b8af663f", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:28.501942Z", + "iopub.status.busy": "2025-05-13T11:30:28.501831Z", + "iopub.status.idle": "2025-05-13T11:30:29.434996Z", + "shell.execute_reply": "2025-05-13T11:30:29.434505Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "GEOMETRY_TYPE_MASK = 3\n", + "\n", + "libcarna.volume(\n", + " GEOMETRY_TYPE_MASK,\n", + " data_seg,\n", + " parent=volume,\n", + " spacing=volume.spacing,\n", + ")\n", + "\n", + "libcarna.imshow(\n", + " libcarna.animate(\n", + " libcarna.animate.swing_local(camera, amplitude=22),\n", + " n_frames=50,\n", + " ).render(\n", + " libcarna.renderer(600, 450, [\n", + " dvr.replicate(),\n", + " libcarna.mask_renderer(GEOMETRY_TYPE_MASK, sr=800),\n", + " ]),\n", + " camera,\n", + " ),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "963a2341", + "metadata": {}, + "source": [ + "The 3D visualization clearly shows that most nuclei are properly segmented, but there are several occasions of falsely\n", + "detected (e.g., bottom left) as well as falsely merged nuclei (e.g., bottom right).\n", + "\n", + "## Track Visualization\n", + "\n", + "Use *line strips* to visualize tracks. First, we simulate a track of Brownian motion:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "1e2cbf14", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:29.442424Z", + "iopub.status.busy": "2025-05-13T11:30:29.442310Z", + "iopub.status.idle": "2025-05-13T11:30:29.444747Z", + "shell.execute_reply": "2025-05-13T11:30:29.444365Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "np.random.seed(2)\n", + "track = np.cumsum(np.random.randn(10, 3), axis=0)" + ] + }, + { + "cell_type": "markdown", + "id": "b6ac2c7c", + "metadata": {}, + "source": [ + "Then, visualize the track as a red line strip:" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "dab0513a", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:29.446255Z", + "iopub.status.busy": "2025-05-13T11:30:29.446056Z", + "iopub.status.idle": "2025-05-13T11:30:30.235444Z", + "shell.execute_reply": "2025-05-13T11:30:30.234995Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "GEOMETRY_TYPE_TRACK = 4\n", + "\n", + "libcarna.geometry(\n", + " GEOMETRY_TYPE_TRACK,\n", + " parent=volume,\n", + " mesh=libcarna.meshes.create_line_strip(track),\n", + " material=libcarna.material(\n", + " 'unshaded', color=libcarna.color.RED, lw=4,\n", + " ),\n", + ").translate(y=2).scale(5)\n", + "\n", + "dvr.sample_rate = 800\n", + "camera.translate(y=-10, z=-60)\n", + "\n", + "libcarna.imshow(\n", + " libcarna.animate(\n", + " libcarna.animate.rotate_local(camera),\n", + " n_frames=100,\n", + " ).render(\n", + " libcarna.renderer(600, 450, [\n", + " dvr.replicate(),\n", + " libcarna.opaque_renderer(GEOMETRY_TYPE_TRACK),\n", + " ]),\n", + " camera,\n", + " ),\n", + ")" + ] + } + ], + "metadata": { + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/cthead.ipynb b/examples/cthead.ipynb new file mode 100644 index 0000000..34b6461 --- /dev/null +++ b/examples/cthead.ipynb @@ -0,0 +1,575 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "79e9884a", + "metadata": {}, + "source": [ + "# Computer Tomography\n", + "\n", + "In this example, we use data from a *computer tomography* (CT) study of a cadaver head: " + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "94b5ef80", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:31.941828Z", + "iopub.status.busy": "2025-05-13T11:30:31.941728Z", + "iopub.status.idle": "2025-05-13T11:30:32.355719Z", + "shell.execute_reply": "2025-05-13T11:30:32.355253Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "import libcarna" + ] + }, + { + "cell_type": "markdown", + "id": "d9805aca", + "metadata": {}, + "source": [ + "Get the data:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "1ee080d3", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:32.357299Z", + "iopub.status.busy": "2025-05-13T11:30:32.357117Z", + "iopub.status.idle": "2025-05-13T11:30:32.484031Z", + "shell.execute_reply": "2025-05-13T11:30:32.483644Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "((256, 256, 99), dtype('uint16'))" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "data = libcarna.data.cthead()\n", + "data.shape, data.dtype" + ] + }, + { + "cell_type": "markdown", + "id": "4cd5ba6d", + "metadata": {}, + "source": [ + "The data is 256 × 256 × 99 pixels (uint16).\n", + "\n", + "## Maximum Intensity Projection\n", + "\n", + "We rotate the head so that it stands upright:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "7af5a922", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:32.485668Z", + "iopub.status.busy": "2025-05-13T11:30:32.485559Z", + "iopub.status.idle": "2025-05-13T11:30:32.940363Z", + "shell.execute_reply": "2025-05-13T11:30:32.940013Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + " 3272\n", + " \n", + "
\n", + "\n", + "
\n", + " 2454\n", + " \n", + "
\n", + "\n", + "
\n", + " 1636\n", + " \n", + "
\n", + "\n", + "
\n", + " 818\n", + " \n", + "
\n", + "\n", + "
\n", + " 0\n", + " \n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "GEOMETRY_TYPE_VOLUME = 2\n", + "\n", + "# Create and configure frame renderer\n", + "mip = libcarna.mip(GEOMETRY_TYPE_VOLUME, sr=400)\n", + "r = libcarna.renderer(600, 450, [mip])\n", + "\n", + "# Create and configure scene\n", + "root = libcarna.node()\n", + "\n", + "volume = libcarna.volume(\n", + " GEOMETRY_TYPE_VOLUME,\n", + " data,\n", + " parent=root,\n", + " spacing=(1, 1, 2),\n", + ").rotate('x', 90).rotate('z', 90)\n", + "\n", + "camera = libcarna.camera(\n", + " parent=root,\n", + ").frustum(fov=90, z_near=10, z_far=1000).translate(z=300)\n", + "\n", + "# Render\n", + "libcarna.imshow(r.render(camera), mip.cmap.bar(volume))" + ] + }, + { + "cell_type": "markdown", + "id": "65f9cade", + "metadata": {}, + "source": [ + "The spatial structure of the 3D image is difficult to perceive from that rendering.\n", + "\n", + "For a better visual perception, viewing the data from different angles is benefical, that can be achieved with\n", + "as a subtle animation:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "493f1153", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:32.942033Z", + "iopub.status.busy": "2025-05-13T11:30:32.941917Z", + "iopub.status.idle": "2025-05-13T11:30:33.347677Z", + "shell.execute_reply": "2025-05-13T11:30:33.347213Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + " 3272\n", + " \n", + "
\n", + "\n", + "
\n", + " 2454\n", + " \n", + "
\n", + "\n", + "
\n", + " 1636\n", + " \n", + "
\n", + "\n", + "
\n", + " 818\n", + " \n", + "
\n", + "\n", + "
\n", + " 0\n", + " \n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Render as animation\n", + "libcarna.imshow(\n", + " libcarna.animate(\n", + " libcarna.animate.rotate_local(camera),\n", + " n_frames=100,\n", + " ).render(r, camera),\n", + " mip.cmap.bar(volume),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "db245a72", + "metadata": {}, + "source": [ + "## Hounsfield Unit Normalization\n", + "\n", + "The data from CT scanners usually comes in *Hounsfield Units* (HU), that range from -1024 to +3071. In the HU scale,\n", + "air roughly corresponds to -1000 HU, water to 0 HU, and bone tissue to +1000 HU. The image intensities in this dataset\n", + "are not normalized to the HU scale.\n", + "\n", + "Normalization of CT data to the HU scale is beneficial, because it permits direct identification of air, water-rich\n", + "tissue, and bone tissue. With HU-normalized images, we can also render *Digitally Reconstructed Radiographs* (DRR), as \n", + "shown [further below](#Digitally-Reconstructed-Radiographs).\n", + "\n", + "LibCarna-Python provides a heuristic method for *approximative* normalization of CT data to the HU scale, that is based\n", + "on the histogram of the intensisty values:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "696c040a", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:33.350375Z", + "iopub.status.busy": "2025-05-13T11:30:33.350168Z", + "iopub.status.idle": "2025-05-13T11:30:33.441500Z", + "shell.execute_reply": "2025-05-13T11:30:33.440988Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "data_hu = libcarna.normalize_hounsfield_units(data)" + ] + }, + { + "cell_type": "markdown", + "id": "ab1a5633", + "metadata": {}, + "source": [ + "We then define a renderable volume with the HU-normalized image intensities:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "fa026447", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:33.443055Z", + "iopub.status.busy": "2025-05-13T11:30:33.442941Z", + "iopub.status.idle": "2025-05-13T11:30:34.253172Z", + "shell.execute_reply": "2025-05-13T11:30:34.252573Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "GEOMETRY_TYPE_HU_VOLUME = 3\n", + "\n", + "hu_volume = libcarna.volume(\n", + " GEOMETRY_TYPE_HU_VOLUME,\n", + " data_hu,\n", + " units='hu',\n", + " parent=root,\n", + " spacing=volume.spacing,\n", + " local_transform=volume.local_transform,\n", + " normals=True,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "b6866626", + "metadata": {}, + "source": [ + "Note that `units='hu'` is needed to correctly interpret the intensities in `data_hu`. We also employ `normals=True` to\n", + "pre-compute the normal vectors of the data (see below).\n", + "\n", + "## Direct Volume Rendering\n", + "\n", + "In a *Direct Volume Rendering* (DVR), surfaces are rendered by simulation of the absorption of light. This simulation\n", + "is most realstic, when the spatial orientation of the surfaces can be taken into account, which requires that the\n", + "normals of the volume have been computed (this is why we used `normals=True` when we created the `volume` node).\n", + "\n", + "We use a ramp function to strip out the air from the visualization, and we use the `hu_volume.normalized` auxiliary\n", + "function to directly supply the HU values for the ramp function:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "6e7f236c", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:34.254808Z", + "iopub.status.busy": "2025-05-13T11:30:34.254696Z", + "iopub.status.idle": "2025-05-13T11:30:35.014910Z", + "shell.execute_reply": "2025-05-13T11:30:35.014452Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + "
\n", + "
\n", + "\n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + " 3.1k\n", + " \n", + "
\n", + "\n", + "
\n", + " 2.0k\n", + " \n", + "
\n", + "\n", + "
\n", + " 1.0k\n", + " \n", + "
\n", + "\n", + "
\n", + " 0\n", + " \n", + "
\n", + "\n", + "
\n", + " -1.0k\n", + " \n", + "
\n", + "
\n", + "
\n", + " \n", + "
\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dvr = libcarna.dvr(\n", + " GEOMETRY_TYPE_HU_VOLUME, sr=800, transl=1, diffuse=0.8,\n", + ")\n", + "dvr.cmap('BrBG', ramp=hu_volume.normalized((0, 100)))\n", + "\n", + "libcarna.imshow(\n", + " libcarna.animate(\n", + " libcarna.animate.rotate_local(camera),\n", + " n_frames=100,\n", + " ).render(\n", + " libcarna.renderer(600, 450, [dvr]),\n", + " camera,\n", + " ),\n", + " dvr.cmap.bar(hu_volume),\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "ee0f8920", + "metadata": {}, + "source": [ + "## Digitally Reconstructed Radiographs\n", + "\n", + "*Digitally Reconstructed Radiographs* (DRRs) are 2D images created from 3D data, like CT scans, to simulate what a real\n", + "X-ray image would look like:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "41f16aea", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:35.016862Z", + "iopub.status.busy": "2025-05-13T11:30:35.016752Z", + "iopub.status.idle": "2025-05-13T11:30:35.522063Z", + "shell.execute_reply": "2025-05-13T11:30:35.521595Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "libcarna.imshow(\n", + " libcarna.animate(\n", + " libcarna.animate.rotate_local(camera),\n", + " n_frames=100,\n", + " ).render(\n", + " libcarna.renderer(\n", + " 600, 450, [\n", + " libcarna.drr(\n", + " GEOMETRY_TYPE_HU_VOLUME, sr=800, inverse=True,\n", + " )\n", + " ],\n", + " bgcolor=libcarna.color.WHITE_NO_ALPHA,\n", + " ),\n", + " camera,\n", + " ),\n", + ")" + ] + } + ], + "metadata": { + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/introduction.ipynb b/examples/introduction.ipynb new file mode 100644 index 0000000..5b82088 --- /dev/null +++ b/examples/introduction.ipynb @@ -0,0 +1,381 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "1171f244", + "metadata": {}, + "source": [ + "# Introduction" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "3bf7058d", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:37.159368Z", + "iopub.status.busy": "2025-05-13T11:30:37.159210Z", + "iopub.status.idle": "2025-05-13T11:30:37.733839Z", + "shell.execute_reply": "2025-05-13T11:30:37.733418Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "import libcarna\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "id": "61f2f668", + "metadata": {}, + "source": [ + "## Meshes" + ] + }, + { + "cell_type": "markdown", + "id": "ab31c1d4", + "metadata": {}, + "source": [ + "Using polygonal geometries is useful, for example, to create *markers* or to generally enrich visualizations. In 3D\n", + "graphics, *meshes* are used to define polygonal geometries. We start with the definition of a mesh for a *cube*:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "cd38b675", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:37.735613Z", + "iopub.status.busy": "2025-05-13T11:30:37.735453Z", + "iopub.status.idle": "2025-05-13T11:30:37.737396Z", + "shell.execute_reply": "2025-05-13T11:30:37.737148Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "cube = libcarna.meshes.create_box(40, 40, 40)" + ] + }, + { + "cell_type": "markdown", + "id": "d618b43b", + "metadata": {}, + "source": [ + "The size of the cube is given in *scene units* (SU), and here it is 40 SU in width, height, and depth. Scene units can\n", + "be anything that we agree them to be, like micrometers (e.g., for visualization of cellular image data) or millimeters\n", + "(e.g., for image data from computer tomography). It is only important that they are used consistently.\n", + "\n", + "Next, we define some *materials*:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "8518d1b2", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:37.738879Z", + "iopub.status.busy": "2025-05-13T11:30:37.738781Z", + "iopub.status.idle": "2025-05-13T11:30:37.740641Z", + "shell.execute_reply": "2025-05-13T11:30:37.740403Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "green = libcarna.material('solid', color=libcarna.color.GREEN)\n", + "red = libcarna.material('solid', color=libcarna.color.RED )" + ] + }, + { + "cell_type": "markdown", + "id": "d2571cec", + "metadata": {}, + "source": [ + "Materials determine how meshes (i.e. polygonal gemetries) are rendered. In LibCarna, a material consists of a *shader*\n", + "and a set of *parameters* like colors. Supported shaders comprise `solid` for materials whose colors are affected by\n", + "light (the default), and `unshaded` for materials that are colored uniformly.\n", + "\n", + "## Scenes\n", + "\n", + "Now that we have a mesh and some materials in place, we can create a *scene* that defines some spatial relations. We\n", + "create two spatial `geometry` objects, both using the `cube` mesh, but with different colors:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "df9403bf", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:37.742124Z", + "iopub.status.busy": "2025-05-13T11:30:37.742021Z", + "iopub.status.idle": "2025-05-13T11:30:37.746048Z", + "shell.execute_reply": "2025-05-13T11:30:37.745798Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + ".Geometry at 0x7c02b5141eb0>" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "GEOMETRY_TYPE_OPAQUE = 1\n", + "\n", + "root = libcarna.node()\n", + "\n", + "libcarna.geometry(\n", + " GEOMETRY_TYPE_OPAQUE,\n", + " parent=root,\n", + " mesh=cube,\n", + " material=green,\n", + ").translate(-10, -10, -40)\n", + "\n", + "libcarna.geometry(\n", + " GEOMETRY_TYPE_OPAQUE,\n", + " parent=root,\n", + " mesh=cube,\n", + " material=red,\n", + ").translate(+10, +10, +40)" + ] + }, + { + "cell_type": "markdown", + "id": "d34de318", + "metadata": {}, + "source": [ + "*Scenes* are defined hierarchically, so they form a tree-like structure. The local coordinate system of a node always\n", + "is defined with respect to the coordinate system of its parent node. In this example, the green cube is moved by -10 SU\n", + "along the x- and y-axes, and by -40 SU along the z-axis. The red cube is moved in the opposite direction.\n", + "\n", + "Note on `GEOMETRY_TYPE_OPAQUE`: A *geometry type* is an arbitrary integer constant, that establishes a relation between\n", + "the `geometry` nodes of a scene, and the corresponding rendering stages (see [below](#Rendering)).\n", + "\n", + "Finally, we define a `camera` that will serve as the point of view for scene rendering:" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "4a1a1c31", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:37.747577Z", + "iopub.status.busy": "2025-05-13T11:30:37.747480Z", + "iopub.status.idle": "2025-05-13T11:30:37.749306Z", + "shell.execute_reply": "2025-05-13T11:30:37.749077Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "camera = (\n", + " libcarna.camera(parent=root)\n", + " .frustum(fov=90, z_near=1, z_far=1000)\n", + " .translate(z=250)\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "0d14105e", + "metadata": {}, + "source": [ + "The `frustum` method defines the projection from 3D to planar coordinates. The `fov` argument defines the *field of\n", + "view* of the camera in degrees. The `z_near` and `z_far` arguments define the distance of the *near and far clipping\n", + "planes* to the camera; geometries, that are closer than 1 SU or farther than 1000 SU, will not be rendered.\n", + "\n", + "## Rendering\n", + "\n", + "Now we are all set to perform the rendering — almost! One ingredient is missing: The *renderer*. We only have *opaque*\n", + "geometries involved, so we set up the rendering pipeline accordingly:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0ca491a8", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:37.750878Z", + "iopub.status.busy": "2025-05-13T11:30:37.750675Z", + "iopub.status.idle": "2025-05-13T11:30:37.833847Z", + "shell.execute_reply": "2025-05-13T11:30:37.833433Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [], + "source": [ + "opaque = libcarna.opaque_renderer(GEOMETRY_TYPE_OPAQUE)\n", + "r = libcarna.renderer(500, 370, [opaque])" + ] + }, + { + "cell_type": "markdown", + "id": "b1e98946", + "metadata": {}, + "source": [ + "Each renderer can have an arbitrary number of *rendering stages*. Here, we only use the `opaque` rendering stage to\n", + "render all geometries in the scene that we have annotated with the `GEOMETRY_TYPE_OPAQUE` as the geometry type.\n", + "\n", + "And then it's time to render. We can inspect the result with matplotlib, for example:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "37ff9c22", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:37.835247Z", + "iopub.status.busy": "2025-05-13T11:30:37.835139Z", + "iopub.status.idle": "2025-05-13T11:30:37.931324Z", + "shell.execute_reply": "2025-05-13T11:30:37.930910Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "img = r.render(camera)\n", + "plt.imshow(img)" + ] + }, + { + "cell_type": "markdown", + "id": "83a936e6", + "metadata": {}, + "source": [ + "## Animations\n", + "\n", + "It is much easier to visually grasp the information in a 3D scene by looking at it from different angles. For this\n", + "reason, there is a set of convenience functions that fascilitates creating animations, by rendering multiple frames at\n", + "once:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "10ab7a0a", + "metadata": { + "execution": { + "iopub.execute_input": "2025-05-13T11:30:37.932674Z", + "iopub.status.busy": "2025-05-13T11:30:37.932571Z", + "iopub.status.idle": "2025-05-13T11:30:38.079719Z", + "shell.execute_reply": "2025-05-13T11:30:38.079276Z" + }, + "vscode": { + "languageId": "plaintext" + } + }, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "
\n", + "
\n", + " \n", + "
\n", + " \n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Define animation\n", + "animation = libcarna.animate(\n", + " libcarna.animate.rotate_local(camera),\n", + " n_frames=50,\n", + ")\n", + "\n", + "# Render and show animation\n", + "libcarna.imshow(animation.render(r, camera))" + ] + }, + { + "cell_type": "markdown", + "id": "7d4913a6", + "metadata": {}, + "source": [ + "In this example, the camera is rotated around the *center of the scene* (more precisely: around it's parent node, that\n", + "happens to be the ``root`` node of the scene). The scene is rendered from 50 different angles. For each angle, the\n", + "result is a NumPy array.\n", + "\n", + "Use `libcarna.imshow` to view animations, matplotlib does not work nicely." + ] + } + ], + "metadata": { + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.10" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/kalinin2018.ipynb b/examples/kalinin2018.ipynb deleted file mode 100644 index 0553091..0000000 --- a/examples/kalinin2018.ipynb +++ /dev/null @@ -1,700 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Using matplotlib backend: Qt5Agg\n", - "Populating the interactive namespace from numpy and matplotlib\n" - ] - } - ], - "source": [ - "%pylab\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import carna.py as cpy\n", - "import skimage.io\n", - "import scipy.ndimage as ndi" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Carna 3.3.2 (CarnaPy 0.1.5)\n" - ] - } - ], - "source": [ - "print(f'Carna {cpy.version} (CarnaPy {cpy.py_version})')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Example data\n", - "\n", - "**3D microscopy data used for examples:** [*Kalinin, A.A., Allyn-Feuer, A., Ade, A., Fon, G.V., Meixner, W., Dilworth, D., Jeffrey, R., Higgins, G.A., Zheng, G., Creekmore, A., et al., 2018. 3D cell nuclear morphology: Microscopy imaging dataset and voxel-based morphometry classification results, in: Proceedings of the Conference on Computer Vision and Pattern Recognition Workshops (CVPRW), IEEE. pp. 2272–2280.*](http://www.socr.umich.edu/projects/3d-cell-morphometry/data.html)\n", - "\n", - "**First, consider the following 2D example.**\n", - "\n", - "The image is from a 3D stack:" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "data = skimage.io.imread('../../testdata/08_06_NormFibro_Fibrillarin_of_07_31_Slide2_num2_c0_g006.tif').T\n", - "data = data / data.max()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The z-spacing is unknown, so we will just assume that z-resolution is 4 times lower than x-/y-resolution:" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "spacing = (1, 1, 4)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This is effectively the width, height, and depth of a voxel." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Illustration of the example setup in 2D\n", - "\n", - "Lets define some example markers and the camera position:" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "markers = array([\n", - " [ 40, 600, 15],\n", - " [110, 610, 16],\n", - " [150, 665, 15],\n", - " [180, 700, 17],\n", - " [180, 740, 18],\n", - "])\n", - "\n", - "camera_position = [400, 200, 50]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This example setup is shown in 2D below. The markers correspond to red dots, and the position of the camera corresponds to the green dot:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "vd = (markers[2] - camera_position + 0.)[:2][::-1]\n", - "vd /= linalg.norm(vd)\n", - "cp = camera_position[:2][::-1]\n", - "R1 = array([[0, -1], [ 1, 0]])\n", - "R2 = array([[0, 1], [-1, 0]])\n", - "rot = lambda x: array([[cos(x), -sin(x)],[sin(x), cos(x)]])\n", - "vpl = rot(+pi/4) @ vd * 500\n", - "vpr = rot(-pi/4) @ vd * 500\n", - "\n", - "imshow(data[:,:, 15], 'gray')\n", - "colorbar()\n", - "scatter(*markers[:,:-1][:,::-1].T, c='r')\n", - "scatter([cp[0]], [cp[1]], c='g')\n", - "_xlim, _ylim = xlim(), ylim()\n", - "plot([cp[0], cp[0] + vpl[0]], [cp[1], cp[1] + vpl[1]], '--g')\n", - "plot([cp[0], cp[0] + vpr[0]], [cp[1], cp[1] + vpr[1]], '--g')\n", - "xlim(*_xlim)\n", - "ylim(*_ylim)\n", - "tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The green lights indicate the **field of view** of the virtual camera (90 degree)." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Direct volume rendering" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Example 1.** Use `dvr` to issue a direct volume rendering:" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/void/.anaconda3/envs/carna/lib/python3.8/site-packages/carna/py.py:92: UserWarning: Unsupported data type: float64 (will be treated as float16)\n", - " warnings.warn(f'Unsupported data type: {dtype} (will be treated as {dtype_fallback})')\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "with cpy.SingleFrameContext((512, 1024), fov=90, near=1, far=1000) as rc:\n", - " volume = rc.volume(data, spacing=spacing, normals=True) ## declaration of the volume data\n", - " rc.dvr(translucency=2, sample_rate=500)\n", - " marker_mesh = rc.ball(radius=15)\n", - " marker_material = rc.material(color=(1,0,0,1))\n", - " rc.meshes(marker_mesh, marker_material, volume.map_voxel_coordinates(markers), parent=volume)\n", - " rc.camera.translate(*volume.map_voxel_coordinates([camera_position])[0]) \\\n", - " .look_at(volume.map_voxel_coordinates(markers)[2], up=(0,0,1))\n", - " \n", - "figure(figsize=(8,6))\n", - "imshow(rc.result)\n", - "tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Remember to pass `normals=True` to the declaration of the volume data via `volume` to issue a computation of the normal vectors, which is required to perform lighting. Also, note that the `dtype` of data is `float64`:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "dtype('float64')" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "data.dtype" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "However, the data is only 8bit, but `skimage.io` converts it into 64bit when loading. This is okay for system memory, but video memory is usaully rather limited, and although Carna currently only supports 8bit and 16bit volume data, wasting factor 2 is not very appealing. This is what the above warning indicates. To circuvent, simply use the `fmt_hint` parameter for the volume declaration:" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Example 2.** Use `fmt_hint='uint8'` to suggest 8bit volume data representation:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjYAAAEqCAYAAAAGShpIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAADS6ElEQVR4nOz9fYxsy3rehz3VPd09PT0fe59zzzn38t5LUoEo26SAWDGtOBIQKJYTK7FhGgEk0IAdBiDAf2TITgKYpP8xEIAAAwSCHcA2cmErpmHLFCHbEGEgki06suCA+jAd2zJJS7zWpXjv5bnna+89H/053b3yx8yv5uk6tVavno+9Z8+pFxhM9+paVbVqVdX71PO+9VaoqkpFihQpUqRIkSJPQTpvugJFihQpUqRIkSL3JQXYFClSpEiRIkWejBRgU6RIkSJFihR5MlKATZEiRYoUKVLkyUgBNkWKFClSpEiRJyMF2BQpUqRIkSJFnow8GLAJIfyxEMLfDiF8M4TwMw9VTpEiRYoUKVKkCBIeIo5NCKEr6e9I+l9L+o6kvynpn6mq6jfuvbAiRYoUKVKkSJFreSjG5g9K+mZVVX+3qqqFpF+U9GMPVFaRIkWKFClSpIikhwM2X5X0bfv+netrRYoUKVKkSJEiDyZ7D5RvyFzbsHmFEH5K0k9df/2HHqgeRYoUKVKkSJGnJ59WVfVe7oeHAjbfkfR1+/41Sb/rCaqq+oakb0hSCKEcWFWkSJEiRYoUaSt/r+6HhzJF/U1JPxRC+D0hhL6kH5f0yw9UVpEiRYoUKVKkiKQHYmyqqlqGEP55SX9JUlfSn6mq6tcfoqwiRYoUKVKkSBHkQbZ771yJYooqUqRIkSJFirSXX6uq6kdzP5TIw0WKFClSpEiRJyMF2BQpUqRIkSJFnowUYFOkSJEiRYoUeTJSgE2RIkWKFClS5MlIATZFihQpUqRIkScjBdgUKVKkSJEiRZ6MFGBTpEiRIkWKFHkyUoBNkSJFihQpUuTJSAE2RYoUKVKkSJEnIwXYFClSpEiRIkWejBRgU6RIkSJFihR5MlKATZEiRYoUKVLkyUgBNkWKFClSpEiRJyMF2BQpUqRIkSJFnowUYFOkSJEiRYoUeTJSgE2RIkWKFClS5MlIATZFihQpUqRIkScjBdgUKVKkSJEiRZ6MFGBTpEiRIkWKFHkyUoBNkSJFihQpUuTJSAE2RYoUKVKkSJEnIwXYFClSpEiRIkWejBRgU6RIkSJFihR5MlKATZEiRYoUKVLkyUgBNkWKFClSpEiRJyMF2BQpUqRIkSJFnowUYFOkSJEiRYoUeTJSgE2RIkWKFClS5MlIATZFihQpUqRIkScjBdgUKVKkSJEiRZ6MFGBTpEiRIkWKFHkyUoBNkSJFihQpUuTJSAE2RYoUKVKkSJEnIwXYFClSpEiRIkWejBRgU6RIkSJFihR5MlKATZEiRYoUKVLkyUgBNkWKFClSpEiRJyMF2BQpUqRIkSJFnowUYFOkSJEiRYoUeTJSgE2RIkWKFClS5MlIATZFihQpUqRIkScjBdgUKVKkSJEiRZ6MFGBTpEiRIkWKFHkyshXYhBD+TAjh4xDCf2/X3gkh/GchhN+6/v/cfvvZEMI3Qwh/O4Twjz9UxYsUKVKkSJEiRVJpw9j8O5L+WHLtZyT9SlVVPyTpV66/K4Tww5J+XNKPXN/zb4QQuvdW2yJFihQpUqRIkQbZCmyqqvqrkl4kl39M0i9cf/4FSf+0Xf/FqqrmVVV9S9I3Jf3B+6lqkSJFihQpUqRIs9zWx+aDqqo+lKTr/+9fX/+qpG9buu9cXytSpEiRIkWKFHlw2bvn/ELmWpVNGMJPSfqpey6/SJEiRYoUKfIFltsyNh+FEL4iSdf/P76+/h1JX7d0X5P0u7kMqqr6RlVVP1pV1Y/esg5FihQpUqRIkSIbcltg88uSfuL6809I+gt2/cdDCIMQwu+R9EOS/sbdqlikSJEiRYoUKdJOtpqiQgj/gaQ/IulLIYTvSPpXJP28pF8KIfykpN+R9MclqaqqXw8h/JKk35C0lPQnq6paPVDdixQpUqRIkSJFNiRUVdYF5vVWIoQ3X4kiRYoUKVKkyNsiv1bnylIiDxcpUqRIkSJFnowUYFOkSJEiRYoUeTJSgE2RIkWKFClS5MlIATZFihQpUqRIkScjBdgUKVKkSJEiRZ6MFGBTpEiRIkWKFHkyUoBNkSJFihQpUuTJSAE2RYoUKVKkSJEnIwXYFClSpEiRIkWejBRgU6RIkSJFihR5MlKATZEiRYoUKVLkyUgBNkWKFClSpEiRJyMF2BQpUqRIkSJFnowUYFOkSJEiRYoUeTJSgE2RIkWKFClS5MlIATZFihQpUqRIkScjBdgUKVKkSJEiRZ6MFGBTpEiRIkWKFHkyUoBNkSJFihQpUuTJSAE2RYoUKVKkSJEnIwXYFClSpEiRIkWejBRgU6RIkSJFihR5MlKATZEiRYoUKVLkyUgBNkWKFClSpEiRJyMF2BQpUqRIkSJFnowUYFOkSJEiRYoUeTJSgE2RIkWKFClS5MlIATZFihQpUqRIkScjBdgUKVKkSJEiRZ6MFGBTpEiRIkWKFHkyUoBNkSJFihQpUuTJyN6brkCRIkWK3EVCCK3TVVW18291UlXVre4rUqTIw0oBNkWKFHlrpAnE1P3m1+s+A1K4loIVBzD851pbYOVlFSlS5OGkAJsiRYo8WmkDVtLvKeDw/w5gHKBInwcsqfi19HcHPdxfl982IFSAT5Eid5MCbIoUKfIopA3zkQM0KagBSHQ6nY17Op2O1uu1QgjqdDoRfDiwSUEQ1/239XpdC4r4v16vG5+rCbzsygC1ybNIkS+SFGBTpEiR1yq7KO5c2hwT438unU4nXu92uxHYOHBxkEOabrer1Wr1OcDCZ4BLej1labaxQKk447Or/85tAVFTXYoUeRulAJsiRYo8qNwVyOR+y4EaQIxf5xr/9/b2sgyPdKXI9/b2IvhZrVaSbtiX9Xq9AYzW63VM46wOn53ZyQGWHAjKMVCpvC6n5fsCSgUgFXndUoBNkSJF7kVuowh3dQauY2u63a46nc6G+cmBDGmckQGkdLtdSTeAYbVabZitADbL5VKS4r2r1SoCG+5zE9RyuYyAJQU+KaBqAltIav66b4Zmm9wWoBSAVOR1SwE2RYoU2Sq5HUR3yWOX35v8ahywAG4crHS7XfV6vQ0Gp9PpxN/T/JbLZTRN+fOuViv1+32t12vt7e1puVxG4OLsyXK53GBypBumxwGO5+0gBt+gtkq8bbqm3WBcq/tcV5bXNVePNk7Yu0gxtRVpKwXYFCnyBZY6Jda0lTllDOocaZvK2wZicjub3CeGaw5out2u+v2+Qgjq9/uxLsPhcIOdSUFQahaiDDcnXV5eqtPpaLVaqdvtarFYbNwDkLm8vIz/F4uFpCtg4+yN++fkHJj5775AaZvl3tk2qWN6ctdzvkq0hdc1B8LSHWBtQU+uHR5S7hMoFZD0uKQAmyJFviBSN5GjnOoccNM8UMxNJpEUmNSZW1Il6GkAMKnpBual2+1qb29Pe3t76nQ66vV6Ojg4iL4ybqKSFAEN18nn8vJS3W53w8cGZidlcBaLRbx/b28vAhqYGsxU1AcwMJ/PYzmkdRanzjSVY3RSlijXjk3vL9feufJ4127K493TppJimvSe3A6xpvrlgPU2eSyA4q4g6bE8x1ORAmyKFHmikluBbwMhKHs3i/i9q9UqKn+uoczcL8V/kz6/is8p2Fx9c0wK//f29tTr9TQYDLS/v6+9vb1oLur3+9EMJSmakNxEBWjhOjuhvCxYIMxLlE9Z+NXMZjPt7e3p8vJS6/Val5eX8TdAAWwOzA8+OykoqAM27NLKmX5uY8bLtX/Oj6euz6R1BAw6YKuTOtbOGas6k1xbENd032OT+2CPHvPzvW7ZCmxCCF+X9O9K+rKktaRvVFX1r4UQ3pH05yT9oKTflvQnqqp6eX3Pz0r6SUkrSX+qqqq/9CC1L1KkSJQ6E4O0ab5Jf0+VlDvWOpvjzrmugP1+Z1l8VZ8qOk8He5KL/eLl+3eYmv39fQ2Hwwg0uN7r9dTpdDQYDCI4Wy6X6vf7WiwW6vV6EaiQP9fcIbjT6Wg4HEag4mmcteH6YDDQ5eVlvAfTUwhBl5eXG2CGNur1eprP5xEAublquVzGa7R7yoDUmXr8v79Dfzc51iYHKJyJ8fwkbbBffr+bDtP+BIBM33tqdssxN3VszjbF/tTBw32a1pDH/LxNElp0hq9I+kpVVf91COFI0q9J+qcl/R8lvaiq6udDCD8j6XlVVT8dQvhhSf+BpD8o6fsk/WVJv6+qqlW2gKsy3s7WK1LkDUkOxKRgwtPVKTIUDcqTPFJF5DuHcn4hqd+Il5mCmpQJcmWbA0CenwObXq+nfr+vk5OTCG5CCBvmKdilwWCgxWIRlTD1B8QtFovI0FRVFc1Iy+UyghfuA9iku7DwwwEEYcoin/F4rMViocvLS81mM83ncw0GA+3t7Wk6ncb29m3iACEADcxRHXOTvvsUyLqpLO1HtB3PmZq60mvp+3QWz/uEX/Pf/HlT5+q0L6Tmt/R/Kikj9KYU9NsKDHaVHItWB7h3bZOGe36tqqofzf2wlbGpqupDSR9efz4PIfympK9K+jFJf+Q62S9I+iuSfvr6+i9WVTWX9K0Qwjd1BXJ+dZeHKVKkyKa0MSOlK+pUkTuYcBbG00iKrAWAZm/vaqpwxoHVdm4lz383UVFumsaBVgoi/JkBHdSb9JiinDnodDrRHLVcLjcYAp4Fk5DnRfq9vT3N5/MN0xV1w+TU7/fV6/U0nU5VVZUGg4FCCBoMBprNZpIUzVWLxSKavjqdTgRSPOdgMIhtQBu7n08KWp25SZVKrj/4d/L14IXk0ev1PgdOQwgRzFEP91sCqLiprqqqz/knOYhJAyfyLtI+kwM6/lx17FUde5n+/tDAoy2LUlfvtwUY1c1NbdPeJv+mttnJxyaE8IOS/oCkvy7pg2vQo6qqPgwhvH+d7KuS/prd9p3ra0WKFLmF1E3SfE6VGNdhIFAW+JGkgKHX620wNpKivwk+Kq6EfbXv25rT+qUmBa8vZTkT5MAkZYWc4XHn3n6/r/39ffX7ffX7/agQUzMUQKLX66nX60XwQtput6v9/f34nfLZKu5bu2GDaFcAEaAAJ2F/B+v1WoeHh6qqSuPxWJPJZKNNyYP8aFdAFE7LAAyYoG39g3fpbU87eP/g+XjfOZPQ3t7exntzxgVQQxssFgsNBoMNE1rKJqZmxpRdTOuRY5BSVmYbS7OtrXLyOsDFfYIAl7cFGO0ibUBpa2ATQjiU9B9K+herqjpraPDcD5+rQQjhpyT9VNvyixT5osiuk5kzGOkfCki6WV2n4AYl5ytrHF/JF4WFknRTjAe9czODKzNncPy4AgcIKYPg7EzaLl73Xq+n/f39jTqu1+sISsjXd0XxDPjKDAaD+Jn8ASteV8AQDsXUcTgcbijxg4ODDYXvDsgeVwcgAbjk/uVyGc1hqc9LylrUMTbOzPgzuR+SA1nefcq40abk5T5IvCdAJe9/OBx+julBAEipvw3i7U1+uTagvt4mqekqbbP0/jbSNB6b8vH6vCnZNpekYPF1SV15Te9sF2kFbEIIPV2Bmn+/qqr/6PryRyGEr1yzNV+R9PH19e9I+rrd/jVJv5vmWVXVNyR94zr/pwcrixS5Z8kpdlfc0qYjp6/IEVfcbpLxfGAQXEHCUuAA61F8Udj9fj8yCSg1WAVYCN8+7IKypz6ADJRxqrx5NhSuK1aezZ2DPQIxoKGqKu3v728ABG8TWBIUOzubuIfn4TeeHZCCSWk2m0UAs1wuY758B/SQvwNC9/lJAUCuX3j7uDOvAzt3rEZgbBx0+Hv09uX947NE3SXFNqEdSe+feU7vBymgdXOUA2YH5aR1FjHdVUa5uTa6D0W+TfHmfn/TYMelLYNVx5r5Pdueq03f3Va3OpNdKm12RQVJ/7ak36yq6k/bT78s6Sck/fz1/79g1/9sCOFP68p5+Ick/Y1t5RQp8kWVNquSFNT4X85fwR1yHeCgLDDdoGBQdtJVcDlnO7z81OnXd+/gYyIpKngcalPWyBVaCr64Jt349qCwHHy5kqY8lC3KFLCFckZQlACo/f19zWazDQZiMBhEBY5ip32d+RqNRhtKl6jEgBYcl/EHmkwmG0wFgIK2JC0gg+eYz+efe//bVr2p/xA7ycjTAQTsl+/uAti4qYy24P1QBs7QBC/k3Tko9nedgg/vs7BC5H15eRnBKYxO6nDsTFauXdJrTaDDWau6+28ruzJAr4tNaQMycosr/94WeGzLS9p8F15+m7Zow9j8YUn/nKS/FUL4b66v/cu6AjS/FEL4SUm/I+mPX1fm10MIvyTpNyQtJf3JqmFHVJEiX1S5LaCRNgFGCmhQwJKiMgDIoBj8qAFJ0RGWrccoJtgaZ1ucGUHZuZnKFS+7fVJfCerA6t4BC+Vw3ZWepM8pMeoEMIER6HQ6cRs1z0fbdbtdHR4e6tWrVxuOvLRXp9PR/v5+3LLtrICkCIpWq1VksQBPpOfa8fHxBoOEovagfm5CI2+PgTOfzzeOa9hmQnBTjQPA0Wik/f39DcDKM3MdAESZXHeWjz6CgzZl8hlQR1viSMyze1vCntFe9AnfHZZuzfdxkTqwc83bIR1Lde23TXHXyUODnm1zRQ5QvAlmaNc5za81AfXcu8j59yFtdkX9l8r7zUjSH6255+ck/dy2vIsU+SJIm8HedE8KZvxP2oyo64pJUlyds1JHYfHdd9y4Ey1mGjcdrVaraIbB+RZl7JOMK7CDgwNJV4rOmRg3fXigO2diUHi9Xi+ezwSb4T5AsAGAhPl8HoETEyUMBEqw2+1GE1EKEkMIms1mG/4bi8VCo9FoA4wgk8kkMkQI9ZYUt3ZTp9lstgFQnI2ivr7bxwP++Vbvur7lTAP14G84HEZnawAd78D7gIMVfsMZGyan0+lE3yIvc71eaz6fxy34mN5Go5GkK0YQwAnI9R1VvrXd/Y0cINNu0s0OPupAn61ro7v4btTJLvltA6X3VX4bMJSrw30zRE0AMV2g5NKlDGWb91ciDxcpco9y1wmzjqHxwe2xRiRFxS9pw+dE0oZ5CJ8KFBLHD8xms5g326bdeRWw4aYYrxdxYJw5crCEvwrbp525cJAAOEt3GTmIwETjMWvSLeiY0hwwTCaTDaYAk4uDJL4zccIgAMocOHleFxcX8T5MchcXF9G8M5vN4vbv1Wql09PTDb8TgFNq9gP8SdoAQg5sSO9KykFNp9OJ0ZkPDg4i0IW94fl5Lw6K5/O5Dg4O4nsA2AFyYGRoG3e0pq/t7+9HJos+OZ/PN9KzdZ4+5M9KtGbeJ88F4PF2aKP0csq8SZF7W+Z+uw0AaAtC6kxn9w2GttXnNs/exMrw2RlgB7UOYnIbB3I77FIpwKZIkTvKfa3+6mhwN7dIm4HqABO+fRdfjvV6HRkWHFqZMAaDQQQ9ft2VF3+U7Qqs2+3G+C3p7hr32fA8fHeLO/66bwpMEkosNR/BFkiKitIBDJ/d0dbzBrygXD0ezGq10ng8Vggh+h9xkOV8Ptfp6WmMUYOvyXw+13g8jm1AflVVRZ8YN2ctl0tdXFxssAz8d8Dnz8Xv6V+u76T9xhmYZ8+exWCA/X4/RkcmLaCHttvf348Ahd1cqUmRvgSTQ3vRV70fStpgttzxmjoAsGDGaFN3agYMIbQv+bt51NuqDvyl7ZaTHMvg128LNprKrfttG9jyet6HbKvHtntTVsb7uC+AEN8d6Nedod72bAXYFCmyg9w3hd2Uv69WfEJA2eODIl0Ndj8fidU023rxk0Cxw8wAPlghOyOEkpGk4XAYQQkra4ACW6Ud4OA4jGI5ODhQCCEeZ+A+PvhTwDy5+QNz1d7enobDYQQLgBHSoIxR5P47DsRMsovFIgIQAI6kjZ06KdDAXDKZTKIp7+LiQovFQhcXF9ER1xU3ytejBy+Xyw1FnDIO/Hcl7KtZft+mwFKlvre3p4ODgwha/UiJlMmiHQ8ODiLoXa/XEdAhxAPy7fK0/2KxiCbNg4ODCCaJtAyTRVm8Z/ex8dU8fRHTFiygt4eX76DVzVa58bYrAGjLcHjeuXJuy/g0lZn7/T7Zpl3r5iwN31PwnvoEwhgzN9CPfVwXYFOkyC3loUHMtjJQaoAM2Bg/6NFjohCszmO6sKL2HS8oMlbMmF0AOL6Cdv8XP7gRyph4JZzT5OzJcDiMExdmA4/lIin69Dg7Id2YnNKJjOdH2V5eXsYdM5I2FDarfgAG9ZpOp1EhIwAc7mNnj/sQUR/aANbKfUFSB2Haid8BVSnrkrIgfr3JSTLXh3L5DofDyHh54DzAB+/YmSd/h77LzAH3crmMflSwPDhQ806km0NL6QfD4TCyOfTDvb09nZ+fRzCKPxJ9Pw0YST8ENDlrmLapt1PaznXtd1v2o4l5zaW9D4BxF+YnlfsygTlLg7AYY1yxU445jfRpYFDyY57aJgXYFCli8joZmW3pUvqWCQCFgd+C+5ywRZlr7nMDyJlOp58DLyiuNGw+ZgSUNCtx9xFBITIhOfvjdR8MBlH5+1Zm6ujxcVjZS1fMx3Q6jb4d6bZprnt7sSuHbddMqDitssL3OCzunAsocoYIpgXGijo7kPJ37Lub/HNqHqnrG02sTltzBGloY/yqFotFZOEcDMKE8M6cwXLfLZ6p07naPQYbA3PjfmAAc94LbB2ADaBNGQcHBxuHiQKAUHK0swMjdyZ3MOgm27aKuS0jc1+ybXHj6e6b9dmlPnVlNZn13BRdVVVka50lHg6HG+EMnIn2OYL+AehpkgJsinyh5XWwMm3LSdM4KGBC8AMeAQB+RlFqqnKTFBM84ADTC/mzenKF5oyRl4FZA/MSCtP9G9KVFfVn9Q7l7Gc6uQ8Oyo9nR3E5g0BefsiltHnsAoxJuhrcmGBXK4Xqyi9mbYrRmSYmWT/TiLI8GKGbgXKAJmcWqQMqdavnNn3JQQnms9VqFU04MB1eNgCSbeG9Xk8XFxfRKRqwiUmNdwdz0ul0IssCO0RbAszxX4J1pG/NZrPYn51x5B0DTAEumCzH43EEU5Iii8e7SVmDNuBwW9tuEzcX3qW83JxQlyYHkl8nCGuav/jsx7ewqGJnHe/Q4x/5mHH2sZiiihTR6wMwty3P6VbpZqXjDsH4zsDSsFrGMRO2BiDC9mxnQny7MsrJD5CkDgAWadM5F9MEu1hI78rTGQ12szCZYXbiWc7PzzfMbACPlNnwXVI4qcKwAMqoK/WEefH7MadR3moy0eWnn6p3eqr92UyL5VKz/X2tez1NBwMtzUfDAYnXzbdtY65yJsGBTjpRe36ujFKzSVO/aVKcgFF2hvHOR6NRNMnRfzioczQaxXcHKOb3EIKOjo40mUwi8PFnTE1tsH2UA2tHX0nNRt1uNx5HAePGri6PGO2HkFLm3t7ehmM3bJq/p6axV/cObgMOtpmgctfvCkK2MU1pOQ/B9ni5PgdIigsxdhbynT7CQkxSBDkcMst7ZJeeO4/npACbIk9eXgeouc8Vkq+2HdQMBgMNh8MICtjxxO9MVAAVJnlYDg+hz+TvMVYwz7DKJn8YEsCUm2X4DRDGahlgQfm+00ZSBBhsG6btcCD2nS8AERSar/YAOM488d+dU93xGnPL/OVLHZyd6Z3ZTKPVSt31WnvLparTU52vVvpmp6OP3nlHS3NG5f24knTHZA+iRztT3xTMpIoFMLBNEdaxOGl+XKcu7MYCjMznc52cnMR0i8VCh4eHUXnQpsPhUNPpVIvFIr4TZ9/cjIlzuDti08/Ij77nadiij1kCRcZ28aq68dlJ/X8ODg4+xw46iEzNUXXKvg6M3Afzkntfuev3VUbb8nNlIrua8DxPZ2voJ4w9nM57vZ4ODw8j2wr4hcUFEDmTjE+Y+8flpACbIk9O3qR5aZeymyY4lLEHT+v3+3Ei8Ng1OerWI7W6Aywr3vl8HvNIWR5WxwATVv3T6TSW5X4yKE6POwNzwQQE+HCHUncm9c/4XLgZyU1imDioGyYJ6kQaaTM2DuV0Oh1psdBBr6d+r6fRcqlhr6fBaqWDa4DzparS8XKp/+7FC33z5EQKm1GRHbD487lztf+XtvtLeJ9ImYM6MJNbfad5LJdLTafTyJy88847G4pkMplsOEsDoEMIGxGGYUZ4Nyie+XwegQVBIC8uLqJiA/ilW3fdfESbAorW63UM6Acz2Ov1NJlM4pjw87e8LwK+vd0d4Hub3tUs9NCmnqb5JNcn7sou5a43sT519zBeWXS53xy/Macxlt03i0XVZDKJ85RvfvBFWk4KsCny1snrNiu9ifLTFc9wONTh4WHcdeK2awAJE4WbA3z1RPwSZ1o8D+kmirF0Y5pgpQWTggmMwGtMcvjfoGhY4fsuJgcoziIBtGAAnLXye1yZ9Xq96NvjEXD9j23ugLz1ei1Vlfrdrg6Pjq7ATgjak9TvdLS3WmnEVtP1Wj90eanvnZ/r1fXOH3dKzW09zdXBFU6OGWijjLaxNTmmhv8AD95tp9PR+fl5ZEJgWjAvdbtdjUajGKOH+2DU/FwwbwP6JQ7bh4eHESgPh8ON7dnd7tWRFm62hGW8uLiIJlaiQ9PHQwg6PDyMjqYHBwfq9/s6PT2NLCDKkWfKmf7SNrwvpjWVhzL11JW3DQj579tMnE1pmsrxcbu/v6/Dw8O4qGB3HvMUY9p3ZYYQYoylw8PDyO51Oh2Nx+ONnVJ1UoBNkdci2yaPbSvYh5wgmqSJqt01n10EIIFj7Gg0ipFiMee4acS3ffu2a2hc/B8wLbh5BxbCmRcAVWrOcR8VKGMmKxQd7Av1oUxXsLkw+TwL8VM41sC3oLMt1I+FcGA2mUxiu8AqwD6wNbu3t6det6vh3p6WMCshaNXrqbq8VGe1Uv+6/l9ar/XefK6X+/taG1DBIThH37sJxBVqmhaw1abv5EwUOYDkoIbPmA4BGfP5PDr4np2dfe4cJ8xBFxcXms/neuedd/Tpp59GM6h0BYDPz8+1Xq81mUyiHw/v+Pnz57Ee7Jpit9VsNtOzZ88kSePxeMPcRP+gDpg2eb+s+Nk9BRCrqioGSgRgsYWfqM/ez3Ls1m0YkDbjeluaOvNTE5i9D2YmzacNUGpbLnMGpmYWGcw9MJu8LxZjHMWBf5RHyuYsuNFotHVnVAE2Re4kuwz+XUDCLpTsfct9ln1b0xQrHFgJtsAyEbhDLv9TPwKABqsgTEXOOlCWm07m83lkOnDk9fg3gBsUDBMXZfpuJvL23UqsqA8PD+MKjDx6vZ6Ojo42TD7uIOxby6UbExCfcazGrLVaLvXZd76j6uxM3fNzVZeXugxB1Wiky3ff1aDX0+joSHNJHUmD4VCTxUL9+Vx7q5V6IejQ2igFYv7cKUvj5pAm4O5pm8wCOWXMvdv6mQOxV69eqaqqjS3zk8lEs9ks+tgsl0t99NFH8V1iSsDkN5vNYlyeg4ODyPr4rjU3FwGs6VeA5qOjIx0cHOji4iL2SXd8v7y81KtXryQp+tSEEPT8+XMdHR3F+qAM+b3f72symcT+1UZ2ZSl2Ydp2kW2mIT5vq2cTaNl1sZYC5zSfNA1jml1vHiCSMcsOOH9v0hVopi/hh4XTu++Ya5ICbIrcWbbR5Nuu+W9vgpm5L9B0W3YnnbAQJgdieaAoAD34k7BlF4WA8B06HyXlShT2Id3eDOvjQAWgRTr8GvDPAFSg9Ji8ACaYB0ajUVSUTGB+SCYOwYAalJ37e7hpjMnUIxeHENQLQZ/8vb+n7osXej6fa//yUqvLS4X1WuvvfU+f/Z2/o1df/rL+/n/4H9YiBK26XS06Ha0WCx2Px1dtJOkgBKn6/I6Z3KSee7dpv8jl42AF2Tae0nvqxhvgx/sD75025/wr6sOOKfxynHHjnQNsnz17po8//liz2Sw6Hk+nUx0fH8cT1Ok/sD7U5+joaKMe0k2YAvowfY5YJ3t7e3r27Fn02VgsFjo5OYmsDf0O8OY7r9K2a8OE1Unut7o+0Mbss+v8V9cfm/rQberVVG7uN37f39/XwcGBhsOhJG0Evlwulzo6OlKn09Hp6akkRZM1u/LOzs4UQtDJyYlevnyp5XIZnd0LY1PkVpIbKDnEnt5zH+W+bdJ2Imy6D/E2xkbNAYZ1VLIHQ2OVw8DnHrZIe+yW1AkXkwVMDYoMMwUrdxxzHbAgBFaDPZlOpxs29Mlk8rndDb6rBZrazxzi+X27ujsUorg22I/1WuvPPtPJaqWOpJP1WvshaK/bVe/yUmG10vFqpc++/W19u9vVB7//92u1XutsNtP+3p4mIWggaSVpFoIqa28fF3x2k1NqYtrGADr48TybVshNq/cULNHOaZC79XodfWgANdPpVJ988kl8D2dnZxqNRjo/P48+UKenp6qqKioZ+gbmhtFopPF4HHeS8S4PDw91fHwsSTo9PdU777wT/SbYwbe3t6eTkxNNp9PoKEz/gYk7PDzUaDTa8Cvj/2QyUQghRkNGqeZiB+XeRe733PtuSt9Gcnm1ZYpy7ztNl/bTXeq57bemNoGtwTRNPKTpdKr5fK7RaKTT09NoYo/m4etdnx7HhvlPujJZSopm5cPDw9o6SgXYFNlB3kbQ4fIY6t+mDq4gUeqHh4eazWYbu4rY+gwDMpvN4q4UTCdsrSVfzDnO7qAgADMoaVbDABr3nfGdDR4rB6WCcydKfjKZRAV5cXGho6OjaD5glb9cLqMd3X0uiHviq3oYLI9zArsQQtByPtdgvdbw8FChqtS9vNRwtdL+cqm+pG5Vabheq7de67e/9S2Nv/51jY6PNR2Pteh0tL+3p4PFQi8kfaffvwI2mXdYt/J3SXfjpMCD+1Llm2N3uO4mr9wK2q/l/nh/rJ7pA9PpVL/zO78jSXrx4kUERbPZTO+//350CAcE0/eGw6FOT0+j6YF8eX+sxjFFnZ2dxQNFOfkdxce73Nvb09HRUTxqYTabRfMGO7owV4UQNsxR+KO5KayN5N4NkmPq2kodo5J7X0331qVJ65nm21Qvv6cNCM/Vi37oCyEYZdjfw8PD6Cuzv7+v09PTCLZZDEk35nAAK35go9EovmfmlzopwKZI7aC7LfvQht68C0W6izwEmNk2STXJNtYLQcnhYwMz4U66rISpB/4GIYSN31BOgAzS+a4rSTF43mq10nQ6VQg30WAxgcHA+DZxNxGs1+vPnVUFAEOJsfr2Z/GV3tnZWVzFuVnMnY17vV50OgXwACC6nY4Ugi6vzV7Dfl/LyUTd2Uzd+VwHIai3Wqm/XmtZVfqgqvQ7v/VbOvhDf0ir/X2tjo918eqVpp2OPlqvdXbtsFoHTDy6bd0KlnfQ1BfqFF7d6tzBTe4+r590AzKduYG9cVbuk08+iSYr98Ni27izPOv1Wt/73vckKYJW0g0GA7148SLGtgkhbPhKffrpp7Ev0NdhXdwxGGVGMMnVaqWLi4u422o0GkWncUCwHwiLebUtMKljSNK297R15qBdQEZT+V4G0mRay5k360CTf/Z+5b5JdcAqvZ97eNceaoB5AFDCIoz+OR6P9fz5c83nc11cXGg0GsWFyvvvvx8Zw8vLS52fnze2YQE2XwBps6p8qDKR3CSeozNzk8d91eE+5TaTVJvn8XcVmZKrCzFKJ795JF3ABowLkwyAyKMP5wJnSYq7my4uLjai5nY6nY0YJigQtnLzmd8AQoS6x8xwdnYW2RtWYJPJJIIlVvMffvvb0nqty+VSi/lcJx98oN71tl4UMaYpjz4M4NFqpXUIWnQ6Ojw50XA61elgoHVVaTgea6/TUScE9apK+5IGIejyxQt9+L3vab/TUafX08sQNOt09Hf6fU263VplI22ewo7Jh3fkaVLl4NtWAWipCSktL1duk29FWqbHN3KFj98LZkBAjvvkfPTRRxoMBnH30XK5jDFw3IeKenHGF35VnU5Hn332mc7OzjSbzWL7fO1rX9PZ2ZmePXsWd8h88MEHsT3oWwAddljt7+/r3XffjUwNgB2/GtgbnjM3p+TmxiazXu795763kSbmZpfFUx04rruvCXz7fXVgLZcmrTsABHPiZDKJ7xFTNDvXSH94eLgRz2YwGOjs7EyXl5d677339M477yiEK3MpJsY6KcCmiKS7+4bkfq/r/G38BJquIbkJ6CHltiuutvf778P1Wu+dn+v4W9/S9Nvf1uL5c3W/9CWt3n9fh8+e6eDoKK6C2M7K/ew2wmeBlQ7AhtUQq2FAz2KxiBGNLy8v1ZG0Go81W68V9vY0OjyMkxAxTk5OTqKS8ngzw+FQn332WQRfZ2dn0bfnxYsXGgwGeu+99zbilJy/fKmPf/3XNf/mN/VOt6tet6vQ70sff6z5cKjV17+u4QcfqGdnYtG3er2eXr58efV9tdJytdL+4aGGh4fqV5VW3a7WBwc6n0zUu7hQ0NUW7/V1u4X5XOOLC132elqPx1pI+l6vp0/7famqNiZ+WA9/b7Q9Sh1QWre6dVCTW2U3Sbqbre4eX3l7gESu8wyAsVx9AUCAtfl8HrfqLhYLTadTSYomJEDH+fl5BFKAE7aZf/zxx3G7Nw7kgKeTk5ON/orPz7vvvhuVJTul8OXpdrvRaZi+JynGxAFANbVtbi667cKoCZg2gVCXHGvSVF4dCKlje3JAOc2rqTz+0kCVfh3WFzCKHxR+NIBeYt0Q0wom5/z8XN/73vd0dHQUncMB0gRvrJMCbJ6YNCn4XRVzW5PSthVNOlhyg60O1KTP01TWQzE09wn6PE3uWbqSfljSP7Be6yvzubqffKLpYKDxfK7pZKLLyUQv3n1XX/19vy+uYF3pul1b0oaTLhO8RzMG1OCHM5tMNP3kE01+53c0GI+1+uQTXVSVZvv7Gv3gD+rk+79f3WtH5hBCdOJkMvPDNXEgDiFoPB7HIHrn5+cajUb68MMPNZlMrnZHXF7qd//iX9Q7n36qH1itdHgNoNadji67XV0cHGi+XmuxWumdH/kRda53eRFsDqU5Ho/17vHxFaALQdOLC60mE/X29rReLNQZjbQ8O5MkzUPQZQhahaDQ6Wi+WuliPtf5ZKLpYKCLEFRZpF1JG0rS+2Vqqmp679zrSqhJ6bQF/V6XtH/x2Y97oM7OLnldPAQAadIzeug/ADVMjQAcTImc/4Q/z+npaWQLYXAof71e65NPPtHBwYHOzs50enqqL3/5y/H4j729PZ2dnen58+c6Pz9XCEGnp6cbB6Eul0u9evUqOjrTBtvaLn0Hu0qbxZpLU538WtNvvLMmQJKrVx0jlMsrBWlpfuk1wCzAF1MyTJ/703lsrk6no4uLC81msziPHF0v4tgVST9rkgJsnqDsAmDagBdJnxtEPphyq8a67032Wf+cTsjb7MMPIbvmf9f0e5L+4arS/1zS+1Wloa5iq1wuFvqs29XH/b6ms5lWk4kWp6caXu8qCSFE/5i9vb0Y9wMTg6+4/cwn/BYAPdViofNf/VUdfO97+urlpfarStVqpVVVaT6b6fy//W/1O3/rb2nyAz+gr/+D/2C8j4nq/Pw8hkiPcWRWK43H4w1nQBTfy5cvr5ieqtLv/hf/hb7/00/1QVXpRNJQUne1UhWC5p2ODpdLvQpBF5Jm776rw+//fk0mE7169UovX76Mymw8HitUlfqXl+ovFrpcLNSbz9WdzzVcrxWqSpeSliFo2u1qKmkSgi6Pj7XY29N4sdAsBC10w6o4O+PsB6a3HBigz7pfTapMGDvO3njaJiXpC4o6sJ9jldwEhX+DB2t0psA/88e9tAXPAGACIHP+mDuPszOGfuExiGDucCJm+/mLFy9i2RcXF5GBYbW/WCz02WefRd+fi4uL6MPz0UcfRbNq2ra5sZhrzybWpY1smxNyc2BT/Tzdtjm2Diw13ZcD5zmA3QSivJ+7OZZ3zvinL2J+xAx6dnYWt/ATtfiTTz6JdXjnnXciEKqTAmy+gJIbJOnvUv3W0jq0nssrpVNzu0Nykg7Oh2Rjmtpil3zuKl+T9IckfZ+kE135fgRJl1WlcK04Pr681HSxkC4vtZrPdambXU2EwWdl9OrVK52dncVAZkz+z58/j216fHx85Yg8meizv/bX9LXvflfvX17qsKq0V1XqVJUqSRNJp1Wlg9VK3/rWt/SdqtLJD/1QXGmn5/mwa4YgaShQ2moymUQHwNlv/7be+/RTvVtVeibpqKo0DEGdcLXNelhVGiyXCq9eableazoaqff8ueaSPvnkE52enkaT2Hw+16mk/fVa1fm5Tno9HazX6qxW6i0WWlxc6HK9VtXtarpaaVxVehWCPup01E1i/LALLH3Pdf097dOY+lwwzUibfja5xQJ5ktbBSm7FXbfCphxX8DB6Dq4ALYA3N01VVbXBwPiz+K4vV1iYuC4vLyND47FwMEsyP5yfn2t/fz+WM5lMIqP38uVLjcfjuA18vV7r4uJC3/rWt2L/90M6cU4mL39HOcXfZsGVkzoAVJdfjuXbxlzX1aOOaeFz2nfq7uFaam7NAZqmBaznxWffYQkglRT7iaQIUDGru28Xi6TxeBxNWLByTVKAzVsoTcCj7b3bOmhd/jlAwgTYBEJSD3tWYXT83IDaZWW0i9wnSNp14qtL35X0o1WlL0l6JukwBPV1xdgsJWm51PzyUi9mM2mx0HIy0eE772h2vVXW43kQII1JfbFYRADDzpJXr15Fk9WzkxP91l/9qzr5u39XX1ks9G515VS7Z+WPpHhtVVU6/+3f1tnJib70pS9tbLPGv4KYNbPZLNraATds553NZlqvVjr88EO9I2kUgg6uQc2+tVO3qrQKQYOq0mg81sW3vqVX3/d9WhwextU5bYwpbrpYqLNaabxaSauVepeX6k4mWq5Wqq4nxbmks9VKn/Z6WhweKlxT49LNFm0YGT+ryHdgoQxSc1UKavz9O8vj2669zziDUtdvmvqeP0fuPgIgYs5zMOU75vx7apoiH1fObu70se1bv/0oj1evXm2cRYYPTwghmh/Ih111+ON89tlnsa3oe7CHMIje1reZL+vmIJ9Hm6JG14GPpjrU5ZMCsXROrZuv6/JIgYj/9yjbubSU5+DX88+BHPqBpA1T0qtXr6LvFzumQgiR5SUcwGKx0GAw0OnpaVxQ1UkBNm+RNIGRbenbDFD/XzdI6ibKHGBKBwb3urJwBZIDOP5/m7RNl7vvoe/Zlv6DqtIPSDqSdKArENHTFeBZVZUu12sdXF5qtFxqulxqenam8OmnGoegdQi6uLhQr9eLh8ZBwz979iwqBYKbYSZgS+7L735Xnd/6Lb07n+t5Ven4uvzuVcW1qioxDS0kPZf0tarSr/+P/6Muf+/v1eLycmMH1MuXLzUcDiOD4nQ0imC9vjpjaD6ZaHB6qp6uJqO9ENTTFaCqwhVj1ZHUCVcMTqgqhdlMH3/rW7r88pe1vFbQr169iqtBDldczedarlZaXh+RsFosrrZ4h6BluNr19GkI+uToSIv1WuEaCLpTrYMPfwbvz868IB7tNmVwSOeMh4N8P37C2yzXj+qUCv/TnVOIszSY8TzPNDq135+anh0A8scK3fPkz4ESCszBI6AKgIKywy+Duvo2dQTWCZ8r6rBtXrjN4jC91jT/NLEmXGuqYx3LnbuvjkUhH//N5/M0reef9qU6UJSCXz91XbphhXh3OBZ7uAjGA+eZsWvTGTnvWzkpwOaRyLaOfR8DL/1eh+ydIvVr3oF9BecTml9zION50DlzA8UVXzqBbhvQ29rkLgxQGxBZRz+3kb0QtFdV6upawesK2ITrv15VqVdVOliv1Z1Otbi40KerlcbdrjrXuwomk4mGw6FWq1VUBsQiwRnv+fPnMdZICFe7icZ/5+/o+PRUx+t1ZGb2r8uVpLVumJuDEHSgKwA2uo55sn99cvNisYg+DQCN1NnW2+ny8lLh8lL7q9WV2Yn+VVVah6BlpxNNYetrR+JVp6P1cqn5xx9rPBxqfd2fWLFT1uXlpcK1I/PsOjjfpKrUryot9/a0CEGvJF0cHWnW62ltZjLABhOzX/N+Km2CdNLhw8TkTv24n9+8bZz1xIST9qMUPNTtzPLPqbnDQQsKx79zD+waICWEEL8Dvvz8qXSnVgpmUzCHOStldcgLR2Xuoy/BDlJPQg14HQnwRnDJOsWfMic+D6W+U7eZm3Pzq/f/dI5N78mxJem8m7s3BbneB9KFZjpvuRN8Wn6dvvD70zZN53MfT/QVnont4CHcMIEeBoFyAMJNUoDNI5DbIPhtedUNEL7XoX//zATrg8AHlf9eh/5ZufkqOKXJfYDlJpXcs7Shle8KNtpKWk9XJLl0OYDW1RUroWtF7lJd/3XXa/UWC/U7HU3DVQC6ab9/5WtzbZJZr9eRsieyK+an/f39uINoQxYLDVYr9apKe7piajrXf0FXxwqsJXVDUPcagPUkhelUH3772zp6553oJIyzsjuHuomG9xtP+u50VPV6Wl/HnllWV8693XDFqiCXVaVFp6OFdOVnM53qfDxWx8wakjbil4QQtO73ddnpaLZaad3va71YKHQ6WnS7CsOhFK62enufpI/6FnaUaVXdxHyRbkwu3Osrztx7991DfHYln07inoePQ7+egsc0H88vNf+mvje8nxQAMY4BHe4z5ePYz/zyejnIo2z3YXKzBiZU6sB18qefUyZRa2kLlKTPO3EsZcZl7j21nSty89CuCy7/nJuvcvOgl5UuDEnrfzmQVAe8/L/73fA9NVN5n+Je96NKy/B3ijmUMeb3kR4TI+kwszdJATaPSFI079fTdEiTAk2/bxusTQPJJy9P72mZ0NMJwg9UdGADMMrRlS7pCqLuOe9LdgWVXr+mOtX9HlDoVaWVroDEUjfAYnl9rbNcam86VX+5VFivtagqjS8vFQ4Orhx8r09q5gBAzFO0sW/DBXysl0tNv/lNnazXsbzK/mLdfRK8rttA0vra58EVCW3nDqqpWSKCgH5fF4OBxpOJZrragt2T1NeVCW4taRWC5iFoEYLmksadjk739rS4vNSeKcsQQnzeDfDe7WrZ62llUWi73e4VKDLWYdvK2GPBMDmjWFMFw3ffCu3MTXq+FT4mbpZN+0469rwevgBJ47b4yjidVzx93YIHoOBMFt8dBHq7++4p8nBWClYnDUzoQCytP2DKzWf0MQAS9XDfn6ZFUNNiw9s+d73pWpOkz9sG3OTy4M/fvTMuqT7xvp2y8rm53OuTsue5fkLesDL0OX8Of7cAGWcy+Z2gm4SPkLTRx1Kn/lQKsHnD0jQIbqO4tw2E9HM6EDx9OuhSH5ncypRJ21dVhFEnPR3fHQx94pc2mZmcWaptG7S5p25y21V2BZB8rqpKL0LQ70p6t7ra5g1T0pF0ea3QF1Wl9eWlVFVadru6qCq92tvTgUXg5TlCuDHNeBA0YkfgkHdxcaH9xSKCp1W4CloHS6OqUhVCBFzSFcipqkqXIWi2Xqt7rWwkbazAeTZ38EX8nb/q9fRC0kFVqdfpqNKVKUxVpWWnc7U1OwRNQtBY0mmno4tuV9U105Ku8EK4ObDTQXXqu0F/YwJ2JUF6/437AYn0536/H9uU8QQj5e859Z1JzzFKwVVaH//NgU66mEj7lo+llA1yEJXr/4AEyvZoxbmVOkctpArNn5vP/mzO/rifhv9OXbxc72/OIvn8k7ZHKm3ADZLzWWqac9N0vFPPo24RlZtPvA+k7HfqcO6siL8Pn6N9jk9BTOpKkANBKQhNzVspWE2fD2Cd891MdVOdCS4nBdi8RmmDxtsq4rqOUjdI/S9lQNw/oK4eABLvaH7WT1Xd+CMQ4ZZ6uFOYT/A+0fsKNl1hooDqmJtd2+8+7s21cy5NU5v6hDKV9Ld15UTc1xWI6IegPV0xNnNdbbleVJXm67Xml5e6WK+1sgjExKTB58C3TFIOkxbmql6vp5mk8xA0qSodVldmJoUQGZsg6fK6DvOq0kTSuaSzvT31rs/u8VV7ulLEPOHpAAiLxULzXk/f3dvT/moVGaqhpO616ekyBE0kXVyX+WIw0N7xsTrWf9zHgnKZNLlGpGJnRYh6nNZZ2tztB4jhz08V97IcKHmgRG+XdOz576niJL2PGTcl5UCy+wL5eM0Bfp9H0lV8atJK76/zzXHgw2cfzyn7yzvyuSIFT14f36EGmHfzWW5+9LrnFnK5dsnd25QuJ7l2bvrN54S6+cJBgPePlLnjntSX0RnDnN+W9/eU/fQ+RV1I40DIHe89zAP/q6qKdWZ+5316OQ5onR30w4BzUoDNa5DbAphteeWQfNMA5nPqL+OdOM2bjs422nT16/kSnMvpd3dS9YHFYGRA0MlhHtJJMVUMPN9dJc2r6b3U/VZ3fdvkmCqL35T0lRDUryotQojbq5e62o10LulM0tl6rZfLpV5cO6kS48EVkpsCPDosv7uNetbp6JNuV8+qK7ZI1fUuqBDUuf5+qatAdue6imfzQtJZv69wbdLiPUmbsVp4TqeRHQRIV8zQh8+eqXt2puVqpXm42vbdCeEqmF6no3EIOu929d29PY2Pj9W7ZkkwiQDk3DwU/WxMMfIuvH+lk7akaNLyvp4DHw5iOLPI84RKT8uhrunK2fsjZeXqz/cUQKAw/Fl8/PPfgZODrRyL4Pn6dWdR07GYY2dyrJoL/cTBb8rSxGCS9rwOhOreuZfh/3PtlD5LExBKpWnhte3+FNTmgI2ncUDp45u03l98rk3zypXhJqK0LM/fQZWkDRCT7gKsA8eMIX/XDmykm8jFde4KqRRg88BSh7rvkkfutxTYpAPWr3vHze3M8NUVyNjp7k7n5kA6V2IcPucrMd8hkiqeHKXPoWmuDFN68zHJttVc3e/pb1VVaRaCflXSWNLfJ+lQV34sK10Bm7Oq0ktJH4ag7+ztad7rae9aadJOvDf3ReDsHNoTnwne/+X+vr49Gunk9FSD6srPp68rJ+KgK9PTpa6A1StJLyV9r9PRcjTSXrW5c8H9G3ziciWMUvNdNou9PX375ESnk4m+PJ/rOIRolrrsdnXW7ep0ONQpodczvhQpaOYZMflIN+wO7QGAcRbJxwbMjE+kPvnSx5l4Yc0wT6VgA5BDEEUHB9TbwT3XfWUt3ThJ+yJA+vyE72PWxyV9LmVjcko+11fTe1O2JAVfXp/UfOVlOfPiY8WZmTQPf56UsfH6pWNx28IjTZOT3Ly0bY6vmxNyi9b0PXhaB9p1QDa95uad3LzqPkvp72kbOjOY+oe5GdjLzwFTnyc8bRoWgN+2gRqpAJt7l1xnukteue++unRAk3Y6Z2QQkDUd3JVQSll6uUy6dGZAjJ/63O/3I2uDYvAV5eXlZTyVmfD7PkHt7+/HTu42dxR1k5Njm5VS00R213flUgdo6srxer0MQf/fEPRbkn5vVemd6mrH1KWkT0LQJ92uXvV6WvX76th7o22YkKRNJ0FMVa6E1ut1DID2vYMD9WYzaT7XTFdRj3u62qm11tWupDNJH0n67W5Xnz17po75Uvnkl4INxE0XuVXxstPR6fGxTq+PQwiSwv6+Qrcr9XoK/b5Wl5dXgMcUuQM1j0hKX3UTiJ9Xg4lOUjzR2u/r9Xrq9/sbk3E6YbNaZacZ6TlpmskZkEk7OGhhbDnQo76wFClbxDsHiKUrWQcxDihTJsbrkJqi0rHlgQfdeTM3vnjOHHBKgUs6lkmX80Xx1b3n52BnG0uTltMGiDQBv7q82uiCHJipy4v/zs5Kin2SZ3cW0Bc8ue35lJVuw6csZ/OZ/9PFsINmafMoEh+nDjxzbZd+dkbPzb65LfypFGDzAHIbJVnXqXMKOAU4dQidjle34vOOljoypo69nU5nwxGTwEmAEE9TVZX2r30vptPphpmJk1tns1k8mp6VLHXFN6Tf70fF64O1qa23AZxtAyLXjrveQzvuugrknlUI+lDSx53O1XlR12276HRUXU8k3fXN9lmUYk6ZMfGvVqsYityVJ1tr1yHo752c6Oz8XD8wn+vdqtJAV/F11lWluaRPJX2n19Mnh4daDQZXoCYBVJTlfY5n489t5VJmu+jenibGEHZDUL/TUT9ZqaUAlz4JG8T2UEkbvjQAIAAOgMfZD3x26OP0wX6/H9kwDviEeeR3BznuNM9z+zVJcSy4MuCZfIWdA/Me84a2zCkONyPlgEQ6j6TtTFqfRxwo5ECN55UDsrl3mf7P5ZcDX96/cuOrzRj2fNL5OJeuaW5uAojpIjRXbm7uSPuRdBPlmr7MOGBO8O/S54OjpuwJfdJdB7hvMBjE8rkvjVyd8xlLQXMK3nPmNcYC7x1TszuvN0kBNneUuoF7mzzqvueu5wYH170zMZlLmzEIUrRNx6GzQaX7yhTQQvrBtXIjb2cI9vf34/Zi/HMYLJJi+P/BYKCDg4MYVZR67e/vx4PwuLYNqaeTQi5tm9XZXe7ZlrZN/eMKVFd+LZIUqqtzm4KtljqdTmQamAikTWDjABaFnG7DjpNkCPr4+Fgvlksdzuc6vrzU3nXZpyHoxWCgVb+v0L3ZJp2aARwsp6tnAAMTkwMfX4m774l0wz74wZo+WXOGjINx7nNAQzn8d/s+fZpxwJZ5xMtgbPjKFJDjk/X+/n5UOP6eAFGMPwKOuZM9DGUK2qrq5iBTfnOA6ErGFyU+NlKQ4O9nGxBJzU0pmGgac6lC8vvTz2lecUwYU5OCvLTMujqloCUtJ/c5/d52wZPe3zQ31YEl/5yam6VNk5D3Iz4z/0raCILn84A7ZEubvknehxhPvuBMWRzahoWF95l0LKbjP20jnytSoNUkBdjsKDmkzfUc2t8177rBkiptOltaB+/4joa9Q6EUoLHpnJiVABaSNlA/aRkQIQSNRqMYupz8er2e9vf3NZ1Oo3mJPKkPJimYIqj7qqp0cHCgg4ODeICir0hSRXkXya1ab5NHXV2aJl6kbtLNrd58cs+Vy2/u/5H6uJCOtGkArRCCFp2OPun39Wo0knTjmyNdgZxutXmic91klNY3t6r2iSs1hfqupJwCp7+R1tvcgYibUJjkSSMpmk+9nHQl6m2+t7cXIzxTX+riQN7bZDAYbIwRgE5VVRHkM2bdzONt4mmc4UlNPv7fV8oOxkiTAwD+e3q97t60P6fgwd91rl/7fQ5y/XsOhKR5p2X6e9tWx1yd66Runm9zX1p2KukYp639fp/nfTdqusCkz7tuAMCwgM0dp+Hjw02hsDbpIibdzYYZFzMxbCjgHJbT+4SbGFMg435tOeY+lQJs3rA0IfTcdf4DMlIa2v+4Jt0MCCZ1wAr0eb/f12AwiDS6O/262Wlvb0/7+/sbEywDBf+F4XAYT3ne39+PAZbo1LPZTPv7+zo+PtZ4PI6RcUejkV69eqX1eq2Dg4PICqFAGDxtbKy0VVO6VBG0fQ+5leRdJHd/qqC8vFRJIShFV15OSXPN44ykIMSpZN+RwO8eLycFRi51ACbdzkk+bqPn+X1Cd6U+GAwiIGayxd8L4M1E6eDIt4kCXAA1gCDAie9yon6+u4lThy8vLzUYDOIkTlqAPCAJGt0djXn+/f39DfDkZj1/x+kixRcvfjaTr7B5bvpCyrik/S1t/5Q1899Ts1luDOXAhr/39Le6/kP6urGSAvdcnql4fXLPn7s/B8bS39qUnaZrqrOPVQcvzLcA6XT8A5jTaNDuHgCwpv0APg5CXHf4+PE+6wAKIA94oc+jZxgjhHvwcenAKn0Xzq6m/TGVAmzuQVLQset9fE5X+OnqyK+7v4B00+l9V4crKqevF4tFnMilq0m91+tpNBptoGhMFzAoKERoendc9MGSUqG+W6TX6+ni4kL9fj8ql8VioeFwGAETCJ8yfJVy23dz1zQPUW4uXdNElyqaHEjgvtQs5YrK83GF5JNUCDdneqWracr3CcjfUar0/Pe6lWhaF74708JvTOY8HwyKpAg03HcGEOQOvL7bCRMo/l88G5Mv7bC/vx/HjtfPzVB8ZxwwJgBdfKYtUuVxeXkZwRZl+urY29tNVw5yUEwAGQdbbm7IKdEco5BjDPy39N7c9xREpH1h272psmuzYKF+bViSbdIGqOTm7pzknjmd59N0Pr58nnWzJkBG0sZv9A3XGd5HWaD4yev9fn8D2JOngxjphs11ME393OSV1tef0d0cvH/mwLr39SYpwOaO0jRY6gZ93aoj/e8TLNe84zjwgU1h0icdnYGJnglif38/HgnvKHs4HKrb7Wo2m2k8HmswGERfATqfKxZQeRo1OM2X+kHhOwXqfiDu60Onxlb7uTOObiHppLIL43KbSXKXyXTbSjO3eqVOtF+ahztdpwyfl+vUP/k7LZwDYCkbI+VP3W1SWpQPQPE8nXVw3xbvi0zS/OaghgmTccFREvQ7+qWzlt6ugJHUJ8XbHIBO/Z2JcYXCWPP356tlxgPjCXACyIlHYKxv4sH4xO9+Dm6O9FU+84Kft+QM7jZwkZuj6sBGXb/PgdemvuHtVVeOj8ldmJK6BWkOZKQAPld+W8m1Uy5fV+bOnANKnJGkn8zn8zhnc5+HNADAHx4ebvQzXyTTX2FdGBMAeF9oeH9F5/ixJpKiTmEspZsHAD4sIKRNiwRgBp2XvpucFGCjdr4t91GG1Gxj9WvOuviEmvq5MNHTQaHlJW3Q9XRaOtbR0dEG2oY96fV6GzuVOp2ORqNRFjyt1+sYz8ZXBJTjK3xnDKhnp9PRwcFBpP4BXNTXKfROp6PJZBLz2nUycXHl5O/lLu86t9Kqy3uXuqdtiORMCs6KeLmpyYB7XWmnuw1ShZUrh7zSa9S1Cailq1E3gfGZ9w7rQh/BhwsWkIkcRuXy8lLT6XQD5DNRc6xEGr8mhKtozFzzvsfY4pgENzsx+bMDSlIEXSmAoC4wnu78mfr54FDvCxR3Mua+Xq8XfdxQAOTjfhY+Rj0+FHOHA7qUlUvBcG78ObDyvpcCpnQc1LEbuf62y0Ix1+fScVg3fnJ1rJPbAKmm39K24Dpgw33HmLMlRbMOfZbxQl8cj8dxnh2NRrG/ebwkAIYDZxhL6rRcLjUcDuN3v4f6pjsJXV+x4PUx4Y7NvgijDu5WQZ/OLdBcvtDAZpsiu09Qk074dQPMkXrTSsInsXQCTx0XPUAZ8TsGg8HG5M/EyWBhYvVts0z85I/C8YneFSeraDougmJi4JydnWk4HGo+n8fJnM6PkvHJt007+zVvu9xvbeQ2fSG38rttHv45t5JOgUJuFevOfZI+FzeFNCFshjb3svjvjrP+P1f/nBLM3eNMA5Mzfla+64nJGEXt/wEkfowEZTpFTtlcA4TgQC/dTNruOwDryGQPEJcUxw+skdP7vgsKx3xOKfYVOW2Ov5sDR1gXN/f5Kpz3Qj7+Lv390x60cwg3EcIlbRx46e/Q2WNXLnV9vAl81IGM2y5Ymu7LlbPtHv/d/9eB9V0XSNuAnOsCZ9zw56LMdEFJ/yNdCEGTyST264ODAw2Hww1g64vbvb09TSaTOOeSF6AD3cCiwvsDdXS/Sn8Gn7/dqsCuQcYKfZw8U4uFm6vq5AsNbFyaUPtdJUXkdeU5aPEXmg4sOoS/YEforAjxBwBh01Hc78DLZyKeTqdxYGBrdcbHwQud+fj4OK4oT09PN+IcSJsOj+4b4AMVcxY0KoMBgJXa2XOSAzfe3unnbdd2BUT30W/aruy41gR4Ugo/ZXPSydtXRE0KKwec0u+5+qR1ljYPRExNSJhH/bwn6sXEvVwudXFxEa9XVRVNO4AdzKVMoL7i9ZOhaQP6ofcBVszD4TCuhAH1xLVxPwbfkUWkbca1M6QOErnXQR7tg9KgjsR7gjmSFBXKer3eUD7p9nHKp739PfmGgG3jxoW+08SW5PqKs4/bJO17be6rAxt1Y6AJ/LQtb5vk8qEtqJez49INQ8eGCuZzxoF0BRgODw8jK3N+fq6zszMtFgsdHh7q5OQkgmbmdPoGrJD750k3h+jSh2FOh8NhZGDo+8PhUP1+X+PxWNKNm4G7GPDHNeZ9jwtFe/gC3xdmxcfGpI3SuU9Ak+bpq8d0heJAxleXucHmnYs/X+GCwqUrRXBwcKCqqjacf5nMADTOwqzX6+hQyWRKnefzefR1YVKG5pduOqObonzV6spVUvQvIL0zT3Rw6cZUQt51ctsVX500gZrcRN0k21ZzbVZ7OZDr19O6pZN03aqzDoykdcutXut+97o4yMrdm67meP/85x4m9nQF6CyDm9iqqor9z+ltWEMmVgA4wAFgAaPCYoHxAmvE2Li4uIjl+infKUPkjvp+rIgf3llVVdxRKCmazlyp+aIHAMgzd7tdTafT+DkFAwAsb0P3c3O/LAdaXr90DObed91YzIGcnLnLy/P5MteH68ZhDjzU9XHuzdXPf0vLyNW7jeQWt14m/Y5+Km3uROz1ejo5OYm/z+dzrVYrjUajqAum02nsP8+ePdPh4eGGb5Y7wzuDQ70Wi8XGGGRh4TFqmP/5jE7A78wX7MQ3AxD5mXbuiJ++B8a2++U0yRcG2DwEYKkrp0m5OrhJlYRTbj4Re3pXZu6LgEmICYuJmM7ldHu/39f+/n6cjOm0dCxYGwYAgyaEzW2urApZVaNE6IA4rmHbJb3T4O4bhFLwyddX8alJq817aAMW6sTbu24V6uXtUrf0/rTMXJ5NZeT8cNLVcG5lynfKTc19qRJoUgrptSYFU3cfjAjghYnOfQxShoF+79tGUcxM9lDqq9Uqmm1gUkII0edsPB5/zgmXMnH+5R78xOgjjDHa3f2FUBqwn87CUL9er6fpdBrr5iYl9zVwoBdCiDvCnCniWd1/gTmEevtYTccKv1NG7l2m/Sd9594P6oBPDjz75yZwVFdebsw3gZSm/HP55oB57rlydXCmIZ3/c2ONuTVlO4bDoZ49e6bRaBT9YAAyi8Ui+l6dnZ1pvV7r6OgobhiZz+cbbggAER9HzN/T6TT2bZhKPzYH8E0fZB6izvRj+vhwONT5+XlcJAOsWMwCfOj7i8Ui+g7BCkn3AGxCCPuS/qquzuPbk/Tnq6r6V0II70j6c5J+UNJvS/oTVVW9vL7nZyX9pK7O7/tTVVX9pW3l3Kds67SvU1xJ5f4c1KS2RA8SxooqBTisNumY3vH8pFU6ra9sHUD4WTuu3DBxcYI0oMmpfD7PZrM4AC4vL6Ot1neLMKFPp9NYT7z02QrO8+K07P4JbiLJveO2E90u7+62su3+urruWnaTYkl/y61wU8k5JufKrEuTXsv5RqXKAEljc9CvF4tF7HekQ/HiNIxPCsDEHRr53O12dXBwEMcX7ApjEHMV48XNS75rCxOq92kACI7EXEtj7qTsI9f7/b6m02kEZSwauKff78cxhvIi3pOzSIxJP/yU9+Bgx98PpiffIoy4Sczfbx2rQZ6567k+sA285NKkwKIObKR1bRon24BUG73SBvyn6euu03ecdePa8+fP9ezZsw02Zzqdajqd6vDwUN1uV6enp7G/wOKs1+sYO8x9K10X+MIUsH90dKRnz55FwLxcLqP7AUwOYT+Y1903yB3hGYMsYgH9/X4/BnzlWT2WlqT4vNvmxzaMzVzSP1pV1UUIoSfpvwwh/L8l/e8l/UpVVT8fQvgZST8j6adDCD8s6ccl/Yik75P0l0MIv6+qqnwkr3sQ73B1q93XKXUr7TpQI90ACNIxsXtncCTL/azODg4ONgCHT05M7HRAVrJOpbMadQQvSYeHh3H1DIsDgILOh5UBZA2HwzhBX1xcaDQabZiz3GHMd1UBbi4vLzUcDiNtCmKXdjM1tekDbSerXe5pKtfBaZt7bzOh51bDubo3rRRz+aX35+qX+5675itz8iVvmI7RaKTRaLThdFtVN47L0k0gSYAODI3HqYF5cX+ETqcTJ9Butxsd16fTqebzeezjzgTRF1HyTPCUO5/PdXR0FO/xfs7zAnicyWF8zmazjeciTze/UQfy8PN7nNZHoXgZPg+4Dw1zga/gU2bBfa/8fW3rA7nPuyxKcgxIDsCk/aquPk3l7CJ1jE7T73UsT3qfuyTwzgg9ICnO+SwiJ5NJ9DMjHe8KM1Gn04kLzclksuEzOZ1Oo/6AqaOPwKYcHh7q4OAggm9YI+rHIbvuy+XAn3c4mUw0m80ic0kawL37iE6n0zjuWWy4b1iTbAU21VWrX1x/7V3/VZJ+TNIfub7+C5L+iqSfvr7+i1VVzSV9K4TwTUl/UNKvbivrNvImAUyTNDE1vBgmCWc9nKHxrXJco6Oljoh0Ola5dCRWpCBr2BQPvAeQAUxRTr/f19HRUVQarEh5Bn9GDzrmWxLH43GsA38HBwexs7NSZcI9Pj6OYAgFQ1pWEd6+0t39araxE7n32iR1YCOnCNoyNE1gpY41yeWf1qEO1OTq1badUyfSdCykTuC5dMPhMNLs0s2xB/yOORSA4uyhm5BSs41041fAf/o3JiZfbKQ7A+mHs9ls41BR95EhL1dIsCGsQhkLjGVnlNwMm7KVmGvJ049jwJGYZ3efNjdbYwLwuYg2ZuHh4NEdmf09Uj9/LznAmgPSOYVex6LU9ZO2Y8HF67gtr7TcuvyagFzaZlyvA/tp3cbjcXwnvGcWeg6sue4xnSTp6Ogo7oKCmeG9u7mU8bZerzWZTDZi2Eg3u5h8nOC07vXA3QAmcTqdRod2FtAsBCRFvYMrgkf39r7MnOAsVpO08rEJIXQl/Zqk3yvpX6+q6q+HED6oqurD65fyYQjh/evkX5X01+z271xfuxep67SPCeDUrQiYRHyHEJ1WunEWc+diXiLf+cxZS6Dq/f39CBIohwmUVSLsCHZTj+XBvdhroQupy/7+vk5OTrS3t6fT09PY6dK6UWcPM49ZCt8JOig7WXyyZSshz4RpglUBbdmG6m4jd2GAdilzG9hpSu//27JLdelShdO0ik6vbXvenMLiOv2jLj33+I4oN/2gfN1nhAkVMIF5BoXLZ5iNEK5MtxzpwaoXhiXnPMn4YEyk9aavOttBOdQX8EJfRkHwTG7+StvZAwcuFgtNJpP4TCw+qAcmL2+r1ATgoAUGmOjGLDB8wYUyTXdJpWZzrm3rd3Xfm8bBtnvb5pMbv77ATIFHOv6a8vJ61eXDb7lnys0NgNXBYKDj42P1ej2Nx2PNZrPYZy4uLjSfzzUejyMA73a7MQ3xnTzyu7szoHN4j4ATGFPAuS9GfN7H7Mridjabxd+lm8jnPl65Tt9Fl52fn8dxW1U3Ow6dgfXdh03SCthUV2akfzCE8EzSfxxC+P0NyXM963M9MYTwU5J+Krl2q077WCWtrzsipp0dWzu2Rgc+XGclt16vY6eD9fBdEz6Zws5I0snJSez8sDdMnFCJTNRMxJLiIGGCZCLA2YvJkIkSUDMajXR8fByBTQhXh2ZKipO0AyCATlVVOjs7i+zO4eGhxuPxVqXd9p3k7r+PvtW0Ws2tPNuyNW3EJ9DchJrWJ/3u/3M0r4PJ3Ip3m9S1TW6id9YSYEx/hsFBkTMemDQ9ppN0c+QCY4FVJpMj+cM4djqdeLyHg2mn56k3CwXpakULi4Nzpkd/9WNIWBXTpn4eFQ7NmHadpWWCd5Dk75m5BRCCMnJF5LugJEXTMcwQAA8Q5M7FDnTSvl3X13YZs3V9M/e9ib2puzcdI03jowm4pNeaQJCny/X1OtDkJiHvjyz+AAswNYTogOk+PT3V5eWlRqPRhu8YdWDROJ1O46JgMplsRHdnOzfmJd9x5S4R0k0wR3bzVVUV84YtAjBxn7s0pH5epIGdcv9OZ6TqZKddUVVVvQoh/BVJf0zSRyGEr1yzNV+R9PF1su9I+rrd9jVJv5vJ6xuSvnH9cmMt3zbw0lbcqc8ZGg9rzUTCiwWkuJ2dyQxUzoTjkzx+KlB/2FR9UDEp+24kFIh7uFNnfBBY1THx9fv96PDrB555DJBXr15pPp/HCKnL5VKz2UyTySTWn8HKiuTVq1caDAaaTCZxsk8n0tsAnLuAorqVGnVK888BjLbl51ZwbdLWleEKZpe8mvLclkc6idetUj29m2Xdt8zDyHv/Y1y5fworU/LECRemAls9Oy4kRVCPIvHTu7nuPiyABjd1XV5eajwex36d7oDiPhYA0PoevoGx62xROm7xTWBBQTsQcgHzhfsI0c65MYxzsi9YGPsIz5CyMtuYvhTItmF0moB5rh/5b3W/p/fnwFmuPtvmmSaQsqsuq6tLCCEecQPzgS8ZjuSw7gcHB5pMJhFUoFv29vbibqTBYKCTk5MI7MfjcfS1YQ5ncZ2aSJ1FYcHLdw+dwCIAoO+bSNB/uC0w7j32FP0N52cW4AiL9TppsyvqPUmX16BmKOkfk/R/k/TLkn5C0s9f//8L17f8sqQ/G0L407pyHv4hSX9jWzlPSVIE7ysgn3R90Pjqi//9fl+Hh4exA/Fyj46O4qrQV32SIuChQzIh4/TFBAywcSobJzTqCIImQBOd7/DwMA4mOiKTBZPhwcFB/A/F6BMjA4OVLUAIZD8ej3VxcaGXL19usE5I08orbdum39pMPrkJsc19TRNiHRCqK28bsGhiosjHTSxN9WsLYppAUk6JNa2Ynep20yppcYJMz1FifAHk6bP0Q5SAdGOacV+V1N/FJ1FWjCgW6svk7hM2bAcrTJgVd+BFCVGudBOF2/0mWGQAanxnCKtbFIof5eC+MLQBygJzAoAH8wPtxQLK56q0r6cMjLd1rm/l3j9yG7DvaesYlW35bhtjTeBrV0nnmbpx18R+scjF6Zbvr169ir4x3ocByzB+s9lsAxDgUrC/vx/9XwAlLKDptx64zwMFAoJYCDu75M9QVdWGLxoAHDDjbe++Xm6+grUkTdt5uw1j8xVJvxCu/Gw6kn6pqqr/JITwq5J+KYTwk5J+R9Ifv35pvx5C+CVJvyFpKelPVi12RD1VpoZJIwU2zq74Fm3pZuWKMsLvBDMV5h13UGTl5x7oUNc467pTF52Oidz9enz7H0CHib7f7+v999/Xp59+GrcCUhZ1GY1GG+CMmDnuQMwEulqtdHFxoWfPnsV8aDd2VjHpA+LS9m2awJrey64TmIPVbfduWzXm0qS/5Sbqugm96b66+32iTScOr0/dhFy3qk4BTK4euQnf7fuYWqQbPxWYO+5zVgL6Gyd5n+xhHFNHdK+PT96eLytYNyHjeAy4Z+Up3cSrcZDF2IQxSdlRbzOUEYrCzWrUAaDPfOJtjSLgOWlD6uvzEb41tCULJAdqboYiLe8K8aM5vF/kQHsbadPHmwB1HYu0S3nbGKa6+vkcUVf/3L05QAgQwDF3tVrFuDE4vsOCwMIRhwmG0vvas2fPdHx8rE6no1evXun09DQCFOZZ9BBsCb4wtAeBH2F33DzZ7/ejfgFgufnXmRzGpT+z90N0H7rHnd/bYIU2u6L+O0l/IHP9M0l/tOaen5P0c1tL/wKITyRMwA5iSMNE6qdpL5dLTSYTHR8fb+wcYiKF6j49PY3Ovqwg6ViSYhwQJlqADUrg6OhoYyJn5caKzle6zhq9evVqY2eKO0HisLZarXR4eKhXr17F/FKHT1bEsFA4GeNnk1Pcd3kfuc916e5r9dZ2pdEmn20Tf3o9VTievk75pKuvFFDWpav7rU07+gSHcsYHBOWJg65vf3agDGBHKbPCdTaCZ2HihxliXDpw8G3VKBK2u3pMHdIRYCztpzCermgAkykzk5qa3LeOP3f29/bFDIXTqTNL0g0gyfnSACZpa59DKNcPKuSdUbe0n+VYkDaAJ9fH24Lqpr7V5pr/1gSg6uokff4stG3l1M1JzMH0Z9j45XIZw3DAbsLiAH58ly39ZTgcqtfr6fz8XC9evNDFxdVmZ8AD6Zm3GYf0TbZfYy4FXNFHQwgRLC8Wi+hWgBsF+oVxnM4r5I24D44vYNrIFyby8OuQ3EDzCcyd/lJvfPd5gYZ3ypp0xCtgsAAyWKlBMRPszk98xYGSyZ7YBWyrPTs7i6s+bKGs4pjker2eDg8PN8JsdzodPXv2TOPxWC9fvtSrV6/0/vtXm+Twnzk6OtJkMtHZ2ZkkbThZLpdLvXr1KvoCdTpX29MxjflESTu0BRyuyOsmqW351TEdaRl1edWtInO/bwNedQxJXR23KYi0Xm0Yl7o6pav29P70Wvqszkx0Op3oiAhQdhbTt0STJ7+hxN2/RLrxvfFopm6GkhQBEQDBWZ90xck4khRXr4Aw/GTcR8YndQCE+xt4WASUh8chYcygcNx5GcDhdaFcN4+5WcvfhwMzTNakYx7A1OW7ZFz5tWUydwX3twHIqeQYmLo+nuv/DtSaykvLqKuLp/XyvBxnXBBAqPtWOcPhJkE3L6FziEZ8dnYWfc+cqcSExeISlpO+znd0DHVHH5A3JihJG+VX1Y3vGX3RTbY8C32Y/uVO8zCbTVKAzT3JttU/kyOrpP39/ciYgLA9DeYht6u7Qxd+MwAHp5npFDjfEhDJTU50JmLZhHAVhIntg36kAjuWqqrSs2fPNuh6lM97772nV69eRSe3Fy9exBDc1N19J87Ozj63/W8+n0cKFf8bmCBfDfmk3PZdNIGatvncZlLOSdPkeBdmZxto8XRNwMXBTZsVtadNJ/a6OuYAp/9fLpc6Pz+P8Za8L0o3fi6uxFPTULd7E9qACL4oaSZ8Z03wo2EMOXPk5aXmHhSQT8JVdXOcAytNH8vOGmH2YeUM/Q8rS1koPVbenc5VUEvGJ3nAJrHIceXpGwL8vVEmYMlZJPIEcPEb9SfftM+0ARFN/eS2AKjutxwAqSujLaDPga4csMnNJXVlpCwp7Z0GRJ1MJnHuZnEMYw+zQ5+CxWeLOG4IbmZlAYwTcr/fj/5pvvCQrnbYSjfsJkwKC+MUxNNPeBbfEEL5WAVoG8xORKZ38+idnYeL3E3oEO43sL+/H7fhMcmAgAE1voJyOyaKfbVaRXsnKzqEzgH9yHEITLjT6TTW5/DwcCPODVsHpavgTthssfHSGXmOqqo0Go00GAz0zjvvSJI+/PBDzefzCGxWq5WOj4/j8xwfH+v8/HxjoqQcBuTp6WlcPbikpqlce9/2PTUpeSQ3Ge6yisyxI9vuy4GIprLrgN22tDmQkd6fY1nINzVXkb6JjQJY8J+VJ3GNoKa9z+Ozwk49Ny+5wnAFHEKIMTbcsd5PxXbW01kMxq/vSul0OtEHjPHrEzr1QbEcHh5qMplEUMOk787MHnoBvwkHIDwrPnm+Ioa5YQyxCMr5vzCO01U3wI95ACXivj1uIvQjLCgjdSJO+14KaOtAdK6vpHmlfa1Otv3WBuQ35dtmPmgCUQ4a/D/vyoW+Rowxj0/DO8JUSsgN4sT43J7GVaJP9vt9nZyc6PDwUPP5XGdnZxHcsHMVcFVV1caOWD/7ibMDAdiYMel77nPDUSHuII1OgzXCz8ZZ/CYpwOY1CJM20R2xZ0qKLxyqDQDBhOn7/LFxAnC4n9gGHkUYKn00Gmk8HkcPesK0+zZXJikvi3phx724uIiOwvP5XIeHh3r33Xc1mUwkSWdnZ3ECx7kZpcGkiZ0W9ghT2IsXL+LqlokRqjTtwOmEmJO2q71tabYBmm1SN1H79zYTZ3pfbnWYY0Ca8szdV1dm7hlSELQNNG1j0QDvsB9uMkGB0nfd2ZGJkTEB2JFuTE+MGbaEw5pSPsAdFhSwjcJ2FodFgj+DO9fD6MCMDAYDHR0dbbCnjEX8ddxvBbDlbBL+DO7nBpX/8uXLyAb5bhVYYNJ7TBSPAwLAYou7vw9ADkAPResrbx+zaR/IvfO2jE1OHDDeB3O6ray6MeKf6xYDTeAmN6/kFmy8U/o2Y+Pw8FBHR0e6uLjYcEvgAEwHPrxrAO9sNovMuY8BgDRszcHBQZyTZ7NZdFcA+EuKeoSxheP50dFRjLPG4gCGnjwAYpjacElgwUwQV9ga+p/vnmqSAmx2kG0dNyf+Qg4PD+NL8hfkTpKsKplofXcIKyJQO5MpzmHSzSTtq086CRMp92P28RUcnf78/FyvXr3S8+fPo8mKVRzAhsn5k08+0aeffqoPPvggOmC+8847GgwG+va3vx0nzhCudjqdn5/Hc6IIA8+WQGLzgO69rX2CSf0ndn0vTfc1TZq79IG2q71cuiag0JRvG2q9jvXx/H0HzG1XtPyey8+ZlfTz+fl59B+A1SNcAX2eWDFuXvUzlLjfQxcA1iVtOEV6pGtWiu6sDxuS+uZU1U3UVNIwblmtsligTOlqtQy1zmrYHSer6uZMNxgbVsK0E/ehqBgPKBeUJQsmnPMPDg6iGdwpfVbhKDKUEPMKJkHYKoAWzBnP4H2hzmScA9HpNYBh7r6mPt5mjGyTbfmn/bcuTVrvtuWl443yPKjpy5cv49lPHkh1b29Po9FIR0dHkhTjh9E/mP8ZM7B2+Gr65hZfIJCWdzyfz+OCFN9NAD4si/cxABd6C38vnokAg++8845Go1FkGskPpgnn/Nzc71KATUtpq+xcfKCxesME1ev14jlKvV5PR0dHG6s+Xh6/M8h9RwjUo2+19g7Y7/c1HA51fHwcAQSrRd/1xE4mJmzK81Xz8fFx7IDQjDy7227x0xkOhzo5OVGn09F4PFav14sOZZ9++mmcDFmNswMqtbPSjt6m6bW7TGJt77vtCrGJpnYavklSEJTeS1s1sTa5Nqqjv72sNO90x0fTatZNqF6G3+N//Mbki92e8AHsBsFnJQ3KJykq33RHU+qnxXO4PxvKnXvoj+QdQohpAD4+jgBBfh9MD0wqTCWLDcCXm6RREL6d1sEVY4b6AxxzysWf03eXoKyog0d7ZT7Bt8lBDAwSK2/fjp6+27Q/1H3OgfscY+L3NfXnNO8mAJLWqe3CoA1gqwMsaR7+OR2L/n4x+6Efut1uPMuPfuH+KKSDtfN3zmIa4O27poiDkx7TQF9kcfrq1at4P4yfLzqxMABSeCYYT68fOm00GsVDlL0tAHDki8WhTgqwaSG3UWrp4ANssCqEpfBtcqRntQSyZfXm+cKAEE2SyROfGfecPzo6ih2fqJOgbJ8808PxJEV6noHBZ+pOh+t2r876WK/XMWrwyclJ9PGZz+eRkgT4AGhYNdP507NJ6iaSu7yvXcBE3e9tQEkuz7rvt81nVybR06fgqu5/3bM2AZy0jKbnSYEyKzToc2z40PCj0Ugff/xxZPjo6wS0lBTHgaQNR1qYF5S5O8N7gLLU3CspmltPTk50cXERAVNVbZ7XxFhxHxQAkztlMr5hgpgHABsANBQE6aQbgAadz5jEbODtDvBys5eDEj85HWWKfx/j0c16vCfAFO8u59yfYwvvwqa0vXfXRUNa1zRN3ffctRzr0iadM1bS5plcfj11ZyBswTvvvBOBAQCY33znE/43bi7y/sbGDUnRT8ed5/3oBe8rFxcX0aUCoEXfB1AzvtFzvCdAC/2QcUUeq9Xqc8c+1EkBNreUNgotnbCh/aBvWVkx+fnOAqLxsqLEdyCEm61u5MWK6vDwMHYCyqds2Jbnz59Hdqaqqg0nRECFdLOtEM/7fr+vd999N65kX758qfPzcw0Gg/j/4OBAr169irui3nvvPUlX4Ag77cXFhc7PzzUajeIW79ROz3P6M6QD/nWLT6jpaqtpdVmXx20m93Rl2TQZ15XveTlLsq3uubzSPNLPubrl2s7rIN0ccInS/Pjjj1VVVdzZxITuTu0e04a83GkREEDfZyyijJl83XmYCRbHYiZmzDmYnFAepHFTkJu1WNjs7+9HvzcWDPgbQNGjbLz9WOF6zCvGLAsMrlMWixfGFc9FvXhuPy/KF1IcbOiME8+FAnT/QGdbc2zctn7Z9NuuCwnuqcs3B7ia7mn7W7pYqPs9zS/HWqV1ZqPF8fGxVqtVXCROJhN99atf1XvvvRfPiSJ20/7+vo6OjiJjjp8OQNfrC1PozvuAIhan+LsBTDBZnp+fazweR9ZU0gZ4pg+FEKKTsPuLEbcNpod+TjwczFa+PbxOCrDZIrdha1xShcckuFwuo4+LK3O3ycPaAFbwK+B+JhR2ZwBAPO4AqzzoZSY/VsT4tWBXZdKizOl0qs8++yw6HaJAMG3h0c5hldhz6eSg8+l0GkGMh3OnfZyyr1N+DwFu6lZWuTR16ZpWpE35peCgrn51E3Auv7Rt6gBUXR1zk3LKmNWV7+/K/aPS98d1vz+l3PlO6AFJGwe8EvOFnRI+QQJaMPf6lm+c4/EPc0dfN8F6XA1JEXywUwnQNRqN4qTrzA/PxX2Mv1SZ+ATu28BpI0zFACMUAwAJnzfqnMbbAfxhtsbXCQdRSRs7Tnz1TcgFf0/+DtbrdWRjcVRO322uvzRJOiZyfXGb1I29tmN8F2nL9OQ+141twDLA1sc3rIUDV95Dv9/Xy5cv9cknn2yEDwHgE8qD8eMgmbJ8RyLvW7razOEsJ6AGnxxMlIAVQJCbOSeTSYyPg5kZdwfmfkIuwOhXVRV1Bwse/IeapACbGrkroEHoLHz2XROUw4uHVh8MBhqPx+p0OnErdb/f12Qy2ehwsDUAFSbOwWCgL33pS5pMJjo9Pd2gqPF2d2dEVotM2mwHB8QQfns4HOrLX/5yBFTSzcRP3BHpaqI8Pz+Pu1igGKEZOWIBWj1VfinL5W3p76ZptZO+y22TSZ2yTsvdZWL1/OukafLdVSGk+dWtHJvATloPd+DMAZQ6JeGKmzrUOXy7MNEBtFerVXQmxoG4qqq4a45rgBNnTQaDQYwVBfXOypJFAFu4ASTQ7e6UTD18R4izJDwTiwIHSfwxvhn/HpPKY+QAGFg5A04Q2CTud1MFfi8saHAcZY4gPWEe3M+H8nlO90PyvsWqHmZpf38/AiLvu6mfnPepHIuXG9NNLErbsd8kKXOSy6cNGGoaD23Gv49Tzwtwk+a7Xq+jScad8nEDwIn4+fPnkm6OKsF3DXYNP0j6OvM14AcQwnhjLDOuGZOUke6q5SRw33F4cnKyESyQxbpHx0ZHUA/KArAzBpukAJuM5Faz2ybznNAJmJx4cb3e1XHxL1++jDuOnLVhAgRV81KPjo42djX5ihBfBGhltoB++9vf3qAQCaC3XC5jbBkcfqHHZ7OZjo+PIxgKIUQgAutCB2NFx2oAe3yn09H3vve9aAoghgLPCZjyVWo68aVAJ/2ce29113IKf9u7S+9LJ8G0jFwfqVvJ+WSWMh65+jdNsE1pXcmk6dJ7c+2PpEouXUm6GTUt3/94hzmFB5sJ0K+qKjqlYwZ58eJFZAQ7nY5OTk7ixM3RIAcHB5FC53R4D7WAogcUochhRwD0LEoYW5IiXe6Osx6jw81ELAD8XDcYKAKrAZYYM9wPs0PbwLj4ogImivs8RATzCPVmAcPuF58j3CHZfYIkxbJ4XhQYQBFH0jqA3kaaQEvaz7bl3fRbU7+/j4XsrszStnxycxdAhj4HyCD+keuLbrer09NTVVWlL3/5yxoMBrE/9Pt9vfPOOzo8PNzYHedsEeVJimDcmUN0G+wlC203u8L64Yze6XQiW0qMHMy4ACz6qrtnjEajyOpTbpMUYGNyXyyNCx2FyY0YE2nn9MlfunF2ZBVFR3UKneiT+Ov4YZFHR0eqqir6u0DN01GIWMrEzcRJpF8mX/dPAGVzoKXHMDg7O1MIYcO2C8NEG4DccVh2QOMA0NutDtjcl9SBkm0MUCrb0rYBYm0m7vS+NmxSzqGTe7YBMCZSJhyue59lcs3lnQK4VJG4g66zmNLNWU6wKqwqqRc7OajPl770pbgihFpnfKGIUQDus+blSVeOtAcHB5/bzQG4InyB17uqrrZo43+D6RYG1OPi+G7Dqro5WBCAQh19Ak/LcQdrYpKwaKCtYHF4NmLbjEajaEJgVewMne+6AfTB1LiDNWY4TFd14KYOOOQYk5w0LWZyeXkf2iZt8t5Wv6bycguq3MI5dx/pcuyX5wcAAKTju8m8TB9kIQAwwWEcoO/P2O12N/rXaDSK9XCndcA88zs+MEdHRzEPzEuSYrr5fB7DfjDHHB0dxWfy7eCEeZAUx4bviMzJFxbYbFMidUrnNsLLXCwWOj8/j4wHdDOKI4QraprVlDvjAYKOjo42dih89NFHMUAfnZQjFKQbx93pdBppY9C1U4IwNXicn5+fRySOYoTqZwUNsmcVyqFq7h+BssLMRp1A5QxYn7jrAIwr1LYAp4l52TaRtsm7Tb/I1TkHSHyFVjeJ7VpH7k0n1dwquI7h8fSpIsjlJd30gToWKnc/fcLrkAJemEdMMa9evdJisdCzZ8/0/PlznZycxOMSHBgMh0O9++678X52VKGwuQ5l7n2TNIeHh9GcxXN4v8bPzNkQwEWv14urTj+kE6bIlRjmIhYmKCIYGbbkuvMmJjHGVgg3Jm7akq3qHhuHwGg+D6Eo3feCOuIfwXUijPs7Tf2E/H+ur2zr12kfaQMw3GyS5pWWX9c3c+V7mrp02wBYKj7nMW7SRYebnHys+tyMr9lyuYwLzfF4HOOSPX/+PLowAFy9f2OGhBkBINN36beSNnxsADbotRBC3EXFQpi+d3l5qfPzc52fn+vly5eStBGUz+PepIfN+vhIF1KpfCGAza6r74cQVp+wGNDBTFB06nRXEogWWrmqqg2qPTUx+eqK1dRoNNpgjKSbVZ7T8Kxk3bxFXaiHAyhWopKiLZ+2ZtAwSFgZ4l3vyjNlbvxznXLcVeomnW15102ETSvNbau3FAykeaXf61a728rIgae6tF4eSsHfUTqRb6tnmk9OvH6pYnSmkMkOAF5VN2ZbIu2GEOJKDv8xlAETrcf8YLUoaWNX0Gw2i7FynAp3NgbGlIUIq2RADewoygMgRniENKQCZbkCA+B5/4eJol7sfup2u9EZk7Jghn0LrfspuInBlRyACwBD2YSKwMTGPEP0cMrOMYPeR1IQUwdqcsBnG5jO9S3Pr83CoC5NbizVPWed3KbMbYsAv+ZsJuOHCPAAUD/GACd6TLifffbZxljDKdzPYAP8YzIFhEiK/jKMW1wQcBqm/4/H43hQpm8Hd1Mo+sXj6zCmXTfVyZMGNulE+6aEzjabzeJOKBzwmPxx5MMUhD0dJM5LffnyZVyFDYdDPX/+XJPJROfn53Hync1mevXqVYwrg70UQHJ5eRmdwQiuROcdj8eSpMPDQ4UQYifm+sXFRQQ+HKYGEpeu2hnfIFYTvvPEB6rb8qlf7nuO1WgrdSvD9PdtDN5t5Tart6b0Dvi21TmdGHMAzHfjkNbNCjlQ4mYpL9/r5Kv/puf1PNwslZo23ETp4AYfkYuLC3388ccRcPi2bvxKYEzwt6EsQIT7wM1mM718+TKCEHZ70B6wJ5KibwDOuwTG9B2PLCT8cEJ2PzrLwHMzZt00xPMTo4Ty3VmalbS3qR+FwmLJD8V1J9DJZKLJZBLnEt4JCyl3ipZuTmIHFNUtUvi/bfzuwuS4pEC+zT2vQ5oAVt2CxQFumtbHqJvzAbDMtR4jBtZG0oYTcbfbjeOCs/oAuhcXFxtH+FC++4v2er24UJcU+3Wn04k+mbD+jFm3TPjinHpWVbVxMvhoNIoR+7EOOHtVJ08a2DwmcRTqJiGPRQEYAHkfHh5KUnRoZFVKpwGUMFlBReJRDuo+OzuLEYjp1Pxn1cfhYjg4SjcnKJM/jNHR0VHsvO47wGTHNehNKPeUBUgnsRzLkDIGOaWagh+XbZNbChaaZBuA8Ho23bsNbKVpvJ45SrwNOMu1j9PZ/hyeX/oeUIQ+8TozkjoZp/UinfvTpGDI/yMOkGBQmITn87kuLi700UcfRSaHcAqkraoqjjWob8C8dLOrjxUpK0L8zCTFLafPnz+PcaOYyAEJ9HvMM+5ThsnITcE8Nw6/KAeeHRMToMG3qDswkW6OieAZYKBgW2GXiGUCwMP8nZrDaS/AH+8WnwyehXeSY2CalHeuPzZJjr1oGpN1oCD931Sel3XXxXHufl84pHMI390868+Rmvzoa/5M+E7i07K3t6fT01N1u119+ctf1mKx0OnpqcbjsV6+fBkZGwAJC21YSCwMOAbj40n/YAF+enoaFxX0EUzELBIwo/qYA8ADtkejUdxd5f452+b1Amxek6zX643dSdJmyHkmoaqqYkdcr9cRafuqzg/TA+xIivcBKKbTqU5PT2O+dCaoZajCs7MzTSaTuFsKh1+PT+FByjBBsc3To2DS4dwxGnDkvhJMoHXKuO0qb9vklJMcxbur5NilXerWRKG3ZZnqAKKnqwNuOSCW/u6MDtdQpDkw6atJKc/2OBPB+yffnANqukvH28gncWz3rFLZmQRIZ9cfh7EyDvEXk64m3tFoFPs/FDirUrbR4t/D89D/odsBLSxgnKl0HznGMKtn3/GBgiEv2BZAFBM+48njleA3g2mOrbT87kqQ1TQMF0zNs2fPPmeCxizh80yuj+8KWtqM4V0XLruwPdskB2rS+Wlb/erGin/Ppfc/Zxc9fwdu7pvGvAur+erVq8iIdDodfeUrX9Gnn36q8XgcN5lgasVPExDBuKWv7+/v68WLF7E/SIqmyqqq4mIc8ItjsbOb/hwsxGFyPB6TAxp2326TJwFstg2MJurvISXtgKDS3M4f0DDUs9szATN0EH73AzNRFLx0Jh/smhcXFxuKh7x9hxOAyXdkMMFCqwO8OK/DwRlgxSdP6cb2njoH51YddZNDHQi566TVdgJsAijbVn27sjVNdUhXn7ny/LOv9PxaOlnnGCFPL90EqXMgku7Y8M9puTmHYvqj19Xr546s9HUmWcSBFHS2dOUwTGylTz75RIeHhzo4OIirTKKc0qeJ/eGB+qgrdRwOh3F1CiDw+rGLywOXEUgthKCTk5NoMuI+j9njK1N/L/i4wJSw6wQgQ3uy4GD8e3BOFBxxsVi0oECYW4bDYfSdQRlyQjnxrogtxPxQ50eV9kneedP3h5bblpcyTTnw1oYJyuWb1i8d57k288WuL1583MDSrddrffrppzGwa7/fjzHO2PzBAoK5nd2BLBIYFwR2pHz6sfvwOMsHyGY8kZ764neZgkT6J4sPngu90yRvNbDJTczp9Tcl3jGlG2Aj3cQiANm6ndrBB4BCugkQxiTondZ9WDzegDtjXV5eajwex44EAqYD+kToyoVORD5Q/Q50fFcF11PfCgcxbodP/+dWNXXgI/3c9r1vS7etH+XK3bZy3KVuuX7tbZSajpry8fycHfG8uZaaezw9E41Ppih7wM02hqppsvb+EcKNj4lvd/bdQ54vK0MmQcYVh8ziGMlKk2CRvgORA1xxZiQwJQwQ9WeCpS3YMs3CwxU9Ezn+NiGEqBw4adt9IQBB/pxpG0s3MWVYtLCgYaXNCtvrjW9RCGHj9Gfyh5G6vLyMZijf3v3s2bNovuOZmVcAUumiJTcH7qL4PZ33l1x+uXtI47+5tAUfaXl1v+XKqJNcvdJxno4TfzZfVLh53tMwnpjfPYp0VVX6+OOP1el0orkS8A1TeHJyomfPnkWWnrx8Me1lYx4lf0D4y5cvY3ry9j7vYQcogzQev4k/9FyTvNXAJu0cjwHQuDj6ZGJGeDGgYe/A+N6wUmOiTM05dBYPlc7EA7DxKMdMPnRg8vatrr4F1SdIUHduteIo3Cfg3GDPDeiUtXHJTT51K6X7lDagpi5dOtk13U/6dNLPAQE+pwojzTu9L534nBnxa2528nzc7yVXdwflXqdcuV7PnGKiXs6C8AwOuOmnsEgoeXee9N1ROAOHcLVFfLVaxVPDJUWg7xPs5eVlDKQHOKAsd/LFVOSrXOrDs/t5b4xND/dAPVgN4+NAWih9Z718LuDZMZVhdvLxTb1Ho5GeP38eFzgOAr1+rMI9qB+s8suXL3VxcRFN2CyI6hR8HTjYZfzUzSMuTfPAbeeIOjCWq3tTvXL1z42LJiDovzEGvD4+fzjIhDEJIUSGj0UrfcC3W5+cnMQAruTV7XY3/MwwSzEeqRemJtwo6PfoEcCJm0CdtfUx5r/5sSU4F9fJWwFs2iqubYPqTQodUVJExXRAX6HxYlkh0+l8UgMUuckHBAx7wuQEKPLOx6RFvZxJSVdd0ubOjHQVka7++XMGAOaI8nLgpWnS2rYaagIQt3n32wDDtrK31amunFzaFBzwm09idek9bXo/7z3Nk3SeH2Wlk6bvXnKFm6uz+wZQLqZVL9OBF/0nXRmm+Tiw4lk4nBHzEKZYzLKsJtfrdTwH5/LyUsfHx3FRgQ+a+6MwHqm/pBiwbzqd6uTkJO6AcmdbFhmpH40/lysK95+DmXWWzMcWJqoQbs728bnFt3kTL+T4+FhHR0dxQwNpfWHkB166TxTjmXZlR42zuGmfyvX/bdK0QNhV6Je567uMy4eQ3GIx9+x+zU37/FY3zlNfRt8WzvjgNzaEEPjys88+i31rPp/r008/jcyfm1kx0WIyJY4ajsk+3wDY8ckh/hkCs8r4Yhx4jB0nCXLy6IFNbrKtS/MYJYee3ZGYlZ2vSKGqsd87Re8RUyVtKADS+XcOq6QuXHd0TJ1S3x8vw1fydC6upwOOe7w8fwaf8NyMkWu7nDQN+tx9dwE5t8nnNhNxOiml17aV6eAjN8GleTaV73m4KYTrbppM73EglKtXukJFaXpa73/p7/ynTzn4p16+OmUSpL/ymUkYpgXGpt/v69mzZ5K0cRQIAAHnRbaq4kvD8Qwedfj4+FivXr3S2dmZzs7OYnA0Fi3elrwj5gRWpc7ySDdhGAAxMFLOznKPn8DsZ87ho/POO+9EMIPj82KxiLu9JMW2BSTSLpi/fHNCrq/dFZy0AUY5AHXfOiEFzrnfkdwYTiVdlOTmljRPn19TQEZf8oVsWk66eE7Nz2wXB6ycnZ1t7FKaTqcbZ0bRdwAe+/v7MQZUCFfBAT/++GPN53MdHh5umDdZDNBH/KiQ9KBZgBnRlFnoN8mjBja7ds7HBnByA4zO6UCHTomknTiEm9DoHhHSV7aslkiDUJY7bDnVjI8N132wuWki5xdD2Z7WwY6v3h3k8Ezp4L5Ne/pvt813F7lNn8zVIa1nDrzkAIozFN5/0j6UK9+BR5q/076ej4MKlHITI+SxVXzXE5NpCvJJSz8EjKTKwf0JKFfSBovoptqqqjZ2+MFyUq4/o5thx+Nx3LHEb+TB/fgf+ETM/xCugtZxbAE7Oc7OzvTOO+/E7eMAI6If8wwwOn7IJukwX6EIOKGbHYuYhtg2yxgfDAZ67733YtDAwWCg4+NjPXv2LLYN5jSen3Y6OzuLK+7Dw8ONKLOTySRGfs4xHy6p4t6Wtg6c142lujzShVRaH+6vAxZtxnubhUNOcm3hC+G0jBSgpOWlLI6npb+zGGAXK+POfdiWy2U8xgTfLPel4jf+ANKDwUBHR0exz7948SKe6UaATEy1MJMsGnq9nk5OTiRpI+q2O+DT52ATm+TRAJscUk1f3mMDLm0lZUqcuZE2kbQPJnxh/I8VZzpw0/z4753dPzvAyrEs3IukzIrfm/ufAplce6QKbldwUzcB1P12V8lNjm36ZBNgyQGypnp7X/B0bq5Jr3u/YIJDKad5OshxMOOmJkCwt4GbSj0PL9cd373fuek1ZYa8j/DnjotMxm7O9Z0gDtZTh3c3rdBOhD/wQy+rqoo+MlVVbcR5ItYLjvic1wOI+O53vxvBgq9OMfe4D0y644PgZexGevXqVbyGOelLX/qSTk9Po6+LnzvV7XY1Go10cnKiL3/5y6qqKrJK7qCJ0oDBgfGC8U3fO87XL1++1NnZ2UYbp7JNaecU9C5ym/FXV78mgJSmvY1sA3fp9Trgk8s3ZXJ8TvUFR6oreKekY0xxxhT9zVnRs7MzffbZZ3GR7XUAGPkO4MFgoNFopIODAw2Hw8jejMfjDaAF2wiAms1mkVn0gJs4tzfJowE2yLYB8hTAjZQHDtLmGTvuQOnnLuHE66tvSRvsiU/ybjJITUz89zKdPUiBTDoxeXofVH5fuvr2NtkF1KRtedc0nq5pRefX2va/Xfpp3eSaAqAUsKblORBI36N0s6OBVVruPp/cfEJMzYmAGerOCjBle6qq2vAP4Xm53+vldUXpejRTd4T3doG1Sf/o/3x34F5V1Yb5Ckdeoml7CIW07rApOBaz04pYHR9//HFkMr773e9Kkp49exbHIgHHxuPxxrlW0lW8HZ4Rev7k5CQCjqOjo3g0BLtWiETs4NGPbTg+Ptbx8XEEayEEnZ2dbRwBEUKIZ129ePEinvHDfEJbYKJ49eqVXrx4EQN71o2XtE/n0tWNlaYxtO23dB7aVocm2TbufU6sG8v3AYpyCyLXE4zRdEHg5k4fF6k/HmCYPH28+S641WoVfW2c8QfYs10cVtF31eGL447+1IOjTvzolNFopPfeey+apli0HB8fN7bXowE2uyiNt0nS50pX1DkfE/e3SdE19/gqNXUo9M8peOF3V44OqryepE0VAuIripQ5yrEKpGtiJu46ATRJEzhuKreO/dnWX+smIwcc6crKJWdaSk0xqX8KCghl5W0OUGFSA1xQLn0mtV+n4IhrlOXbrdkRwYTKPUym6bPA1BBh17+7WcsVFXVwdpD6SNrYlu4TJ33ZfdpSNsd3mpAHTBKf8Sk5OzuL/R32BZ8Tj9p6fHwcGRrpZsfTcnl1WKGkGDcGBfLs2bPoG/MDP/ADGo/H6na7ev/993V4eKjFYhGPhUCIOUKcHgAf0WWpYwhBn332WVRMHFjY7Xbj+VCXl5c6PT2N7xF/pKqq9OLFC718+TLGQUnNH6lsG1tN6Zvmil3KS6+9jrln2yK97nodIPK5k34tbS6WfTx4u7mTvt/jeTNuWCyQzk21sJUE25O0AXxxJl+v1zo+Po6LB/xriI3kh8R2Oh199tlnOj091XJ5dfzIu+++q/V6rQ8++EDHx8exD1bVlUkUP7g6eTTARqqn5uq+vy3iSssVv1Rv0/WOR8ehs7EKTtOlkzSfc/Xxzw6YvE7UNV391A02/8uVl5abPnNTu92n3JV5qVuV1aVBckAlV54DEpSyTwLklbJhztSxg8AZC96Nh/L3SMBeLqYUFFtquqJPerwJdzR0EMV3PyTPnyWNW0G9AEQ+4ZNW0oZJ1vNM/WdI447E/rzk5e2VMkipUybsDj4vAAi2TmNeQgERCLDT6ejk5ERVVenTTz/diDGCH82zZ8/U6/V0fHys999/P4Ki999/PwIeAAUOz/1+X+PxODoss9MFNujly5fxM9tscZyGGZNu/IRms1ncWYbTNL59n3zyiV69ehV30NSN+bbsRW5euQvIeBN6IvcMt5VcW+YWx3VtnrIwPn+nc7unc+d7Tw/T6LsUAT++OMY3Zzweazgc6r333tO3v/1t7e/v6+OPP46HMcME7u/vR0bzk08+0WQy0dHRkZ4/f673339fVVXFLefEl6Jeb40pqm5V7L+/7ZIiaT7nJuJ0UnC6MWVbcsCENDm/mxSE5FgF6pvW35/DJfXPyd3PtaaBmzIb2/K7rbTNa9tKL7fK4nqbPpvSwSmr5myDtMmm0JZMSs7MkNaZCspJ/XHS0OeAH3co9nr5dwfZDrpQ7FVVxZgUg8FgI7AW+fA7352tZCXI86SxXNL6+ATt7QPwSB0s04mf9F62LxQAV1Dp6cnHfKZNWdUCAnCkBGwcHBzE/Ny/ptvtxuBo4/FYe3t7Ojw83DhZW1L06YElkxR9HPb396MTs7fHYrGIfgv4zEDzV1UVV+YwT/g78F4+++yzaK5y5dY0prx9c781Xdu2kNimO3Jym3vuW5rAHtfSuc/nT++TKXCRPj8WPC/3vUOc5ScmEv2KceBzEtfIv9PpxJ18hD9gTJyenuqjjz7Su+++q5OTk8h2fu9734v9s9Pp6OjoSB988IFOTk6iaTWEm8CYAPac76bLowE2dSj+sUqTsq2rew51p4orp/jdMTItM03rZqDUhOSrZAc9qeRYoBQE+aBKwdguE5j/1nTfY+8PSN0kk3uGHBhK+4S3CYDB0+d8mFJ2hf8OfgglwI6WFBx5XKQUgAMw3KxD/byefh9RQ/1QRvLCQVG62bUBw0J+gC1/dmdn3LTmz+6OkVzLjQ1JcdJ0cxsgBeYJsEi4Bj+SxM0DIVz53nQ6HZ2fn8dVKruP2FHiCxSCA85mMz179kwhXG2ZlaTnz59vtBFgBqAzm802gCP+DaPRaMNXiTJpS3a4YDbrdDrRnID5Cmdi6WouevHihc7OzmJedYuVNpKClqa5LZcml65ugbUNSLSVHNDaNvelsmtd6vSD92HGXJrWFzy+ME7nGK7l/CbdlAWYob/SD1gYcR7bxcVFNOPi/N7tdvX93//9Oj8/1/n5+QaDij/Nl7/8ZY1Go3g2G+ZZ/L7cR7BOHg2weRukbrWwq+Q6Zg5MeAfNMS514Irfue7mCCQtL8eYpCvZdEDvAmp2bZddfrtPuW39m8DXNlCTm+QchKbvMzVD+vtJTSzOMKTghN9Q1h5UzqNXO+DhWUiL+ajT6WwclOq+N6RLt2jiC8T91A9gw6Tptn/3E/GVZ67/um8PAMyZJG9zJnTalb7tLJIvCuqOGnFQB6PD/ZKigyTvEHMPW1kBHezOWq/XGo1GGw66sCuAROpBULT1er1xVhUgzNvi/Pw8OnmyzZtAn+x2IhS+s1bUn226ad+8L8Dg1/zd1v122/yRpoXqtjzr6pfmn6vvLuWl83GuTJ+XJW04v7OYdaDjjCW/O3DOgSDvyz7fMA7w2YKlJNowoQkAMphn6ZuEIdjf34/HnOzv72u5XOqzzz7bOPts23svwOY1yraO3TRw08nDFZmnTyeY9J5cOW3Ky4GsdFLL5betvKcmTW2RAzAOXpB0onQGx5mKqro5HiOXJ58x9TAhOCMBk+LlpEABYOTfmRTdN8ZXjExeTFxMlICdEMLG8QWwRAACB1JEApZulLpPzimIp62on7eLA/xUQaQrXNo0Nfu6Oct3K7rTcgghBv7zEPL43ziY4f2wq2o0GkWfFgexvCsO7/R24f9kMomxPtbrdQRO/X4/MjOc+O3HT7Bjam9vT+PxOPrQOLCBvWEFnZr1to2BtM3bSjp2XLk2lbOrtKnXNvDVpi67sDppurpFULpoTedlBy+kd5BPmzqYTxdJqcsEO/EIeYAJk4UKO6QA3YyXs7MzTSaT6DjP2PdnDiHE7eL9fj86K4dwFfvm8PCwse0eJbC5Tad8W2QbCPDPacdOgUTaydtOMun9TWWk5TStbNLf7gu47Loyq8tDareT6SEkbcNUwabpnCVgAnJGQNJGwDwHI24qqqqbk+P53X1a0gikaVv7rilneAApTGqeBraGQxM9H+5zEEGe7ISi3y+XVydND4fDCILI35/XJ1z3cXEw6IxLKukK0AGkr2qdofHVr4MhQKDT5e5ADVDAsRrgQzrey3Q6jaeEA3hoOyLAOkODYjg9PVUIQRcXFxsxdTBbEWDt/Px842gIGKf1eq3JZBLvd/Dj5/2kfkf0nVTq5rIm2Za2bv7j2q5zRZv06RzpoPo29267r6lOTfemYJN3mgJ30ubK9LQwMf683vd9jACQYf7oY4D2V69excUU0bgXi4Umk4k++OCD6HzvJ9Kfn5/r+77v++I8s1wudX5+/vbsiroNkn+d9bgvxdqUZx0oyTEkaedMgU2OeWlq4xwYaQPC6qQOqO0qOdaozT2vAxy7Ukvfy7Z6pNdTvxpP5/4qTCLSzY4X+oCzMyGEeBCix5lAQZPOTUo+0eUch1G63Le/vx/ZCCYzPgN6MFEBSHyF522XHjWAWcuD2dGmfPdVJm21Xq83lLSzNO7gK2kDYKHk0wncn0m6AU7UhQme+uAIiVNtVVXRPIczZFVVG8CTlS/AYTqdRhPSwcFB9DXodrvxTCs3L1VVFd81PjN+/g59hlUuW8Fh1QA2BFwjSBpsFG0GmPHjVFK5D7ZmlzlqW5kPpVNyY9XHe9Oc17YNts1hDiykzzM1aXvX1dX93VLmB3GTVQ5EUjYBHTudq7ADfKZvMmbcf4uxeXBwEEH7YDCIju0cwjoejxVCiIxkkzwaYCM9DqamaVDdd/1S9F6Xf27A+G/eobcN+rrB17TaanO9zaTVdrXSpq1zA/ZNAON0lUM9ciwMn1OGA/CCpKYkwIcrVMR3Cfkkw1ksHrwOhQQg8fzZ3u0skXRzCr1HBaZ+mKEo189wAdSwTROljK8NwMvfHfmzlROARDvxu9v+cUz2PEiX7tbyd5GCIYCJOyhzHRbGj3pIzXspm5PuGKHeXPe6+XsN4SbMvAMYosBeXFzEVbArG8DVZDKJ7y23dR3/IHd2BkgCbAA5vvr3ZwKAeb1zc0/a95uYlqb0uXS537ctFHP3P8Scfh9p2qZL5x2/nqZLr6f3eXwn5gt+Txdu6bxHX/KwCCn4I74NIIc0mEj39vbiUQxVVcWwBdPpNDoRI0TYrpNHBWwei2xT9K8LgOUGXl1HTifHpkG7KwBow/g05b0NmO2SD/VoU+e6wd1U1l3ebW7y8N8cFKTXHPCwEpe0obg94nSqMD0GS7/fj9t8mZwwQ2DvRsmioGFeUpMXE5EDIX7jQEWuU2cHL+mJ8O73wr2AHvcBIg9WkcRdcUdld3R0cwrP68cW0O6+pZWyUwXpC4X1eh0BBvVPgST3kzYFA/57VVWx3Xl/Xh4UPqAJ8IipCUZmOBxuPBPsipscU6dPAgv6kQn0w3QrvG/99mdJWYHbgIe7AIq7LmjqFpLp8+w6d+ZAVts87yJehs8ZiPeFdIFVNy9732cuSPP333wx4eJ5+/ELgGv6NeZPd6h/+fKl1uu1Tk5OdHp6qvV6rU8++SSO9fPz88Z2KcBGeV+W11FmKjkA0bT6r2NActfrJpemVc8u7dJmddW0UttFbnNv20kl9w52mZDSZ3TF4ivnuvtS9gb/CFf6OJ46o0AZ/X4/hsonLelw2gUwuJnKTUGuZJkkYWC8Xpw5VFVVBCOp8y6TmnRDdbvCpByu00Z+SJ+zE6wqAW3OPACWAFxsb/Yt7YBDfz/pFnFpM8il+5SkSj3tJwALNzX5ipbQ8Kl5xx2t0/9u7mOlCijB7AVoccbNt+h6+zobk5oqHdBQT8BXzvyUjsVdxnjb+SQnqULextY0jeEmsLLrfbssknJp2ywAfaGQ9uW6eT9X11w+256D/lAH7KXNOFn0HY+D5HMAYw8fOvdB63a7mkwm+uSTT2Lf7ff7b+dZUa9TtnW8h2JmtjEqdZJbJTUBk7b57AJuPH0TOGtT/n3Jrm3ZJn2ujbeB0dzkVDdh8b2OwUHB++F1KHwPyMZuFjcp+Rbs1GmVa+y4IR0MQbfbjbsRmExgZ6hPCFe+JAAfTFCcZu1B+AA2mMCcbaLe+ApRPtfYDeHK2ic4ygesDAaDaJt305q3sytoAIPv/sgtHNJYONIN8wOYIz1gxFeyvvoF8FAXPwuLOuBjQ739OXHGBqxRhpuHeOepjwR9zNndOkYGpkva9EWqWxDlFG/dmLmr1C30tjFDt513Hvp52oq3fTqf1M1Xud9z+To4SeevurxTZ/y0PF8kpWZR7qWP0bfxdWNhgy/OaDTS4eGhut2rc6K2vYcvNLCpk9fVeesUbBN6bsqrbZn3kaYO/NyGHk7zvA/gs61d69o+B+TqpG4VxP+6SdXTuMLx3UYOcKSb2DX87kHseBYHKJeXlzHwnTvAUo/5fB5BQGpacXEamvzZdgy9jH0cnxnyS6lsAAffUwdmyvc0/X4/xrtAibtzNMcL+ITou4wcjMGmOGhITUv87u/A35uzTqmTsLdZjuVxUxV9whkRQE+6S8tBHeADMOf+DF4PABn55Bx9HchIN/5U5JVK04Io7dsPJT52mpgJ/7/LmM4BpV3mI2dB0kVNG7ntgjd9zlx75J4nBaX+2fuWp0vZGjd5AvKdtaEv+dxGOuYk+jaO9u7MLykykiyUPAhpTp40sNmlQ/s9r0Nuy9bU3ecd8C7lbCt720BJy20DJtpK0+qr7j1vW6k0rfjqym6bn/udpHVJgQTKy/0pULjOuvguJlgSlKFHooWRwITkyhEFzyThyhzmg8Me3WnWY8K4EyqMjUcQZiW2t7eng4OD+PwEjXPHxDRWCvXxYH8OPFIQ4uYdAB31JRIqIITnpL1oO95JOnmn25p5J1x3c40DOr/P28x3gXi/SIEEbUQ9YNdSPxcvIx2brnAcBHn+fi2ts/vwbCvT26xOWd4He+LSBni8KYblNuW2AWFNC8gc8PDr5O/3poAlfbcAjlxZqZmyDmizGJG0EQ/J0zjA8fr4JgZP7+bjnDxpYPNY5S4KvunepkGRAzy5iSm3Cko/N9UlN0ia6tH2913a6zaA9q7ik5L/T9Okn32ycXbAWQwP8CYpAhaU3eXlpSaTycaJ2KQj2q87Dy8Wi+iHwg4YZzoASM7wOKNAeiY9QBfAwX1a9vb2NkxQ7jCc+nP4TiHKdWdfZ4/SWDjOCpEHzsPkTRvCVJFvHTAnP8pLfX2on79rgBiffXInX3+OVAnw3QEdJjo3Y3mboCzoP9yfroxpdy/H6+Hp03qlfTenhHL9fFfZdW5smmPue1HXVtqmzc1Tdc/fNE/nJAXVfE7BTa7OuffrdUvHTMpMpuOX8UM/lW4OlaX/ugMydcEnEODDfMSCp0kKsLmW143s7wpuUmnqqG3zaLq2bcClg+02k9vrBiO3kaaJrm6llH5O0/pK131C8Kc5ODiIK2xoWHxMAAqkhZ3wvPm/Xq9j1FiYnNwEmMazcAWfe2bADIc1AmDczEX8FumGfvZdV3x3u7xPlOTr90g3Pi79fj/6GznYSc15g8EgOh77ZMk7SHcSpW1I/rwrZ5N8YnY/mtyk70rD/X6or7cLJr90+/p6vY7t4myegy0UiL+LnJnJV94+lr2tHTjlgE1uscRvu4ztXJ9sWiTkvr8tUsdw3UUfpaC5rty6e9P/uTnex4D3j5RJ8v9p7Jlcn3EzrbOUXhbjqEmeNLC5j85+1062LW/p/kBVU36552iL+uvy3FXeBJOyTe7rHeTa1hWkD2LS+5/XRbphTThjZTAYaD6fazqdKoSwYbJi+2+qzN2UwWocRe6rJ5QtTEtVVTFvB1MEzHPTD0AEJohrmJJQtmxPXq9vtnamIIW6uKKvqpudTtTRV3vur0N+2OeZ/NIzbwaDQQRCHnTOlTX385/Vo4Mcf5c+0bIC9Unb34V0w7bwOR2f3Oenbvs93Oc+PrxXX1Gnq2Fnqrzfpb95HVzppExOKrsq0tz9bZjn3ELuvufTNK9d8k9BQNN92+bFJhDXNNe3yXPbfJyyKE11dtDufShdEHC/z4npPJjOAZI2WOG3KkDfY5CHGByvo8wc4q8bEK+bnUrLv+29uWfKgYLblOMD8K4ALPcu0tUyZfkqB1MJgAYFvL+/H3cEMKhhbFDqIWye6ZTu9EEpYp5B2cL0pEq4qq78YQA7gCIOVyRIHGAC5oh8fNcQDBNHLLjS5cDH1KHWV4Hc77Fr8J1h9YaJhVOqafOUyfDt8ekkDMWdmo/cwdmZohS4pvmlfjQOClImJ5cP7yLtM55nWl6unJwfTTpu0jqlfdmvp4DnvqStskXajtM2814uTd19ORDqdXro+bXNc+TaJVfn3LyaPl96D3mlZbkvjoNgHzdpPmn56W8+L/C/rn4urYFNCKEr6b+S9N2qqv7JEMI7kv6cpB+U9NuS/kRVVS+v0/6spJ+UtJL0p6qq+ktty3md0qaBnqI8xHO3WSW8abkNNYvkJrOmwZ8DYA5w/LvnxzUAgQMcX5Xjd4OiRvlzoq4raHfE9W3QsCbEhAAcuJMtu5Lc7OK7n9iV5I6tvspjt5SbmWBUJMX60AZuGvIYLgTxSyc6PvMsmKZ8InWnZyZL2h3TnbS5m8n9i2gbB4juDOlAoq4vOFPjIILrnr+DDe8/vPttCqZOuaYgh3uoewpYHBinz5NKCny4/z6kTT5pndPrdfk+tsWf1+O+FlppnttAT3pPrj6pyVL6PJAnbZouZQr9Hp87mA/4zet/n6aof0HSb0o6vv7+M5J+paqqnw8h/Mz1958OIfywpB+X9COSvk/SXw4h/L6qqpq5o0cqD9nBd827bQdvk27XgdIGDD00qKmbUO9y/13LT39PJ6NUyfh3FD8DGkDCwPUAeeSFkue03Mlkok6ns7EjCcbCd1cBDLiOQsaJOIQrJ2XClvs132qe+lkQxRYggjPzcrmMYAyGhRgsdYyCb08GKPmRDLQN5TgQoG2ItyPdmHv8KANJG+da+RlZOFj7bixvPz5TX9+Z0bQi5ZlT842DAUCVT945psbz8CCAqTjzk/tO+TmzU07Z566n0nZ83QU8pPf4XNeUX6pMm/LxdNvKv808mssnBY91Ulf+bee2unqkZTSBQO6rY1PqfP48z9S3xsG2LwbbSitgE0L4mqR/QtLPSfo/X1/+MUl/5PrzL0j6K5J++vr6L1ZVNZf0rRDCNyX9QUm/2rpWRe4kDwUwHjMbc1fJrSiaZBs97WmcofHfUJgh3JzLgsKEgZFuglchRP1dra5C6XtAPqd9UdRMDkw8vusJAIOSdlMLwMfPiQrh5lyh5XIZgRB+N94egBOPQZGe68RRCtzvRwLQNoAChLZxhetnI7ELaz6fb7BJlEt7wAj5jqL1eq3pdLoR1Riw5OU5oEodiNP29nJzQCNlY3IOxtQtdVDOAQ7/jbrVmZnqAJn36fQ5vG/vKukzt8nLx1b6eZdy0891wOU+F1B1n+9T6vLNzUnp4it3Tx2AqWNe2tbNQbybd308kS/jyuvrrPG2stsyNv+qpH9J0pFd+6Cqqg+vK/xhCOH96+tflfTXLN13rq+9MdmFfntdFORtyrnN6uBNU6pPVXKTbTph5piadHADIFA+KG18UjCroHwBJQx8QAeKmdWNgyFABkKcGmckYHcAE348gvvrMAmxqiLEP747DhJ4fp4BRgKn3fV6HYFR6vfC/e6IS72crfEt5vzO81RVteHTg28Q6fAXIsCgt+FsNott5tvc/V15uwNU6QvuBO2SA7/evrRX3SqZ9ylt7rgibQpiUmCUps85hzqQrGMEtn336z5OPL9d5qY6YJLmUwcktjEOpPH/254nl+99zrlNAKytLsjVN/dbEwBL09QBJv+cA0CpQ31deT7PcL+bureZoaQWwCaE8E9K+riqql8LIfyRrTlKubf6ubcQQvgpST/VIr9bS1MHfEiFXzchPRa566rrdcjrqON9vqdtExoAgXJZsfghlLADnOXkwe7cGddNEH7Qoyst2BTfJQVQIB+UvwMBV36wMgAC8vQ6u+8L/jZeJqyRn+mEzw6AzZ2fU9MSjBMO1cPhUNLnt5aStzNXPKOzM+5bRJ4+WTpzkm49p1xnknJ9iLpLn3fWpQzSOQjit/QvZa2aVtUpkEl3P1Gur5Bvyyo0pa0DG/cpbdrgIcppK3XMUu66g6q2oHHXum6bn7ZJCiRzC7qmujuAdj8zBzApe+NjI/VLa5I2jM0flvRPhRD+d5L2JR2HEP49SR+FEL5yzdZ8RdLH1+m/I+nrdv/XJP1ummlVVd+Q9I3rB3otKOB1KfJtneSxsEK3WV28DaCojdx1kG+7t2k16RGG+QwLA5OAkkeBw0y4UvLv0+l0wyRFYDoYIJ9ILi8vdXh4GHcVSYrgiDw5o8mBFKdc+6nbgK8QQmSYAFwOnqbTaaSROQsJpsXbAcbHt6y7v9Hh4WEEWQAeYvN4XQggiMkKk1N6jpbn7VGE2YXlq0fa3J22+d39g3yXlq9Q68ZbymSkn3N9iL6RU5opGPN61Cmfuj6/6/VdpU757yK3ZUkeci6ry7PN8zal2bWd2rBQdfd5u6b/077t9UvTpPX2PpzmmY6V9Jrf1yRbOZ2qqn62qqqvVVX1g7pyCv7Pq6r6ZyX9sqSfuE72E5L+wvXnX5b04yGEQQjh90j6IUl/Y2tNvmCSvqzXWe7bICk9ft/yEO2QG7x1K36UPkBmNBrp+PhYw+Fw41gEV6rpYYgwKLPZLH6nDOkm7oOblFzYEQVQSU0iHIdwcHCwsQsLHxt2ZwEW/FRtdzrmXo98DIMDYOL5MJPRRoPBYKNNKAOAVl0zS+THhOiMEQwN32FpvG1Xq5Umk8mGaYz3l4IhnplTht08xv9091uqJHLgI/V3yU3q6edc2tzW7fsAEGnfvi/ZlZHIpd8FMHi6Xc1hd52zc/dvA0EPLXXPkzOz1fVFzydN52PA06c7AFMTaq5Pk/82cHOXODY/L+mXQgg/Kel3JP3x60J/PYTwS5J+Q9JS0p+s3tCOqG1I/iERu8tD5O8d5D7yb9sWj5mp2fV9evq7TFY5diYFZjlgw1buw8PDeFo2W7Ex0ywWi2j+2d/fl6Ro7kHBo8SpA4p8Pp9vbGX2FT7sC7upqBfMjcelAbTwm295hgnxXUO+u8dNMfipAI4cVDg4QhyMSNooFxOYpGgCo53J38sGFJGvn4btPkAOgngf3JcCRwdvOD078wW4cfaG5/A+4QAr16+4N+1faR5N/bhu9f9Q43lb3ve5cNl1vG9L0wQ0mtp32zPdZp7xe9rMb3W/ef9oaybMAeg2ZXl52+qdAvFcH5c2/cNyTGUqOwGbqqr+iq52P6mqqs8k/dGadD+nqx1U9yp3VUBvSrZ1iLoVyK4dqU261yGvCzC2kYdsl7pJsGmCQ9F5EL7RaBQZCUkbu4PY2eNgYLlcRhZDulG4mFEw6eBj42CHSWS5XGo6ncaoxbAeTDQOmtKjDgAgmHwQGKX1eh2db3kWygWAMDl5RF/qPhgM4jECtNne3l6MukzsGQARZiPanCB97IiirTkwlPT49njgPvdJ4XkwZ/Ef0MJzAJx4Fynrla5y+R1/n7oVLc/u96X+OOn/Ouq/CQDlFF1aj9vMu03MSlP62yyuttUv9zxtFXyu7Fxd69o/Vdbb2vah58027ZyrY3pfjpFxSU1MObOYg/o61q1u91+TvPWRh+8Cdu7Sge5S7rbVFWm2ld82bZs8biPbQEPaWbdNSE0T7tss6YB1sAA4AEig6PDZAEQsl0vNZrMYHM/vPzg4ULfb1Ww224gpA3jAYdi3dGOmGo/HkbFYLBafAxppJGNMML5NHEbDD1C8vLyM27wBNrQB7AzAxn2AQgjRNAaYc3YKYOHxanq9nsbjcWyT+Xyuy8tLTafT2F6wK0yk7jDNVnOAmIMX361FvdyMRR3wIeL5fQeHM1OpMkjBStpvYLpou1SJNCmcOkVTR+Pn5qWHXEjeppymeaZtHnXt01Rmri293e/STtvmvPta0LfRN23m3CZWy/OqA3D+vpoASwqIdnlvbxWwqRuo21DyF022dbyc3Fd7Na1G2g6I1y33UW5uNcJ3V2Cpj41/xxTisVVQsoCFwWAQfURQ+u4I62UNh8OoiP1Z3dTFyeDk78AK5gVnZgAI7BJKlzxns5lms1nMm23UAAiOQXCFz6GUzjClDsuz2Uyj0WgjQrIkjUajaPpxkxr1pwzYKNrVYwZRf99VRnvRFtLNlnh2efm7BrR4rCEHp+Tl5ibvF2kfagIw6YImd53f/H/uN8rcVdE/pNx2HmpT912Az7aFY5MybmIv2pb/uuSugGwb6EivN/W3XB/OldHGefjRA5sm6m/bPQ8pTUzDNrlN/e7rmR7LAGs7Ee1S37rVzq6yS1/blo8rKQCHO6CyewjWAyCDEsdnJYSwYS5C0ui3Dgw84i5/1AcFj0J2Z1lJ0UdlMplE4EB5sDs+NnFe9u3k7FaCUeL5KQOw5M8PGIEZWi6XOjs702Kx0MHBgUK4MkWtVqt4MKikjcM5PbIy7cLJ34AayqdNMGU5kPH7naEiXRr92M1nmLZ4Ht67M2r0sRzrQls5y1MHYry/tf1epyReN7jx8fE65aEWcnXX7lNyfSVlQ3Jy12fOgZIUsKTfc6RD3bNs66+7tOujBzZ1D7sNUT+k3Bc12DafbR2yrlNsmwDvkz3JrTJ3lbb31tV/G2N3X4BlF0kHuIMbdvwQu8aV2OHhYQQf7qfCjiRYF3esxekXMw2B8BDyr6pqw2yF30kIIYIcgBR5eDrq4mwQCh1WB5Dh5i13cK6qm9Dp3i6YkA4PDyOIwVH45OQkPp/7G/m2dOnqPXO4JgCNZ3fAw7M6sMEXCWYJBifd1i4pmhBxFsa0Rxv7PX4SuwMm8k/7pgMrnqlpheuKpWlcpJL77XWNjzfFTLQ1tzTJrvNcGz12F2kCN22BcJ3cpa51emlXVqzuc508emCzizz0gLwvRgB5Hch+G3hpAgBvQuomjG2Da1udH5pR477chJIzO+A3gmkJpQrbgKMr8WTc/AHocNACAAEIwA74Vm73l/Gt3fy5My1Mg29j9iB3KdNxeXmpfr+/4S/i0UJ91xAgxE8W5x3h4zIcDqMPCwzNdDr9XJ6+VRzQ4uY92Bp/Jj/WITVL7e/vR0fjxWIRTWuAJ/x7BoNBZNbIv9/vb+xEI1/3KfIDOSkz3Y7voIb3ne6a8t9Tuev43ZUpva00gbGHLLNNmtuClrbP0gZ43Eba5nWbPpIDF7dZyDq4qcunzWK+Sd5aYJOugt90mbu84Nt0hLSstnltowPbIOddpOn++1yd7Pr7Q/aRpn7ogMbbxmOq1G2RxqyEIud339mE8vdw/759m23kKHEUO6yHB9Tb39/fiH0DCHF/IAAXph331+EZHHwA2vjMXwghmo9SoFZVN6Yt0sznc00mk9gexPDBLwkGxx1+aX+2g/O7rxh5foAHbU67wvJwnXpjFgNI+fZ3N2u50zVxf2gvdyx28JubW7wPOQjyay5vGtw0zVlvQrw/bJujdmGNd7mnbXl1i7j7aMO2FoK2LN9DgdK0DXZl3N5aYPOmZRd67rbAoQ6QbOtMacfcBfzcVna5fxdq/DaTzG3qkLb1fbVHTlHlHIjn83lkLGAm+A2TEErctz8S08ZBBErWD2/0gHgAG5Qs1waDQWSG8OXB1yUFTX4cg5ujMONQHswGzIizF7RPqpgBEL6bCkdnghHiGwQoAVRJiswRcXp8dxht5O3mpjYcsvlOn3AHbcrx+wFCADdn02hHWCrq6lvFaVu/x99z2od81ZuTNspyFwX2UPKmAU8qqTmnzdxyX+1023zq+od0P+ajNr/dpe4uvuio659tynp0wOYu6Pd1SB3D0dSBbtvJtnWwXcDNXctryvOuoKaJUdqWRx2luytVehtwV5c+BTW+osek49FqfacOChiFiQkGkwhKG0UIGIKNQBG6s66zL6RzZ2VnMnzHVVVVkTFxEJFum0YANh4h2cEVLBO/+XZpV+Bpu/hzTSaT2LYcwAmwcVMOYA4ARls4mKM+lEm9aTNvUz8CY71eazweR7OfH+/ggIi0OBLDZHHdTYJ85jndH8oneTdJ1bEG98Xe1I2J3NjaNnbq0t11Zd6Ud1PaNmnaMim5+2+7wLqt3Gc+OaaoLv82YK/te6nrGzmwue15Hx2weQyyTdHeFkXeN2CrAwm3Kec29a/riLuUcVewt42ZekiQ7IOxCeRgivA/jymDAkfBoYxhJWAoWPG7L4ubcfx8qP39/ajoUbquJD2gnJtwHHyRlm3c3Jduu+Z+6kg6B2E4RyMAOXZF1ZlkaAfEn9EBHWwMZRJXZjKZRPDhAQR9Kzh+SG4mS+cA30oPaPKTxT36sm8Jr6orR203K/p7If8UzLkSBSzl6pWbq7aN022S5lXHON+FFdhW7kOkr5MmUNhUbpvF7LZ0ufRt7tkVzO2SX9M7v6vsqltTENO2Lo8O2LSt+ENTmPf9Mu+S3y73v0626z7Kuu/JcRdpMtndhsFJ7/VBiaJ3Z15XlihflK475aJ8cWoFDDhTQHqUKGcYYWbxIHTOKrDrijoBQPgDeKUxZtypmHswP+G7g+nMWZiquvEPceYE8APgcaaI3zFpOQvizr88p7NivA/KdaYEVsRZEN+55WBLugFVvBfpZjcYdQa4OMBj23v67AAt6u8+N16X2/a9+5KHGKO3GV/b6uF5tq3zLnXItetdF5Ft63cb5V5XZpvfmhia2/TJtuAqfd7b9uNHB2ya5E0oPy9710be1cRSJ68TrLxJaWPqytHgTffetszbSNPKz0EASncwGMRtxZgpOIrA2QDETVB+UCZHEHBat5+VlG6F9hg6mJtIi0J2Z2XfaeQ+KM5uSDcHbvp9rsyr6mb7s6TI0pAetoV8fPs1z+BsE/k5OPR60V4AOJgyP8eJPJwhoo1geHg3lMW7xYGaa2ldqEO3e3VmF47ObvYjf0mxHM/DAVXap+5rbtkmu7IZfl8qu7KtTffel9wl38c6L9+HvnkoFi4HXm5T9rY0bxWweZPyWDvxU5HHwtTdRpoGaGpSSH1tnPpFYXKdODCAD0ACZiWUvW+LdmUrKQIMTDSAK/fn4A9QId0wTM5skIZ8YXqoH6YdB2PUGVYHcAOw8i3omM84sdzZJj9yAjDAbymwod5urpvP5zEejufp+QG0aBvKlBRBHD5DgE52RwEGJcV3xVZ+jz3k5jp3Mk7j6DhjlPaz1FyQAx51abb125zsCqLq2JJd2ZGm/O/KxKR1bPNst9UBdfXlWpsF3W2lDcuV+96WVboNm7cLiE3n0Lby1gCbx6jQtsl9It/XIfdNYT+U3GWSTu9BKd7HQE5BTO633H/q4YoZUw7sBYqTmC44EqOc2daN8kRQ7u7o62X6sQ7STRA/mB1JGo/Hkm5YCUxTsE6AMBQxZquU6WD3FcCBvHzbOnX1+DTkk/rhAJicDXKFThqAB+0BYPKznwjmx3ujPh53Bj8emB/aDtbN2SqiKcOi0SaS4vXUFEZ5lMVOuZzwnE3gJQcs6vJL+24doMrds+1amsdDMKRNdbsrSLpNvdI6pL83sVW5+aNO2rbrfT5njkHfJf9t/bQu7S5lPBpg85iU6n3W47E8U1t5TO8B2bU+t6Hp2zx3W2YmlwYF5uxAzqHVnWlR6F4/33FDWvclIaAfaV05O/NCvpzT5FuwqSfMB/Xk/2KxiAwIoAEg4gAtfR/Ef2E7uDvKuv9KVd1sY3dTkTtAO2NFe3jbwlTRLrAmkja2kdPOtCFlpXn7++O9wDCR9uLiIrJVPCtpLi4uNBwOJWnj0FJJsQ3oA71eL5queIac4k6BTU7h5KRJGToo3JZPU5l19z/03NJG+T0EsNo1/11BRhvg8hhkW79pmkPvUx4NsJHa2WWLPJw8tba+LUjLDbS2q6GmlSIsBSt3N804o+AmCgLpuWkCsxPgwYO+EczO46rs7e3F+C+ACOnqEMlerxcVrvvFOItCUD6vB2yRn0dF3d1ERr6wOycnJxoMBppMJvEUbhQp27O9rdzs5I62tDOMjZvMuJ/6T6fTyH5g6gKgEASQwzhhzCRtABmPWcNRDIeHh5pOpxEwsYNNUoz/MxwO43lWg8FA/X5fBwcHGyDX/Z3oD7wDnok2SrfIp32tSdHeN2vSFkjdJd86SQFYU15tTBm3bZNc/m2U+l3a7j7bPa1/OpfdBnCkz5n2v13v9/9t5dEAm7pGfJtMOUXuLvcx6baZyNK0ba835VM3IbhZJA28N5lMIqMgKfpw+NZhgsyh/CRtmHkcrKQ7aXJmJhgCAI2bZ1yBLhaLuLsqhBB3ObkJyk03+MlQvm9D51lgMXBCdmXuB3xST0xGXjdvW9+JBHsEkwFoGo/HOjs7i0dOwNgMh8PPxaeBIcJXCJDjJjs3SXHsgteL/4Agd4bGDAXjRZkOCAFl3n70nzYMSltFsisDsMuYuMsYTsfPrszrbcq7jTQtYtrcmzMVbqvTbdjopjLTcus+71LGfUrKiCPb6vZogE2RIsh9rShfNwOVW/m4ssPvYn9/P+6W4R4UPQyEm0FgRaTPn8aMsJJ3cxB1gqlAKaNkcaR19sOj3aKwnUXgWfzZPAAg6R1AuXnHTWfOWkjaYImos0/kbiojX/KiXsvlUtPpNAKz1Wql8XgcTyknL48L42YqACeABeDlZ3qxSwvQd3FxEdkxnkGSJpOJLi4u4rulrv1+PwZc9LYfDocb28Mx2aXv07e/uzir533yqS4OcwuYOtPa66hL07zVBig+hBmtjbnsLu2T5l8HQu4Csm8jjwrYPOVB+BRkFybkrmW8DbKtPVDGKHtW68PhMDIK7hjryti3BGOqQDF6HByAD6Yi9x9xUEBaN2+Mx+PIPrD1nDOY8AFhl1UaUJDngllw519nHDwYnqTo+Ozbwz2mCwADFiPdscTWaQc0XiaAAX8c2A7awbeOu6OydMPK8A6kmxPA9/f3I9DgvVI3PgNM8EHiGQE1DkTcd4jvAF8YNECNp/HnSfuhgz//3La/vglpUry+KNiVXfL8t6V5G+S27+6+gF4TeGya/5p+30XamvuQRwVsihS5b2maFO/CDO2yKgbYsMWYU6DJw48x8LguvrMIcwl+Oa4sh8Ohut2uTk9Po7ImqJ+zKA5OHAThWwKb42BisVhEkAAYw48EhiQFaNLNCeKpQy/HLPj2aEBBVV3tHgLQpaxQVVUbUX5hVtx/BjbK4+Q4MMM3yNva60w9aV/ACe3g/jTc64DH3yOmI3xtpBtHYXxteC6em/5BPv7eUzNc2gdTMJMzdeQAT1PffgyyjRF4LHLXerUFAHctp+392xixpt9vw9rkJAfi27TTowE2j2kVUSQvb9M7uot/zW0lN+jcFOMsiysY2JycDwlpULQOKlDCKEUHLyhid1RG8RII0M0jfmo2YIWyUeYOBPiNfCnLA9aRJ88KGxRCiA683gapiYq6pit3np08cM71AHwOnDAn9Xo9HR0dRQdrfwbqAIuESRAmarVaxbOp+M4zp2dEORsHWDk5OYlmL9/tNZlMNnxoAF6Y1Pr9vqbTaXx2B491DM1jVfyp7GJ2SX0/dlXOTeW+Le11n7ILC9YGCLeZb3cFN3fRN48G2BQzVJGHkje5ynOw4uYPV7zuK4LDrPR5nxaUPyYWQAinWDvAoAxASRoTB8dYWBBAgtfNHWk9ijDAAdaHsetOuCh0j2I8m810enq6cUI3DskcnQAA8qjJlOdxdEgHq+Q+KN721NPBBKyRdOPgy308NzFu3GeIXVu0gR+w6dvy3adIugJcR0dH6vV6Go/HMbo077GqbuL1SIrRk53h43kBizBCHrNomzxWBb6LD4aD3Lo0u8hDt8ltzDFN9zxEfXfN874Z8NxCrqm92pTxaIBNkSL3JQ8JkOtsvDnqNWVf0vTOopAOxep5oCDxuwGgYHpx51dXkGnZgBtXhs6KsKPJQYD7yuAgvL+/HwGCAwGCBFI36caXpKqqeDAlIMaBDc69Dq5goJxRkW4crd2vx5/ZnbBxJCY9EY0PDw9jW/muJQCZH2/ggQ8BMjkzkPcDbyf3BwKgkA9mJwL98Z79nQ+Hw1h3WBsHY6k8ZnONdLfx2aT4Xoc/TV3bvm2+PPcFZiRtzHNp+zT55qS/577fVgqwKfLk5DarpDZy2/zSAY1iw3cDHxc/X8j9KthG7U63k8kkgpzpdKrJZLJxTALKsdvtRlbFfUn8KADq41F++fO6pmYxwAvKl91e3v7up+InXpO/BwEkOq87EXuQvZStcgYJPyV/Tp6HtnXmCVAEsHCzGL87WKT+pE0Bj7NH7hsDsCNmDyCU+/v9fmSv3KQFqOp2uxoOhxtB/OhDbpJ6m+RtZufvq61z5rBti6W3QR5q7t1VCrAp8mTloSaGu+SLUyirnNTHxJkHj8QLGOh0Ohu+HiGECGzcXIWSTB2C2WXlfi6SPmf6cSdbwAT3A2x86zZsjTNVmKLcl4XngWVxIOORmEkv3cTmSRmT1HeJui6XyxjVlx1NRFieTCYb9QTwAJrw0bm8vIy+LW42ok5uLsPPyYFLamb0mDap+Ym60Z7+rtIDPck/jWnzVP1G6hiSu4CjHOu2a/m5POvuv829TeXehZF7G5ilbe+2TZs+GmDzphHeU5DHgpafqtx1MnXF5GwFzIErXIAMoIYVO9FtHYRMJhONx+MYWyU9AgAfFPf5kBSZBgcWmGE83k4a0Zf8/VgBP3zS/WXctOXnJTkwSR1iSe87xGj3dBu49Pn4LYvFQuPxOD4L7SIpPiORgdmhdXl5GZ2Qyc+dktMgh+47RBv5VvWqqjZMcrwH2sT9mHiPgDR/boIZSorsDoA3F4nZQV9qLntM0hZcpCa++5rb2rbHfYKfxyCvw0cnZ5bnf135uTyazPjb5NEAmyJvnxQgVS+5gelmCw/IBkBwBQeL4OxO6hAMQ0HMFBxiUZ4oRFfAbuaCDfBdSH4sAr/DJvj2b8wpmHk4LgDmg90+MBP+LJTpz5UqunTnGPd5fBrAG+wFbbderzWZTOKZTAA5Z8B8Wzwgwc1DviuMQHyACgchsDjkh+mId+gO1M74sLsNUxXgEsCKjxEgjjKpg/sg5XarPYS8KXBxX3k91Hx1l+e4C/PymMBUE1C9LUjZhVlLpQCbIjtJbnIoAOdKmp7f2wi2ASbCQQ7KfL1eb5wBxX8P4OdmIjcBcc23I0s351ChIHGw9S3bgBOP/UL91+u1xuPxRiTiEEIM7ociHo1GkV0CLKTbyWGK0vaj/vi1OHgBOLADDPDmzouAMtgW7sOHB7BH+8EiAS44O8u3rnPNwaE7LDtIo3zf4TWZTCKY9Hg8Dsow+wF03I+I+g6Hww1g47vf3Mzn7ZkyOY9ddp1LbvNMuzCv25xf6+65i/nqoe57aGnLbu16z22kAJtHILsM5qa0X3RgkcpjAVw+eJ1VcMDhyh8gw64adsPkFH1VVZFR8Ki1HjMH1gBQIGmDBZBuAIGkDUDjbIZ04/ciKSpifgdssCMItoQ8Dg4ONJ1ON7aIux8N+aQMFWDAGSfSpg69RE92UxF1Ja/0eYbDoQ4ODiRd+QoNh8ONAz8BYZzxhLmN5+KZaVPfRi9p43BPgCn1djDjJjCcld3ZeDQaxcjLDnbpEy5ukkr74G3lTY+jVO7qZ9K2jF3SP0Y26zFIDmDfpa22tc+jBzb3qZzqbH9vUu6C2uvQ70M+l+f9GNrvdctdJlN3dMW8446xHpUYtgaTFN8x/bCbh8+YPWBj8F3hN9JSPkoahQjj4hGDUxMLwMEpYpgI3/FEHjAgpIf1wLFX0kZaAIGblRw0Sdrwm5G0EcWYZ8RJFxDhAMdNYR4PJnXgTf1daDOAk/sQ+fZt8vXn4jc+u2Ox9wsO6IRZ4v07+Ds4ONBkMomgyOPaeNiA++y7r1Pq6p/OO/f1LG39fB6L+eqxLNa2yS7+U3X31fmJtXn2Rw9sHkoee8e4q7wtA+CuklLvj0XcPCLd+L1wzY8hmM1mOj8/j+cSuZlD0ueYHRShdHNEAEo5BwZSh2XAwWw2iywPAekAOH4IJMob1gB/E54F05Kb0BygUHcYJACUOyFXVRWjL7MbKY0jwzWewUEN5ad+KTBEmPxoSz9JGxDIieWACW936rZYLOKuNAd4lO3xe3wbeeocPRgMNp7JIzQ7q0Nd/PgM7nUAlfa5VGnchx/Im1hI3afk6rlLu+wCqN4W09822fXdb2MIdwE7OSKibZ97NMDmvlBzHQrclm7XQXtf7M9tn6kuLybHpvsfYiJK2+tNsGN1faQO/DzExExevhqnLAcJkmLE4MVioU8//VS9Xk/Hx8fRXOSsAQwFjAlKDf8cafOsIw9+h2+OsxySdHh4uJFub29Po9FIIYR45EAKlDB7oZRR2m6iQnm7D4mDCGczvN4OBgAoIYT4301dg8FAJycn0aHZd4v5PTA30k18IDfDuUnHHaTX63UEQh4JmHL8vQCkHLARA4iyMb8BgDxonzMuvFt3NAbcURbvzXdx1ckuyjU3Hh6jcn6Tdbqtae++5prXCSIf47tv+/yPBti0kW12uod4EQ9BQ7YpU3p9YKBNWXdlRh7z6u6+WZ+0f6YAAIXo4IdYNATrw68D84ak6Ni7Wl2d9eQh90nnzABK1a/DTqCoOdQSs1Gn09F8Po8Re1HqgISLi4sNhgZF7udJeVA9nHQBCqTn+fEN8vgw1BMWCYbJD5fsdrsajUYb7Bagw3c6HRwcxHbo9/vRhOcnjzs75oAix44dHh5qOp3GezBjOSDLORf77iWEHWQ8NyY6Z3gwAXJ9MBhoNBppOp1u+ArdJ0OQm/Oa5tnHPLbvS7xNbgMWX4c8lvdwm2e+77q/VcAmJ3WNmGugpsFfZ9fbJnVMzy7pmlihXV90OvhuSwluu7ctk1V370OyJf79rhPLXevp7wOlD5hxsOGsA2AAxYoCHgwG0ReElT0MENuF3ZnUz0HydgBYsTVZutlejYJ1HxK/bzweq6puYsv4Lh7YCE8Pw+LHOfi2dHcEdrABsCFOTuo0jFnOdz2leUg3wKPb7erw8DAySDjoupnJY8ukefCeYKwGg8HGdYAX75Zt4b4VnfeCP1TaP3BMBrySL2OG97a/vx9BrvfRur7blv7PjZddlPnrWgTe90LkNuU2pXkqZih/jhywu6tp7zb3PEnGBtlFKe+y8mjKqymfNvndFvHfVprKusvk5XnkOvpdAFNduqbOvG3wpWl3kftcAXvcFFbqrpBhCqbTadwR42H5UWawEAAQV9Ds1gHMuGNyri2cMamqKjqlTqfTz5mhnHnyGDeAjdTJ2MGVAxC+S5vmGfeT2d/fjyDOIx2j5Cm7qqrobC3dMFP4L1VVFQ+8ZLcT9zkI8vg7qV8PcXskRYDV7/d1fHysbrer8Xi84R/jvk7SzZZ+/mDjPK1HeAZcYg7zSNLu7Ex75Pp7Ckj9nb+OueexMAe7ym3qnQNZjxHUPMQ7ed0Ac5f2fSuBzS5St4q4C5Px0JJOQG/LCuA24O0+VnkpuHkI2aWeXhdX3H4kAGDGD3Ssqioe0ojvCxFyXdHCPrAd2IO1jcfjaEKCPfH/mJt8B5DvxAEYpc617vzb7/ejr4/HYZFuAuhh/knbAxZCUjQtpcH2RqNRZFd8CzWgwwEKdfK2lbTBiGFOAwhJigzXer2O+eEQTRmXl5eazWaRbaJdcbDm0FDAKM/p7wMmh7oR/M+dgnkn5OeRm3lvmOV4Jp4b1ohn5v+ubI2/n7dJ3qY6b2O5bwOo6oBt3QL+vubbNN/XIbuU99YAm9swLZ5+GzjY9vtjG0BtaMG2cpsO+hCduwlsbnu+NuBvG7O07Zna1CMFd7k/lKcLYIazjFip+3+PneJxXDz2Df4fHhvFzU7D4TAyBNLmgZtVdbOrCIZguVzGgHXk5UwPwIR8AGApG8Wze1wd6UZBOwjBj4SYLqlPDr9JN/F4aAPSdbvdjeB76/U6+iXhT+QMlG/hlm7O1MLvxY+cwLmbZ6EcB2cAH+8HsD++C84D/+Gr430IXygiO+PPxDOmjFquvzf11bZyGzZ2l7mpaWzuMubuW5qe+z7a96GA5evUV3W6+S7l33Ux/1YAm/tQottATfp9F8Yhl0cbaWNiaatkHwP9+5Bl3+fzbQOwLrcZYHWTlQMblHXqx4FpCXMMAAIQI92c8eS7gBw4pCYo8iBP37GD3wbsB2X1ej1dXFxotVpFRe5HEsAkebA5N0vRdg66qurGzIS5jGd3MxWRfj02C+0zGAx0cHCg+XwegYIDktFotMHGALAkReCXHjaJCXA2m8WyABKj0Si2Y2oedGdw2o96EoE59a2hL3BoKfWiTWlfGDEHYgRspC/lgA3PdNu++xCyDajkwFDbvPz6fS727iKvs83f5IL7vsrN9dO7tuFbAWweWupW0W3uy31O5bY22/tMu4vswn7ch3j7tyl3F9PiNtlG2+/6PppWL24qQDmyCoc18LOgBoNBZBY4bdpNLr6bCWCBfw4KFgUPg4MZhDKoJwAEUNHr9eJRAASlQ0lTX/cl8Yi+1MHNbSnwgmXJMTr9fj/6EdEmzj7hpzKZTGKdpJt4M/v7+7q4uNhIR/0wuQ0GgwhY1uurs6Vms9kG84RJing+3q7cJyk6WwMIHfjBtF1eXm4cKoqpy8GROwRz4CX9Ex8r7yPejwBz3t+29d9dgU/b9G3Y78cot51X2szvdWlua35qY4FoyqdtubcFL7ved9/g7K0ANq9jILwOhmZbXvf1nPeRz13q9ND3MDDv4zl3yes27zwHfn3L88HBwcb2bvxmPIos5iZMHgAIAA3OvyhLmBYvG8YAVkLShkKEVeA67YJPiseWccDl5hHu94CA/OYAxJ2ZAWdVVcXt2JjMlstl3HbuwIa6YaqCZXG/Fo8VQyRnTD08D/4z+MH4oaF+PyCS3yjPHb5ns1kEMrSrAz/+A0Q59wlQQ54wQrAztB2O1H5WlJu96pRdHdDOyV1Y511Yl10lXSA8BmB0Wxb3rnNI7tpd2yN3/7Z6Ppb3UCdvBbB5jPIQjMWblrvW4XU+x323/y7p2j4jLATt4mYntu0eHBzEOC4wCpKiozD3o0QBFy6ADzebsMPJ48OgSFNTjJtBcGR10xL1AHjALDig8K3nbuJy84ykzyllAEOv19PR0VFsj5TBcrMMjBDlUQZ1dyVPG/jWa9pjMplsACvvv91uV5PJZGOHGm2C2QmwOZ1Oo9M2PkDUBcDEPbxf/Jh4J3zHDLa3txdBnZslvX/wXKlJqqlP78LGtlFuu+T7OiQ3Bz2kaeouQOVNzvl3nasfw7tukgJsXoOkneghbIqPRR7rc7yuiTdlgBzcSDeHYOLMS0A+zglCYcF6oHRRjgALwA6r/263q6Ojow1FPZlMonKH/YDlkRSZIj67CcbZGJiMg4MDHRwcbGxX9yB01Btlza4u97vhOSgTUxR5Hx4ebsTUId/5fB5ZjqqqNg6CdB8jTGB+fpOzXIABTHvUxc11mOz8efCpcadqmBx2sqVB/2DIMGXt7+9vHHrpzwlw8YCFgCFnyS4vL6MJjrqmzuK36eePYWGVE3+ebXXcxXy+jd16KLkt07NLHrssvNK0t22DxwDWXAqw2VGafCgeg1K/Sx0eC3PUJLtQ6y63bZf7eK8ObMgT5sVNK76l2iPwojSXy6WOj483AspVVRVBASv3brers7OzDWAAi5IGCXTfGMw71JUt1g6yCEzn9auqagPM+MGNPLsHEUT5p1vI9/f341lUACf+YE88Xg9MEPWFHaG+tCtmHFgg6cY0l4I0/w944nkAaPP5PPofOdPl/kOAK7bP+5EN6bPDxsHkEYsHIIXABo3H48j2uAluWx9sK3fxGXlIaTs/tUlXBxje1PyXAwb3ZWrfJvf5zNsAzrbnvK+6tAI2IYTflnQuaSVpWVXVj4YQ3pH05yT9oKTflvQnqqp6eZ3+ZyX95HX6P1VV1V+6l9o+Ism9oCYl+BhAz1OS265K2953Xz5GKXND3s50eHA6Jldfgfv9KHOAEcyKnxTuYMYBgh/nkJqjADSwIyhLwJd0c6aRpJgGBogQ/x7PxcEOZrR04iJvdxrmfu7xvDzwngepS0Gbm/D8NHTaH9OWs1+0d87c5f49sD2c9s0OJt/plpqG3Nma/zyvtxMMGb5T+AXRvr1eTwcHB5H9gU3ybftNffcu/drvf13ytjHbu84v9yW3WYA95kXsXcHOLozN/6qqqk/t+89I+pWqqn4+hPAz199/OoTww5J+XNKPSPo+SX85hPD7qqr6fPjTIo9aHusk8jpNSvcpHlwNZQyT4oCAlTpmH1gITB+uaGERUPQElWM7NL4gzpykjrS+Ewtw4P4qDkgANOwEgqVA0VMWTq4ofG9Xbw8HIIAK6skuJDcPnZ+fS1L8jW3ZMEHO1JAOcId5iTbBrJcyVTgW0+YeydiPOuB+36kGgAGAUvf9/X3t7+9H8IIJjaCKmK3c/2q9XmswGGg2m0V/m+Pj4/j+ZrNZZG7qIhFvAwZNfXybsnwd5oe6OjQxG3f1HdmF7bmNAm5K5+XvAlbug5G7y/tM6+rP4fnm8s7dm9Zr1zrdxRT1Y5L+yPXnX5D0VyT99PX1X6yqai7pWyGEb0r6g5J+9Q5lPSp5bPbEh5DcZPEYgM7rNCndhlbdRdKznMgHVgVHWkAKypmTt1H6xL7B4RVg4/4nHmDOwQ7lofRTloh6SopblzFPUSd2Y2Eq4rkAN/jq+DPC9ABI3FSGucZNdvv7+9Ec5cwM9QIIOTMlKbaLJF1cXGzUByAAo0M7r1YrXVxcRFAG2HDWCaYGYOFpEYDaYDDQ0dHRRswd2B0YMfcXAtACvlKWKGfOor38vd2mn7Y19TR9v0+hz+yi7B5qft72nNt+dybxPsq7T7krM/3Q9dgV3LQFNpWk/zSEUEn6f1ZV9Q1JH1RV9eF1oR+GEN6/TvtVSX/N7v3O9bW3XpoG9G1Q9mMUnxSeEoC7yztJB9UueaUmKL8OYIBFkBQdRHEYxcEYMAMIIBZKCCGu9FerVWQa0gB4DnA8YjCMhB8bQDkABsxF0o1vCiDCTUCACGLF4IvCEQzpadkOQvjDUZnnh8HB3wXmgnarqio6QcPWuAnJwZbvciIuDGAF5otDPgGGzp7QPpxj5f4vgB9AH+AJtubw8DDWz3176Be0C7ujvH1oN9rU28z7Ffnw19RP637Pjf83LXcdu0ibZ9oGlt607GpKTJ/5rnP5bdrhvvTHLuCmLbD5w1VV/e41ePnPQgj/Q0PaXMmfa40Qwk9J+qmW5Rd5zfIQppi3WepWjrfJB+Ag3fjbYBJBIeKMipLzQyBT8w0KlzOL0qB20k1kYzdReIA8GAR3dnVgBGBAweIDAijD/ASwmc/nGyDLIyJTJ3YdUQc/3Zz4NAAIWAqcd3NgKH1mv8fPZ0rNSs4a+a4tf+cOwg4ODiJYpC2qqopgJTV9pUCFetBm6VijXSaTSXR8xlwGMEv7UxsmYJcx/VgU+TZpYypzySn6XfPYVR7aVCd93jzmZe5iWkuvPbRZ77b5bpNWwKaqqt+9/v9xCOE/1pVp6aMQwleu2ZqvSPr4Ovl3JH3dbv+apN/N5PkNSd+QpGsm6K2Wt2UieCi77a55v41SN1G2vReF50qIlT4mouFwGM0PMCUoQpgAD70PA+DbrAELgCHq6WYSaTMQHek9posH7gMgeIwb0uO0yllM6blL+P24CQwlj0nNdxDBWnW7V4d9YpZzk5X73/AsnU5nw3RDGgc1tCvP7PGD3M/ITVQedE/aPF/LTXKU7c89n89j/Bm+06742nh7AwLxq1kulzo4OIjv29kaBzTp9y+C3IaRStO0TXtbeShQ0xas3AXUvM2yFdiEEEaSOlVVnV9//t9I+r9K+mVJPyHp56///4XrW35Z0p8NIfxpXTkP/5Ckv/EAdS9yC3noTvvUwY1Lzjku/Y3fXSmxvVdSNHWg6DjLyc1E0+l0w2cGgODmET8MU7phaJxFQJGmO4hghygXBeuACt8P31IOw+MmMFeuafRdBzu0EYwVpiKP0wMj5FuyJcXfyZ8TsyVF8xXO1IAZr5vHtKE+PAdtCyiEScOfJQUisFO0rzMrtB1xbhaLhabTaXw/gCzydDAzHo+1Wq1if/Ao0b6dnv6Vtm3b/vtUx2qdwr5PoNGm/V4X891Ul9uaou5S7/t65txztcm7DWPzgaT/+DqzPUl/tqqqvxhC+JuSfimE8JOSfkfSH5ekqqp+PYTwS5J+Q9JS0p+syo6oL4zcdRV1l/S3zWtXu/Wu5UqbZgjfHQVbA3jAHOUB4qbT6Ub0Wjd1SDdHGMA4oHhT85V0swMKBsW3CgMyOBuKeru/Cc6ubn5CEbsDMo6vOLv68/qOIP/P7qDDw0MNBoNoJqIclL6zWew2wvfm6OgotslgMIiRenEMxvQDCOQP3xX3d/H2c2ADM+XmNo8cDOhxE9disYg+Pu5MDXCRFJma2Wym09PTGFE6XDsrSzcRpFMzWcrYtGEXcwrjqQKdnOQWJI/BXLfNNPa6XQQe+jlzz7OLKS0nW4FNVVV/V9L/NHP9M0l/tOaen5P0czvXpshbLW1WL23lvgfvQ9jR21LdbnpBAaUKFGXLFl6UuSvPlO2BBUApe1A86eZcIkwtpKmqKp47xblE6UGVxGbBdOLMDcqZM5LYheU7lTgEkki9vtUaVsMBynq9eRAlQIJ6XlxcRPDkgAyGh6MZYHMwreHsG8LN7jFve9oU0xVgJq2nm6L8lHNAGtGfKdt3OVG3NFaRR3nGn2qxWOji4kIXFxdxVxxpKNMZpLQf5kBNqrjTa/49BTfb2Mg24+CxSN2cktb/bXmeVHLAtAkIbVvo3UV2BYg5hvsu9SiRh4sUeWBxPwg3GbjC6nQ68RTq/f39DbMDoADThys0gA3AyGOkkC+rfQdWMDEc7QDzAgjA1AQT4k6rlCsplg/TRP4En+N0bOkmjg+mIWcveF6PoQNLxDZ2zDO0j58d5SY2P7gTwV/GY75ggvNYN5RJPT0f3z1FnvjYuEnJo0lzf2omZAs7ysiPz+BwTvdlQhyQ+ZbvdJs59a9jYe5TedeVsYufy33XKSdvgu3wcu/yfPdZ722setu0j1nCY6h4COETSWNJn25LW+S1y5dU3stjlfJuHq+Ud/M4pbyXxyu7vpsfqKrqvdwPjwLYSFII4b+qqupH33Q9imxKeS+PV8q7ebxS3s3jlPJeHq/c57vpbE9SpEiRIkWKFCnydkgBNkWKFClSpEiRJyOPCdh8401XoEhWynt5vFLezeOV8m4ep5T38njl3t7No/GxKVKkSJEiRYoUuas8JsamSJEiRYoUKVLkTvLGgU0I4Y+FEP52COGbIYSfedP1+SJJCOHrIYT/TwjhN0MIvx5C+Beur78TQvjPQgi/df3/ud3zs9fv6m+HEP7xN1f7L4aEELohhP9fCOE/uf5e3s0jkBDCsxDCnw8h/A/X4+d/Ud7Nm5cQwv/pei7770MI/0EIYb+8lzcjIYQ/E0L4OITw39u1nd9FCOEfCiH8revf/h+hRVCfNwpsQghdSf+6pP+tpB+W9M+EEH74TdbpCyZLSf+Xqqr+AUn/iKQ/ed3+PyPpV6qq+iFJv3L9Xde//bikH5H0xyT9G9fvsMjDyb8g6Tfte3k3j0P+NUl/saqqv19Xkdl/U+XdvFEJIXxV0p+S9KNVVf1+SV1dtXt5L29G/h1dtavLbd7Fvynpp3R17uQPZfL8nLxpxuYPSvpmVVV/t6qqhaRflPRjb7hOXxipqurDqqr+6+vP57qanL+qq3fwC9fJfkHSP339+cck/WJVVfOqqr4l6Zu6eodFHkBCCF+T9E9I+rfscnk3b1hCCMeS/peS/m1JqqpqUVXVK5V38xhkT9IwhLAn6UDS76q8lzciVVX9VUkvkss7vYsQwlckHVdV9avVlUPwv2v31MqbBjZflfRt+/6d62tFXrOEEH5Q0h+Q9NclfVBV1YfSFfiR9P51svK+Xq/8q5L+JUlru1bezZuX/4mkTyT9v67NhP9WCGGk8m7eqFRV9V1J/3ddHcr8oaTTqqr+U5X38phk13fx1evP6fVGedPAJmcrK9u0XrOEEA4l/YeS/sWqqs6akmaulff1ABJC+CclfVxV1a+1vSVzrbybh5E9Sf8zSf9mVVV/QFfHwTT5B5Z38xrk2l/jxyT9HknfJ2kUQvhnm27JXCvv5c1I3bu41Tt608DmO5K+bt+/pivqsMhrkhBCT1eg5t+vquo/ur780TUFqOv/H19fL+/r9ckflvRPhRB+W1cm2n80hPDvqbybxyDfkfSdqqr++vX3P68roFPezZuVf0zSt6qq+qSqqktJ/5GkP6TyXh6T7PouvnP9Ob3eKG8a2PxNST8UQvg9IYS+rpyHfvkN1+kLI9fe5f+2pN+squpP20+/LOknrj//hKS/YNd/PIQwCCH8Hl05cv2N11XfL5JUVfWzVVV9raqqH9TVuPjPq6r6Z1XezRuXqqq+J+nbIYS/7/rSH5X0Gyrv5k3L70j6R0IIB9dz2x/Vld9geS+PR3Z6F9fmqvMQwj9y/U7/D3ZPrezdf73bS1VVyxDCPy/pL+nKg/3PVFX162+yTl8w+cOS/jlJfyuE8N9cX/uXJf28pF8KIfykriaLPy5JVVX9/9u5YxSFYigKoPeVguUsyK1YiriGWY0MyPSuwUYrWyuXoWSKWFsMw1cy50DqhDwI9xGSc1Xt0g/xW5J1a+0++ar/N7V5D5sk20dDdkmyTG8U1eZFWmuHqvpOckzf51P6b7bzqMvkquorySLJR1Vdk3zmd+fXKv2F1SzJ/jGez+3nYQBgFK++igIA+DOCDQAwDMEGABiGYAMADEOwAQCGIdgAAMMQbACAYQg2AMAwfgAQrAifkWJlOgAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "with cpy.SingleFrameContext((512, 1024), fov=90, near=1, far=1000) as rc:\n", - " volume = rc.volume(data, spacing=spacing, normals=True, fmt_hint='uint8') ## declaration of the volume data\n", - " rc.dvr(translucency=2, sample_rate=500)\n", - " marker_mesh = rc.ball(radius=15)\n", - " marker_material = rc.material(color=(1,0,0,1))\n", - " rc.meshes(marker_mesh, marker_material, volume.map_voxel_coordinates(markers), parent=volume)\n", - " rc.camera.translate(*volume.map_voxel_coordinates([camera_position])[0]) \\\n", - " .look_at(volume.map_voxel_coordinates(markers)[2], up=(0,0,1))\n", - " \n", - "figure(figsize=(8,6))\n", - "imshow(rc.result)\n", - "tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Example 3.** You can also use a more sophisticated color map, like $[0,0.2) \\mapsto$ teal and $[0.4,1] \\mapsto$ yellow:" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "with cpy.SingleFrameContext((512, 1024), fov=90, near=1, far=1000) as rc:\n", - " volume = rc.volume(data, spacing=spacing, normals=True, fmt_hint='uint8') ## declaration of the volume data\n", - " rc.dvr(translucency=2, sample_rate=500,\n", - " color_map=[(0, 0.2, (0, 1, 1, 0), (0, 1, 1, 0.2)), (0.4, 1.0, (1, 1, 0, 0), (1, 1, 0, 1))])\n", - " marker_mesh = rc.ball(radius=15)\n", - " marker_material = rc.material(color=(1,0,0,1))\n", - " rc.meshes(marker_mesh, marker_material, volume.map_voxel_coordinates(markers), parent=volume)\n", - " rc.camera.translate(*volume.map_voxel_coordinates([camera_position])[0]) \\\n", - " .look_at(volume.map_voxel_coordinates(markers)[2], up=(0,0,1))\n", - " \n", - "figure(figsize=(8,6))\n", - "imshow(rc.result)\n", - "tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Example 4.** Direct volume rendering can also be performed without lighting:" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "with cpy.SingleFrameContext((512, 1024), fov=90, near=1, far=1000) as rc:\n", - " volume = rc.volume(data, spacing=spacing, fmt_hint='uint8')\n", - " rc.dvr(translucency=10, sample_rate=500)\n", - " marker_mesh = rc.ball(radius=15)\n", - " marker_material = rc.material(color=(1,0,0,1))\n", - " rc.meshes(marker_mesh, marker_material, volume.map_voxel_coordinates(markers), parent=volume)\n", - " rc.camera.translate(*volume.map_voxel_coordinates([camera_position])[0]) \\\n", - " .look_at(volume.map_voxel_coordinates(markers)[2], up=(0,0,1))\n", - " \n", - "figure(figsize=(8,6))\n", - "imshow(rc.result)\n", - "tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Omitting `normals=True` if lighting is not required speeds up the `volume` command but produces less realistic renderings." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Maximum intensity projection" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Example 5.** Use `rc.mip` to specify a maximum instensity projection:" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "with cpy.SingleFrameContext((512, 1024), fov=90, near=1, far=1000) as rc:\n", - " volume = rc.volume(data, spacing=spacing, fmt_hint='uint8')\n", - " rc.mip(sample_rate=500)\n", - " marker_mesh = rc.ball(radius=15)\n", - " marker_material = rc.material(color=(1,0,0,1))\n", - " rc.meshes(marker_mesh, marker_material, volume.map_voxel_coordinates(markers), parent=volume)\n", - " rc.camera.translate(*volume.map_voxel_coordinates([camera_position])[0]) \\\n", - " .look_at(volume.map_voxel_coordinates(markers)[2], up=(0,0,1))\n", - " \n", - "figure(figsize=(8,6))\n", - "imshow(rc.result)\n", - "tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Example 6.** Use the `layers` parameter of `rc.mip` to specify the color map and/or multiple layers.\n", - "\n", - "In this example, intensities $[0,0.2)$ are mapped linearly to blue, whereas intensities $[0.4, 1]$ are mapped linearly to yellow:" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjYAAAEqCAYAAAAGShpIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9Sax0SZYeiH1md/D5ze/9Y8QfQ+VQWZlVJKu6RJC9YGsiNw02BFCgFgIFEKgNBUk7ktr0qgFq0ztpUYAa4oJqqjQ0yBYgtdgD0c3uIrO6isWqyMyKyMiI+Oc3D/58vIOZFuce9+P27Lr7+yP+zIiX9gEOd7/Xrpnde82OfefYsWPKWouAgICAgICAgLsA/YuuQEBAQEBAQEDAV4VAbAICAgICAgLuDAKxCQgICAgICLgzCMQmICAgICAg4M4gEJuAgICAgICAO4NAbAICAgICAgLuDN4asVFK/TWl1MdKqU+VUn/vbZUTEBAQEBAQEMBQbyOOjVIqAvAJgP8JgBcA/gDA/8Ja++OvvLCAgICAgICAgApvy2Lz2wA+tdZ+Zq3NAPxjAH/9LZUVEBAQEBAQEADg7RGbRwCei/8vqmMBAQEBAQEBAW8N8VvKV3mOLcx5KaV+B8DvVH9/8y3VIyAgICAgIODu4dRau+878baIzQsA74j/jwG8kgmstb8L4HcBQCkVNqwKCAgICAgIWBdP6068ramoPwDwLaXU+0qpFMDfBPBP31JZAQEBAQEBAQEA3pLFxlpbKKX+1wD+MwARgP/IWvujt1FWQEBAQEBAQADjrSz3vnUlwlRUQEBAQEBAwPr4Q2vtb/lOhMjDAQEBAQEBAXcGgdgEBAQEBAQE3BkEYhMQEBAQEBBwZxCITUBAQEBAQMCdQSA2AQEBAQEBAXcGgdgEBAQEBAQE3BkEYhMQEBAQEBBwZxCITUBAQEBAQMCdQSA2AQEBAQEBAXcGgdgEBAQEBAQE3BkEYhMQEBAQEBBwZxCITUBAQEBAQMCdQSA2AQEBAQEBAXcGgdgEBAQEBAQE3BkEYhMQEBAQEBBwZxCITUBAQEBAQMCdQSA2AQEBAQEBAXcGgdgEBAQEBAQE3BkEYhMQEBAQEBBwZxCITUBAQEBAQMCdQSA2AQEBAQEBAXcGgdgEBAQEBAQE3BkEYhMQEBAQEBBwZxCITUBAQEBAQMCdQSA2AQEBAQEBAXcGgdgEBAQEBAQE3BkEYhMQEBAQEBBwZxCITUBAQEBAQMCdQSA2AQEBAQEBAXcGgdgEBAQEBAQE3BkEYhMQEBAQEBBwZxCITUBAQEBAQMCdQSA2AQEBAQEBAXcGgdgEBAQEBAQE3BkEYhMQEBAQEBBwZxCITUBAQEBAQMCdQSA2AQEBAQEBAXcGgdgEBAQEBAQE3BkEYhMQEBAQEBBwZxCITUBAQEBAQMCdQSA2AQEBAQEBAXcGgdgEBAQEBAQE3BkEYhMQEBAQEBBwZ7CS2Cil/iOl1LFS6iNxbEcp9c+UUj+tvrfFub+vlPpUKfWxUuqvvq2KBwQEBAQEBAS4WMdi838B8NecY38PwH9hrf0WgP+i+g+l1PcA/E0Av1Zd839SSkVfWW0DAgICAgICApZgJbGx1v7XAM6dw38dwD+sfv9DAP+eOP6PrbVTa+3nAD4F8NtfTVUDAgICAgICApbjTX1s7llrXwNA9X1QHX8E4LlI96I6FhAQEBAQEBDw1hF/xfkpzzHrTajU7wD4na+4/ICAgICAgIBfYrypxeZIKfUAAKrv4+r4CwDviHSPAbzyZWCt/V1r7W9Za3/rDesQEBAQEBAQELCANyU2/xTA36p+/y0A/0Qc/5tKqYZS6n0A3wLwwy9XxYCAgICAgICA9bByKkop9R8D+CsA9pRSLwD8+wD+AYDfU0r9bQDPAPwNALDW/kgp9XsAfgygAPB3rLXlW6p7QEBAQEBAQMAClLVeF5ifbyWU+sVXIiAgICAgIOCbgj+sc2UJkYcDAgICAgIC7gwCsQkICAgICAi4MwjEJiAgICAgIODOIBCbgICAgICAgDuDQGwCAgICAgIC7gwCsQkICAgICAi4MwjEJiAgICAgIODOIBCbgICAgICAgDuDQGwCAgICAgIC7gwCsQkICAgICAi4MwjEJiAgICAgIODOIBCbgICAgICAgDuDQGwCAgICAgIC7gwCsQkICAgICAi4MwjEJiAgICAgIODOIBCbgICAgICAgDuDQGwCAgICAgIC7gwCsQkICAgICAi4MwjEJiAgICAgIODOIBCbgICAgICAgDuDQGwCAgICAgIC7gwCsQkICAgICAi4MwjEJiAgICAgIODOIBCbgICAgICAgDuDQGwCAgICAgIC7gwCsQkICAgICAi4MwjEJiAgICAgIODOIBCbgICAgICAgDuDQGwCAgICAgIC7gziX3QFAgICAr48VM1xu+RcXXrOT4n/vjx95wICAn7RCMQmICDgG4TbkBROzyREOceBRXLikhWX3GgARlwr8/MRKL7WJULuf19dfPUJCAhYB4HYBAQEfE3xJiTGYj7D7lpf3HQ+q4yb1q2L/JZERTtpXdKy7m+3DCOOB+ITELAOArEJCAj4BeO2BGbZ9dr5XWcVqSM7y9K6pMlnCZLX+eq37HhdPnXlLMvbRSBAAb88CMQmICDg54Cvirz4LCFMNoznnGthUVgkKnxMY9E64it7GbFYNq20zLLC5MvAT2C+7HP7qvNx4bvPuqm1gICfDwKxCQgI+IqwzLLwZSHzrfOV8Vlh+BywaMGR590pH3leOefrLDu+6a86y40kVdaTzgeu+9eNLCyzOn3ZdvB1u9eAbwoCsQkICHhDfJmpkTeB63zrG1R9x6Q1Zpk/i0uS4Pnvpq/zz3EHZZdU+ertI0huPX3n7ip+HlamgLuIQGwCAgKW4G0Sla8C607fSOsLY5mDr2/wc8lHHVmqO8bwra6qq4tMJ6fO6ur4VWPZ1FpU1e+bRhR+HuQ74BeJQGwCAn7psM6UUd1gW3edO+B+lSt2ltVXTjNxWkkI6lY5wTnvkgbphMxlGKcctx7uM5NTRy4JisV5zleSGLd8tjyVTv7rYJklyYU75SUtSKtWevlQRxDrpv++6QhWpq8DArEJCLjT8Alan6+JOzDLgVZaKlwCACwO+L6y3RVEy/xQltWnjjC5pEaLspd9+3xe6uopSYevXIvFwdolMm5aWQbXN6q5b0kA1llWDtx8R/KeVxFPWedlvkK+KUFfu6pbQeabynPrHwZ0QrAy3QaB2AQEfKNRRx6W+ZJIQcaDlxH/OZ1LGFyt3yUL7m9ZLzcflyi59XanfeQxtzz50U4al+QweUD1uxTp+FuuUGIriW/QdYmfa9GR+cj6+urt5i+fj48U8RSQ+/595fieozwH59wqUrQsj7o2IdPVtZ+6fO7ewPv1wt0jTYHYBAR8IyEHbjlQuBYCg5sDp0sgfPmiJo3r3Fo3CLq/6wbhum+3rLpBVYtvYJHIaCwSGXlM5svX87OKRHmSDEkrDJMYeU+SqPlIj0vqDEgEu6RDki1Zd1kHScrked8g5Vra6giimx6oH5jkM7e4Wc9VWEaG+Zgk2z4LTiA8X3/chjTdlsTWpw3EJiDgaw+f9ioHJx9RYLiDpk875nS+KSI5gAE3p2R8AzvEsTorj0TdYOteJy0Wsm4R5qKM66HFOTlA8kf6qrj3YXHTsmMAFJgTEmkxkfWS5MP9z3WAuCbBomVGkhVOw3Xhc1wv+b/OcgKRxnfOJY9u2TK9Oy1Y907r3qWPoNQFPFSgd+pO6cln7eYXiM7XH67cklg1Nbr++125u7dS6h2l1H+llPqJUupHSqn/bXV8Ryn1z5RSP62+t8U1f18p9alS6mOl1F9duzYBAQFYtCLUTQm4Vgp3ysX97WrYvuuXkSB34FArPnCu91lm+BNhbiVxsYzQSFITAUirTwwiDE3xnVa/Eydto/rw8cTzaVV5NEVamWcsykycshJxDVtntKcsvn9ZD843ra7h+6xzYK6zgrjPjUmBtE7Jern5u0TIbRvutJh7ra9tyjLr2tAyC5Qvv7r259Yp4BcLn3yre4++6XD5jmtKsHY5C1JKPQDwwFr7R0qpHoA/BPDvAfhfATi31v4DpdTfA7Btrf27SqnvAfiPAfw2gIcA/nMA37bWunZTWUag2gG/pFjWQVm4+7YGgDi+bFqB/6+rdfs0Z1/3rLPGuBp0nWZWNwgCixYO3/WcTmORNKRYnPaRA7V1rvM9W7e+bDFg4VqIuvmmgRjuEmi29viWRrPFpsDN583pIwCZJ6+iqscyy4l8R0wk6t4df6TFSb4b+SxcS4p8hrIM9/3JNiffg7tCyn0O7r25U2UukauzILp5B/z8sIpYuu9wmfwBgPIPrbW/5TuzcirKWvsawOvq97VS6icAHgH46wD+SpXsHwL45wD+bnX8H1trpwA+V0p9CiI5v7+qrICAu4vbaIvLBn2fJi6Pu0THt3LHJTQWiwOWW34d+amzCtTV3T3uQlqSfHX05cPWDbaS8HSO9F/h63lKia0inE5h7iAsrVrsi8PEg4mOnJay4hinN1V+TCSmouxSpIFIk2JOHmQ9clEXl1yMsUhC3GfjkmBOJ61zpUgryYB8x7INuO/e9bNxyYSsj7xe1rluyks+D3eA87UF9/wywl1Xt4CfH5a1Cf7tEm83jR+38rFRSr0H4M8D+FcA7lWkB9ba10qpgyrZIwD/Ulz2ojoWEPBLgC9r7l7Wges0mGVTVgzjpJV5SPJTt+TYRyzkIOg6FS8TQnWDlCxPWjfqTM8Kc4sNT9ckmBMI6XvjDt7AfAqMf0srRCGOo8qHr2dS4zrwyudRYE56EnEvbJlhwpI4+eeYE60INA2WYf5u+LmUACbVtXWCXj43l3DyfxlPx3XElmldK5rM17XsuGmAebuqaw91/cYluT7UkRwfiXdJGjy/f174ZbEc1fVdn8Lis0L75ODy57Y2sVFKdQH8PwH876y1faVqBbjvxI1aKKV+B8DvrFt+QMDXD1+WxPjgEgOfeXZZ+dJnwY1uy4OWu3xZauYyXx+ZkXXktFHNcZcgLbO8yPNydZJv+kAOWExuGuI8W2qk346PMDKB4m9JbtzBWtY9co773hUTFp4uYsLC70c6LzMhK0C+O1wXJkRRdT0jE/fvs5S5dZMfdxqO4VpcfAOOm7+LOhIl6+or003raye+9uQS6nWIgu/8MmL4NonH28zb11/eVjmMOkuY+9uXdlm+br9dRoQJaxEbpVQCIjX/yFr7/6oOHymlHlTWmgcAjqvjLwC8Iy5/DOCVm6e19ncB/G6V/y8DbQ34xuNtEBlf/nVkok5AudYIOYi4y73rBmy3DvK8ez1PvbjXu/Vm60LdGgXfIOfT/Pm8/C+dX9nHxnrO192XdT5unVL4n7e0aCwjfZyG68YkqwQRE54qk/VhMmoxd0bm5815LzPby2fmc8yU5clpMz7vxvRx24xvmsklIL76+QY1l8zK9+ZuI+GW67YNN17QKoK+7nCzLln6uuPnUf9lpIbPLyM6rrIi86xLW491VkUpAP9nAD+x1v6H4tQ/BfC3qt9/C8A/Ecf/plKqoZR6H8C3APxwVTkBAV8f1Gm7b7tMqYn6BMGy/z7TO7Ao5KU1RzrW8n+5yog/8rh8FpE456b1ledaNqTo0Z6Pm9atO/9u4OZ007J3Vzf4yXLcOrjPchl8aRTmBIdXVLHfDjv/skMwf7iu0s8nFscUbk4PQaTl9sAfd/UW358kXfzueWWZr03IVVxypVaExTalPcflqi7l+eZ7dgkZav5z+mXn5bO57TTYNxm3mbp7E8hnWjdVVGcdW0eR8pVXJz9uYh2LzV8G8L8E8KdKqT+ujv3vAfwDAL+nlPrbAJ4B+BsAYK39kVLq9wD8GNRb/86yFVEBAb84fJ0E2jqmWXewqhP68rckAT4HVJleEhPpTFy3kkZaJ1jjZ2sDCzA5+EpHVffe3Pt0iQVPobnTED7i4lqC3Pt0/7sWAl96Wa6v3fisTe49cRr2p5lg7qfDx6TTMTsru4PIBPOpLfc+3fcrp+Vc8inhvuMciw7VcvqNCZmcvpPO2JxOknXfffgsUS5Bd9/XMud2+Sx8z8a9Zhnhqbv2LuCruKc6a5ZPYXDLdduGr5/5+un6FrSVy71/HghTUQFvF18XAuN2ZgnfgOl2aHnM/c3waetMANjvQw5YTBj4OjnFI51s2aIgCZNc5cPHOW+eUpErhgpxXtZRTpvJ+5D+IEyW2OmWsQdgw6l73YC1bjuQ76iOyPjS+8qSAzswf96HAAagd6JAVhL2KWISIqei+L6z6lNU33XLvdla0hB5x+LbHThikZcFreSS01RyWXqJRWLDdZb7ZMmpNWDeTjg9O1dLkuMOXFK7l21KQpbhll1nNXDJkfu+v0q8jTyXlYWa8lzZ8zbqJOXSKtLik4U+5WBZnfM3X+4dEPDNwdeFwKwDd2Bn1Fkz6vwM5G+XyEhiIsviQYrJghQDkfPhY+4AGoMGJ6nZA3OSxAOMu1yZ792dipL1dQmWJGLuYMU+KxzDxqfVr4NlWr5PuLrk0ReJmNMxIWFyN8WcOPAqKX5uwJxUppiTR/7mTy7ydi0c0pLWANCpfrNjsrTAyPuWRIpJDLcPnqJiYsPfrgVIY9HRmYmtJMCSoMhYPZIY8X34SLis96oBepUVqI78rpvvNwVfZV3f9N5dRazut1RofERnddmB2AR8Q/GmJObrJJDcQXJVGglXOLv+LTKaLw8MPFDyOR7oSiefVKSpG+B5GXMD88FZOhWjOs7Lr+V1DGldks/A9b2Q1iO3HlNxzGC+7FtaeepM2T5N0benk28QlQMlD74yyB6f5+c7rY7lmBMbYNFhV27ZwM/PncpjkiPJgdt+ZN0boPfM5EQ+D/davh+2FjGBkT5WTCC5Llx3+XxiLD5jTi+nnpjYWee4TCfJnltnSYak5cf3HIDFd+eec7GOfPC1pzfNax2sI7dWWWqWpbtNOavg9i+ZN/drN1q120fh/JcKxGrZH4hNwNcUb8v68rZJzToC06f5A/WCQP52rR/yW/rHyKkMdvZsVOdl+H4eEKRFSJYrj7tppKOoFFZcD+kYy/Xm8qR/huvvI51OXWEm/XckuZiI/+ybwml8jsCyDnJgZN8VthSlVXp3moXrXIiy+b98RgUWp/E4ve9ZyXrJY/K4O5BzOS4ksZFbNvgsEu57l0TZN0SwxU4SJZf0AYv+We7GnmzxY+InLUX8X/6W8ZU4b0mkXP8e997qprrgSeuDe4+u4/bblitvmv9trquTue7zXJf4cd+T7UvXHPe9M9/x9caFQGwCviZ4W0TmFw2f0JPaB2rOu7/5Ww767rQCQ+5RxP+lb4VPA5IfWadFp0+lAGt54Oc0cuUOxHUsXmQQOrnyxyUdbPmQkYTd5yR9dGQ93SkRvk5Oo3HQO+38Z+sD338mjksCw8RHDqAZ5lMvbrwZHqwlmXNXPckBfRXJlaQHNencsuVzmb9LpQClLIzxXe9rf3XwWX5kW+X/7lRqE4sWKPfZyim4QlzHJEYSaVm+7/n4BuLbEoVlykrdM/yyZOfL5OEjsKtQZ/GRhHedPF15Ii0vUvmSfmdymllaadx83ffrRyA2AW8RPqH3ZfLhvL7OWKd+qzRD97cUENI0Lx1s3ekCubzYJT+u0JOChAa/VstAa4vxWCGODay1aDQ0ksTi4sLV1JdZn6RATAB0QVsBAHOixfkZcVw6uLrEjcuS5dUJQx954FVIBjQlkmPR14WvYYuSwpywSIsMMI9Jo8T1wFxwu6QMuOljAvHfR3jloO2zMtT1M74HBp1rtSySxCKOgX5fodm0yHMgz1ERHSpDawWz3jiC+uW3sp24bVv6eQGLpMWN9yMJLDtPy2flRsx2fXqAxXrUWZreRL4sI05fluB8met9CtPPU376lvNLPzq5AauvHddNP68eTwKxCfiK4Qov32D3dScnbxvLNCPfMR+hARaX8MqVNPxx/W4Wpx8oeLiCtQpaA8bQu0pTi729AgcHBQ4PY7TbFmUJtFoF8hy4vtYoCoU4pkFIKQtrgbIEosigKFwNjO+ZSZe8J1cb5LrK3+4gVEdg6q7nZ+WmoeB+CgU0xlDIYJGjXFi2zptPFlhc0sz351oN3OkQd1pJppXPRz4HVzN208p7cAmee96N3qxQFECvV6LRoPoeHBR4/TpBUUTodgu02xbGAI2GxdFRgrJkKx2gta3IzrKBheskp9ki57xL2oGbDuDs58NEhQmPHAxLLLYP+Zzl8/I5nsv78J17E/jIwzqEwl0VyHV603Jva6VaZdm6jbVGEhopg6S11Fe2tCxyejeMQLDYBLwVuOTENxivulZe755fp0OuIyh+3tpJHdapw6pnKAmO3NiRfSgaWPSrkRrS4jOPIouyVNDaoNcjYaIUae9nZxGUAnZ3S+zulrh3L6+mnoDpVKPTMbi40ODdVIgMFdjcpMFkOEwwnSo0myXKUiOKgOlUVYMhkR9CMqvPOnPtXIdlZEYphTQ1KAqFsvQRoZvXKyhsw+AxJngPGTYxxRgGT1HiFQxeoRAlWMynROSqHWlJYS20boBdNjjwMZcA8e91+pWr8bpBFel4WRJBUYrIS1mqiqgCaWqxtVVia6tElimMRgr9fgxjLOKY2kmWKVhrhXXHQr67OAaMMdAa2Nws0WxanJ4qlCVZgOZWIGk9g1NP18dHPrsc8/2z8urD1h75nKT1TdbTZ625LdaVVcve3XKrw+1Qdy/rKpPLzt/2eXE/kFZkll3yPclnI5Uh7gM8hT7FzdhYwWIT8EbwadLAzQYpj7u/6zRQmWaVllHXoVZ12K8DqVkXrsAFbq4GYSEhl2pHIC23LdL4BDd9p6nB1laJfl+h3bbY3zcoS6DTMbBWYTJJYS2wsVGg2y3R70eI4/n7m0xoQEuSAnGsobVCnmt0uwW0BoqCym00gOkUGI/pXjY3DZSyGAw0plN3mXGBJCnR62lcXUUoSyIKcQwoZRFFCo2GwWikkOcKStFz4fhb9+4VuL7W0Nri/fdzXF1F0Nri8DBGWQJlqWdprVXV/QC2AH4FJf4HmOI9FNiHRQMRFAwKWLwE8N+hxO8DGN8gSa6lBuK3T7N0LS/yGDzpGL62v5ysLV4rCe68XGvJ6pYkwPZ2iVbLQmuLNDVQSiFJLJLEII4Vut0SeR4hy4hgljN/Zmnxo+8osjO/HaUibGyUODgoKssQHR+PNfp9eodEsrVDdFxy67s/7gfAfHUZMN+BXW5AWkdm6uSO2w/XlSO+NuL+diHr5KvDLxp1Smzdf3mdtCJLyw3LL4hvvoY/TEh5FSf72vE7dRcc3EQgNr+UWNfq4mu4dY3ZFUqucFrXcuEry8UqDdaXL1/3pnjbwkY+P/c5SmtMozqWYh76vm7fnwJaR2g2LaZTssT84AcTvHiRQing4KBAniu02wbTqcL+foTxmDTq8/MYRUHaeZJgNv2QpiXabeDevSkaDeDwMEGrRX44RVHi6ooGzblVxyCODXZ3SzQaEU5O5s9Ra6DVApJE4cmTKV69SnF0lKDVIquBUhZFAaQp0GppDAYa1haIImAy0dAa+OCDKQaDCEUBfOc7EwyHEba3C/zrf92qpsQs+n2N8VijLBUePMgwGUfoHiX4y4XCe2jgARS2UKCFotpK0+AeMhzAoAGL/y+U8+al9s//5QoeYLGtfFkLgc/6JPN208mBhQeCaHbeWoXpNIIxBlFk0WwaGGMRRfS+JxOF6ZTKGQ5jZBlZzIpCIYqoLVhLRCdNybKzuVkiioB226Dfj9BqEYm+f7/AZKLQ7WrEscF0atBu68pny2I4jHFxgdm7Wn2/fMy18gBzPyhedSbJZd0Uxpu8k2WEsy7/dS08b1onxqq63bSI1l/vewfL3gsfl1tzMCnhd8abvXJoBmBuCZWLIriPcV4s2+QquXoEYvNLB1cj8p3nb6lJ+IiKLx8+7i6HrOtQPiL0ZQYA3/W3JUI/T9QNVDxYyn16mgBa4tjNoHdzXxmg0SCNfHe3wOVlhFaLpo2sLXByEkNrQCkFpYBWy6DTKTEcxohji2bTYjzWyHON8ZgGwP39AvfulWi3DR48yNFuzy05jYZBrwfEscV0GqEs9cw6Aiicn0cYjzWUMrh3r8RkotDrGaSpRZpaPHhQwFqFPLfo9SzeeSfHYKBRlmS5GQ5jKEVaPk1nKPR6BR4+zNHtTnFyEuP6OsLBQY533slwdBTh7CzBkydTPH+e4unTBElCA288jPC9AngEYA8RNtFAFwlaKNFAhAYKdBEjhsFfgsHHMPjMqyHK/uHuGuO2wWUr4L6M1XHZQGRAjtocoE/kbIEoAkajqCJ9EaLIVm2CSMxgoDEa0W9radqq2STiYi29c7LczIlst1ui0yEr0MOHGR4+zHB01MBwSI7nSmk0myWMIetfu53D2gSXl8ohN/N7ozZdp/REoD5hsRjFeQwiOBPM341csebmsy5RWXWujojdltgus4ZI+eojgXWK6rplyrJ917r+Sj4rG8srJjJMdFLM34kMAsqESPrd8XUWi75UXId6BGJzJ7EOcak7LgmN27luLhv1d0BfZ6w7twxux/IRKp/A+6q1oHWvryv7TSxG0lLDQqGNuT/NzTzJP4IIwvW1xva2wnvvZeh0SiQJrXKJY4VHjzIYQ1aPfj+qNO4CRaHRalns7JTY3DQ4O4sxnWpMJhHa7RJKaXS7eeWjo9DtFmi1DEYjjc3NEtMpYK1Gu20xGpFFZmOjxP5+hsPDFFobbG4CDx9mKAqFvT2awup0yFm51ysxHLZRlsDDhzSt9Pp1hCzTGA4VOp0ScWwrgmSRZRrTqcL2Nj2D8/MIjx9niGNgf7/E+TlZf3q9Es2mQqejoZVC80LhHoDt2KJXKHSg0YRGghgaERqYIEEOA+AJLL4Di89hYG88c1cb5wHnNv1vnTZR159Wac8FgGGVrgk5kJSlwXCoK8sNkeGytHj0qMD+fo7rayKn29sGSVLi8jKe+VJNJhpZpqAUkZE4JitQlqHy3aI03S75cX3xBU0jTiYRrLXY3S0wmWhYS/5Y0ylNJR4f8/SSqUgsrcxrNoGyVEgS8t2aTCi/xfuWPhqsEEgrWp1T8VcNaXldNd0F55ibTqZdZQmXz2OZlchVWN3y64iZhHsvPiLF0+T8XjieksLcd0ZOS/E1rjVGhpJgB/4IwWLzS4G6xriMYNSZe33EQaZXuNnZII7XxdnwmejluWVTUMsGCvce3qbQelOsshj5BkhgbpFhrbQpzs0tAK0WWTK6XbKARJFBo1FiZ4eIR1GQT83lpUajYdDpkAWm39cYDBQGgwhXVzSd9OiRwb17RUWEcnQ6Bs+eJVW+FpeX5LvS72toHWM00lBKI4oUrCUH4+mUtHIiLQZZFsEY8tfY2DDY3y+wtVVge7tElpEVp9ezaDY1NjaIvHQ65MB8ctLCeEzWnemUyNtkQk7JUQQMBhHOzy2ePUtRFMDFRYTd3QJbWyUaDYPj1xEmX8R4dBLh/rlGooDR1OJQZ9iOSuwXKVowlaWGSEmGDTSRoY0pWlDYudF25bfPYuK+c98AJzVPV5HwtY1Vx1xwX+RVXeyAuQm2+FlLy7w5bVlabGzk6HRKHB8nODuLsLExJxnWkkVue5ssbv0+kaL9fWpPZ2cRptMYWhsUBRHb0Ujj4kJjMKCBqNm0M1+qVssgishvZzyWGrhGFBk0m7Q0vd02iCJqtxsbBY6PIzx/3kCWKRjj+pXx/cSgPjMS56WcqRuc6wjIKkK6TM75yM4qJciHdawzy+rlk+submOp8im+TFxSoJrYnVvRpFyLnPSczrc0XFpxXEu1H4HYfCOwrIPJY3WNvq5jrWuidKOzumWsEgbuAFB3H+ugrqNCHP86YhXJdM8xoeF56blgiGOajqEgawpRZLC9PcXWVg5jElxextjeLrCzYyqfBzUbPLKMpgTOzkg71pqcfNNUzfwiOh2ywrTbFr1ehsnEYjCgwWg8Vri6okGKp7OurqLZyqUooqmlZpOsR1pbTCYaeV5iY4MIU6NhkecK5+cxGg2L+/cNxmNVxcyhOp2fx9jaKhDHBs2mRqdTIs9VZSmgPKLI4uQkwuUlOTn3eiUODxNsbNBAa/sR8GkLv5op3IfBBgooWBhkmNocr6c5/qVK8e+ijY4tEcHCQkPDokQyewNb4NZbZ35fdzCS/+u08NtgGZnnMpjc8AByDRrw3dVzGmkKpKlGnlP8osFAoSz1bFrx7IysZtZi5rME2JkzsDGqcvKmcACnpzGmU4WzsxiDgUajYdHpUHuIY4tWi/xsyMIopyQAa2kFVZJQe9/YKLC1ZdHpFNWKLI3jY/a7cjV4frY8HSIdjBkydkrdN3Dz/a1jjV4mg+oIzTp4E6vxKqVqWZ18irAcR9xr2FqWgtoYO//W1V07v900brTp1YSGEYjN1xqrGPY6Ddb9LZ2zVnWyumsAfydeZRqv63R83BfLYRl8HctXzm3xJtcvs4C56fi4T9uSz5xXEbAZ1yJJgMePM4zHunL8LHF2liCOaSUKTR2Rb0wUlZhOI/T7GqMRWU0GA7KsDIcKGxslikJVK14URiOaEmDfmCQhgtBoWAwGwGTCfhk0BaGUrYhQic3NYkZs4piW+VJgP8q70SgwGmmkqUGaUsC/yYRIyeamwdFRXC0ppymD6VTh4iJGp2PR7eZotw1aLbIKZJlCp2NgjMLhYYTtbYMPP8ygFPDyZYLLywiN3OD+pxa/kuW4B40NRGgiRgJbtbIMj5DjlR3gv1I5/qreQGwsUkwwRYSsmtsvYDFceI/LyLRvIPC1k9u0r3X6KFtnXMggdTJgIG8ammJuBVSYTIA/+7MGWq0Sg0EMYzSGdPMzPxdrI+S5qlZHUb0mE7peKYvj47gipxYffdREq2XR70ezFXJKAc0mEefhUOP0NMbJyXwYIh8f8quhVW3sA0bTVpNJDGMU7t8vMJ2mVToDpWhF13TKy9eBuWKwzrN2rXDu8XWvZywjnbeFT/G57T3V1aWOwPnKXodUsDrAipiM9yTbqSSWroXGzW8dcraIQGx+oVi3oQD+jrOsgbuNxKcp+vJXuJn3bciGb7B261XXUG8r9JeV82Vwm7xuow0tS+sSPo71wJsY0vtstQx6PYPNTSId5NdCRIMEukaaWoxGEY6PKbeLi2i2pHYwiDEem9kAE8cWWRYjSQBrLa6vI3S7lDdNL8S4uopRFBrDIa2yub4mkrS5WUJri60ti/39EmUJ5LmC1rRShqYiaFDb2ytwfh5jNFLY3IyqmCa0AudHP2rAGIX338/Q6xGhyTKFPAd2dgpEkZoNhtYC7bZFUaiKhCn0ehRJN8+JnL18nmDnhcK3swTvIMM9ZOgiQgpdRdEgq8w9TNFBgT+2F/hZW+PXTYosizAtNaZoQUPhCMAfQcHcIOF1Wuuy9+673r3GbQs+Ilw3CMNznjexVJgTHd7cMqs+bBGMMRhEs2mj+UDEQfloWpGWd1toTUvDp5VBhNohKlKhqtg3ZTUtVdKzneoqlAAR8KurqCJGRIa0JstfkhiUpUKWzVdrHR4m6PVK7OyU6HYNmk2Dzz5L0e/H1fJ0eh/jMXB21qzugbV8uWKNn02dYrROf/XBZ9VYZc37KrGOpWgdpasur2Vtl8/zVJGcRmJ5Jq91Y235xib3WdbV9SYCsflGw0dKfGmWpfN1vjpz4zILQx3zX9fStE7Hq4PPEvTzxptYeNzBTz5zfhZs0qU0jYZFo2GQJCTsr6/jWXj8RqOslu5SvBByCKUpnu3tElFk8cUXMVotsspEESrnTQqqFkXkgNtqmcrpt5xZhpQi0vL6dYJ+X1fTAznimAgSb8Fwepqg348wmWikKVmGaAWNxfGxRp4D9+5FSBIavDY3ybfj8jLCdAo8fpzDWoXTU7LMXF2laLUMHj4kf4xWy+L4WFVWG2Bvj+ra79M0WxQBZy8ifLdf4J7Osb8LbE0Udq7HAJroYowpUkSzQb3Et2DwcT7Ar7Q2gLREAYuzqxQlND5Didfe/rBq0HK1UWB5216H1N9Ge5X15IFFOtcy6eGVJzlo9ZRv6425HxBHpybiQm2w7h6LQmM8ttWKKAoC+Pw5TU/kOYURIBJEedKScrLaaG2RZdzGdRX40eLJkxz37uVIU4uDgxL9foyyLJCmBsYY5LnGxobCdFpiMGAnYrYY+J5nHereW901t7Fs1J2/zbtdZWFZZs32XXMbi2Tds+QPT3PKOsiFJ7Fzfpmlu258Wo5AbN463pT13zb/Oi1vnTLchlVn2VnWEOvI05uQjFWagVv2zxu+ZyHPrathrNIY6boUFgUUoA0mE6Dfj9BsmmpVEJGMdpuC2bXbplq1RE62RUE+NUUxN9GnKZVxeRkhTTXimGLctFoGr1+n+OlPNb71rSmmU9KOnz4FGo2imgpKYK1GUViMxxGmU4s0VRgOaUUVTR8AR0cxooh8NaxVGI+Bqys6dnGhsbNTVlYAssJMJhGuryNMJiXGlwbZqUZ+FGFyUWC0H6PTsEha5Yy0PX5My82zDNWKLJqeKgqLzXiMg6KJLVti86FGt2/RnRRIihEUIkTWQMMigkUGgx6AfjHGJ40GdqYpMmNwCIMzWPz/AJx4NfFlGmZdm60T0sv6bl1fW9W+5GAu/RxYU+a9lpjgcNh6ueqEtW++TmrZVY7W7QtzBYf8bMhiYgxZ3WhPKhrkaKsGeT90fZKQE/x8JZVGp0NBI0cjhadPG9jby6E1BZ3c30dFYoBej6akut0Mw2Fa1W+Zxdk3qK9SzFbhyypWy6x0X7aMOnnFkAREtnNfvVyiLbdPsKjfxoTzd5+tjOgtr4En7fL7D8TmK8cqLWBZY11mOanrgK6lRDnX+awqq9i8T0C7jY0/vngKMg9fPVy42jCctKsGjC+LN8l71QDm++1L438mGzB4FxPs4RItNNFHC+ewOBpqXJ1qdN8rq7D4tPx5NKLIsWVJEWCTBDg7i2dOxuNxhDimPYK6XbLEXFzEODgoMJ0qXF2h8rdRuLqKce9egdG1QsMaIAPixKLdVmg21Wwlzfk5+cXs7xcYjRR2dkpMJmThsTavHJRpJdbJCS8rBl6+bEKpDPfvFygK8qeZTCK8+FmMqx9abL4y+NBatJHBwKJ/1cLFZznGH8S42FRoNEqkaYnra135YGhcX8dot2k5cCOziIxBkiq00zFaqUZna4q0qWBsiuHLFhJrK3IDRFCITI6fXgIbZQMjA7zCFH8Cix8tvG9gvoRYvkfZv6SfWJ1Gzf3GtdYBN30Q4Pnma1b1K5neF6LBzYfrJCPG8pYdbPGRU9x1ys9N+WQtqv2nDPKcBjzyv7KwlqZPez1qP8aQL1CrRf5cvR7FTppMNI6OaJqSlv/TVKm1qtqnTKPVyhFFBpeXLSilYC3vIA5PPeuwrtVk3bTrwifzVhEz9/o6pXCVYrVKPsv07jt3rytAcYRa1X8Zs2YZsZftc9lzXS2rA7F5Y9y2Qfu8vlflXceMUXMe4r/bSQB/o3LT+NLV5SPLWWcAZ6Ffdz+yfPeefL/da9wy3zbWER51pM1/HzGAvwiFfwsG72GEGAWusYU+NK5MEyeI8PTCwO4DqmtweUnOnNZiFkG22yVBmGUaxpAfxHBIPi+0VYGqQt/TNJBStLJpNNJItUVrbGD+VOPyJyniywx7doirhoHutdBUFkPdQKPB4fEVskyj2TQ4OyugFAXVm05pGkApmhorS95QUlUxUSJ8+OEUR0cJXr5MYPoW3x0O8YNijEcw2IBCDIUIJQYY48w0cHLawEVviuf7FiahVVmjUYzp1EBrg8EgQp4DowuL/ApAkiM/AVRZQMUlzF4CrQq0Xg+RlCNkMDBQ1ZuI8PtZDw3EeAbgCOfoA1iMsyHfXV17YLhBzNxrXYXky1hm6gYLH8mwmPtvKfjju5SgqSkNemdjzK01HH/Eit9s6anvC+QsriCtPuyro5SdkdXRiOLj5Lmu9q4qsLlJYQd++tMWsixFFFkMh7Rlw2hE+1h1OgUGgxivX3exv59XBEmBVkTJPaNc1MkK+ey/ShJTZx3yya+6Oq+6tk7OL5O5btnu9T5S7UtnMI/8zG0ImDupczRsn0XHYpE4M1bvDeUiEJuV+CoZ+W3zW9aA+LjPfLesE9dZQnzanDy/jBxxg5TCdBVpkfn6BoE6IrOMtNQJDV8dVuW17Jova0HyP5sYCn8NFn8NwDuw6EAhQo4pBniBTZxDYQsZds0Inz7t4fxxAaVQOQCTf0KeE6FpNEwVwl4jjktsbOjKF8ciy1TlnEtbKMQxEZyoUPi1K4PH5RDvXI/QRgmNDCVyTKclLqYWP0GCP1J7ODdbIK2b/Cg4kB/tH8WrWSjSLFl4WOBZAF2cnsZ4+TLB8XGMbGjxm4ND/OVygCcocQCgCyCGhgIwRo5TlOiNNK6Pp3jwZIof6008KyIcH8eYTCjS7XhMRGowAH7FlCizIcZnTWAvw/Wkgc1yCjUCrIlhkGMKYAKFa1i8Rhv/Ag3QQDiovn3E3d0jSrZdXz9ah8TL/OuI8LL/q9qhLF9aWKWy5SNwBkQK2FrDGxJymghz53bev0c6icbwywNpQVFVxGmNy0va+kLrEtZqKEXTV80m+9yomU/P0VGMqyuy9FgLXF01MJ3qqu1p5DnXndvcbZ7XsjTryDf3vysvXPJal8+6lhd40t2WjLly36fELitPti8mkxnmQUY5T2m5kUTa3fnbVRI4nfxfj0BsZviqCYyb7yrmvU75y9L4BKI87qJOCLvlLGP/Pia9jCDVnef/LEzda/j8KoF0W8LiS3+b9+DTsnyQWkqdFm7xbVj8uwA+gMUuFFqgLjxFDoMMTWh0UaABjcHEYHJSYLunETdp08nJhPxnrKXgdWlaoigMtNbY2ChQljQd0O9T0DSaeorRahmoTOEv9C3+/KSPD3CJXUyRgvxQShgMAJwD2MAUPXuE/yYr8Bz3ZvdkDKqIwApxXEIpzJbsUpoJKFiaBZBgNGrhpz9tYjIBHhfn+EHZxyNY3K/uvQMgrvLOkaOLazSyHC8PAftnJR7+5hAfJ01MJgpFEeH+fXIcvbrSaNpNXEZnOCkTNEYRGscNdMYK5ZWFKjRKq9GCQh/AOSxeA/gxVFXHQVVP3kixThlw24Lbxt02JUMmyDR1U1fuwCbz9g2Sy9qtJGVu/py3uz+Pj9TJcqWvzhTzAYyXlCsQ6UnhjzHDedAxsuZQ+WRpIYsO70J+ft6otlygdNMp72elQZaBeb7DIT/XAebWg2W4LQmQyhjDfU+utcctY53QFuvKIl86H9FZR165pOY2Cpy7nxM7CstnoDGPgs3nuV5MoOV0rLyXZYRyEb9kxOarJi/rvPR1SIvUnlZZGer+16WJsGhu9qWtH2xvpl9GQOqIhYK/k7jCYVn9fPn6sO47ccvwpZF1rutY7nHf+142MNKxGMD/FLR/0T4oKBwt8rbIYZBjBIMUEQwsClzFEfrTJo5jg7ElEjGd0n4/7XZRTUEp5HmMTqeoVjVRpGGKQxJV0XstIqXwq1cF/q38Gt/BFR5igg6AFLSJQA5gA2RBSmFhUODcnuIULUxUt4o6zM6gBsZoGKNnUw2UwxBzgTeFtQ1cXZHgeg9DPITFNhQ2AWyANo+IoKryVTV8ZchK4PXH28gfakynNJ02Hkd4/TpBUZBztGpY/AQdbEMhKQ0wjNGFxmXWQhMFLAzaUOhD4TUsfowIz5BUdZxU9XUtM9zmfVPKsn3z/7q+47Yl4+RRp7H6rDgull2/LJ0ceHhgkjKpFOlcUsKaOXCTEDHp4akrYD6YAW7gyUXSRAPjYKDxyScp8jya7YF2UzY0xH8eUCegYIS+/aF8WCbDlvVnX/p1FbBlWCYLud2skovrjDvLjte1Z9+1kiD78i3FOd4agd+d7BdMhGU/cWUxsOoZ32Fi81WTmGXlrDOQupEu3Tzc33VpfencPNyy1yVBddf5GLNPiLrCTznHli3xk0JN1qHuWS3TOGTaZe9mnQ5TR/h8A4Ksn4RZco7wBMD3AOwA2IBCF3a2K1QBgx5yXMHAwGIKoFVYNHKD6XiMk2YbW9u2iilC+/sAHCdGV6unaKAuCooDQxpyjDwHtvIcv5EP8AR93EeOHQAd2IrEaBSY61g5NEYAvo0Sn+EYn9gejKGpr/G4AJDMItLSZwyygPCUgAINdjmACDFybGIy2zCiAYUGLBpQlXCyswmOFiyaUEitwvEfW5xboCxJQE4mrOlpTKYxPsYGWhijQIoJiCx1UKINgxhjAArnAD6Cxr9AiglyUS+fQF1GXHztyNc+fG3Ep+VDpLOo7wduWXXl+fJ24Q5IcqsCV+Nm8gPxzQMW93M+V4CeqZyi4kEtqc4pkS+wGG7fzoL78fJ8GgzdFV9sKeIVXmORfhV8CsuytEC9nFmX1PhcCPh6H7GQebtyld+RlJ0+cu2TsXVp3bqsytM951oH+f2w3xZb+EonXQkiN/KeZEycxQjVdbgDxOZtEJh1BMI6hEZi3bQuOfDV6zYawTIC4DP7yd91Kzd8GoSP5CzroMr572prdfVdl+jVpfENEL79rZYRHV+HX4a6zj+HjC/cgJ3FhaVubdFBDiCFgYVFjqadIkULTaTIZpsCUnAyoIFms0QU0fLnfj9CklhsbNAy2iQBzs+TWWya+8riISz2kWEbJXqwaMPO3EJZvyoB9KDQg8UugF2UUKDYJrTXD29yx34ZPP2UYdFhMANNE2g0kGMLGSKomdjiIU1Xz0xjLt4iKDSQwZw30J9ZAqQApHdZwODfIMUVFL4L4F1MsYGsWmlVYAiNTxDhh4jxqqKPi/4kPjIvj7vvntP5BlL3OtdnQOazjvLjHq8b+CCO1/Uv97c8L6eV5DF+1pLUyHSS/EiFRio43KIycS2Tnci5jp/XpPpmoiRhMX9/FkRSC6zeu879/VXI9WXKZl25svy6a/kanzypk83yujpiLdMvI+1uW3dJL5y08rzs/5LoMLHla5kM83tLsFinxc1c6/ANIjZvg8Cswm0a+FdR1qp79JGeZdqe7/q6POV5Fig8D+rGwYBIJ/NZRn5kB5GESVqy3CWpVqT1kQ1fJ8SS/xKy4/mewar8fAJlVXupPz/f2o3yuSlGLJoYo48WMrQre4dCjCYsDC4uAGMoKiytgEqQJAWKIkZZ0rYI5GipcH2tcHVF2xoAEbQq0MMYTZgFUkW0gf1s9GzigLe36yFDij6m2MLiLsq8N88Qc63Z1fqHABRyAOOZJ4+q3FX5m54EGbGtMGbnmKKHHBo02HHb4cGO2mwOhZ9C4QUU7iOvrDUFFEocQeMEEQpYzAWp7Ft1Doo+su5rt+5gztCea7QnHaNukHQHHJeUrEOO6tq8JPtuvayTRsofJj38XwYFtE4ad9pK7sbt+iOxZu+STpZPpbiWr8ux+F7de5GySJ57E5m/iqww1s1fKpxu2+Fn6I4F7rtd1l5kXdzn4crCOiJfVxbXz5eW6833V8L/PuRqqUxcw3k0UN8/CV8zYvOLIC8+fJWEZp17kg3MFYZ1QsWnpS0TjnUdYJkTnMzbXTXhXusKG1862XmklsZp6jqr7Mzyntw6r0IdCZTn1knLx9+kvfrrmkNhCosSdhYPlkV9DgUDgxb6aGOKpJq0yZFiAMAigikXByljyOcGoFUi5+cRRiPAGI3JBLCWhItGia4t0MIYMYywmijxttTsO4KZRTkhB98S05mQGmM+oFgskhq5xHg+0GXQeAWNK5QYARhDoQkLBYUECgoWGRQmoBVMQ1hcweAFChhcYN42eQoJTlkKYxh8PhvgioXy/SQb8LdDd5AG/I6xsl278LUzX7+W/aOOIHGZcsBw/enksbr6rCvvZB0Kcdw4v+UzdLV6V1mpGxQhrivE/1xcVzrXsBJmxTlJXnyyzvee1vF39J1bVwa58t497xIKnzx20/mINV/rylpfneQ9qCXn3OuWkWmf3HbDC8h6c16FOMbf8p1LK48fXyNi83UhNevituSnbhplXVYsy/R1CrcRuGVxY3fN4lJw+gT3qjq6wlZhMRCTbLxcvhVp5X1IjaSus/iIl9uZ6jqj+/zgnFvWBusEke86Xx2Xpbd4DYXPYfEItNQ5AlBAVdFxNaYwFYUoUaLABCWuUaKPEnY2X81B1bhc1mB1tVSWNaW5qd8AGKMBW/nvGKiZbky0AtX013xvawsLXtQ5RQayvuQgIsNaMpctV9u4daN7fw6N11DYATkNM01JwM7DwBAKFwBOQQ6/Lxd8duTzloJTTplIq5FLGvid+TRln/CWxBxYHETc9y37lK/vwXPNssFF9lcXvoHH93vZNcBNy8syWef2XTlgucRCXuM+R/bPAW4OxD6yw2XK87LNM9z3KlG3KmkV2VslU9Z91nVluG2Nj7kyXpannXRuO/ERJnm9PCZXca4al9w27Na5TjbXEUxuE9Kfxp3y/EYRm7uMuoHWJ7A4ja+juI1b5ikbtK9hLet4kvDIRrOsM6HmnJwf5zxYg5abo8nrpWBiocYdy9U8fCTHhSRpvrS3IdF1ZdwkJ4vHlxGlm0KgD4sfAngPNItcYL4yqAAwQYkhFIYwGEDhGgrnKDGYDdhMbPgZy5UoctDnZzt/J2eIcQ6NIcgy0oCFhqJtHGBnk0sTWIwBDKBwCeA1NAoYkL8MkwdJZhjSdC6JB7WT51D4EWhFVFqV24NFo0qTw+IatLXBCyj8CSKcLfh/yPxkm5fn3eki/kizN7dbeV5OHblTsgr+NuoOIK6y4PaldYiMe87Xln1l1CkjqwYcn3Prsv62bJCuq79sJ/K5+ab23DrI6Qy3rLrnXldHtwzf9Hcd1knjw7Ln5Q707jNxy/cRoLr25hJGOXZIuNOBwM225jvu3oOvT0iiMpcDfoWWr+djciypRyA2Xwp1g1vdOVd4+ARaXR4+rUM2DF96t1G4Dd5Xz0UnTD+hkQ3X9blJqt/ctAzmsQxkECafIJXLSnnAKT1p3bqswqqOd5vr68gd/64TyD4sDi7/HYAPQcQiA031JNXAPoXCJQzOoHCMAq8A/BRFtdBWhizn58bxIRTmm9KlmO/qzGXHOEGBz9HEAXJ0wEu851NBJcgFeACLKwBnoF2vX81sK8BcKLkOp1KISrfg+TRCDuC/QYwEJQqQdWYDFJDdQiEDcAngJYB/BY0/mtXKJcC+QUwSbvfZu34wsk2z1ir3tuHr5G/ORw60su3LPisHYUmGfNZcl4j7zsu86vwa5PV1g18dyXLL9JF33zn3uAw5Ia913xWXze1HWg4Y3L7lXleyHdSRmrp6+/77SJ3Mg8tz8/U9+9vAJzt8clamke3WJdnLZDec69x83TrV/Wcsm5HwPW83H3e88YUokf+Xr3YLxOaNGTewXNOqSy/LrEvvCiBf+joBxt8cLEt2QpmvdtIzYpHGZdNuh5BEhQUYXx+Jbzn9JH1wJJuXc/YQZcqlonVTZb5nUHdulfa2zrXLzi97r8DiO8DC7wGA/wTAJRT+Iiw2AbRhUYL8b84BHAL4GAZ/iAInN4iDwaJ/C4DZNJUcKHjwJafLcwA/hMVDaHRQwoCsRRxhogRZai4AnAI4AvApFE5uLNeUGpZss+6A41pb6N7/GTSeweLPweIBgA5oRdQYwAto/AkUfgyFseNDs9gufStw3IFb+qTImBnSWsPt13e99O2Qg4m0SLoDjvsc5EDgEqA6UuMbyOpkhEzn5l03KNeRQgnZ3txjEvKeXX+XusFU3pPvmQGLU4oMn5Wwjti4aW5LRnwE8cuMIT6Z7vMnlIQFuOm3yNdLWV1HKHzvfFl9XNTdd127dWWej2z5/rt5u8+kHoHY3KpB1jF+Xxo33arOvKxB1bFvt1xXCLvHfYLPl87nKOyuYvCVp8VHNq1YXMMDietAaDAfjN0OyktCpaa/6r3VaQ+rzi3Lz3d9nQBZB/J50jWHAP7vAH4Ijd8C+dyQn43Cc1h8BosvYHC5IARZyEnrFufpavNygKH0FhZ/CoXdavrqCSy6oLgxCjQ1NKqI1VMo/CkU/hhJles6mrK8V9/0AZ0fQ+GPEeFjlDgATYddI4IBOQ6PbuQlCQgfl34XktzI4/xbTtlZJ50kPjI6KpNHSSLlc5UkXpI4W5VVeq5hpUDCZ4GR7aXOH833jAD/e3FlgpwO8Mmxuv4jz7v3JcvmNK7l2R20GZLEuHWVz1jWwy1bXrtsEF/nOMP1+XGfe52sqCvDV183r2Xv1rWay7q5dfD5eS2z9rl1cqeV5PJt3z1w+S4ZdPP21XVdYnQTgdjcGuuyxlWDm0974ON1jNYVUnXkBFhsQNyY6zRd7aSTe3nI/Tm0k9b1l+GBgDfH4xgEsjO4Dn9ywONBhvOR9eV78lmffMJUok77c6cv5L3U5eMTwqs72s185O/FsgoAPwPwORR6UNDVMxhCI1sQAG57qLNoyakTgLp9Ic5R0L9/DoVjxPhtFHgHCj1oxKBVWgMAr6DwJ9D4E8S4qp36WUY6JSn1tX+yKI1BBOpm25FkRlpb5EAgv/le2ffIXXbOMVP4+UhSw9dIy00Bms7jWBuJyIv7iawT36skc7If8n/XV8glSTIt34c7kPB5n0zxtX/fM5MKhS8/X5782yVaywhJXZ7ub/e+3EFVtutlcnmVLH5TuLKXv+uIlJvWV083H+CmYupaBV2CJ9u0j2DIvuWrl5w29l3ryj4p032kxa2Hry24pNhtg+6zcafmFhGIza3gdlZ5zD0uj7npGD4H11VaRF3DkfVxWbkszyU1brAj18FXhiTn69lnwy2HtVs5JSW927lxluKY7LxyGoyPdbHovyEHJ5+FYhVcQQv4n7k74DBcYXBbobmu0KWVR1deUseWK/deOJ6HrKcUSHw/7lQKtZkpgH+NGB8jwmOUeAyLBAoaEQ5BRKsPDbNAlIFFAcVwBx/f83QFmBy44HxLUiPbGPvByPJoTRmd5zCHCnMyx20vEce53bNQl7413E+5fTJZcskjO1DLugM3o+/K5yPrAywSU/e9SYuqKzdch0xg8fm6dZLHXFm2amBe1uZdS2wdaXHbtfzvk5l1ZNgnh+vgDo6+dyFRd3xVGeuiTtZLSIIh5TdDTvXLZy9lrquE+BzmpexwCZOUx9ymZL9z6+G2X9R8F6LMVe9y3bZJCMTmjVAnyIHFF7CMpCwbYFddx+X4BD+w2ADhpJd+Liys2dRusRj7lRuwFuf4GjnAcCPlvFyw0M2wqNG6z8gndCKQGynXh+OVLNMq6+B2tmXX+TTTdfNn+NpEHQG4Tf7uQCd9qeT74mvk9IvrzwFxnNKPAHwCjU9ukEZ7I+3iebeucjBytS55TZ0TL5z7ZIHNZCV1zst2wVZDGcxLRsJlKCzuQh3D/8wsgBJKxbDWZ5WRjtvy/lgRoA0pKP8cN++X61LU5MFwyZGUI77Bo65tLWun7rV15MdN6zu3rI24/crXRoCbPiNum3LzqCNG8rzbPt+ExNRh2TNfVl9fu4+cc667gCQ+sl9LwuASn1iklbLCVw+3nfL17LwtlQopH/i/7GuuI747beabVnVJr/yuRyA2t0bd4OWDS0LqXowrbN3y6vJ25+VdJ12fdsOxTrhx8ZSRFM5sjWEhK9m51Ap4YLFVHtLiIu+d69nAYkdzBxhZT0nSWpiTsREWO9Ey0uBDHVFZl8B8WQHo3uc6+deRIdcqU0cu+LecxpD5yHfhWk1cUuL+9tUPS875CKM7UPuIOpNvOcXZxCLpsc5HWgG5v/BzqyNt/AyIqGutEUUlksRic1Oh18tRFDkuLiJcXcUwhvN2hT/nx9ZJrqskoXwtsNiXJTl1B3BJBmV/rPOt8BEQ3zH3Wrcv+ORTXVoJ93nIa+v67qoBzOfPUdefZJplWNaG5fW+vrbOc/Dlt6y+2vnIdiKVT/4Y57er9HC7l8Rf1rfOT4evYcLP+UiC5Zbv+mrJukvyI6fMgMX6u9euO+YSArF5I6wzCPrY77Jr3UFDslufCV82Iit+A4sOj7I8bkx8DQfJl/4DfD0wJytSw5SC1bXkyLq5DVPm62op8tm4AoPrnIAGB64PX+sKFVdY+DSSOrhCaxnJ8J2ry9+912Vk1f0vhbw7BSEFjBzMFepXj8hB0DdgwjnmEhtf2jclem6bcS0z/JunlCSxkVOoBouarbSo8PQQ9QetAaUUypLSKkVTSGkK7OwYjMca19cRtI7Q6Vjs7EzRbgNJYvH48RSPHxfIc4Uvvkjx0UctXF1FiGMDrS0mkwjGAErxTucKxsjpMt68kTVeSUx5MOAduuRAJJ8x35vb5+Sgw8fcb7cNuX0Pnmvccz74+siya91zbnvy9YO68nykpo5A+Ij0OlhWX5+isoy01NXBle9ydSl/uG1LOS3buZRfrMDK6Xr2DWOy7bYVlifSwslTVNwufT5vPgWVlSipTECkl+OILJvhk62yDS9/d4HYfCks64Q+YuMGJ3MHfniOy4bjzoHKNJHzLQcIt/Fww2qCGiw7QnLjlQNGjLlFR+7J4jbum4xaKQu70D59lhr5PCC+fUKiAerUE9xEnSDxdRCf1uUOAHX14zRSu3DhvntOt+5AUVd3roc7xSiF6jIfIB9J4Tbhak7rkJu6wUTCnaeXqCOHbGnhtsrElnepmls3lKJds5KkhFIKea5hzFzjU0pBKQ2lgJ2dKfb3DaxVOD1NMB4rpKmBUgrb2zm++90Jrq5ifPZZA0licO9egcePC2xvFxgONb7//Qk+/HCK4VBje7sJYyzOz2M0GhZaGwyHMRqNHBsbFsfHKaZTjclE4fIywmBgYQz3R74f6ZPja+/st+N75zxwuFOMPpJrnePAzTZdp3C5cPvBqsHevdZ3n3VEhOGzsClPWp/scMtZpjz4jvtk9DKyBtx0VF9GdHx5SNnN0/usZGpQH+ByOF8mLdx/pGM758sxrKT8lv1T+pcZkSewOG4sc0zm39JfTW5sKcczn/+X790q59jqdhqIjRd1AncdQS7PS2uKb/CWnWbZwAAskhIWdFJLlYOBW5ZcncRkhRvZGDenkXyDnFxZInfg5WtkwzNQSh7n3+yH4yMWnMZCKbreGAutKT2Z/Nmkz5FufVrSqufpCnh5TF63TBjdRuOTg4uvQ6+Cez+ukPYJ7bqghpLMuELJd6++Z+R7Z8uwKl8X3F65TTIxZ4udAmuCvZ7F/fsG06lFp2Owu1vg9esIh4cpJhMS+hsbBjs7JbQu8f77Uzx5kqHfj/D8eYnz8xhpWsCYCHt7Ob71rQyDQYl2GwAMDg4KbG6WODjIMJlE+Ct/5RoffJDh5CSCUiUajQKvX6dIU4vpVGEwoHyePMnws581EEXAdKrx+ecpfvKTBg4PE3GfWtwfKw486LiBKusGSvlOOK0kQb7BXy61dwftunfrIzO+AcanALgE2SXGPvIhr3fL96XzleueW5X/qr4uUXePddesS+olGeUp+AbmfSEW51x5x+RHnnPL4rbkTiWxzDfOMd6Xia/1pXPvz32vwGLcLDkdxm3VTS/btPvMVsn3+dMI+FJYRwtY1vFkx5Yv2GXTMsgacNOxjJ0pZXmchkOt8faKDcytHkx6XA2lFNfL+rvxbGS955qAtYBSsnGyB7xvWo1B58mvwSLLIkSRgbW6IjbAzZ1d6wZ+1KSpIxWuhuBe6+tQq4SeLK9uMJBYTxu5Wb5sM/zfNwhKM7J7fh1CVzeorRI26ygEsn2xEOc9xqVfAZUdxwZ/7s+N8IMfTHB4GCOKLD74IMfpaYSPPrI4OYlRlgrb2xmePMmglMaHH07xzjtTnJ4mGI3IWtNsGvT7wMFBiW99K0OSGHzwwRjn5yQau12LrS2D0QjIc8AYQGtgc7PEhx/m6PVK3LtHZOnwMMXmZolf+7UMBwcldnYKXFxo7Ow0EUUWZ2dAUVC+ZMl0nShboIGEtzVhoc/Exn1+pfgwOWJNW76jOgufnHbgdD4CXYd1+1wdeVrWblbJVJ8i42vXbl6ryJgPbj/ztee65y1RR9Dc+rHM7mA+/S5lsjvwS5cAtzz3mTG5duvI/c4dc3h88D1rmY9LRNx2VWK+l5xrhXTfE+fl+lK5JLkegdh4sfyhLcJ96W7j1Z7jPiLhDhrS9CcHLTktpZ1ruFMozH0S+Ddwcym362sh70FOOblTYO59u1NlFkopdLsWw6GqSEki0tQNdJR/klhobVEUBtZGKEvZoKW1yDfQ3ubdSSwbfPkeb2NpcYV+nWBeVo9l9aobLNapl3utT7CvS8Tc3z4h6IMvX26fTGoamJNyEnQbGwWaTYU0tfit3xrjL/2lAb74Isb1dYRvfSvD4WGKLNPY2iqQphatFlleut0Sv/ZrE+zslNjYMDg9jTGdFhiPNbIM2Nub4IMPJtjdLdHvazx92sDpqUYcW7RaFklS4vg4QbNpcX2tMJkoaG3w67+e4b33coxGGj/8ocbmZolvfWuKBw8KtFoGV1cRlNIoigiff55iNCrQaBhMJhpnZxplGcMY+by4fUsyKj+s/fJ/uZu6JCvS6iO1crki0n0fUh74lo+771OS5Tr4FAMpr9ZRDuryX1cJ8N0r4F/d52u365B4X1189+fKLN+4wO2/iXlboPdHyqJGkpQoS8AYDa0t4tggywpYGyGKqH5RpFCWClpbGENWb2vl2AIsPl+fjGK4TvryuNs+fPfNfZs3ywUWHendvPme3c1rmcAtl8WB2KyNZYOH23l9ndh3jUwnrSPc8FiASWLhEiVOz/9lYDEZm4PTsUnQF7RMEppl98lC0tcxydzYaABFoaGUQpoCSQJMJmqBpCgFWGugtar8DyjPoqC8jFFQitNx/lxvn2ZZJ+hWCdK6Yy7p9J2X975sEF9GWOrKrsO65brluELntsRqVV1k+nXIlqtV85RTCtrUQe65BGxuWvzgBxl6vRJaA7/xG2P8+q+P0e02cHgY4/33MxSFwuPHGp1OhIODHMYoWKuxs1Og1zPQGkhTi3ffzbC5WeLoKMFw2ESaKkwmwGCgcXISI8uoTtYqaF1ie9tgONT44osUxijkObXNdhuIIqDZJJ+cZtMiTS3ee2+KKCLLjtYWea7w/HmMySRCo2EwnWp88UWMPM/R75OF8/paYTSSgxlwU/mQK6akbJB93GIxirdM6+6UzL99/Vieq9OS6xQ697yrlbvpVvXfuuOuFcG9l7r27CorbtluP3HJkNt21yHwdb/dY+xHU2JjA2g0LIZDjSQhQg8U2N0tkGVAnmtoTc7tFxcK47FFpwM0GkCzSe0uSUrEMTAeaxweKuR5BK3NzMF90RpKsjpJyJHeWoU4pvszhhRWa8tKXnOdmTCTQqqURVn6CKC0xk6xGGhSkkx3ekr6jsntdeoRiM0bY10twh1MZINwX76ME8NCXr5IJj9Sk+Nj/O3GpWHH4ByLc6NcBrDIxoFFYeq7F/fc/B6Voo7R7ZbIc1utLiGBf3iYoCzJImOtRhyXyHPAWos4VpXWodFuU6crCl69ws+LNVZ46uD7vw58QrAu3zcpz31mdQPEbfME/G1NalDrCF73+jfVgm8LX3/g6VTa15yhtUWrVeLb387xm785QaNBy69/9VcnePCgQBSR8N/aKvGd70yRphbPniW4d6/AcBjh5ERhMonw6lWCjQ269gc/GOPgIMfxcYzra6DdNuj3Y/T7wOFhjKJQGA6JlHe7wGRicXwcYTxO0OuRT0+nY6CUwXisUBQKW1sFlAKurjQ2NmiaK88trLXY2Cjw678+QaMBAAajkUa320CSANMplfHFFyl++MMEw6HPygvcXAggp5l5kJCKjNvu6lZMyfcxe+pY3o58loZl7dKXdlVfWAZf3W6DOjnN576MIuJaNFwyVNcfFy02W1vAX/gLQ2xuGrx4EaMsdaUIZmg0omrFXY4kUTDGotGIcH2NysKoUBQRms0MGxsW+/sGk4lCo9HA+TlZcsZjXU31k5tAs0m16HQKJAlwdRUhyww2N4FOxyKKLIpCI8+B09MYo5GurEDztrK5SVOwn31G/j5EnPje5JRZB/M2Wzq/gcU2LNtKhJuxnm5iJbFRSjUB/NegHhQD+H9Ya/99pdQOgP8bgPcAfAHgf26tvaiu+fsA/nZVy/+NtfY/W1XO3YCP9S+z1shVQkp8M+mQ5EMuwdaYz1WiSserRbgjGSdP12mMG4z7Xw6O7pSP/L4p+BoNMn+mKTlNJolBktDxTqdEmmoURYyioHsyJoK1xPDjmFawNBpEjFot6kiDAWnE1pYoCknglhHLda0ywKLg8WEdi8WqNHVC3HetfMar6mGdtLbmmMzbp0G7JNWtj5te/v8yhMlHblJIsRTHFjs7Je7dy/Hrvz7Gb/7mEFqTs+7ubo5Gw+DRoxxZpnB1FeHx47wixAoPHuQ4P8+R5wlGoxjTqUaeG/zWb43R65Xo9Qz290u8fp3i5CTGeKwxHCoMhzGyTOH6WmFzs0Sa0kAxGsU4PIxQFDm0ttjeNnj4sERRAJOJxnSq8eRJhoODouoLRID29gyOjy2+970pDg4KTKcKl5dE4Hs9g+trhfffL/Dxxy2cnCR49ixFt1tU+UawVmE0ouc114T5ebEiIwcFucwWmA8SchsNOQ0gV8lYcc61Usi2dRuyLuu76pxrgbkN+Jp1psc4XV0+y7BOvXwEZh05oQAkUCrCd787xQ9+MIExCtvbJay1OD1VlTW8QL9voTXQapE81doiy2JkGa+OMuj1FD74YIJ33slweBgjzxU2NlBN86coigj9vsZ4TE7znU6J3V0i/1dX5AbQ7Rrs7BikKYXZyLIET582cH4eQSng4iLCeEwWzG4X6HYN9vaKKqyCxWgUw5ho5qM2H9PcLUkMFmOnSWdjd/r0y09FTQH8D621A6VUAuBfKKX+PwD+ZwD+C2vtP1BK/T0Afw/A31VKfQ/A3wTwawAeAvjPlVLfttYu32f8TkAKavcDcU475yT5kKslJFEBFgmMnHPnPFxPdy7P58UuSY085rMo0f8ksbPlscaQMyXP80YRab0bGyQ8SYslMqYUoJRFmlJDLwpUlhqFdttU1h1aqquUQRQZdLsF9vYsDg9TXF9rFIWsX93S5GUaVx3qCEcdfIRB/nefoTy3br3qyPBtSIS8r3WJknuuTnN1B7Z1/Y/kFIqbP+dJbabVstjaKtBoAA8fZnj4kIjND34wRpYBT5+mOD2NsblpsLVVViuTNA4PExgDpGlZERyN4TBCWZJ5fXu7xJMnGbQGosii11N4770Mp6cRRiONq6sIk4nC9bVGnlNb29ggCyJpuArTaYQ8N2i3DeLYYjKh6YCNDYPHjwt0OgbTKcXMiWNbfYBer8B3vjNBlmlcXWl0uwaPHhX44z9u4smTHM1miZcvIzx82MA770wxHtO0WFFovHoVI88jHB3FmExYU2aiwgoQ9w320ZBEh9OyFZgdlKWlh6eq+J2679s3/ey+R5/FiLEOWXGJgKux+8p2r/Pl6VoO+LcbZ2Ud+KxEPgJzGwVL1jPB1pbFX/yLQ7z7boHPP2/MZGi3q5EkJFPb7aLysSnQagEHBwqNhsbpaYw8BwCNra0S3/tehsePc0RRhCwrsL1N7bLZHOHZswTdrsZoRNaVVsvi4CCHUkCaUnymg4MCGxsGcWxwdUXWIbLGp1WdU7TbQFkqHBzk2Ny02NrKMRopTCYawARlqXF+HuH6OsZ4HMEYOdXJbU/uvyZJDc82uPut1WMlsbHWWtD6WmAxTO1fB/BXquP/EMA/B/B3q+P/2Fo7BfC5UupTAL8N4PdXlfXNwqqO6zPBAYukxp0KkjEu2PmXWSwwJzzG+S/zkJ3OdS6+6eRLMM71i/eglEWjYbG5WVZ+ChajEZnfp1OFLNNoNAwaDXLW3NoqYIzC0VGMqyv6FIWqrDNG5Kuwt5ej27XIMovx2CJJeBACej0DpTLEcYLT0whlyc5n6wy8dVhlcViHQLh+SHWWl1V1WodcrIPbpK3TItfVJmVaH2n31cvXJ3zPi9p+HJP/zN5egdEowr17U+zuGmQZ8OpVgkaDBt7j4wTb20Q8rCWyfH1Ng35RRLi8JBLdaJDflrV25vMCkCAmXxmFVousLsNhhOlUQSmg0TDIMoXXrxMUBZBlJPzJ4hhha4s0W546iiIiS9bSwMHTqET4DY6PYzx/nmJvb+7v024b3LtHFqmdHYXRaIB3383x4YcT9PsRPv64hTzX2N0tq+8El5ekIY9GqiJRBS4vo0pTd/1zSsxXl7EcYeuNXM7rDuyyfctFDPK3+86XtQUXt1E+6q6t6/++dPxfOcddJcCXj8yv7ty6kOX5nhG5IDx8OMX770+hNdDvA8fHKe7dy/D++1OUpa7aIjCdlihLhXa7xNVVjG6Xfk8mOQaDBFFk0WwaxDG5B8RxiW6X/MmMsdjdnWJvTyNNqS+Mx0SGypKsP6NRhIuLCFordDrAcBij0ynQ7eZoNoHhUKPZzNFsUr9rt8k53xiyJJE9wyKKyDp6dUX94OyM/NjId5KfhfQplVOu5G+0uKJqOdbysVFKRQD+EMCvAPg/Wmv/lVLqnrX2NQBYa18rpQ6q5I8A/Etx+Yvq2C8hXLOqa1WRL5A7mYxZwCSG82FtSxIWSUjcY7LjAjc7ukzv1nle7zgGtrcLPHqUV2TD4uwshrXkB0OaLTmqNZtkhowiA6UKaN3A2VmC0YgGDGNs5akPNJtEYNLUVhFhI6QpDQjNJmaOa52ORZ4D5+dA/RJA3Ki3X4Dw/dYJwHUErq98ed0qC4lP43sT3Eaw1xGtda1A7nUM6djntne3HnX3zelpirHdNvje9ybY2yvw+nWMvb0Cjx5liGPgpz9Nsb1NRObiQqPRIAtNv6/x4kUCpRTGY+DyMsajRzk2NkqUZYGiIB8uAFU7tZhMUGmUwPZ2ibMzaqNxTNadsiSH95/+NEGnQz4zWtuZY2ZZanz0UQvX1xrNpkGnw0H4qD0XBa1I6fUM2u0Sp6cNWJtWlk/yR5tMFO7fz7G9TYTr+99X2Nwky9LpqUVRkIWn2YwRx8DBQYyLi3jWnz78kKYqfvKTBl68iJHnZEG6uFDVoCGJTip+ywjeFotxoaT8kFMCbI3h9+daTn0yZx3ivKwtuu3Z99vNyyUqPlnA30z+5EC6DpaVX3fc7Sdueh7cU5Rlgc8/T3B1FeGTT1J0uxa7uyUaDSDLaMrIGPKDGQxoPBkMYkynCt1ugTQ1aDRM1U6B0Yhkb5YptNs5ylJXSoDCvXsWjx5NURTA69c0XVUUFHm706F4Tb2ewaNHE+R5G9NphCgicjOdxtjZATY3KZ5Uq2WhlEaS0O+ypDru7xf44IMSV1c5Xr2K8fx5A2dnMa6veRrNoCgsrC1RljEW2xK3vQbmQQiXy861iE01jfTnlFJbAP4TpdT3lyRfSzVVSv0OgN9Zp/yvL1YNUG7nkn4z/F8u7WSHYXYCnmLuIAjcFDicr/Uck+XXaViuuVnej1x9YdHrkVNYu20qgkJTU80mec+XpZ35y+S5QVlqNBoa29slrq81zs7ovpPEoNsl03yjYWZOxFlG4ejHY6pPkqDqYKSB0BxuVJnffdrabQSNK7xWESUXdWlWkZt18qwb9G9TD59FRQ5YUutetQJO/pYD3zLCVEfqfPfipifr3+ZmicePp8gyWzknRmi1ysoHRmFnJ0e3C/zkJymePUswmSj0+6RtWkvOu3t7NC20vV2i36fVSOQTEKPbJXJkLWmyu7sK5+cavV4mplAVzs9jTKfAzk6BvT1TLQePYa3F2VmEw0OKYAwA776bV34JdCdFoSoTPpGb0YjqNZ1S3+n1zMyZ/vqa2n+SAN/73qSaCrBoNskiZAwQx8DubomynKIoyKfo29+eVlafAp980kCrZXB+HuEnP0nx6lWCotDVdLEcyLPqmfO0doTFVSrcRiRpdd8lcFNm+GSMzxrivv91+pPEupZOtz267ZDv02cFWFWvumPLFBrfMSnP5wrv2VmKP/zDFobDCEopPHkywuPHBc7OIoxGVLckobADNDWpMJ1Sjs0mTYsOh3ll8YlgrcZ4TFNN02mCjQ07axv9vsb2NimMzSbLY4rhRESKpqHKUmNjI8fZGVmGrq9jbG+Tn2SnUyJJNLpd4P79Cawl685wGKHbNej1Svw7/841nj5N8egR78Fm0G5HiGNga6uEUraK1A1cXpKTclGwA7I7Zn6Fq6KstZdKqX8O4K8BOFJKPaisNQ8AHFfJXgB4R1z2GMArT16/C+B3AUDR4vxvMOo0YN8xnmoyuBkcz3X4A+aOgD4nX9mZ+KXLst2O7KsbacjWGkwmRuxcPL/WGANjVGVJMbi6ijEcanS7JZpNjo9ARKUoyMkyjmnqaW+vxOlpjLMzVZnoaR42jnkZN5k/+30FY3Q1lwxYWyJJVOWLQ52PNFC5RPA2Voc6rKNRymdWRzSWWY5WpVtV5m3TLxPobvluep8FqO4ccFOLl9etqqdMO/cV63QmuHcvw9ZWiV4PePmSfEzabQqqV5bAzg6wv1/g+fMGhkPg7IwE5b17JRqNElFk0W5T1OFul6ZrplOFo6MEX3yRzqwknCaKLH72swStFnB6imrJbIaTEyCOSbiWJSrHTXL+1ZqcjHm1yPW1xtOnKXZ2CpQlcHBAJDzLFE5OYihF02WDgcbGBtUrz6n/jUbUDwaDCK0Wka7xmAgkDxzvvEO+D1lGjprn5+RYvLlZ4MmTDElicf9+jsvLCBsbBp98AoxGBfIcODuLcHERw1p3uThH8yZfCLfvz5UxTr8s9ov875IevmaZhXEVZDl1y7RlvnV9wK3TsnJkfu51dX3JTV8nY3x5kQI4GuUYDCx6PbJQDIcaJycRzs8jFIXF9XUCYzSur1HtSUZTpUoRWbZWI02JPGeZwukp9Y/Hj0k53dsjZZEjYw+H5DsWx+TH02yaat8zar9UFk3bss9Zr0fyn5aAk9La6/FqQbpvCmVAFvc4ttjbK6C1xf37Ga6uGuj1yDn53Xcz7OxQNPDnz2m69fKSfNmyTOPiwmI65TFTumD4sc6qqH0AeUVqWgD+xwD+DwD+KYC/BeAfVN//pLrknwL4vyql/kOQ8/C3APxwVTl3Dy7xkFNPLCjkRmfuMjeLxaB2rlOe1Kp8U0luJ3LTUdooMmg2y8rZzKdtE6FgrU9rVHOxCo2Gqsz1gFI0T1sUqJYlkgAmX4P5sr8oooZMfjrUeEcj0nopbg1596cpxVqYTKgzTaes1bgWBkn0JKRlYV3Ssgq3tcLwNeuUcdt8l+WxioD5iE6dNcVXhrQQKufYMk0X8JfHgyYdazZJmB4fpxiPaWqoLA0uLyM0GuTUe3Jikedk5YgiYDSK0OloNBrkKJmmRBoaDYM0pZVJWUbLVIdDhSxTaDSI/DQa5NvV6RgYE2EyAXZ2aGPMfp+shllG92VtiTSl+ybiodDtGvT7RPAvLzWspWmiVstUZIWchR89yqsVfmo2TWUtOSpfXJCycH2tZ9bKdttUPjwKWUYrSvb2yKciyxSazRIXFxHabYtHjzL0egUePmR/G4V2u6gcNTWOjmK8eFFUAw0pH+Tgz32EyQ1HPvZtvcBOnHXxb94ELsH1tRVZVp1lsy7fOjLBv6X1dh3r0DIi5LNeuWW6SimDZTxvBVLivfdyPHhgkOdxFVE7RpZptFoUl0YpW1m5Nc7PSTlM0zkZAFA5Fhu0WgbvvVeg3Sbye/9+jtPTGHFsK2KtcX5ORL3VIivnYBChKHjZuJmt/ksSWpXYaCgAJcZj8qHc3lbY3TVIUyL719cUzJJiNGn8+MdNXF4qvHqV4vXrpCJJJe7fz7G/n2N3l7YwaTRKTCbkBM1Tu59+2sCnn8bVOCKnDv1Yx2LzAMA/rPxsNIDfs9b+v5VSvw/g95RSfxvAMwB/AwCstT9SSv0egB+DJsT+zi/PiihfY1aYW1xk41WYOwjzIFyK9JL4sOD3DSByNYTb+Tmtb9UKnStLhYsLYr+kzck8q5RWYTiMKr8ahdNTivQ6mZDz2OUlCcg0JfM5LXMlj33yW9CzIHvTKQlyMokqDAYk+BdhqoHEt7qLN1Nbx9Kyrjb4ppYfV9D6LGNvUp91y67LcxmpWaZBSqLjs8Ao59w6A8Gq8rnN0oCptUGzmePwMMbmJkVU3d8vsLVlcHzcwHisYG2Ey0tgOLQVuaB5/KIwGAw07t3L0WoZHB0liCLMApgZo7C7W2I4pFVMFLGV2uvFBfkUZBmZ8dtt6i+7uyXGY1Pt+G2r7RRoqqzdNri4oMGgKMgSQ0u5aUB4+ZIifmsNvP9+jiTJKutNBGvpOPU/GrjGY7IG7e+TlWY61RiNyJcozxUmE4OdHVrRNZnQO9jcLBBFCq1Wifv3LQ4OTBUIUyFNUxhjUBQae3sRdnYiXF+nSFOF6TTDYKBxfBzjiy+a1apDjujRBPUzjmrM8oqJD3AzOGDdu/YpHu65ZSTkNhZVH9x2q5zjbr18375rXRKzTv2WyQV+vkkV+DHCeNyAUhl2d2ma5uXLuNpMdb6Cif1o+n2F8ThGlhEhmUxo1R1H397bK3H/foGtrbJavl1WFh5gf79Er5chz0k2Hx0lyDKylk8mqrJWRhWxUdVu9gpbW+Tnc3RE08VlSfI8TcmBPk1L7O5myHNqJ0+fxnj1igi8teVs25F336XI4ABN+UaRrTaaLZBltGIryzRevUowHMr4bfVYZ1XUnwD4857jZwD+RzXX/AcA/oNVeX/zsUyD4IaqsNgpeE5b7sMBLO7MqjD3EGdrjtw8UsahcPdyYnDn0+JbnpsLlfn0E+fBjJj+Wwucn1MMmstLinswGtF119dsobEYjXh+t8TmpkK3W1bHSsSxQp5bFIWtHDTtTAtdrBM/oxyLcXR4r5EpFkmeD7534Qopn0Dz1cWFFMrLLBxvSpbc/G5LkpaRllUDybp1fRPLlQ83n1ccGzx5kmNry2Bzk+b2Gw1gb69Akih8/HEToxGwsUErLbKM9hV7+LBAniucnc2XQ5clcO8eLQWPY7q3ra0CRUErPXZ2yOeFLSrGULvsdCgEwd5eiYODHCcnCQYDUzlk2pmlxRiypEyncUVEgMEgqoJUWpyfA8NhhG99a4rd3aKKDkuOkXlOpvs4Nuj3kyrKK/Wlsswrp0v6P53q2apCrWnvqjxXswGEprgUXr8mh/5Wy+KddzKUJapl5wXSNIXWCu32GL2eQZKY2TLy//Q/LfDFFy0sLmYAFjfL5ffusxJb8QHerM0vu8YlR7dpe+4KUPnbtT6tqk+dnJXwWW/kObf/uQSJ9j1rNAyiCHj1KkaS2NmqvCjS6HQo6F4ck8WGViZZbG/nM4f0siQr92SiUZYa9+/n2N0tsb1dzKb7tba4vCTCHkUUL2prixaDXFxEuL7WaDSA3d0MxqAiFhyVG9jYoHLJikpb4NB0FE3tbm5SrCetifRfXGh0u+RUTMErgShSM5IPUL+5d48ihhcFxUOjIJoa+/sFoihBnlMfo9hOfoTIw18JXE3WPcZWGh6o5Rb0E8w3OuPzcgm3JBnS8sJprUjrakbSZ8dn8q0TEPI4lVcUJS4ubOU4aSpCwtsfzK9RqsTGRond3WLmnLm3h2r6IK4YvkarRVaZ6dRdks55udtJGNBO5G7UyTpLiRSGPuGyDLIeq6wSdQLMl6dr3VmnDreBe//u8XUGnC+jfdZpsdIPx7U6Ll7fapX4jd+Y4skT3s+JAj4CqiIVBu028O67GaylaSheVUeOlGrmRLu3V6DZJJ+D4ZDIwWAQYTiMZqbuKCownZK2SdGDqe2Sb06J6VSj1yMSfu9eUYWMJyF/eRlXS7xNFcuGBprplCySrRZZfng1YRRZxHGBi4sIgwE51gM0yAyH5MiZZRppSv12OCTH4s3NDFlGBOfkJIa1JRoNU61QpOmB62uK4XN8nFTWKYoCCxBZszZHHBNBfPgwn4VtODqK8exZhMPDxswKNJdR7NMgY9vwkCEVMYubqxXd9lA3oNe1JYavL67bPn0kxJ1GW8fq6PaldRQf93pf33dlB52zlt57HBtcX9NmwI0GZk7i7baBMXpmHaf3W+D6OsZ0ahFFGnFsZmEHlLIYDCJMpwWGQz3rM3GMWQDKKKKVgFrTKj2ept3YoGCTeU4yu9ejfknWPt5SxGBnh/zAvve96cySRFZPuqfT0whPn6aV9d8gzzX6fQ1jDA4PE1xeavR6ZAHa2KAp2E7HoNfL0WqVODvTePhwina7rBzpNT76qOYVIBAbD9YV7FiRztc5eEpK7sTLJMYlIa6VxWdOBebER5IAadlxr3c7nuxkfM5nBSLv96KQ5Sx2YKUw20eHfAOiKjgaCVetUQX24+Bnsny50kZam/geB5iv3HAFY91U21eBda0mPnK1bj6rynfLWueauuvWsXQtK9MV0r62BCwOeHV5yjZG5H9z0+JXf7XA++/n+IM/iHB4GGMywcwBtigo9lFREBkg53JdrUSyaLctXrxIsbub4+HDHP1+NFupVJYKL1/GszJfvkwqckPkIIosvv/9MR49yiuNFrPBQWvgwYO8itukcH0dYTgkXwhjgPPzuAphQFZJHnAoTlM524BQa1uR/hibm+RLQEtyFfp9igl1fp4gTclRudXKsbNjoVSBOEa1akRjb48GpqKg53JyQiHuj45ItuzskG8FkR7y+SFnbIqp02gQ+el0DD74oMSDBwUuLiheVZoCJyeJIDpSvqSYyywZRM21qkj4lAsflhENSaLk8VVwHduXWTLXzdOVxXUxrXwyoY7UzM8TOSZn3rK0uLjQ6PWAJ08yfPDBtIofpnF5SW2FQmVQPrS6TkFrjTQ1M/+awUDj5csEjUY8czJ/5x1yOM9zjcGAppystTg5iWdhD7a3aWpza6usVirSRrOnpxEGA9oKJIrIShjHFh9+mGFzs8DmJjkRU/T4CM+fJzPSn2VAUdhq0UqEwcBgNCIL0dWVwdYWyYxulyymUVRid3eKgwOLzc0Yg0GCPP+SAfq+2Xjb0wEufBqKPCY3G+NBW5IX16dEOeclXMvNKusL5UsMXlXOwsvTLt6L3BV4LqhoOwRTbTZIJvbj4xi7uzQvenYWo9/XlUaqZumVUigKjvshhSI/G0lqJiBSI4nNMovGKo3Kd89AvVn6TUmJvKYuPsYqofsm9XGJjSts17HirSvglw1odfm7x/l9k0Xl6ChFs0kD9ulpPNtCYTDQ2Nsz6HTKanfsBNOpQq9HQq7ZJNIQx+T82+nQ0udXr4i85LnC06cpGg1brYQCRiONi4sIwyEtFW80aIn1dKqqaR0z2wMqTcmp+eyMSIQEOU+W1apBVe0RRRpxlqkZuQcon3v3cgyHuopmTKtF3nvPVNO+EUajCHt7Bfb3i2r6qYRSVB9e7RJFRIi6XYOtrSk2NykWz89+1kBZKrz/fjbzv+BgmL1eiVbLoN/XmExoWrnTMfj2t6eYTCjg3+ZmiT/5kyZ++tMUWcYkhq04wLwPsh+Ou9vyMiJzW6thHelYRZRXlblue7+NnLmtldS1XFoANK35+ecNnJ2RY/h4XKLXKyoHXvLJYqdhWm2EKj6YRbM5j3NjLZFa3mn+8pJID/lAllWoASLH/T6RX+oTqgqvodDv027hxrDlnpzW9/bI4Z4CWVo0m2QdPD2Nq6ncAtvbJeKYiPLlZVRtQZJDqRiHh7RB8uZmhk6nxGgU4fBQ4/ycyP3WVol+X6PfbyLLaEuRTsdiNNKIohKrFlLfcWLzJlg1YKzS3t2O5Zp3ea+nmyuUCFLT5Sko2Un4eN1yN1dbmOevlMXmJpmgz85iGOPr3C4pU57f88EsTU21nHbuBHxxEePFi2bVYA2urmiPnjimTkihuqnz0FJCi0VzNw+UTGomIP8adhx26+wu/3bvfx3h4lqL1rFsrEq3DD6yIutap5kus8asU15dnesseuvk5YNdcd5NBwAGg4HCD3/YwNFRhFevIlxdAbu7FGV3e5t8BABajTcY6Io0AK1Wie1tCv9O0zdEfl68SPDiBe2qPR4TiaFdj2mQj2OL83PSYt99N5+tOIpjsl4ohSrGB63o471xRiOyOmYZxQehaSSFly8TXFzE2N4usbNjZuHvp1NVRdS2VfwmWoJ7cUFOmfv7Be7fz7GxQab+w8ME3W6J/f2i2jDTVCtGSKPnKbY0tdjfL6ppNlpxGEUW/T75Tty7V1ThEmivHv5cXenZqpetrRLf/e4Ek4nG/j7tFUSOyxH6fRoI89zi4oL38ZKrprj/+dql792varPLyHZdu3lT1Mk7lyD5+sq8zdaT+zrZ4OYtZWoOoIHp1ODkhBaXNBo54jjHcGjx/HmMNAWShFYgbW4atNsFXr5McHRElnYOdZDnHIqDppSuryNcX1M/oHarMRwCz56lePUqxsYGtVlj1KydjUa6skKSMtzva2RZBKUo1liWkaXx+lpXsZoM+n1aaMLkG6D9ow4O5m2R4qFFmE6jyjpp0O1SH2m3Le7dI5+242PaUkQpmmJrNAqkKRGqZbjjxObLNnxfHr7GWmdqdDt7gvmySlcrcVE30LmESOaxOPVE1hEywRtDpsL79+fe7xR1VdbdnQ6SU1uuBkX/ac8dNXP+Amh7hBcvEnS7bFIlU7a1FmVpqo5BS7spGBSvBotFGQZkoRmBSA0vNZXPVU5LuQJJPhv5TJdpbzJdHaQQcq+9TXtzn/uy+rnly6k3l/TId+XTcOX/ZYOI73n66rJKcC9r2xJU7ywD/uAP2jg7yzCZxFBKodeboNMhC8rJSVI5zpa4vGQrIKppGlstTyXLzxdfKLx6RSTh7CyeBc7b3i7R6dD0VadjZ5YZ/sx9Eyh9mpLzJq+kynPy2Xn1Kq2WjRNpB2gqdnOzrALzYTbl2uuZmT8a7WtF00CTiUGnQ3FD9vfJr2dzk1auJImp/ClipKnF9nZZTR2wRk3aMK82HA51pXlrNJvFLDbO5SVp4+MxxdIpSwrup5TFe+9luHcvx717NC1H+xHRKpp3382RJPlsSuuP/ogDbbKCJkPcy3e9TpgFn/zj9uY6LPvSyDxWKSHL6uEuRFinzfv+ryNDfARIO2mnmLsr0DnanqYBQOPXf32Ehw9zGEMyY3+/mO3mPR5HOD6OkKZMzFFZ5yK8fp3OlMhGgwLhXVwQ2X32LJmRnrMzO/PRmgdcJSvQYEBkl6Nsaw0cHyeYTnVl7aP9xzg9ryLsdEo8eGBn7chahYODEqenqtpAk+6FxgeLTofqTdOpBZ4/T3B+nlRWRwoY+EtObHxYpzPUwdfo6/Kz4qNwc0dq7sAuyZFOeD6twdeRXBJFXulpqiu/FhLMtHpCYzzGTMgvRrzk+rqERi4pX9TEyd8AKEt5vwaTia2I05wkkTMxW6tyzOvLJm6+P9YIxyBSk6E+5Lt8PnWtvU6jks9ROd9w/q/bVtyybqO1rlOGex91QnmZoHbbk5vGp7X66uhrz+4xt3+45UqQv8bTpwmurmLEcYmdHYuHDzWUItP0+Tnt29RsRnj9OsFoRGEGdndpIOeovlFkq0B2ZCGMY4PxmMTd9nZWxcrR6HTKKgoxTXU9fGhnq0zK0s4Iy+yOqtgbn37awOUlraSivakoQvbDh/ls126lUMWliTCdkoWlLFH5MmBGkGirBlRBLmngef/96YzEXF9HC2SLfRWShLRysq5QALXraxq8jCFyt7tbYjCgGCVs5WKH0vffp5g/5OBf4uQkwhdfJJWVivav2toqq5VkZJn6b//bdtWH5f49dQTWrwzdPFenKPjamJR1Lrmv67vLsEomuP2o7v+y8nz34DuvQM+TF0nQgpKiUDg8pCmq99/XuLhIkKYlOh0izNvb1PZHI7JsTKeoHO2pL2SZxiefNKGUxcYGhU8YDDR+9rMUjQY562ptMZlEuLoiOc39Y38/x2ikq7arqpVYZMXjtk+R6AGliLwAmIVZUIp+N5sGrZaaBZfkDZWBqIrczX3VYmNjio0Ng+1tg24XGI8thkNAKZrqzbKoClxYj68RsfEJ27cF11JxG6zSgl2NuW6QkwRCXstp5JSLa+r1XSO1HT2L0cEMPU3Jk/7zz1OUpa1WNVksOi37NCZ5T3ycd2GlOX7aBkFae1ztyjrnM5GHxuL7yEBWGtnB2UlRPjv5/SbwkcW6dG65dagTkqsEbN3y9bqyl2mny475ntu6mu46Qlxq7tb5uHm45XI7LJFlTRwfGyRJgiSZYDIhk3hR2CrqKpm6T04iFAVZHnmn+YuLCA8fFjO/m93dckY0Li5oioXCvWs0GrSXDS+bZq2VrRZRhJlfDIDZxpi0yZ+aOcqzYB+NyBHy3j0KNHZ+Hs02K2y15umThHwFhkPSdGlvNVSxP+ZLuJUi/4eiUNUePJTGGCI7fA1bYF+9SmCMqqbADK6vyd/t6iquNs4ki87ODu3WPB7HePWKSB87OyulkCQG9+/nFQki6421JX7lV6b44osUr1/H1X4+bcz9bGQfdVdIuTLRVUrcNuZT6Nw25ksvy5Pp+XtVMD4Xbt4+MlOnYK6rnMpnY7BonU4AtGGtQb+v0O1GePYshrU5Njepv7x6RaEC4hh4+JCC3B0ekuWGl0QzwQdoSvPePUo3HlO4A97O4PIywtlZhKurBFqbarpSV22WQiU0m2S1e/EimbkeKEWxnQBU1ho1a7tJpbNyxOzXr2M0GgbG0JLvdrusgvipiogZ9Hpk6aGtI+ZxqFotIlxaZ9ja+sYQmzo2/1UTnK9iUHRRN3AtWjFuahvSDOl2fHeJbJ024nYSgKZ9UPkfkJCjuB85nj6NK43L7bBMPtxVDrJsHnzYWVBaX1yS5pIbYL4KjLeVcD3bDeaOwhwcrG4LBd/A6ZYnj8m6yTrWOfUuu1Ye9wk6n9BehVWEWaZxSbFMV9eu68i1O7Asq986fUa2XV96X7uQZUzBe6PluUK/n+D4uMRgkFTLu8nxlS0TnU6BvT1bbeCn0Wwq3L+f4cGDHEWhcO9egY0NIjRXV3rmLJzn5ChZFPRNwpYFL/kPkBWIp6BQWUJoKieKKKYMWX3Ih6DdJh8hGhxo+fX2donplPaLoijcZPHp9zWOjigqsDHkAPz4MXn0z7cVoXI3Nshf6PKSfBPOz2mVyfEx+fJMJgqvXpG5vtGgekYR+bpdXtIKl7Mz2qpBa4NHjzLcv08+F+RMbfDuu7wknUI57O8XMzK0tUWrqK6ucnz3uxMURRNHR1ElRzh0hW+gWdVeuK0Ac4us2zZ88s3XZt0+In8vq8dtrTrrKAXyvM/KU5c/y0MFkpFj8JYX1lpcX2s8e9ZApwNEUYk0LfEbvzHGdKpxcJDj6kpjPI6gVBPn5ylGI135oZH1hpZ9k/XOGApf8PhxhlbLVhHeaX+oL76gVVJlScEmOx2D6+sY7badRZ4fDGjKlzfbpClT4OXLFHt7tMqu34+QptQujKHpz/FYwxhWUhS0NtA6qvzFKK8kIaLNYRim0whJMl8QwFtCLMPXiNj48LYsN19Vnj5Gv6wsJgPuIC3hs3zIdFIbdgkEf5eVOZ7yMiZCo1FU4ah95bqDjTv4yxDWclB1NSaptcnpJU4vt5Dg45JMcQA+6SgsB0g5FQbnt6y/e08+rNsG3Dx9S+h9WEVOblOue73P4uh7t/L9rDPIuOX7jrvnZRqXMMvzde2N/3MQyhwk0JsAaHkzCWfaMJWEs8LlZYJWy+Lx4ynefTfDdGrw7FlcEQWNzc0SRQG02yUODgoUBbC5SYH7PvqoiS++aFQOkuRgu71dzILuvXxJMWp2dopKUzSVXw4tm72+pj15lKL+/PDhdBadW2uNq6sIkwnlRU7GmAXUa7UMkoQGl8lEV0teyTTP4LAIbMpPU4tnz4igHBwUODujUPiffZbOBpSjowTttq3qSDs00zJ3NfN32NwkktdoAL2ehVIGn32WIo4pcFq3W6IoaGn8xkaBd9+lDQ+LgpxJDw5KvPPOtPKba+Hy0sLaBkgZWcdv0Cf3VpGOuvM+xWtZLB1ff7kt6ki5zzpVd5/LFB+50pWn6qfgJfb9PjCZNCqfrhzWktXx/v0pHj/OZ6RlMiESPxxSrKbj43hGqs/OYvzZnwF7exGePMnx+DGFNjg6oo1hRyNUpCKqNj6mseTqKprFJeN9qaid6iqCNuVPsaQiWNvEYKCxs0PEhiJcp7i60pUjPa244rZKU1cWaUpBBQcDXfnLobIaaQAFNjYKbG/PlYA6fM2JzdsgNbfFm5Kruo4kB6Z1iFFdvouaDGt4AHnMz+cw1WzedTiMqzS+jlfnY+NCWpJ8A2jqOccEhVdzcdoIRGA4mjCbYaWlRgorn5CqM/v66idxm3fKz0TmW0dUVlk9fHCdLX119U1b1pXpE5x1hKPunC/tsvvGiuOryiJCPt95mqwB06nCq1dEGKyNEMe0x9FkQrsQA6raL0pjd1eJCMAaOztlJbSTme/NxkaJPKep2l6PohU3mxb7+3NnZN50dTJJ0OkYvPdeVg0KEfp9ilpMsUIU2m1y0ixLCqg3mSjs75PJPElIqzw8pPLZKRcg0pFlCtvbBq2WraLN2pkT/txiY2cB/GhfNSJWgMLr1+RIPRrRYPHee9mMDJFViTasnU4VOh2qZ7drZ4EEWy2yxFircHQU4fKS6t9qlXj8uIC1RPiOj2nbiM3NHB98QLGCWi2Lf/NvUhwdxSAL29hpI77l3z7rpuuXJVFnTXWnypfJpFVYlU7m5/aBZXn4CJ6vHPe5sBwwIDk4AQ3TKQBafn90FKPTofb37BltxcHtxxhgezvH48dRtTSbyDRPmVpL7ZgjFg+HFNEXoDADFMpAVdNEFJ+GfG5oo1aePm23SyhFZH0ywcx/7OqKSHK/r/GTnzQxnRI5GY3It4v2/KP73tw0iKICr19HVZBBO9skVimKcJxlaubLFsdx5a+TV1vu1CMQGy/elMy4jZgbaIn5QM2+Jau0fde6w/nIiMOUB8UKoA33aKWEQpJQgCZapkdbIAwGcudud9CT8+PaKUPuWeVaDOR/KWzkQC1j9kgLQoG5c3COm5YaaaFZNWCuIi5unW6LZURi1XFffXzXLRPKrpB3hfg6RGsZGeH8XGuQfG6+wanuf50Qd9Mp8TGYT2tSfBRjaMqFBnpq30TONSYTU03pxNjdLfEX/sIYZalwfh7j5CTBu+/m2N+naKtHRymurzXiOEG/T9GENzctTk9peor9T0YjiuvS6djK5K5nuxs/e5bi7IxWQ/X7NHD0ekUVtZhXH1LwsTgGtCafGjKnk5Oz1gUmE/JZ4PhOSRJVK1vm/jW86WwU2ZnC8vo1rVxinzmALEEvXtB00ulpVE2vAdZaNBo0+MUxDUxEtgBrKd8oouk22r+NAqTRQgC6H47rQ5ZeW/ljGHz4YVEtje9Ve2XNV/D4FQ23/bhtz/32DfaAv527VkKXQNfJAbf8N4HvXpYpEKsg+yET/SnmFk3aiufiIsUnn2wiTfv47LMUV1cUbmNzs6iIhMLDh2Rt292l7TlGI4UoiqA1xW8iomsrYkNxZmilHE1D0sq7CONxhNFIVfuhEfElC56plIUS1s4tNdfXEUYjWt3YbBqMxxTle2eH4uaw9ZJCH9Bqxk6HiZGpLDU0nToYxNX+U2q22jGKaNq301lOXb7mxObrgFUN38fMZedhQsLfvgHJl8eywHwa8+khPROcWmMm8ACKKMnOlZOJqVYuyUHEN+3lBgyU8GndknhwvpLUJc41TFgKLDoeZuK39XyA9QXSMhL0ZcnybS1s6+SzbHrLJ6BdEumrS521Zh2CtQzuALTudXX5MCSxZk21BNABkFSDq5mRGoDCClxdaQAxvv/9KX77t0cwhiwkchM/2nOGfHKmU9qcr9Uii8V0muD0NEKnE1VOmBS8r9WyODuLMBhQVN80JS302bMGPvmkAaUUPvxwil7PVJvH6oos2JmTsTFqFtn36Ig2N9zaolVKtLSVCRGqfX3UbGfk0UjPdrtnJ81Ox8yI3dVVNNs9fH8/RxSRn0Se61l4hTi2swCBOzvk96A1LcVl34mNjXJGBl+94k1DDU5Py+oZUrwd2nSR9vD6znemuH8/x6tXCT76qFVFO/aFLHBJMcRx2Q7cNJJgryLjbltyibJPtrr1rIOPXGGN/+79umSN61an0LDs5OOT6jc5bBtDJOSnP93CgwfXlUVR49131WzpP/tyRRGVc3oaz1b5dbtlFbOmQLNJkYFPT8ma3+1Smzg/j6qo3TwtZGdkuNUiy9BkojCdkjXv6krP4kFZS1PF5AhP+7kZU8425Xz5MkG/H6HbLauQJCWShHxpKEAg+cBxqISypDZ4dhZV+0utlrtfc2LzVQxEb4Jl2uYqDUCm8VlFuEFLB1z32jrHYteSQsdp8zzaU4f9arhMGXtjcSCSncslNxY3O5v7HNx0bt3ZUVjeI1tkSsynnDgPPs5OYa61RgoGt34SPmHhwne/y+DLc1nbXKetuGlum9eyc3X37g4gtyEybnm+365G7lpvVj1nfuc8LSn3SePBc04Ch0ON42OF6RQ4OMjx4YfTagrWznaiZ2vl/fsZrKVpm6dPo8rBlsrq94m8NBpkxicnxRLjMWmJZ2dkbRmPyany6oricDQapnKApPa9vW3w/vu04WW3S/VsNqmP3b+f4/Awwf5+jumUlqw3GhSocjikPvv6Ne3O3OkYXFyQptvpmGqjQlqme32tF2Ln9Ps0yKQpByU0VcRg2kzx29/OkCQa3/72BE+e5LNpvJ/9LEWvR2Hvy5I1dl2FwVfVii7SrF+9iqqVWQW+852iIkTkhPzwYYajo2bNu3WtjNxWZBBS2S5kHq6/jEt0VhEVDX9/ddOsWjywDL57Xne8qiM1LCulHOXjPN3XAhDh7Ezjhz9s4/o6QpZZRFGJKFLVth/k9B1FtMKvKEpojWo3cGqTX3yRYjAgv7PXrzU2N6nvKEWOvVlGcZB4CXirZapNKymUAocgAMhnK8/NLPq2MUSuXrwg4nN+HiNNC0SRmS0l56CtjQYqp2G2WFpcX8cYj8mHiBzvyVfs+jrCxx/z1iHntU/3a05sfhGkhrHuoMeo0yDkeYu5SVF2KI5ZAPj9W1wBMF9mB2Bmquaw16R1KcQxOVBGkUaeS2feusFtGRlw0/D98PSW9KOBuEfumBxF2IDMq0xkGJLkrEuk3DovO1+Hdd+zq4W5x31EZ9mxVe3FJQ6u9ugjLe51Pvg0Z18d67DK1M558ZSpu3qh7v1Isi5XwfGyf25r8+dA1gQiAF98keDTTxtoNk3lLxKh16N69XoGjx9ns12GGw3gv//v29WqH4U4VvjsswZ2d0vs7pL1o9nkTQg1Dg8b6HYp1sz1dYQ8p837Xr6kPvXgAbXdd97J8YMfTNDpkLl/MNDVZoYWUURaaLvNEVt1FYHbzBwlX7+2mE5pS4jhUFV+LeQn9PgxEYrT0xjDIWmux8cRkiSufHFoyok3Hjw8JKK2v08yYTIhQqQ1+fooRZatjQ2D4ZD8LsZjDnhY4uIiRqNBK8uur5PKz2KKvT0iXuMxOXA+eDDGv/7XqXiPviXVUnmS7cXXX/m8jzi7/5cpFz7CUtdn6uCTQ8vKXKYMriL3rrLlHudpKZavjRlxoBVzGq9fx1UwyQjvvz+tAuTRaqMHD2jvtO3torKARPjTP00xnbaQpkC7XaDZLGAtTWvluar29QMGgxiAreJB8ZQS+XCxFbLTAZRKZnunkbWPtnQoClXFs7FoNokkFQXtr0YhFShCN0X6ppg1Z2cazSadA8hHrNejpeDTKfDZZ2n9a8PXntgwbksy1rl+lXm+rqG5+a7SellDkX4jfNznN+NzpnOd44hALDoC22qjP1RaoKmWoyoUBa9CkoMH10HWhf/LaQElPr6OywOXnNbiwF08raBAFpocc+sMExsfmeG83CWgywbrdax7de/qphVsEXXkaRnZWVaeTLMqnS+NS4zc86va7G2ITF3+bltx+5i0LtZtEugj17LN8ZQUtyXuJxHIYZX6xXQK/OhHLTx8WGJvr6g2hoxxfg4MhyX+7X97gP192u9pa4sIw5/9WQMvX9K+UVlmq6XlJLBZYaAl4hGePaMVWFoDJyfsx2Lx+jXFcup2i2oqwM6WaLMDb6dDVp3LS/I/SFPg4oIcgGkKinY57nZJkx4OFYpC4/yc+uz9+zkODgrs7ZVot8nn5eiIlv5ubyuUJa2G6XZN5UsD3L9f4uoqQZ5bHB/TFhJHRwl6PbL6sBZPuzTH1dYQ7DQdVdujlCgKVQUNpGXg7CNBwT/J8Xh7m/weeBPS9bBKecEa5+p+y/xvI++/akgLU50i6euLy+6RyQ2jCWM0Tk4U+v0Wnj6lzVPjuIBSOaZTmlbsdBK8+26GVsvMQgkANK2UZRT7qdOhGDKNRgStUQXNA4ZDi+nUVvtOJSjLsppi4lV+1BbSFLi6Mjg7i6tgkzTF1elYTCbsrxbBWlrFlyQWFxcx0tRgexvVfme0xclwGKHVor2xdnfL2f5sSmG2aefu7jcmjs0y1A0gb4pVZkxfGh/qGLqbD+clQ5ADi/s9cQeQgt3tGK4mwyCCRGw7QZ4DRcEDiy9mjV64bnGlEhMP1prlNgcuGQPmK5rkVAFPI8ipJSY1crpBEj2I465QYNSRK/d5SNym3awiRz6SVWcp8tXpNgJ1GWl2n0Odlid/u9YTVwN125xvIOD2VDdguJq4+5zWAbcHWY7rg8TtlSKz5rnC8+cJ/uzPGjg4iJAkZua3MhwCBwcNRBFZSvJc4eSE2vQ8Ng2Z3kcj2kMnSexsNVKzafHoUV4toY0qZYK2JxgOyepyfh5XK6NQOQbrytdmHruGowxbC5ye0hYPZ2e0tJp2Uc5QFDHabZo6vryM0WoZFIWudjFX1aaH9M1xba6uyFfmBz8Y4+qKBqX33qOIx8+fp7i4SPD4cY69vQLttqni78z9LD7/vAGlbEV4aLqNdzCnaK9kNaK9fTSeP09weUn+Fz/7WYrDQw1rpTzgd7RMWXR9X3xk19d36vp8nRXHTetr876yfBaXdfBVpJP3Kcl8Kb5zkbYFa6ndHR4mUEojimLEMbC3l6HdVnj33QJ7e0W107upVtkpRFGJOFbVXlAaz583cX1Ny6l5c83hMK58vGhalje15EjZxqhZEEqKqo2ZhWZ3N8fmZoGLC9oapdstsbdHROX4OMZgQNae3V0KGHlwQGSm39czF4pHjwqUJe1n9fJliqIA9vYK3LtX4h/9o/qn+A0hNm8T62j6X8V5bpBy+Z5LKLg+yrnOdfQFbvrbkCMxxfHgTuBq0/KYtIjIvJi4MLlRmDsAF841vO2BAWnQXE6G+QoXV2uXAfdcosDlwznOqBMIqwSTe2yZgFwFX31cQbluXqtQR5qWERn3vEtw+JjPAuOSHOCm1c4diFwHdNmOfOW69fb9lmXK9sLlyenOBoAUL19G+MlPGjg6SqropWbmdGstOet2OmTBfP48xc9+1oC1Cr2eRZIYTKcG5+caL1/GeP99Mp+Px7SNAMfZIEdhIkMUl8ZUwfzsbAURR1yl5eCYLbNtt8mZ9+wsxmAQVVsi0CCxs0OrsCj2FGabag4GCv2+xsEBLVOnnb/1bEXW6WmMi4toNt3Flpd2mzZH/PxzXcUGoU0Rz87iKty+ma2IKgrg+po3LCRfnUbDVFFfaUnu3l4+839oNIDDQ1p1lmW6imdCy99Xt/k60iHbhu98nZXDzW9Z/j4SJI/ztXWLNm7bt+uUnWVl80da2KWcNs5vnr5vggkQEYsYP/tZiufPIzx8mMNaWiVFjsQaUUTTlknCQfBouXWWKRwdxTg8pDacplT+3l6G8Zi2L5lMYvR6GZpNVSnQFK2aVuJRm6HdwBXyPKriz6jKB4ysMtbSXmcbG/Nl53t7ZRXZ2GJvr8TGRoGzM1o63umQLGk0DF6+TJHnarZ1Qx2+psSmrpOs03l8WKWF+7SBL1Oe23hZUPPqH0kGYlGG26kkkeD/qrqG2TyXwY6WPiIkNV+pNbFlhTe14zJ4tZIkIBpz73y+x6w6xnnzfctr3Si07vYIXH8pCHzTceuSD58QXJcQLcvbpxH6CNI67ei2mt2qQWDVfcrr6urs5u2SIJcMuXm6v11rnMxDtkMX7r1KHy2Og8Qkmf24YgyHMX784xLNJu1/s7VVVNppVG12mWNzk/aZefUqwYsXEaxVaLejah8pVMtXNTY2Cjx6VODoiLYisNai3S7RbtOyVVrGShYcY2i1Em2jwJth0gosa9UsHg0vtT46ovgcjx6RI2+SUIBAdvCnvdcolojWFkdHtOvyyQkde/UqxelpNNunp902GA41/vRPWzg/pxg7rRaF2m82S7RaBpubtPv3q1cJ2m3ahRkgP4hu16IsC0ynGt0uOZ9ubxscHJBP0aNHZO3JMnLezHONRkNjfz/D3l6O//K/bFWbe3K/rmuD0nfwy5D+28pkX3uX8rZOebhtnThveH67yqrvWldOy+dYOselvBxX5xuYR4G2KEtyvn31KsJ0WiKKSrTbFr0eEdfNTVrufXycQmvak2lry6DXK2dbhGhNROnBgxyjUYHPPmtgc9Og2STiMx7rao80O9uIttGYhz84Okqq5d0xHj6kbRDYb4e3A7m6ijEem6oshU6nxJMnGdptmuLt9QxOTih4YKuVo9u1uLwkZ/5l+JoSm2VYRnpQc87FOoPAutrHsrwUbjZEJg0ANcgm5nFtWDhEmJMUjshqwaHmCXxeifTynHRIZqbPJIOtMWxZkau1mHz5lqhn4r7YIsNag9zl17dvjO/jxsNxSeZXQTR97eJNCaubj6zvKgG5rMy6truKaPnOuys9lllmXPiekY/YSEJVl5bTWSedS5Csk969lhUDNz/ZfqYA2ri+TnF9TfkfHtLyVq0LKNVAklgcHOTVAN/A2RmRoqsr0jB52un8XOFHP2pjMMjR75P/C62mivHoUY4nT6bo9UoMh7oKfodqU07yabPWzlaKKEXfSWKr2Da0EuvePfKnubyMsLFR4tGjHGlKS7yvrkhZabVomuviIsarV2m1pQE5iBqjqkHIzLTfjz9OMRpFOD+Pq8jANIXUaNA+PldXFKeGNg3NK6tMNJt6Mobi+vB90HQD7TZ+715RaeFE/nZ3S3z0EVloleL2NhXtwkfiVw3sdf998PW1OovKMkuLTxGxzrm6a335rErvszCtqp/Ph821uvNiDJqapdkA8kEbjyO8ehVXjuy0d9rmJjmipyk5sbfbBcqyRKdjUZbUZg4OKORBUWg8esRO5LryyyF/GXK8t0jTEpubBru7ZNGkuFAKaZpjMIhwdmYwHJKV8sGDHNOpxuUlObQPh1EVP4qiZD98mEHrFNYqbGwUSFPqM9vb5Nuzu0u+crwjeB2+psRmVSNyUWeqvE0ZqwT9srLqyI3CzWXb0qGWG6gkD2zJkUHtEixuVqnEOXdZJHcWJkPynCQtMmigXNHE5EuuaJJ153stnGNyoHEtQ9bJxycAJerejTtgryIRy4Som2ZVu/kyGp373nz18f33tSsfCfB9u4QLzv9VikCdxunW07XY8Ld0eK8jNj7S45LfOh8saZnMMJ+WonyKgvKl+XnyAzg4oG0Tzs/JRJ6mBhsbOaKIpo2iiKaOvviCAvDlOXB6SkQiTQ263WLmZGstRWdNEmA4jKrN+eg+0tRUgfWoDnFMeUcRmdVp00Hyi9jeLnH/flGtZrI4P4+hNfn8bGwY/OhHGoeHEbIsRZ7Tppa0qWeJJKGNLC8uomp5OxEzAGi1SuQ5BQE8OYmrXcbtLNpsmhK5mk51NaVES3D39khLpvAQlDaKKNpwls0DBvb7Gp9+2sDz5ynmA6uPbLhtA57zdUTIlRXrKLVunnVk3T0nse5YUAef/PIFMORzdX1L5iXHBz4mfSX5WclYYKQwG0NxZYAM5+cxmk2LdjvF9rZBmpbo9RKMx7T3F1tDiqLEzo7B9naOdpvGJ45vMxopFAW1A96O5J13cmxsmNl2Dv2+RqcTod8nC2cUWbx6RdtCXF1RzKSypOmlwSCaBbckvzdapXd9TXHYdnYK7O6WVQR9jUaD/HCW4WtKbHxYhzG76VY1YAl3AFjV6OsaqDuIuNcycbCYTyXJzc8kIUixeA+SRLn3Jq0xdZqxO80kLTIyZgiTHneQcUmSq1H40kvtQn67wqeO8CwTaHVYlbauDhKrAoTVaV8+EuPeD+fv5uVeU0fM6gYCt13UEW5JiH1kz0eA6gagZfVwg7bJ4y5p8Ql33zy6vI4JTibSU3TWuRUzmsViOTmh/lYUtLJpe7uAUjTlE0UUnK/ZJE3yxQuyxpRlVPnRGOzuTnB5Gc9WPKWpRadTwhiOK2PQbJIgV4pM7ldXEdKUnZEpfaNhZuHoeQuFJCHS02zmmE7JubLRKKE1DSZFkaAoKBDn/n6B/f0CW1sGw6GpLDnAyQlNnTUaJdptII6J4D19mqDbLfHee3k1NVXinXdybG+XMydjcjSOsb9fVM+Dpsl4F3Ngvvt3HAPGaHz6aYpXr2IAAyxOmUvIFaGrsC7R97VpX3p5zbI8V6VfVwbddpzha5b1Kzdvd1rfgtq7nArk4yXmvpwKtES8xHDYwHBocHlJq5I2N0v0egZFAWxsAFprFEWJ0SiDtTE2NkzlN0YbVu7s0Oql0YisPVtbBT78MMPeXoHBgKZDmYBvbGhsbFDohOPjCBcXtOM4+XIVGI9p5WCSmNmWC1dXEZpNgzyn/9vb5OiutcVoRGTIrnjU3yBiswpfRqP+qspzBzVpBZGWG0kKOA2wyOqZdDBiLGrCkhgpLJIWYHEJOTdy/rh7MUlioz3nXKsLnGPyeojjvgFdzhNL+I75tK2vAjKvZQTGZxHj69fJ203vtg+XQLhWC981q377CIlbhpteHvNFkIWTzueU7svXDdDI7dfnBybbvWvpqSOf3EdYS51i7i+WYq4YaFgbI8uY3FMAsfNzsnY0GuRc22iQHw5g8epVjOvruIq9YdBua1xdJbi8pHo3m7TFwP37FPhsOASSJMJwSI7A892/6R7abTL9d7vk2wBYbG5SnA6OPjwe61n8mqsrWu11dpZiOEwQx2YWcZU0blpqm2W0w/mTJxNcXnaqiK1JRZ4KGEOWGJ5ievyYYu28806Gbpc0362tEg8eZPj9329XGrudTTvFMa3Aop3BaaVKs0krWM7PYwyHBuTnwe+nTpnzvT/3mK/vuKvw6q7x9ROZvu64DzK9j9zX3UddOYBf7q2SgW5ermXftfgr5zruG7H4zFevUVuJMR7HOD2l1Uvb2wW2t/NqyilFo5FhY4OmnayNsLtLBFdrIvsbG9TeacsOCr6XprQDd7sdYzJRGA7JQrm9nePsLKni1FgUhUGzSTMRWgO7u2ZGpmlVI0XXHgw0trZoQ1qyVM6ne+vwDSY2Pu113etWdbCvErJT+8zq0lLiarRyrT7tnTMfGJipM1tnwsLWIDfQH6fRIq1x0pbONT7NwmeZ4Xq719f9rtOSlgkaH1YJCl8+y7S9derqWmZ8efuIxyrhukpbdct36+xaSBgygKJLYFzC7au78qRzy3VJmZunGzKAn4W0Gsn2yk7C7nN2Hc+ZsGvxbTHfJb6FuTDnvpPMyuTpqjy31T5rtIdTFNFy69GIytZao9cDTk9TvH5dYDQCNjctdnYo/HxRAD/6Efn3cCAyXuZ9fh5VO3ob9Pu00skYPRscGg1KB8w3IaRosGSdMYaiu15dqWrvJ3LUZOHPkY8bDd7wUFVTBQaDAZGpDz7Isb+fI44LNBoFul1yKo5jIkebm0SutrcNrq8jbG0ZXFzoKshaiWfPEhgD9HrlbInv0VGEL75IYS3v8SbfiYTPKucjIr6+s+w6Pl5HNHzX33bMqCMa64wfyjm3inytKpevd8MgsNz1yQVJbBLMfTS5P5BcoIB6EY6PgctLizzP0etFVbRihY2NGNMpkfRmk0jK9XVURbwm0n5yEs/avjFk7aPYT2SJ5N8vX1qcnyeIY2qnkwltuxBFwOYmjWvcxjn+04sXJD+2t8sqFAMqi029FfBrRGzchrBOOvl/1TXLtAYX6+a1DuSAJjVVPuYbjOSqIs5DY94wmdhkWLQquH4xwKJlpU7oyNg67hyuj9xYz3/3/flWQdRpXm7dlhGQujSrCASn8WmUrsOtr65fBnVttE5o+tL7rCM+EgIsvjd3Lto3kPisI77zkpTIe2Bi4uubTChkO5eERhJjWQeX2LjkWZbPCoD0Q5P3z3WIRT0XtdeypGB2V1ctaG2rAGX0HI2xGI8tXr5swBiF7e0cjx7R7satVgljNC4uEkyn5BPQ69GU08uXCS4vNVoti4sLjYuLCK9fk1BvtcrKpE733OkovHpFUWTZ1+fyUuPJkyk+/HCKjz9u4PnzBra2CsTx3BTfaNAy9rMzzKa1yBlaIctS7O0VeO+9Aru7OQYDei5EaGi6rNUySFODskywuVng/DzF06e0lw89Fz1bqs47pB8dxfjoo2YV1v4KNwNp+trTunDb9Crisopk+NqsW9aqPNZRnurGBV8Z6yhgriJZl49rPeXfrvWf0xaYT0/Jfkn9KMtSvHwZAyAn+YuLGNbOg/1lmUW7jWrJNe8MnyCKMozHFFaB96uimE4W9+7lVdRuiiacphRFOEkUlCIiRNs80L5RAEXLT1NqqxcXMYpC4+jIzmJM7eywEu/H14jYLIOPmPi0R3kcuH2n8pX7Jvn4GiT/lw2RG517f+wMKcuW01Wuf4wkEnUOv7Kj+DRnNyiedq6tIw51msWyjuzTwOQzWxfraGq+evjIjTuIuoJlnTLrBKhPOLvP1Het+65859w6uVNrdWSHhR+cdO5/l4D7iIZ20sg2xf9dJ3qL+YDIBAjivIzx5LvWR8Sln4H8sLUzF/lxLCn2y4lmuxQvPit69llm8fp1hMEgxcFBhPv3r/H0qcZk0kSjQVGIJxNdRTdO8OAB7bp9fEw7kne7KbKMYs90OhRhuCyBiwtbaby06zj7EtAuzRrf//4YOzsFOp0SRaFnAfa0pmjAGxsGl5caxtDOzY1GAWNopVO3a9HrkZWG9u+J0O2qWeRYwFZlUeA/mkIr8PJlitevUxSFwqNHOZpNtkyRg+cnnzTxox81KosWR8J121udMgMnXR1R53fuU9bqFBpfGW45sk+vo0BJuP24ThlYds2q/H2oI2WukuDWSfpMAotWfdkPIsyncGnX7qdPm2i1SmxuZri4oMCU29sGUUTOvOwTtrVVYjTS2NujqNYUpoC2E4lj2n6DowefnMSVn5at9oziXe/J54yWpBsUBS0TTxKK3zQYUOwn3hW81yvx6JHGYhTmRXxDiI0Pt22Ub1rGV5VP3SDODVB2NGlydwX4IsMmSEEsNVrr+XB6Hkgkm5d1gzjuEq+6AVg+L3mdT5DUCQlZd/fcsjosEy4u1iFdEq5F58uQrzqS4pJOPl5HVGQ6OOm5XFln2Uak5cJXX//gPi9ThheQv5nMSMuJNJNLQiXbqWvRcSGJk8yb07vLwWXfcAW9JO2yDuyT4yoUnEeE8ZhWfZBTMO983cL9+1MMBgqvX9O1NDAUODmJ0O/TjsftNmY7LdNmgsCLFzGOj2nvpstLXfkn8O7FFr0erUhpNg12dko8fjyFMbQyiaO79nrkz9DplNjczLG9rRDHEZQCdnZKbGxQWQBmq60GA9qxmQaNCIeHMY6PafXXxoZGv09bspycKJycNGEtqgCFtE/QRx+18NOfNpFlU8wjistn5co69z24bdinpMo2IS1Cbtq6/3Xy4LbKk4s6klGX523LqlPwXGXSJ6/d8rg/SvLDLgmyL6eYOxrTVG1ZUtsYjRIcH/OKuhztNm3d0+3STuHn51G1xJuDQzLhMRiP1WzH+2YTM/8Y2uaHppoaDdrZmzbotNV2HkTeDw7ISf7sjCyewyEFhqSNYL8xq6JWacK3PfdVkZI3zddtoNLHwR3UjfiWg6hk3VI7ZgFdOul9QkWW75bnEh6ZBzzf8Bx3B1OZb12Hu40WIyEHsXXgK2MZKar779P26uq3DD7NlB1spSCWTrX8fn2DgK9M6VMTLUnjWkFcAiDJihLfckpH1lO+81jkVYjzrB2y87pr0XGJu/zmfDkv+cxiccznpCkDnPFz4f5jxe8C89AK/DykEkDbB1xdRfjjP+7BGJrKub6OkecWL18mKIq8io1DG/y1WhQr5/paYXOTYnO027zCiJa+AqbaA4fqTH4KtlqpQls9bG4aPHhQQCmDdpvM90qpKhiaQrMJtNslNjamlQ+PwcGBxePH8xUlShGpOTuL0O3SknFjgOfPEzx7lmI6BZQCOp0CQAv9fox+P8FoFOH0VCNNacPQTz6J8eKFxjw4nI/IuL99/+vgU6h8bZUh2ypDeY7J4/x7mcXHV5ZM6+b1pmOOKyfrZKcr333TULI/8rdrGZXWVPa1lOFBuJ9aGJPCGIM8L/HyJYUhub6mzVXL0mJrK0K3W+Lp0xhFwfFvyFG917PV3lQ0PUXWHYrpVJY0nUVxlcgBOU0Nsowc1q1VeOedDL0e7ZHWakWz/ani2FZbBtXja0Rs3gS+Bva2CM1t4XZKXwfl/3Wkhzu4fIlywJLMXQ6+PmIjf8uVKS5J4XS+huOmlXXwCTQfEagjNb5nJeFqZD6sK1zq8qkjPD4B4rt2VfnuwO2SEz7m02DriI0s32f58Alfqa3JNsFt0SU2si3wOXZIBG4+JyYGsq0C8/3EEpBA5SjCkiRxfnIKwn0urvVMibTyft1Vfb4BwPU/YBIkHZ5Zk1UAEhhT4Gc/S2EtmdOPjxPkucFwSMHxRqMcm5u0s3KWTTAaUdj6JCnRbKIKXkbxbWhlk8JwGGM4tDCmxP5+jjzXaLWKKiQ9hZjv9TTynIQ++9hMJhSgrygsjCHil6Y5trc1njyx+LVf49VPFIRvNNJ49oyiM/OSXQq/nyKOyZn5/Jw27Dw5aeL6WuHiIsbz52m13xbFyskyg3mAzzoZAvEMUXNOyj5uA/LYOn1vlexw09XJF9+5VQraOvWqK2sZluWtPOfcslxlqG4s4P/SzzLHnOBzeTHyXOPZsxhXVxH6/RHG4witlsbjx+SbU5Ya0ykF/2M/Ma0tNjdLxDGwsUGrprgdDQYR4pimZvf2yMJKMW2IFNHGr0R64hiYTAp0u6hWFS5/ht9wYsN4G2RmnUHS12jc8wxfB5HH3OXZvg4kO7vbSV0Nm/MwzjXKk4avdwWOr66riBjn5WpPX/YdrXv9bcrypfUJOJeUvgm5qtM41yFZUvDXle+uWuL2VJe3nNaxWCQp0kpoMbfwSMf3FIvvWVpvIK7jVUichgkNf3IsEhuuEy/hluDpIxlAUkK2+TofMbfdc3uWASe5rvycZARw0maNIc12POadkCnfly9TDAYK+/slkgTQug1jCiQJxc8pSzvbI+r8PKqC7FFQM2stPvwww8OHJV680BiPNS4uAGttFfOGfAyIKFF0Yg5oZi1ptEWRwFra/fjRowwffJDNfICyzOLoKMLnn6c4Po5x7x7V9Uc/amEwoFVVzWaJ168jnJzQdFVZUllnZ7It8a7rMhhcHbnx9Rl3gJVyhY/LdyfhG6Td/JfBR1x8v99EZrkysU7ZqSMly+SGq5T4LJu+8QVYVFrccuRxOa0oIxnPZYsxwMVFiskkwvl5CWOGmEwibGxYKGUwHqd48CBHmgKXl7Sybmsrmm102WhY7OyQ7835Oe3q3enYGbF5+RLVsvICm5sc/Zj8bS4vYzx9mkApg17vTuzu/aZYxWp96ZelqWPuvmvdhubLW3aAOkbtCgnXP8GFO7jUkS55zld3Ltu9hmHg70iyI/qmjeoEia88mW5dLec2WPZcfPVxn62LZaTGvc5ncfH9l9f5iI1P2EmLjCsAGWyB4OvJcXCRyHA+cmrJvRefMJf3KImwXIW36LBIkJYh3xSdxXwJqwxtIMk7PwfXcdJHxt0BFSK9mwcLev7I5zMniWUJnJ/H6PdzJAlN62gdI0nIGtTr0V5OZanx6lWMsqT6JIlBo0Gbcfb7Cv2+wmSSYDCgKMCbmyWiyMAYWjl1caHx8iXFt2k0DMZjugdrFbROUBQ0AL1+TYPIyYnC2RlFlj09VXj9OkUUpRiNLMZjWnWSJAatlsbTpylevWpWe0BJzZ+f9RjAULwbH6mRkG1XHvP9Zrj+Yb5rZdteJSNk3VaNC+soLj7FY5286gheHerIodsPXblS93wl6XffFRNVbtvSyVhhvv2PxXgMTCYRrO3i/LyB/f18RkDefTdDu03bgVxdaRwclBiPaZqqLMnHjIJa2mojTtoCJE1p6wStIYJDUv3yXGEyIV8e2uh5OXW548QGuCmEVzWiujzqNBAfy1+m2bskBljM283PLaNOi3HNt7JsObBIIeETQKs6nm/u20fCXKxLOurS3Za0vEk56xCoN2k/EnVtwtXIOJ0W53z+Nq6FQQ7sri+NROqk53hITGzcenD58hnJVUby3VuRj2xzbjosuZ6JmfvcOLIwhzpgawqfk2VLYuIjpfKeXB80aUFl65CMF6Ux38SWMX/WFCnYYjol3wWtU2RZgTieYjqlDSXPzhSKIkKjQTty7+0VODwsUBRlFUcG2NqiYHxpSvsy5TmteOr3Nb74IobWQK9Hg0CW0VSWMRHOzxW0TpEkFtvbRRUjJ8L5OQXc6/eBy8smisJWuzTTc7A2wsuXMQYD2SaZSPIzGOP/396bxty2pOdBT1Wttfb0Deece889fft2OzaJDThEKBBFAUvIYASBRDF/EhkpYCFLlpAhYVJs8wcJyZIlUBSQIMJKAkYZHCskioVEJkNEfmRwnCAlTseJ1YP79h3O8E17XmtVFT+eqr3rq1Nr2t937vm6e7/S1t57rVpVtWp466m33oEWKTHwDNs2vBa3dRP48c+E4zqeF3H+YR/FZcZ5D+UhMd9vAkZh2qayw3T+elt9mjYviL7D9w/zjNcMEd3z10Kv96ExSvxsqMjNOWitwPPnApeXBU5Pc6xWwoUnkXjypMJyKZFlAlm2QVVRskh/UXCWUVQQns0oyaE3Yg2l7C6GWVUpSMmgri9f5rCWwWRpvdhM3yLApg0xdy1WXQOya6Fro9QkbKtDPLlT1KY8G++cwvRNjCS+1tRebTud+Ll4d9xEqbaPr6X6oalv+uTXRUPSxqAudT+Vbwxc/CeUOCC67xcGX6YK0ob3PEgJF/ZQGdaT94kksd+phelSO8IQpHiFQ5/W30uBEoO9mNvXPVRWjHeiYfnh4hkCLx8XyktwQkAX6vqE9Ze4/S6+bvGCkAI+vm1CxWcPgHw7e2nOvt2MYbsYI/HyJSUpL15opzgpoLXE+TkD/K3XClKOUNc15nMq+b56RTNvSmwEqgrYbiVevixwccGgllJqFIWA1sp5O5bYbBSur2kF9eQJwzRcXVF3ZrkErq4yfPwxr9W1gjES1hponaEsQ7DonR16j+Zet8YDHd9XTRudsA9TvKuLN/t+iL+bwFHbPEzN7T58qumZuE7hx6eL533qXVJpw2sxoPG/Y76R0iWL6xb+jx1eegolt/4ZPw+85LIAkMEYRobfbnP88i+fIMssnj/P8P77W2w2Au++q3FyUmIyMVivcyyXPGLNc7MLX0L3B/tQI4APHMsNgLUSFxc0+WZQ1sop3TfTtwiw6doFdD0bUtNC2GeBbLufGsCpXSSCa7GuSqqMPpMlteNJgZJY0hOXmWL+cboYpMV1HgoU43dI7URS9Yx3OEMYV1x2039/rYtiRt/2jIzShLowXgIS6rogSpeS1sRWTMDto55YsuPHgj/q8cdWnpnux+Te0y5gLcXKPh8pWRZjDXHBzzKz8xyqtYUxdZC/B1eegcYSGw+GwiO30POwCb5T4Nr/Dz1kx+MpZPp+MW5aUHzZoQ6SB3xh/7FNrIUTzyvnyIz3FgsJpXJcXVkXZNPg5kbh009HGI81Li8ZoZsMnm1yfU2pytUVnQJmjpM/ekSHgVUFCGFQljlOT1nfq6sM19fAfC7w6pVwOjR58K7hO/ojJx+mJWyPOEhuiq+kJAxNc7Dp+ZCang37rO88bwILbXy/DRTFacPfTfl3gcL4mRT497/b9G1SG1wb/fd9G86rGIj68e2BjQEwAzcYnE/rNefDr/7qCF/7GiU6jx/XyDKL6VTjC1+ggz+vZ/bkCa2lxmOD01N646YXZOG8dRPI0+OwwWxWo66Bqyt6PW6jbxFg05f6TCz/P/VcE6NMlSMafscWRHG9wgkRTtpYuTeuf5xXfGSRSpuqQxOACJ9tAzZt1/rszoZSEzjsKqONmfShWKLRVLe+FNYnBBleydb3ZwhCQslOKDEIn/MSnBSD8wApdo4Xjp1QaRjYW08oSGlwekp/K6MRXPwlieWSwfLynACGkgj6uHj8uMZ4zBhGi0WOqyuBstSOUXFBFYJ9mudw5/HWWQyF+mW+bmH7eElD+NsDN/9MzLTjeeavAbfnXsj848U0VsQOFRu9LtH+eI96A/u6GEOlzIsLhfV6gvU6w8UFfcmMRgU++ijH2VmF7VbhxQseP2kNGKOx2WRBmRmeP1eQktIXISyurgpMp3Sbf32dOcd/cGEcwveLJWhb9wl39X4RTIW2SFHb+G8DDHGaVH5xn6XybeIpMR9IAdw2ntmWd5i+ibe08damdGHeqXEclxeDmyYperhehHn4Z2I9pnjjMMJtqTGllKsVn9tuc/yNv3GK6ZQeiIWAsw4s8fQpQfvTpxqPHlGCI4TGfJ4hz+H0b+hvabkUqCqJ2YxewGezNj3TBw9s4gHYdwGLqWsgtuXXBkL6XutC5E1Aqmvix+U0MQv/PzxGiJ8JfzedV8egp2midIGnuNy4jocAjVSe8b2hIKYPUOqTX2p3mPofHh35+146EKbx36HFEbAXESN4LpSEAGmdnHDMhMddGkAOpYRzGmdcrCAJKY1zxLXBkyclZjMBYxSKIsPz5xLGGOQ5I19LyXgyjx8bPHtG82Mu5ALTqXIKsgZlmUEIjaIg0xyNKkwmYrc7m8/DsRUutuGxnFdG9guw904aArV48YulD6lxHR5ZxXMk3KyE6Tzg8VKpULrj23pfhrUGqxXw5S/nTsoFbLd8708/pZm3MSGIC9+b31V1eyPz4gUgpYG1BazVuC0VC8nHe/LhXPzxUwgkU1Ka1KYwHldtC2oTxeBgCIBJ8Z8YqIQ8tov6pE/Vr0+6VN266hUC7HiBj/NKgZum9SrsTxs9kwKy/kjSj2tvDODzkDDG4sULCyFyfPyxhBD0sXRyUuDx4y0++gj43Oe2zgKKCsSrVYZ33y1xclJjvd7HipKSYRxGIwalbaMHBGyaGrwJhR6SVx+KJ2nqdyrtIdQHbKV2D22AJ74X70g9E0wdO/V5n77vfB/tf5+UktbEv1MMrOk5/79pvDSV3XQtlkDEEpuQQQnsI1h7Mnj9yChefGxwzwMCLtJSWudQjpY9y6UAkCHLgMePa0ipoTU90GrNsTOZ0K/EeEyfK9bSBLko6Pk2y+AC4pmdQzhGpcbOe6kxDNy43VoXUJEO6DwjHY+BqgLKEqiqAlkGCFFCa4uyzKE1j27SR2u+PYA9Aw6lWv6ozbdZLE2NF3M/f2KpUdiXOnreW5Zs3bf3/+MlJD7d/jiOkql9naj7EkpVwr714DYMQeH/s12Yny/L+w7yPmjCBVJgD2a8krQN0nlA1bRRuw2qSGH7ts2ttnmWKqvtuSYQE95r4oF9qW2zGtdvCF9tU7BO3Y91KEWQzvdZakMaA84uIObLCp/xenMhgA+dXPqyePTqvQVvtwrLZYaXL0f4+GODR48mODnZYDIxGI3o0fvZswwnJww9UhQajx/TclBKYDLJvpklNqlJ0kapQZ2631VmnPbQgd+nnJBSAzr8ToGZeIGOJ4MfjH13TanJ1LVzCJ/rAmpdIKEPE7jLmGgDhHH+fUB2/EzMwJG4HtfJ3wt9u/hFLDwqiqU23mlcmFdIBvQ14hffULrjF3mfrkKe53jnHe2UVIGvfrXAcqkwHmuMx3SwVRSMFq01wU+WVc6igUHrrAWkJMjxUh5jLKxlSIE8h1N+5VEIpT7WnaXTWoJlmF2EYJpACwihoVSNstSYTCrUdQ6tKxfWgEH79m0Wehb21l8b3FZaBvY7zhCwpOZHeC1cSMI+DK/F/RH2XYk9uAmtubwpre/TcN6GR4khWfdevgyfPjwWi+PpWPCdw912uEB65egY0IVpfF1SQDAuq2k++G8T/Y83dF1gJqamzUYXX2vifU0byRQo6LvGxM8MycPfN8EntXGJJRqpfFPvGyuvhKA4PA6PwX5Kv83zsbAue4MDrTWur6lPJuXMxUBjOIWvf73GeEyLvUePDD74YIPRiGE/JhOLx4/blWweGLBJLcx90sWUWtDug4bk0zRRmkRo8QBtq0OTpCU1qeO8wkHXhzGF+TRN7vB3HwCVorsCyC5m11WPlASlLV3ISFJgpQvIhYp6ITOKgY5f2MIy/cKYAlIhs2H5QmQYjaijUpY+jUao+6GU2HnGBYDRCNhsKF2hwi9dmReFdbFdBJQCxmOaX2YZ65LnGlmmXJBGizyny/TJhA7mCGr43t68M8/9f+aXZXAO6FjediuQZRrWAouFwDvvCFSVRl0Di4XF9bVywEhDSg1rjZNS+HYrgvbw7e7B4ha3d6MhwwyZd7xDDvtUYg8SYmDTBKp9H3jw6kFYrMsUHq/5D4I0Xp8nBGzhb3/flx9KbOK4cj7PGNSE7xLPiy6dwdS1eCFueq4NELWBlxQQTeXbtHnu2tTEvC7FN1PAN1XXVJltdYr7JZaixJ9YouN/N/VBSGH76MQ1n1eoRB+WFfIy4LYRxL4MaxkaROu9wcB6nUOIGkLkuLgwuLpSO4/DoxGDY7bRAwM2TRQPqD5pffqhKLop/VBQ00SpARwz1FT6JmbR1SZNEygcoHEZXRO/rQ5d7dS3T+JnuvLoaos+O6E+gLltF5liZikmHH/89RDc+IU5PE4JgU0MjIDbEgAyGyEkTk7o7dMYgevrDDc3ob6NZ0iM07LZ8FzcGO6ejCEgAajINxr5oxGWu90qaA1MpzUmE43ZTGCxUJCSR1FZtsVkYjGZ0EJnuVTYbpnnaETX66MRd2m0sIJ71jqvpDU2G3rYLUvGK3rnHYvNRqMsLeo6x+PHayyXAkKMMZvxWOv62riwA779PZDxzN5LSQz2jNkDlBjQh/0fLuSphSPs13jxCcGGCZ4Pf/tnw9+hqbyO8vXleyAUxuBK1c+Pjfg9wzqE3/G8atsAtPGqPnO4i1IAomkz1kRD1oO4jDb+0sUnuzatTUAj/B2DWl+/FA8O+9FfC78RpQ/rEF4PP2HalPQuJUUCbvM172ncH8eGY1UF6TWslU7vTGK9zhwfolL8ZJJ4jYC+SYCNp6EToW0gxdQX1DQh7lT6JiSfuhcPzLg+8XlwPPFS9Ur97rqWorg+qXdILeCpBf2blboYE4L7MWBJMcrUxzMAf2QyCp5JAZk43/g4QmA6pY7Mo0cW43GN01OLr30NWC73OhlKMVhdXUtsNnbnrE2pGkJICEHTy/HYi4AF5nMGw/OWS0WhUNe0ZHrnnRpZVrpYMcDJiUBRKJQloBR3aJuNQF1rTKc1pAQAhbLku1mrXUTsGlrXMKYAdW80ssw6a6wa261CXVsUhcZ8LlCWtbsuUVUFViuWddsc3LeNbyev1Avc9lLs+zJs93iRMFH6sH9ElCbcpYZ1iRegeIEL+zMGXh6U+d++/0PdmJgv+HvhDtzfD4FTfD18NwT3mgwREKVDUL+43C7A0MTTuqgNkPm8UkAi7uu2zVvqnbt4cRe1tWHqempjHAOSpjya2sV/x1I9/74h8Pb5hCA9BCzh0VioyxUevwvs9d9M9IyEtcrp9pHm828a5eGYYqTchnTRcH8oEArzjBepQ/Nqohglt00eRGnCRSy83wUcUmX2SZ9KmwI68XNh2i5KgaU2YBSW3+d9ugBpn7GWohQIjcuRiTRNgMZLarw0AbjNXMJFmQ6tJhOms9Y4yxkDrQEhsAsi54PPjUZUxNtuC9Q131kpLymx0Fpgu6W+TFEoFEXtdkq1i8BLRV4hLLJMYjbTGI8JjLxX0ZMTH9eIEai9RGY2I1jabCS0pvOt6VSirgVubhS2Wx5fSamglMFmI2BMjrrWKEvlgjTWzkupwGJhsN3W0Frh9JTvP50yIORmU6GuFbbbUCE7ZLi+X8ZB+/rjJC9RCXWRUuMjHFOxJCcGBilgbxPPxvPbf0JfOSGwCYFRHP1cIz1PUnpCSDwTA66w3mH5MZiL50L4LnFeMcBJ8bSmtovr1DX/m96hKX0fPtBU39RYCPNtAmxtvLKt/cI0Kb7d1oZ9eFjqetP98FjWU2yN5+eX538Ktzd1eZBH6D4hNH5ppgcEbJqAyZsAFSG1IdY43aG7hbbn+qL6tvK7BloqfRtQSeUdp02le9N9FZfXVJeYYhDYJ9+Q+pTR9ryvQ7xIhJPa71q82aS/T50WOltToG4EdzejEXB6WuHdd2sYY1BVGapKYblklF1aO/mo0gZaW1hLD7b0FWMhhECW0UmWByjGAFpr5DmBitbAaKQwGpVQCgAUioLHVIxQTUZ2dZXBGGA0MphM+D7jscGzZxWUAuqaPiieP8+xXI6gtcRkQgXgTz7JsFwCea5wekqF5LLMUdfG1aGEUjmUkjg91U5niJ50i0JBKe/US8NageVSYb2WKEtaZOz7IB77oZWU99gc+28J+yoEG3F+sb5JvMiEfW+jj38+TAvc1nlJLUzhc7EUKM4/vBf+93k1HVuE3zJxPa5Par6k+GG46LdJPsK2D+sR1yFcpFPld4GjuG5N79MXBDQB3a582jZ3XRQfA8X5xPVIAbPwf+paWzuGY9K3eagILxL3BW4fo3sLqxAc+T4P9dCa6QEBmyYaCiY+CxA0pIyhqD9G/PHveNd1CPUFMPdNTUze/05NpPj5ISAjRXcdI3Hd23ZB4bW4Dz2I8TsU/z9UwuN58uPHFqMR47Jst3vQM50aPHpE/zDWAvO5wWpFJVxKWejN01oBpSjNsZZHPt5JnLV7N/1ADWsJWJSSkNJCCOuCI1qMRvRBsZfwaGSZwXhM4PXqFXY+a+qaeb/7bo3v+I4aWUZJz3oNZBmlNnWtIWUJa3OsVhKLhUKeW+fAT7sgjIC1ClVF0/bZrMLpKUHYdqsghHD6ORpCWHfMpbHZGOfTxfcHmWue8+itqrwSc8hgJXj8Z7EPIRCahMdgoQuchGPAi9f9GEg9G357yUmst5AadynJXgpkpXa6qXrEdYm/m55JURtwiKkrrz6bmbZ5Gd8/BNSE5TQBkBTvTtUxxSu6+FvbRjzFX5uAX9O7t5Ub898m/h0C4LAsjdfLDoGNH5+hUn0I6EPAk6ONegMbIYQC8HcBfMNa+7uFEE8A/FkA3wngqwB+n7X20qX9SQA/4mr4B6y1f7lHCdH/vovPfSx2beXGg+8+du9d+TRNkvA7Zip9dhVDqA3ENd3ry5juQn12EKlnwnTxJG1iZEOZdtdzMVP1x05hyIPQ/wSPcU5PK5yecvJ/+ukIZamcBZDFeKxRFBpCSKzXgFIGea5grUSWaafsa7FaKVhLhdvlMnd+UfjeVSUwnwssl2QWUtIaaTy2GI+F+zaYTGjBpDUV+4yRGI+ByUTvQisoxWc3G4miqPHeexW++MUSQsDFlBHIMoGLC4NPPy2ch90Mm42FUl6HhnUqS7FTUl6tMqekrHF6WiLLJMZjMsAsIxOkuShAaRZ1clar3AEYBSEsTk9rnJ+XLhYTdX6oLO3BZOjk0APPlMJuaqEPmTvwuoQn3k3HR0JtEiAbpfWLRyit8ZSyePQUzwUbpI2vx8/F75u672kofwufS91vs+AcApJSi3EK8LUBmjaekxoHTWlSeYfv38STUvyriYZuxlNgqylNfM2PpZTrEp+myQw9Ho/A68AmdEp5f1ZRfxDAlwCcuf8/AeAXrbU/LYT4Cff/x4UQ3wvghwD8ZgCfB/DXhBDfY+n28g1R2yDuQs99F8Yh1Af8xAutvxYP2CaEPITCAXXIAp7K7y6UYi7x7yHlDwVU91n/+Frch3GalLQmj64BgMRoZPHsmcX779O8Mc8zWKvx4oVAXRtIWSPPa/ctMB4zEKIQFYzJdp46hQAWCzKE7Va6IyS2gVL0M1PXArOZRVVJrNcK1ho8eaJxdkZ9FqUoCSJQkk6SozGZaEynZESjEc01taa34MnE4unTCh98wOMmrRmfqCwFHj2y+Phj4MtfHruwCzRRFsJiu62R54zwu9nA+c4RuL5WePasdhIitrFSlFzleYU8Zx0XCw8ONS4vc2htAWyRZRUePcrwwQcaFxdUlj47q1GWFq9eSVRVqIdTuN8ZbsdKChefGITEx0XxmEgx8RgEhQtsuGuNn48lNuHibJEuM15s2wBB0xwJ63fo4pd6NpZGpdoqRV0AKgYCKZ7adK0JSIX534WPxvXqS119FKZrk1ABr7dvE7BM5Rnej480PVAPKQQ84fPhHPBWfaF+W1hPb9HYTr2AjRDiCwB+F4CfAvBfuMs/COD73e+fBfDXAfy4u/5z1totgK8IIX4NwG8H8Df7lEU6FEikBuJQMNA2yO4qBelbdshAkShzyOLfBRzadhX3TSkRZFzeoQC0T9+kxkfftozrm2LaqTr5e2H9Q70aLyEIj6AkhBA4Pa3w/vs1PvhAQymLujaoqhJ1bbFaaRdPhcHmpKREBQCEUFitgNVKIs8VsqxGVVEqobVx+jSAEPzwWEbg6VNaFL16lUFKgqmTkxp5zsB0qxVd+kvJIHYEOAzuWNc8GipLWlxJKXB2xqMf1gnuiIum35MJ9Wk2GzKvzUZivRYurpHFeu3TWHeMlmG9lri4yPHppzy6e/48x3ZLSU2eWwd2ACmNK1c4/ZoaSmnMZhnefVfji18kCMoyWo3N51QyvrwMz/RjvRuvUBxaIYUfL9mJF+h4PxcuSvGYj8GRxR5Qhc+FZaQkM20AIk7TBXhiCULTpiR8rk2akapT24IbPhtLWJoW6yaKN42pspqAStO7tvGPLulLnLbp+dR60MUPU3kN2Ti2tUPc9k3pm+oYA/SUMns4rlO6cfdjFfVHAPwhAKfBtWfW2o8BwFr7sRDiPXf9AwB/K0j3obvWk+5zQT20I9sW1755H1Ju6vlUp4bPdg3wrsH1pik1oVO7sz5AY+hkbqNwUjXl2wUKm+ocv59PY7FXiPNHUGFohD3wGY0oLXn6tMbjxzWWSwmlaPUzmWyc1RP1YWgxJJ3TPIYY2G4tbm4k6po6MNStoSJxnltkWY2i0Kgqhj949Mji/Jw6OnVNxpVlApMJj3fWa4HLy2xn3SSlQV0blKXGcmlQ1wrLJaUqUgJPnmg8elTj0SN6Ms4yi5ubzCki06PwaGSw2VBZua4pRaLDP0qanjzxSsTAYmGQ5xaffKLwy788hdYSqxXdr4/HdNc+GhkUhUVd89hrtRJQqoZSNYoiw8kJA/F97nNbZJnF48cK1gJZJrFc0oS0rn0fhYuJ7ysfaiAcNxb0/mvxuoOyeCykFsNw3IUWSSlF4lha0iY9iRe/cPyF/8N69NnQpXhl0zOp9E3v3of6gIlUGU2bkL7zOZVn1/UuagN3fTddh6wxTesJousxmOoDaMMy4jTh/1hxOBzHodfseAyFksk7WkUJIX43gOfW2l8WQnx/V3qke/e1VhRC/CiAH72d5NBFq23x7ruAty1gh9RnSNouYNJ0releXyDTtYsYQofsILr6Z4hUZSjFEze+lgJbMdBpq2cbWIrNGkPFUgMpGdrg9LTGo0c1soxOqmjabKBUhjwX2GwyXFzUmEwUypIgZ7VSmM8llkuFut5LIwh4gMmEUgoCJ+rLVBXw5IlxUg/hlG6101mhubcxBvO5QlVlWK0MTk4ApTTKMsNyKaE1kOcGSkmMRjVms9tm5FUlsN1S0ZfX6X9GKYH1OkNdS5ycUEn59NTivfcoMcoyC2MERiONuiZw+uSTHBcXGYxh+IXTU4nVihZWp6dm9w6UHGkUBSVXo1GNyQQYjSQ++KBCllW4vGTZL1/SoWBde0Xu1G47dPLnvzVoMu77zweRjJl4mD61GDYBj6axFY+psKwufti0u46vxXml5kOfedzGr/pIIVKLXEhtOkW+jKY6NPHArnRN4OYQSoFfJK71BaIxxf3ZBIJT9Worr6tfmtLHCvueUq4FUpKhbq2WPhKb7wPwe4QQ/y44g8+EEH8SwKdCiPedtOZ9AM9d+g8BfDF4/gsAPooztdb+DICfAQDhZci9OmqIFOaQ59/EItpFvsNSA/eQ+nSBmxRjbGJsh5TbNthDJhyX1VZuG5A4FIy2tW/fSZq610VeBySMhst8RiOL83ONJ08ofZhM6AV4uRTYbHLUNY+feDwkMZ/n2G4F1mu+y2KRYb0WzspJwFrpPP0C5+c1Tk6M8+hrcH6u3WIucH6u3ZFShqrSO/84RQEIYSAELZfowE8gz6ULZmmxXhNIeCd+PEqrsFzanSRkuZS4vpYoCgutpdP1EShLAjEheJz06FGFd94xOD+vHDgisNlugZMTDa2lC3ppXaRgi7I0EEJiucyRZSXy3GC7pURLiGxn3WWMwHrNI7X33tOYzQgib25GyDKFPJfYbql43TwW412m77/wGMtbUtngXrhTTkkJY0kN0Dw+m0B5/EzIQ9rmZJxH0/+m8d40/rvmcxeISVGTBCH1rnE93gTfT/GePtKqpvKbeHEKWA2tcxuP9/9llCYFXrvWhVCBOMwnVZ+4TjE4T60n8Tx5nTqBjbX2JwH8JAA4ic1/Za39/UKI/w7ADwP4aff9F90jvwDgTwsh/jCoPPzdAP5OVzn9qKtB70PaMoTus7wh+aQGf1PbxBPrLvVte9++IKiLCfapQzjwu57rsyNrY/Tx5Gzb/TXlJ6JPGH0aoFk3pR1Pn2o8eVK7mEsSeW6x2WTYbnOsVgxhwLAHgJRypyOzXsM5vSM4mk4ZY6mqyASUkpjNGGF7NjM4O6PSL03DgfFYo655nJPnyin/GqdkLJHnLHs+pwLz2Rkd/2WZwXIJFAWVnKsqx9UVQze8emUBlFguFT7+OMf1tXTRwemQb7XKMJ8rlKV0x1DM9/y8xHhscH5OQKa1wMVFsWurqqLZ+Wxm8d57NcqSejXUNZLIc6CuFUYjg7K0zsxdY7u1WCzoSJDxpGpYW8AYBvEsigxZRgVGpYRzWGhRlhrWho4RQ10avxD4vqyD71BSkzJ/DcdKvHjEc7VpseyaA2G+TXkj8T+WpHT7Dnl9fsR5NwGcIenj6/53CBybpB9N91MLZ1t9usBKileknmvaoLX1adf9prr14YNhHk08rguc+We9EnBT/h6YhEdPtuGZFLh7cw76fhrAzwshfgTArwP4vQBgrf0VIcTPA/hH4Oz+sfuxiBoqPWiizxL43IW66tkk4Wj6PaSsIW3dhsbvi0KG0iQBGpIP0L27S1ETM0r1RWwB4Bc5fwQVepKtMZ1S72Q89kdFPP4pS4nLS+DyUuDmxqKqDBYLHi95r74AsFxSwTfLakynGlJKVNXeeyed5lkUhUGWaRQFvfwCcHo6lIrQuZ90FlC0tFouKdXZbCSWS77vei0wmYid2feTJ3QUuNlIXF+PHLARuLqi35yPPsqdZ2ILa1nOcknpifegzCCYPH4SgpZVQnjJFQPhGSMcAAPOzjSePq1QlgI3N5SKjEbWRRynlZWUClqzXCktNhuF7ZbsqCwVLi8lXrwoIAT1gPKcR1SUVCkYQ0uxsgQ2G+B2LKbwCNEz5Tz4HwKgeBfqf4e+bVJKlE0LZzjW4utNC3aYru/uO3ymCYTFlJIqpOrSBcpSQDAuJzX/4rZLLfBxOan69KlfU71Sv9ue8fdiUNEEtA5dD/uAyNT4iIFxW/6p8ZEag03f4fNN4Kh9fRkEbKy1fx20foK19hWAH2hI91OgBdWRknSopCe1W4vvh9dTE0A0XO9Tv1T+bdf75ttFqZ2SL6dN2pK61ofRNDHJvswkBmLhx4MaDzosgAyPHpUYjy0mkxonJwx9sFpl+MpXCrx4ofDpp5k78oGLkM24TELUePyY0hTq0nBxZ5wm6slYq1AUxoVVEM75nnH6LmYXkHK9pjUVj3EElksBKXnt4kIGgApYrWqMRgpa00Lq/fcZp2m1kvj44wIvXypcXSl86Utj5LlxJtg+dpPFzQ3zXywoHcpz646ZGLjTGOD6Gjg7o+To3Xc1lkuJqyuJR49q1DV9+fAIDu44S0BrQOsMdS1QlhlWqwxCWIzHEpOJjynFgKBVJbFYUEfIGEYxPz2toRQBJmB3ukNVZfHppznqmnVk+2mUpXFHVx6k+Oh8oZMxPxZipcnwudSC2iXhaNsVA+nFKLU4NW0WmsB/WI+mBSs119sWthSlJBwpSUhcJyTS9ZVe9JnjXWAjXJxjft1Uv7hucf263rcpXVvfpigG3/5aV/ohFOYbzol4PPn7MXWvI98Enoc9NaHX+H6K4gHVtbh2pUmBi74L9qFI29OQgd90vQns3Be1Ta62ydjEQO9Kbe3Ulr/fMaTya9uNpNIL7KU1oRt/IM813n1360IFKDx6xFAFxlh84xsZvvrVHItFDmvhIlZTR0MpYDyWOD/XqOsadZ0hy+iDRggJpRSUYlwmHzbBO9GbTKwLjyB3PmIuL6XzHUNpkVfCXa8lrq9zlCUX4qqS2GwyrNcadW3w5AkBwePHGpsNFZ+9v5ovf3nkJCHW6dcAm43Ay5cZLi4yp/RLnzxUWLbwERCMYRt4J4VCWKzXCllmYG2FxUJhs8l3x3LbLZ0RVhWVmaWkpInxq3gMR72gDOt17TwQW6zXcP5ytLMCE85XTo26lshzOjZ89sy4iOIS0ynzv7yk9ZkxoZKwjz8V68uEDsdCnZymMRM+m6Imxu/vpTYeqUW3DcC0ld+VtmljFdcvfq6LX6TKSzkzbMq7T35N9Y7za3vftk1o/MwQyUxTvqm6N9U7BRrvAuziPMN8w42exevvnNooh584/1R4kdv0TQRsgPSi1DTIYhq6QPZhLIdQ3Nn3mfdQ6stAmnZlXelS9w8hv9tN5dVn8ndRF1PvyivcdXftboD9MRR33OOxwHvvWTx5omGMxXLJaXl9DVxeSuc/JsyHYKuuufhvtxrW5hiPpZPQZNBa7Bz0KWUwGtE7MEDndkoJaL0/ZlkuFZ4/V7i5YZRurSWUKpFlPpgl8/FAaD5XyHO4ozPqxpyeGqxWNc7Pa1xe0qPv1ZXA+TmjgEtpsNkovHiR4eOPCWzoX0Yjy2qn98LgmDxyEphMGIjz8WNKUl69Us4k3OLiwuCTTxRubqgDxLagyTbNuNkXStGUfDq1ePyY7fDRRwWKQmOzUc6Bn4Ui0kOW0RxeqQpFQWsxKVlXHt9pnJ4yz9PTHB99BFxfZ6gq38cKe8lNjdcjJPvv1O/4CNPidhDAMI9YgtHFC0MQ4P83xWBK5dEGVFJlpeqW4ntdYKALVDQthHehWPoSUhOAapNspdKn2qAtTVxGW96pcQS09+Fd1rzUWuzBe8i/47GQ6rOwL1Pt0s2Tv8mATUxNjR9LaJrutw2mu0hlPgs6RJLRV9LQxDz6lj1UotFFTZP3Pqgr77Yx5r/DT1cMr9vHE1LSvPmddyzOzwW2W4tXrypcXIywXBaQ0mI2E7i5gTvG2derrg3mcwljcnc0ZXcxnDyomU6tsyzCTlcGUFgsqL+z3fL4Zj4XuL7OUVWMK7VeK5yeZphOa0ynFW5uhIs/xc9iwRAF775LwGMMj5aWS+lAhMF8Dmy3AvO5RFkaFEWGmxuaa9MnjkXuVFKEoBTl+XMG0ByP6XF4NqPzvtVK4uqKjv+kNA5UaKzXwGKR7cIp1LV0CtMEjYwhxfYaj9nWJycW87nC1VWO+VzCWgVjlDtmsk7/SEAISrwmE0rARiOLR4+0OzIsnQVbiTzP8eLFCN/4RuHCNwD7o8YKexPwUKHYO/zzY8wG97o2cOH484tHl0+bpvmX2jCEG6/4egyq2uZPE+hKUV9JRxNIGgJq+kjK2taPmOI2aOOpffKPF/74XgxEmoABgnRNAO0QvpxaC7r6uc+GL3Wt6f3b+/qBApt4Ag1d0PqkPwS4dE2Ipsndp15t73lIG6ToswJmqb5rm0RtO4a+k6+N+d/1vfswudQONVwgUlI66xZvRt+Wks9NpwqLRQWlmJeUBtttjs3GS3r2+VUVfdUoRZPm0chASoPRiObXT54wOnZZMkTBcilRVTWMof+WzQbQmvow67VwsZaE07Oh3omPAM4yAGtpgUQTbY2yBF68oCfl62t6HyZYyp2jvBqjEeu7WgloTT0iY4STzNC3jTEKl5cCQlSYTqlXM53yqGe1ynBzQ985m42E1qwXP9YFwoSLe0XpSV0rZ5rOkBM0c6c1WJYBiwUVo62VTieHbS2EP9ZQGI/pJFAp9tOzZ156RMB0fg5IqTAeaywWFhcX3g+O90asQAeMNRg13IMa4Da4AfbK5XH8p3hsx6AmNbZS4zN+PrwXLhj+O/YPM2SxT9WlrW4pHtCWbwogdG1CUuma3qnPu3bxnL518ulT79IGbuJ+i9PE46Ntw5qS4rTxzRQATkliUoAYeP1947ybygzLbqYHCGxSu4Wu9H06IEwf3kvllSq/D7hoqncbIu1Lb0NqNBQghteG7KBSzw6tRxODifO8azs2LRCpcROP5bBsSm4mE0ot5nO7i8g9GgmcnUmUZe2UWAk6Xr4UzjOuXziZ315KQId1UkooZV0gyModJzFo5OWlwNVVjuWSXoDLkkc+V1fKKdny/apKYbUyWCxyGEMvw0LsLX6krCEEdWbWa4VPP2WwyetriZcvJV6+zHF5qRxYyJFlAuOxwWxWYTSyzuKLUhIqL3O8GEPdICmpz3J6ah1IkrAWLggnw0UIIZylFZBlGkJkKEsqObNNKP0Yj4GTkwrn5xonJwbTqcV0SmDyySfZzmS+qgROTqhc7a23jAGsBR49qvFd31Xi85+v8c47Neqa8bdOTqiMLESNqytaaPm4XHtg4P/HC7Ld9RvJ+7sR0T2fV8zYYyB9yMYoXuz6bqJiIN+Vd9tzh2wYm6QGbfmE5bbpJqVAU586pcpL1TXFK1J920ZxPds21kPX0zj/uI5d1DTOu9J7vhaXl2r/dnqAwCZF8U4ipKGTMPwfPj9kxxDWaegu5i40ZDFue9cYWQ+t+5Bn+jLKMO/4dxM46MonVcdDAWXTs027pnA8hR9561spKswulxnGY8Z/Go0ETk640BYFTbxXK8Zxms8p4bi9AFJKM5vRgkgpOPPp2kkcDJSiJ+LRyODrXy/w/Hnh8ikBUEmX/l/glIYtrq4kikJA68zFZKKEqSypiyJEtYvC/eoVLaYuLjJcXkrM54AxGlnG6N2jkcHZWe1831hobbBeA1XFhZ/O9OCcBAKrFVBVObTWOyeFXtICEExJabBa0Q+OMdRFYkgIehEmMBEYjRgy4tGjGrOZdqbcBHVCWGw2tAQzhmEkqFPDYztrJaZTg/ff1/gtv2WLz3++xKNHxll/AdfXBjc3BFgffFCiqiy+/vUC63XolM/3V4Hb4zce67GieoonxePaRh/g9XHYdjzatJNvS983rU9zyCKN6DsFDprWhLZNTZxnE49oasv4WlO58fVUfl33uqgJyMT9mXqfJtDVF8zEoLqN16beMTWOmoDy8E3pAwY2hwKOofk3UdOEOeS5vnQXaULXBGlDzk0Ds++7tDHHLqbZh1GmmF1bfm2TqIv67BDj9J5Sgfn8guU/avdbKesCWVJSUZbWhRow0FoiyxiOgLohBosFTcCpJxMyFAEhJIqCvmomE4uqggMiwoVRqCEEI3iXpcblpcFiIQBkTjpBSQ9APR860bMACmSZQV1T+nB2VmOxyJw+Soaqqp1ERTngJTGfM25UUZQwRu3eMcsEssw6iQhNyXn0xWMpawWMqbFcKneUROnHdEpnfADDO8zntN6SkpHIqcMj8eqVxHLJoKAEbewHSoWsAzNU2vZeiP3x3HqtnJm8gdYWsxn75vSUDgOfPq3wPd+zwQcfVJjNDC4vlSsjw/m5wXZbueCkEquVwUcfKWcpBezHhGe3ocQg3KnGm6WmcdYGFoZs/JrmfNOzTYteatPYxYvaKJ7vbenb2iJuz/A7Xpjb6tcFoIbyjKY8+wCjrnR9gWeKp8bRtOP2ivP0Esn4ekrC0qfPU2tF2Ffh9fsJgvkZUtvi1kRvQlpyKDhJ0RCA0LfsvvVra5s+C/8QyUyYZ99nhkhgmgZzahcb1ysut2vxaMq7i1K7C4HbjvnobZPO52pMJjWm0xrbLeMpjcfCedNl/Ccp610oAR6xWFDSwnyVYviDs7MSJycaRSHc8RNc5GtaRdGPTbbzPrxeZyhL4cyrBarKL9ZwkhOFmxuaiDPmEtxir7FaCadLw2jg77yzRV3Twgrw5uQMMjkeM94VpSAMusn3gQM0fE9j+D6bDfNerSTmc+uikZtd6AUGBOXR3WJhcXMD5+NG7donVLS+vlb4+tdz5Dk9Co/HGmUpcXOT4dNP90dmWVa52Fm0sJrNajx5UuHxY+Oc+9F3UJbxc3pqsNlo59GZ4Sb8UR5DPYTM2evOeB9Gfox0SRxSgTXjsdYEJrrmtQdU8YLSBzTFUpH42VAi0sX/Yh4Qv0v4fm15NW1E4/ybAFlbOzRJDbo2buEzTdR3bWtq/7DuMpE2Bd5iUJOS1qTKjP+3ga42oB7nDTSD+9SYbF8vHiCwAfoNFk+HLDpNz6cYQtskTzX+UMDRtSsKGdCh1MUU+jKgprwPqc+hzzTtBA/d1fWhpnETM862ckMfNv4Yah/J+uyMHoUZaoALa1EwrEJdW6zXxklr/C5pr6RKUFPh7Mzg5KRCWUpsNrkLXkldESGEO6KyAAgUplPtQEUGY5QLPbAfZ976SAg6+isKizyXGI8Z4dsYAhSGdFDOPw6Veq3l+1nLD0AwUFVqB9is9Q71vLRGIMv0Tq/FGODVq9yBKoHFgubWWtNSyVpaczHMhHLA6PU+qCqLDz/MUNdjZBn94jBGlcDLlxKrFQBIVNUIda2hdQWteWx1ekpQaC1weZnBmNK9N5xFmVeAtrBWYzSqcHJSYLPxSs5wANCbfRcgsPGSuy1u8x2L29GL/e/UAtM0F+IxGJKIPn2fuysN4S0xGGmbY20LqUmkS/Hsts1VzBuHApk+0pZDAFFXm/QZG+H9lISmie/5dkgFHk092zZ2m+rTdr17HD1QYHModQ2gQ6ivuNJf6xpsKeDSlLatrL40hJk0Xe/Tln0nUkhd+aZQ+qH9Gu/6UmWF7d4lSeqzowh3Q/sjKL979/5keFSzf3K14pGJlExXlrQ2Wq8BH37AWwMB1oVIqGGMgdbZzucNfcLQ/JkSEbgAlJQCjEZwXn6N810jdk7uAIE81xiNJJTi8c5kUqMoqLszGlEaxHhLFtOp9//C9zVGOrDCeozHvLfZ0FybZuke7FB644/S6ho7Z35VJVDXORYLi/lcIs8NTk95dKc1j6rWawIIpawDfq/34/V1htXKBrGkhMt731d1TYVlrblzpNdjOuyz1mC59BI1OMeFAquVxXYLbLcEkLOZwZMnFbS22GwstK6xWo2wWnkHhyEvKZJ1JQCqg2sh0Ik3KW278TY6ZBPTRClJSNfCdki+fRfp8H8b8GkDAG3gpItiwJQCDaky+5Y1FMh2tX8IVOJ82oQBbQrYfeoX9088D1LUBYxIDxTYHILu+6ZvGlRDB25XfcLy+nRYnG+qA7sW21Refdsm3pncF/Wp832U16ed2yZrVx1iUDRklyVwW2mYRxJFYZFlW2gNPH/OgJCbjcJm4xd0Hg95PRLGcNI4Oal2Cq5aC5yfW4zHyi3MBlWV7aQhPh9j4CyqjIvETU/AlKhQB0aIGkJIVBV9uEynCpPJ/gx9NvPHWgQpXjJjjNhZEdExHnYRuJUicJlOza4ODOVgXV40Gzdm72fm5kbuJD5CwCn4UrKS53TYJwSjjK9WAuu1cU4EU5JWziFrBcqyAKBdzCdE/UFgV1U0f1fK4uyM7UzpkXQelwVmMx/aQuL6OsNyySjlQlCadXpaY7utMJnkKEs48/EttB5Ba4G9yB0gC564bz/fQ4d8FQ6T2vaZA00LRNfYTs2zu2zEYiDg8w7rZ3F7/qX4VBfv6l4QX6dD+eEQ/hDfawJFcd5da0MTWEsBur4A+a7rQ9t4a+KtKWHANyWwGUqpDr5v6tOhh+6UhoKQ+wYfPs84/9QuI0VDdmRvAjzFdfDlNN2L0zVNtjiPPiLrVP7hM1xIhRA4OSkxGtGq5uJCOkBjUdfZzvPuYsFgkXVNE+TZrMY775gdsLFW4PS0wvm5BcBQB1x0tVNIpjRmvaZyL0ELMBpZ1LVGXWfIc8aRol6KQl1TgXk0AsZj6r5ICZyc2N1RDgCnTyOcPg4Xd3rxNS4GFXam01Iy2vhmI53yc42zM+r9MNgkTb5PToyLiSV2+jLGyN0xkz/CqipaNa3XyjnkC/syBXA0Qv2mPLcAqE+z9+TMIzxaVW0xHgNZRmlQXVssl9KZtQtcXChcXiq8fKlwfS2dgjKQZQKzWY26psXbxUUGrc1Oh8eYfKfTtK+bl+KxXfbv0eY6vmkxENF36pk2UBNTG5gJ0wzZiKbyS+XftFin3rENZLWNi0P5UN8N29D26vNuQzarYR5xnfuuO0PX1Lb1ok2al7rWxlOb6YECm7sOtqY8mhr1UEDSNCBSiLhvnkPu93mua8HtutZ23efft07x/yYm10ZdICtVZhcQaRs3bROxacckcJuRxNeli41EhVRG5s5cjCPeN8airi3mcx4vATSd9j5qxmO789x7dibw7BnDElxeZvjwwwxlCVhLfyvzuXDm0T5cATCZENSUpcH5ucZsZh2Y4BHQ2ZnZxXjykpjxmKBmMjFusd9bL9U1TbflTr+bgSWrirowUgKbDRVqqwoYjRTy3DqJkHFK0sLp9HgJi3SgTO6Uga2lfouPEB5aP+0pVEL097wSLo/CAB0oGLMfqRPE/OkTR0Ep497P4tNPJep6hMePcyyXBDQffZRhuaTllpQWStUYjwEh6NyvrmtkGT0YZ5nFcql3Pnn2XqhFUL8CeyXzdTTO4rEYv3cTL4rJg6ahFI7p8GisKW1c5pBy/PeQhbyL/zflceh6M4T3NQHPFMBL9XPfd0u1exe/PATkNQHRuP6HCBra+rtfHR8osDmUujqob2OnBkMbwu4rMWoCR23U9E5DOv9QBHzIoByab8xgU+/VtLtr6s+YEfTZJaTqeJf3j5+/bd5L3RaB6+vCHc/wmj960ZpgRGtvTSMgZeUAESUuShmcn1ucntY4PTU4O2PMJkplJDYbSl82m720yBhKQoqCR0azmXWhF7QLscA6vvMOfeAA2OnKSAmndGx2gGO9pnLzdgvnxI96RIzTJJxCMk2st1uCNyo1a2QZj8MAi+VS7CyjtJbOwko6ELPvb2MELi/Vzg/N6wBZO2CUYm1MR0Xp0IOzxmjENqXDQToZ/NrXCpyfs73rWkGpHB99ZPDokd7p9tzcKEynGtMpXGRySrWMoWRuNgOE0Kiq3Pn/Mcgyjfm8RFXl2EtOvEK4BY+fclDKVDaMp9TGqQnE9AHwTRQC8rY0XTREyhDO8xSo6+LzfaUp90l927Zro5mSpA3ZzDWl7dMWbYCkz2a9awPZ9uyQdam77x4wsLnLJDxUitCUZxcYGTLoUs/dxyS7S153KT9Vbh/geJ80ZOK3PdsGHrvKaNp5xff8gqpgrQKgoZSEtZRKcNfPZ/KceihVVcPv4hkrSSPP6bju6dMKs5nF2RkteLIMePyYMZRGIwIYpbxUhYrI3prH2n3UbTqts5hM+H12pvHokYbWdueozuviTKcG2y2lK9TfYTTw5RIOnNHLMUGYgbUZyjLDdksLsNmMrpIZUZtSKkqq2E5FAazXYhe24fbial2wSTjpjnHvgt0RT57bnbXVvt1vhwYgCDHOyso6XR+7A29VpfD8uXESLOVCT1gIIZDnBqvVPu/zcziFbeFAJZWYRyODkxPvR4fWVaMRQ1xMJhaffGKgtY8p5UMt+CMzC0pvChDc+LrHkpKmMZsC8kN4Y4r6LFx9aegzXRu7+PchEqJUOV3pU9fbNlG+boe+/xApVt9N85Dy7yKJOaRPUubr3fSAgU1fOkTkmRpYTYziTQGFWKKQej61SDbl8VnQEGnTXXZNbbuXrme77oX5d6W3uF2HvmPLlxHudENQw8XL67TQMsj7nbHOiZ3AdGpgLaUgPEKipELKGlJukecKJycEIXkOB4goiSkKBq2kp1/jQI3Eem3ckRQtiqjEyzQeuNBcnHosee5NsgFrDYqCujLLpURZEojRIV7mYll5SY1EltG0W2uL9VqgKIBnzzSmU70LSXBz49vIYDYTu2jfm43AZuOBDdvQeyYGrPOszLrXtUVVqZ3OT1l6U/gYXGp4YCBEhiyTO+mYMdp5GdbuyI2WW+OxxXJJ4Me6Grx4UeD58ywIxCmxWBCYZFmN2SyHtewTIRiKIs8FHj+uUBRURB6PLcoSuLkxTo9J70JGLBbeI/MYe3Djx00KbHctpHfdQIVjuk3vJ/VMSEOBVZNUqukdm8ocskb0rWNKUi+ie0MkJ30lKnH+TaC1TSreRm1Sv1Q92uo6dOzF7+ABP7DfmPTrnwcMbO6yC/8s6BCRX1vaJjHzfbRBEyi6L8lJCvC05d81ie/jne+azxAw01Rm+D8ENtLpongdkQrbLU2BfYRuIbw3XjgAJBz4oDm2UhnOzrQz+aa1kg8jQDNy6yyUDPLcOOd62inhZu64hybWRcEF08eq2mwkrq4s8lzh9NQ4PzVkMpNJ7ZSA6celLK07ilIwhtIOIYTTEaJJ+2oFKGXw+LHFs2cbzGbCmU4Dz5+PUFXCRSRn/KaTE4PNxuDFiwybDY9nhIDzyGydIjV1YrKMx3heivP6AhOSBFmewWRSO0sy4YBehvHYoCgk8rzaScsAmp77sBc8zmNQTqDEyUmN9TrDem0BSEynlGApJVBVFfKcR1JKMY4VpUISWabx6JHAZAJMJhWE4HHXeKzx6hXwyScK1tbgkVSBPaDYg7PbukRNlAI+fXbyTdKZvnkMyXsImIjr0vS/z8axKX2fdG3lN91r4g2pMrp4Z1M7+u8QWIRSvLhdYqB8V0pJDPtS/EwYlqStP1+nBwxshlJq8By6uPYt603RfQ+2VP6e2hhCk9ixq35du6SmfLt2Xk11aKIYWAxty6a2GZqPbw/qmgAZsszsdEpWK0buLgqDPNfQukaeq52/GioJM3jjeIydg7zZzDjLKC6+NJsWDtxw4WcwzP3v7ZZ6N955ngciPFKy2G69bo50Up/KgSyaa19fC6xWCouFwsUFLa2E4PHQbGbw9GkNpdg+QtBJXZ6r3RHZO+8wYjclJpmTzCjUtUKWaYzHjAm1XDLUgdYMcHlywsV8vc4cGIGz3KLDvs2GjgS97gylOymJJ0HcbGZwdmaceb10llCVC/tA6ZdSwllrGacPxOOtusbOSd9ymePszLq+HWE2qzGbGWw2GbRWTqJFfaLFQkIpOiFk2AaN01MqG3u/PUVBfZ/lcuQkRAAwAkFMaAYevlc8LpsW2UN5Stfc6Zufb6eu+vQBPk08JKa+c7ZvujZAcuiCHpbrlcnb8ktJsLqkIyn+mfp9SP1T5TZtpsN0XX1ncWibfgsAm/sQK96l7BQy7lP2fUom+pTn09yV+jCSFLAB0gO/a0eZ+j3kne9KfSdhmD52EueJZr1ZplHXjHlkDBdV+p2REMJHvJbYbAzKkvox4zEwGmlMJgYnJwQ1VDTmIj8aceHXWkNrtXP+50ERHedJ5Dn1eejgTmGzsbi+BsqSCq+LBbBeU+zLI7EM771Xoigs1muF5ZJmzjc3EquVdMdfEkUBnJ1pvPde7cIKUPK02dAqa7OxKAq9i9e0WjE+02aDnV+ZV68U1usRTk60i+NEkDEeSxfjisdTrBud+fFIx0c0l7BWu2jhBlWVY7uNx6KClBqzGUND+NhVtPKSu6NAghwNIQwmEzgP0XtTdB4d5ri5sVBKA+D7WUtTd0BgtcrcPeGkV3DtUmM6zXe6PeOxdtKiGpOJxsmJwvW1wWKROSXkAntQc1tXaH8tHq93oSEAvmkRjedNCsR0SYbC55vqmMonJbHrA1ji54dsipv4eZskpynvNuCUStcE/LrWmCbJ5tANYyrfIRK01LP+O4xF1b8tHziwucskDRfYNw1uUmXfRz73/Uw80LuYSkxtg3loPn3EoKkJ1AZqmnYEfRh1H6B5VzDKOltrUNdq5yHYXzdGYLnMsdnwuImKpf44ifovs5nBo0d+l++97XIRNQaYzzPM5xmqSjjPwgQEHiBRr0O6QJLUf1mtlAsq6T3qAkKUGI0qTCZwi7WA1ozXdH0tsFhkO0ssr/h7cmLw+LHG+bnZHRNtNhKXlwaXlwzpwBAM9GfDmFDe9LnGdquw3RI0EWDw3QFaTe0d8FFf5+SEEhuGi2CQTYI34OwMDhgqZ1W17/ssk84qjEdB7BMeZ3lQojXjaE0mGtNpiaKQOD01uL7OsVxmO4Xq1UrDWgWlGJX9yRMe3S2XNLnPMuryGMOApNOphta5U8Y2LlAmTfm/+EWNR49qXF5q3NwAn36aYz73YTgm2IvlQ32D9Bi7/R8Yxiv6LCJ3mQttwKftmUPud11vkgjcx9rR59nU+7fpxLRtAu8ikW7K51ApdVe5KVDWxq9jz9vt9MCBDXBYw8a7tL7SjL5l9NlpDM2zKY/7fi5EwyH1rWsXum8TG8fp2tox7Pf2SK7pvIdKWtqA1iHMI5TiAXu3+NL5pYklW8xXKe2OqeivxhjhzLENioKm1icnNSYTg9nMuAVZ4PlzWju9egV3hCNc8EnmfnlJHY/lklGwr69pxUTdljHqWmM6NbsYSEWROZNzg6srSiuWywzzOX24KMUYVefntTsaoiLto0ca77xTYzKBO/ry1lO5C/IpdxIPmnOHEYLZDt6iyXsklpIm5fSLwzajgjQlNnXN/17ylWW0GGPEcu80cL/78xIrwOyO8Agy2BdCGOeBmP+zjIrKs5mGEBm2W8BboGtNJeos4zHeV76iMJ/X2GwkHj2qnWdnubPwomRIoKqs81bMjCaTGs+eMXJ4nkt84Qsav/7rBJA8Ust37cPjtHA368ft3oty+1hNSUWHShbidPGcja+Hi9brfd7Mk9r4UhMvauNBbfwgfr7PvI/zuy8wNBQ0dpXb1FZx/3RRmzStqw6pcdf0fBvg6aYHDmwOlXykJlifCZJq6Dif1P/UM115xPkdMiH6gr677q5S+TWVe59t49skhfBTO62wHfvsZlP3BdqVMof2k1+AfJ4xoKkhhHLm1nt/Kp7xU/dGYDQSyHOaQC8WObJMu4Wbi/9mo7FYFJjPGXqAxyr0ZiuEwPPn9Ki7XktcXBSYz+E8+xJkTacCJyc1jIGLA8XjIMBb8NCKarkkKDk9pVLybEapj1IWT54YvPNOjXff3UtteHQEzOdqF5JguyXA8iBlD1xDEMgjM3opprWQN+sGmO/VlURZ2l2sqH1QSuv0VHy0b5+3l3RQv8n70RmNxM7qC9g7BqR3Y4nFQjnHgtSv2fvPYb5VBRd2weL6WqAseUx2eko9HR9mArDOU7JweRgYwwCj0ymB6mhEr9Lvv6/wG35DiW98Qzo/RD546gj0cxPq24RtGIOGtnE5dPM3NM/U9aaF7a48sKk+Q57ps+HrWkeGbI6HpGuSohzC22P+fR/SmCZeHl9vA1Lxe4XXh43VBwhsml5uCLWhvqH1eNPP3Af1AQgh9QUkhzCNrnupvPswhK4JHDPGFKMcKpE7dAyEz3rvsvGY5EcIv6hZSFm7YJP0p0KLKeNiQtHx3nYrcHWlnCM5gfHYOJ2VDIsF40mtVmoXBoFBKCVevJC7Y6Cq4uLv68e4SBZnZ/XOp8xmkzkgQx2d7dZivSagmEzsTr9lOiVYKAqLd9+t8O67Bk+fVnjnHQ2l4Ook8OKFwvV1geWS8Z1ubqQDTr4eoVROIW7HvdUT0282Ai9f5phMtFOyhmsnYLtVuLjwoCjsC0o9lDLIMkprplNaPHnvyQD94pSlD5IpnVm8b2flQMl+UfEhJTx4qqocRcGQFVTS9oBM7HSgtKYXaR65URI3GvFozVqN09Mcv+k3bfGlLyl8/LG3ivJWXSPQt41vlBRYiMFN207b3z+UV/pn+uQxhDf0qUeXVKXpWp8FVyTSt9FQvteWh69Lin8NAVDxZq/puS7+n9pEpjacfTaEbWMjBbaGrk0PCtjcNyi462477qQ+aH5IXVL37rpr6iOR6FOPNuoDQPqW1wZeY+aTAkJtwKUvWArr2cbAmhhe37xj0MVPniucn9c4OWGIhe2Wkhkq/gooZVx0boP12sLaGmVJSc5kIjEa1S66dI7l0isjs0xaOzEGFU2VAWMMhNDOaR8lFEUB5zzO7jwDV5V1Pl7gQj4IZ64snPm4V3StoRSB2dOnNd57r8azZzXefbeGUsDFhcJiIZ3zQEo9Viv6avGKwO1Swfial3QIrFb0lHx6anbHaFVFZz63pSq3zaOp4yOQ5zWmU+ECdWJncl+WBpsNwQj1ZQiWKCXyoPD2IuiPpniPEdOrSjqdHewirNN/kbeAEs6PEC3FGLOLPnxGoxrn58Bs5qPCh8dOOfYSnJSEJjXm2mhImvC9UwAhRfF8PYTHNS2K8fzvKmPIhqUJVCDxu4naJBmpeqbARIqntklyUuX5a302uT6vuJ/b5moXqE09G4+LJh9Jw8fLAwI2nvqgy/umPsw1Rvae2tDnEAYTMsv7fO++u5/7ZIJ9yA/ktvKH7IDuCsxi4JEqo08eTf9DRiHgYwNNJgZnZxbn59Yp/woYI3eBKrNsi/lcYLvNnZJwgbqusd1KLBYWeT7aSXKoAEx9E8ZDotRntaLnW2OolDwaVSiKAlVFYFAUXGS9hZX3JiylxXhMiyyA1jw8VmHIhMmEoKIoNGYzgdNTi/NzjSdPqGsjJZwCrsXpKa25rq6AuqZCbOh8r7mNY8bnLc6YXmsJrQ20NqjrWBcrZrQEAVpbLBYG67V0MbKs0/9h6IiypH8gRjo30Frh6spbkPmYTibIUwT/lfM1RACXZbTYKksGJBWCistVRfNyKQEhFCYTOIVw4Y6+FBaLLDiKk8gy709IYe+ReH+8lm678DtszyHUJgmJ+RyC323zuW1T0lbHFJhKbRq6qO2dfJ6p/Jp4Q9NGOt4cp8Z53BZ9wc2bXDPiusZgPu6jpuPPpndp4revbxr2fdAfGzxAYHNf1DSAmqgJUTf9b8pjCNM4dDC2IeOQUgMz/h2n71un+5hMXW1+CMU7IZG4NqROh5Sf2un4/7cXaB8KwDvsU4red70PG6WoY1OWPCLh8UiOqqJSLRdi75lYYjLRyPN6Vw51P6ibw3AIGkoZWLuF1hmWywxCWBfJmvWuKuyieU+nxsU+or4Ig2sK5DnfVUqByYRSDCrEil1kcmOE06Oh474nT2rM5xKXlxmspa+YPLe7NM3jkibUjMhtnB4NQYi1lLRIaZyUJs4nXngplVksgI8+sq5djbN0glMg1jg5YZ/54KSXl8rpBu2PlRiXSkOIfHe053WApPThGqTzzMxjLGt59FhV7Nvttt4FBt1uhQNT0ulCUdqmFPDsGRXGv/515ZwW+mCZNfY73Xij4N//LtQFAO4z31SaroV7KKDpqsOhoC8GMEPy7bOupK4N3cylpC6pcRK2O8f56/fCZ1LzNnWtCSy25dH2v5keILBpQqif1WQaQvfFPDx1DYYmFJtKH/5vQsZ96L7fsS+1iTObGNKbYsJdZbVNap8u9D+idve8tGC5VDsQwrhFgLXaLegZlJJOwiJ3kbAZTBLYbqlYm+fWxYeyTlLAuhE8GSd9kcgymoJnmcZyqbFaSZyc0OpKSgmtvam1xXhcOesk6SJ085iFpuTef4t1Ry8W6zV1f0YjBtz0xzuTicHjxzWur5WL6M0FfjymFGQ+923yehvmOX3OUKkazgePddIoeuzdbPIg3pQPIukX+1haBpSlwiefjLFeV06CI907ErQZU6OujQvZQEkaAYiClHsvzwwOuoExjOclBPVm9jo/3u+NwWq1t0wDamw2mTtyBL72tRx5bvDee9qNB4FXr3j8NZ2u8fnP13j8WEOICf7pP5UuyGdoXZfS40rp2bQtsIdu3trmXdjufZ9tKqetTodQ0zzuI0FJ5ZWqU9viH4OhvkCuT782Scz68C7/3QdMht99+7aLuoBSd74PENg8BOozofqISsNrbdQlgRm6i0g9P2SQdTG/+Pd9goeud+2abIeW1/Z8GyPw97ukDqGkxhMVUudzMpEs487IGImiqHeLKoNVUqdECHrqNcZAKe2kAcItpgQxWkuMx8LptOzrn2XU43jyxOLxY5qVUzKQYzarISXDHwjhQzvYQEriQwEY1DU9Fue5cNG4hTPvlqgqi9VKoijsTneFVj8W77yjsVhU+MY3cudlGfjc5yqcnEj8k38y3plg79uLbamUxWxGZWUGrjQO3ADrtY+tRGeBlOKIoK1jZ4l+98nQEdstFXMZgJRtZC3bra4NxmNGOX/xQrgwCgZKSeS52ekgARJCZKgqOuPbbjMHOPc+i2gWTnBbllQCph6TgZQZRiNasl1cVLBW4NUrSmyU0phOJZ48Ab7ru7bIMuDDD3MXhDN8v1h8H47VQ+f+0Ofi9LH0MlWvto1KDEjbwM7QjVrX/zZe3AZuUhKcJuAXt3UT3+hDfTa5TZthnzbe+Pbliam8utJ05dWnzZrpgQKbw0VQd6O2Sd13IIbP9pkATc82XT8E5MSDtC9w6apT/EyTlK2PGPau4C3MbwiQS+0EDgFX8Xjo2kFxkTNGY7mkp+HxmEdIPIKi5MYf6dAbrnEO7YyzdmLQSS7IBDeAPwqy7nhIoqrglH6ByUTgc5+r8OxZBaU8CNnr1TDwo8ZoxKjj3g8OQxsYp1hMaRFNpQlyeORinaIyA0hmmd05/pvNmOdqRbPy8Zgm4d/xHSVOThQ+/LDAYhG3GcFJnlOfZzaz7tjMQMramWTTqzGPiaiDQlPymIlb3J4HGjQpF6AEjYDKt6UQ1h0RGmSZQJ4rKMX2plNDSr5oYWXdEaJCngtstxplSUeHt33LeKmKD4KqnQM+Ojm8uVH49NMMWcZQFMsljyFPT4HHj2u8/76BUjV+6ZcMVqsce+uxMJ7OffHOrkWtz+KYut90vUlycuhG51CK27Ftk9oGJvrw9zap0F3eK8XPDsmvax1rKzv+Hac5BPT0XyMeKLC5LzqkQ8KdQZ/nuwZ6n3p1lTUESXeV1URNE/JQ1N13AsfXwnT3xbT69EufsrrExGGaeOfnY/2E/Ve5Iw0eM2UZJTFUJJXIsi3KUkPrDFJmKArGVioKOKsdSn/GY+Oc4UkXf4qAYu8Qzu6ifJ+f13j//Qrf8R0lhLC4vqYjvhcvlIumzWOm8ZhHKj5eEj3rGqfYzKMygi0eRa1WYmdmPh7TZJnhE6gETbNwgUePapydVZhOR3j2rMZv/I1bnJxk+NKXJi5CdthPchcugo4J9z5fRiO9k1RtNsqZuQssFhIXFwqvXmWBCbZv89BfzhZUvi0QBtuj0jalUVIqWJs76y06KaRJuHRHTPs4UHluXKR1HsXN5wrzuXTHYx7chNGKa9B6yuLmJnfm6wYvX2pMJtp5XDbOYkrj6VON01OLqqoxm2kw8ncGghsf9btr7KJl7MZzsQ9POlS600e6EOd5nxKCLmri6W0SkEPLjoFAF3/v28/x/xR4bJPgIEh/yHozZMN6X2n29ICATX8xU7PYs89E6BIldqXporb3aJNs3Ofg6kN3lQAd+mycx6H3u6jveOhb1l0lSh7YcLfu+7yuM0hJBdqiUDs/MnWtYW2G5TJ3yr/cnZ+e1hiNaAJMiYB1z/A4pixpiUSHfxZF4YESfaS8+67G5z9f4QtfoMTmxQvql7x4wYjfjLNUYzSyzmKH0bTznBKXzYZ6JHmuUdcGL19KGJNDSi7odU0LHn8EVdcMIzAeU8GYoREYFPP0lD5vtluB6ZQ6KiRKU5SSDtTsHdhlGcNKTCZ0UJhlVKzebukv5/pa7cJMXFyonRk2j4sIrqgz5PVTPNCwyHOCmqLw/mdoVca4UAZZJjEaAes1jwilrFxEconp1OLxY4Hzc42qol+gTz7JMJ8LZ4IuXXBNRlgvS4W91MhiuzXYbtn/JyeUrCkldzo4xghnbp65sVNhD5R8cFXs3mX/nVpoujYhfcf6EIls0/+YDgU4Q0BW6pgoJaXpksj0ASJDN5aHgLS4Hqm8+vbREL7Zlk9T3kOpS/KdpgcEbDwdKs4cWgY6yknRkEkf59+22+8CW30m8xBqY2SpgX2XyXaf1DRRmyZPEwBOPdeXhkiw4ki9vnxfrwLW1tCa1kTjMWMUrVaUhEhpd+76AYMsU5BSuOMYi7q2u0UX0C4mEsFFXUuMx3DKsN4ZncH5uXHHQsZJGvaKrjzyopJuUZidtIZl74/IvGKyMdL5qdEu8CVNphlzqnbKy/Qts1zyXV6+zFw0b4HFQuDiIsPlpXTHUPu+EYJgaDJhKIPZjMDGhzaYTqtdQE1KdghyjKHUJs95pERvxfTdQ2CiURQEQDQP5/sJITAaacxmVMAG4PSXGHcry4A81843EE2zlbLuSE7g5ETg7IwKvoBBXVcwJocxI6zXPGoajeD0koxz0hcq/LIuq5VAVeUQgro93vJrPqdjxqsriclEuhASBagkHUf97hqnQ6UxXdR3o9O2YDYdO7UBsqa8u8BR1/Nd6VP8sK9UOHUiEF5r47WpNSQlRWq6l0p33zw6VQ9flz5t1AQww//d9ACBzZtqaKAb/R0CdFL5DUW5XRM6RV2i3C6JVlva+PpQQNOnzFT6oWWkmMPQfIYAlbsAyXRbSpntdGKWS+OkJnBHInDKuxZa0xqHOiFwR0NwHnMlhJA7Sx0f46iujQM9lLzQs61x/nB4VLVYKKxWAtbuTbq9Ym+e01Edj6io0zOfE1BJySMpY2jSPBpRgfjkxEBKC2MoiSLIoZLtZsM4VYsFF/erK4UPP8zx4kXmdE32RCBh3LePuA2n02MxmWgoRUsw+okRu2OkoiDoYbRthmag/xjjomgzTEFde0ssHsGNxxZnZ3rnaVlrOtOT0mI65aJC/zPeV5Da1Ymm9BZPnmiMxxW2W4X5PMfVFZWH6V/IQkq9s2rTOvSwXMErMZclXHwuOEVp4Y7ZqIz89GmFr361cEdt3gvxkCOKpoW17ZnXx243HbpxSElF+j4T0yGbSX8/zj/enAC38+gLbpqeS21+EF2L82krI84/XJ/exMazjWJQF19vo+Hr6gMENnehvp11qAixrQNSSDymPjFc+pbXlv4QKcuhkplU+W+CUnkPRfR9xL1NzPwQRnB7N77/zfyUAk5OtIufpLDZ+IWuclIU4SQqypl2S+f8TSPLMhQFYw95xV064dv3Y11rVJVxUcQpSbGWei/rNY9ZFguB7dZiu2V6ADugJQR1Z7xTOh/jiI71pNMDESjLHMulcGEhqp2PGx6l2J2l1GLBz2pF3ZP5XOErXwGur+njZdcDQmE61S7cAQERlXWprKzUvv3ynMq8XrLBKN9qB7zij3egN5loB+jI8IWg0vTZWQVAOJ9AjIfF9oCL6M33Yvwu646XKPXy4SyKwgNUSr6yLHNKyQSsbL86GAuh/g2lc5sNw1+cnbEPNxs6+RuNgNPTCrNZidVqAkps/LgJx+jQDVafufumF8OmRf+QPJrm+JvYaDXxnyHA0M/b2IovBfT65hneP6Qd3rQ0J37HprYfWvcHB2xSYrS+L3WXBcg/32dQNw3iLulGW/7xe6fSDnmvlDivrazUva78m/Jsq8tQSr1DOAlSkpu70H0BM7+opI6i9mXlOZ3gjcfA5aVxxyoWgA+UqDGdwu30jQvUyIU/z2mWnGVeQmOdpZTX4aFJ8XarUVW1W7gNpNTOWRycTxUeH/EIJHMWPTxmur6WePUqx82NghDU42GEax6HGSOcibmA1hLLpcV0yqMSAjOv1CxweUmpTFURqNCiSWK5zHFxodw7ECiNRgaPHhHY8FgHWC7pCJC+dYwDDHRoR0mHdACOx2q0UmK7SFm78AW01lLK7vR3GMVbObABF8MJmEyorOvDQJSldGCQx3VK+VAO2IVIKEuLiwvl9JLYLkUh3ZEVdib5lK5Z1LVxCuCxx2Tp6mKdRExju5Woa7mLX/XokcarV3Am8qF1FLDXt4l36E1jFYn7faUDb4pSa8FdN15tZfj829adNoAR55niSX0kUV08bci7N/H2Pu3YVPe+dWirf2qsNY2/w/r6gQGb+1hY+qDiPuBoaN73QalyU3VOiSpTeR0K9mJwdZf3juuQqlOTWDeVj0/fV0Qd/z+kLYZQExiL86PTtuWSkof9wg4ADHJJU2yahWcZ3CJ8u26jkY9pxOMkOm6zCNvaWgkptxiNSgDUddlscqzXEuu1gjHSBXiE81fDOl1fZ3jxIsdqxWOwyWSNs7MaUtI5HKUkPD4hqKL33M1GQWvrfMPwKOjly3xnJUTpDRV7GRBTBfUVODlhlPDJhMdeDCPgneF5HzpwfnwkplOzcwZoLY+VisKgKNimWcbjNSGM05vxXpoJglYrhppYrxVubvyxknFAiKAlz7VzzkfgKIR0YIjHZcZQ6gUIZJnahZyYTi3mc7jjJw9M4QAZbr333okjwS1gUdc1tC5RVdRVMobAs6qyQDHax47y1lHxQvFZHzsgUd6QTWMbhbyiDZTFUo/4fhMv6CN57yrf328CKU1t0SVxG8K/2tIdAlJS/2N+3bahbsq3bQ1oyrubHhiwAfo1TJ9FHQ1p+jbSfe8Ouui+QF2fSROmb6pHH8bYZ/I3lRUznbb3j98r/n8Xxt3ElLrqNGR8xO2wj1l0fZ3tonfvzYKZviyBmxsugCcnZheywO/Mi0I7PQxG3fYKvYCA1taZkHPRFkLDWuVCMDBAJaU2cNY/Cus1Y1JVFWAtj6CurhSEIJCYzSSUUsgyDw7ETlrhf1cVfckQJPkQEMBqpbDZ8N58njnlXbGTsvhFWUrg7Ezj6dMao5HBagUAOZSC0xNifC36kBEQokaeU2HYewI2hvpGkwlgrXLSHQCQrg0p4WA4B+mkURLX19aZp2t87nP0yVMUEnXtI3RrGOOd7dECLcvoRE8pxnmitRRwfm6cJ2gvOcLONw77Qe2OwUIJn1K187CsnTQnQ1mOIcQGZelBJXBz4y2+fMRvL7WJx+ebBjV98+9a2PvwkT48oouPtoGN+F6b9AZR2rY69eW7IZhp4p1DgEiztLj/mEiNqaYN89B6hhT3393G7QMCNkMX9s9qFzJEMtKVTxv1BQhN19JSgeZdSxvFdY0naNuEPRSgHTIR2p49ZMfYRCHTK1anWAAAGmFJREFUicXJcZmpclIMl+CEyr4e7Ph0+yi3PoiltcBmg12gRx63cPGczRhGIc95HEKzZuN81ACbjcVymeP6WmA65f265tHKZkMpizdrpm8VApvlkhIWpbwSbb5TTq4qRq8GFPKc9dKaZss+jpN3UkdJEvO7vs6wXPoYUrcXdYBHXGdnGk+eVJhMLC4u6NGX1lnedJw+eRjzSu6icDPKOcNO0ATb7GJkeakKYJ0yNH/Tykw63SPpfONQ8Xqz2fcpPSzTqzOPhODeHxCC4KmuDUajGnleI8+VU5w2LvQE/epozXqW5X4M+P4uCvrBmUwAIQyMqaE1fQdVVYbrawFAYblU2GxCiyofXiF0BtglTYjHZ19K5d1nRx+X37RR6QIxbZvVvukPpZSEAomyQ17RhyfGbXGXOqfq0na/b15DNsx980z975KEtV3f0wMCNkOoj4itS2rThw4BT0PFfG3U1MFtkpamfA6ZMIfsRg6hPpO/7w6qb32adpBt7xtS07s3Me0QuNze8fid/O1nuNjzmKhCVeWoaybyXn0B5cCNcdGfvWIty6pri6urDFWlsF5XuLykMz0hCmw2PNrYbHz8J7nTV6ElFjCdUhoEiB04obQDsJZO7LylEWBckEeF5dJgu2VspLqmzgxAZeHra+XM0uP29z5mhFOy9d6W7U5aQzNpggPvIZgAag8W6hq7+FQ0z7YudhZ2wEQIfyxEB39Zpp1+E9veWu3M7CmtyjLjfAspB2oM6jqDUhZFUaOuEUjSLLJsBC+BWq32ytZVJR2A9PpAvg0oNZpMakynNGmnFM+DKoP5XGK95vEf9aEs9iBGYa9XFY+jmJoAxBAJZNcRwhCeMGTj1VTGEAlQ29rRJAWOpSlhXjL6H99PSYZSv1N5dElImmhIX/alNiDXt6z9eO9el7vWuPb14oEBm7uIsvwzd9mZ982n7w4ltWDeh+Sgi8IJ1Za+Kb/7aMM26gMkut61b1/3SdOVV9tOrW2CxkzKP0e/M0DmTLqNMz/2z3jnbcYt3AQTWWZwcsI8RiMqAktJB33UH/FHJhbGKGcFRKuh5VLg8lI65VmB8Rg7Z4CbDa2tCLKk0wGhx1uvHMwFltKd8diiKAh66DiPirBVJd2xlsB6nePiooC1GpOJhbXK6dU0tTWZnVL0zkzpiY8Ntc/35csMk4nBbCZc8M29VRelKMJJoKjfUxQ+crnZgR4hGBKCIRPsLp+6riGl2uVJs26mZ+wouICWbAtaREmn80IAIuUI261xPmrETiJGyYvZSX5oFbW3ZqIpv3WOFoVTvpaYThlodL3Od8rjVL4OwzNI7K2j/FgLqWnBTlHftG1AoM/zQyQZfevblTaVpovP99kQhpKZPnw+FbC0L3X1SYpSm60+a8OQOoV5d1Ffqdvha9MDAjb3hS7vW5IQUxNa7TsQ+nTgXYBF6v2HSCHCPGLq066HgsvU5OvzTEx9gUwfSr1LUx1T18O+2O/o/ZEBj5OsM1sWQQgAYD81/fPamSPzmhBbCJG7KOB8zktCtGYkau/fxkfdvrmRLp4RPdsCcGbKykW2lk5HhSbmDM8gnGSGYIYejA2yrHbWQ9Ydg2Xu6IVWOzSPtk6hVyHL4nAJ4aKxB4oEC3DPE/SNRjySqaocL19KTKfcJZelDRSWpdN9EQ5ISBcfS8M7LzSGEhc6DrTOISFc29HfDH3z0M+NN+U2hno5m43cgQqGmzCQsoK1DMtAiRDTlqVFnlfYbjNst8IF6JSoa7OLBB62A8sVTkGcUiVaXdnd0d9mI1wkc+kkfAJ7peGUnk08Lv3/cEyG4/VQafOhO/gheYcLcbixSN0fQn1BQjzXU/y1b/lD+eMhfLEN5LTl07XBG7J2da07XXkdLqh4QMDmTdBdJleX6K2trCHAqm1gpBaCvuCiKf+Yhk6AvtKqPnTIbuWQsvo810dKdwhYbLqeuQja1J5VSjopinX6Jx4AsWwGydzi5KSGEMqBh9rpnigXAsAv3vQ3wyMPSia2W2A+p5l4UUis12J3zEMg4KUFXhrgF2mB01OL6bTexYVivYWL/m12DgWtBdZrheWSlk9VpXa+coTwxy9xO+6PgGjKLZw+jHBxp4QzEafUY7HI8eqVdo7xKHGhhEbBWumOpXhsBdCkfrORDnQBxlDx2AcGpRIy+551piI1AYZGXStMJtIpcvPdAO0spjSkFM6Um+URINkdQFmvvaUZ+5NOAf0ivJew+GOyqrI7Cyo6O6TlXFnKnXSIuj9hO3rAnAXXu3bjqU1Mam4P2dyF9/rynSZJT5xvnzqk0txlDRjKa/vm2ZZPE/8fWk6bVOpwScjttH37eKjULmz3sF3617EXsBFCfBXAHNwa1Nba3yaEeALgzwL4TgBfBfD7rLWXLv1PAvgRl/4PWGv/cu8a3ZnuIu2IqQ9ibBKrtd3votSAGCopuSuoO5SGiL1TCD2VT1sZd5nwQ+7F5Q4hAR4/eYsnLo57SQvvjcf00uuVeL03Wka4FhiPs50zOFoA7UMC0M+N2h2XENgIt8BLaJ1jubQuuKa+pb9CT8ReWRguBAE9DVeVwHjM4yQ6v6OFEQGBjyrudX6o57JcSqzXlE7QIV5omhy3Ndsjy2gNxWCdXJiFsJhMtmBcrBGur7mwX1/nGI8FZjOzC8zpzbzrOkNd82iN0iPhgljW7t28Z2e7a1sGCvURvXmct91m0Jrm1UWhUVXAcunjcEnnW0jtwJG11HshKDQuqnqG9do7RiRg8YFL2YcWPJLiMVRdS9dvVDymMrRxx3LGWVTlrt+9FZ3Pw+vZ9FnEUtdin0spsNMkiQyvy4Z0QDc/SNXzUHByiMT5LhvHvvVMbRjbgMbQTXIbb2wDVeFGqmuTfuimvU+aoRKjNA2R2Pzr1tqXwf+fAPCL1tqfFkL8hPv/40KI7wXwQwB+M4DPA/hrQojvsdbq17McSl3iwfjafdAQcVjfOjSJ4vpS02C/a75Dyg/LS5UZM7623V/X7rJJetREqd3jkD7sU86Q3ayvg58CNJ/mLt7HYGLIAyHU7liFiq1UcGV8J2/WbdwiyQjULFM56yCL9ZrSGq986uulNUMoeMVcwDofNHQot1wqZ63DIyDv9K4sDaSsMZkQqFABmYqzXmpBb8MZtluCGioke4bZ1A/7cTEeazx6pHFyYnZxsrLMYDKRKAqCCiDDYpEhy2pMJtQtkdK4DwOF8p29zkyFuoYDHbXzGpw55WHjnBxmKEsqWmeZVwJm3ShtIshgcFG5O+5TCjs9nSyj00NaLwFU+la74zQhKpSlAcDjOh7rGefTR4Fs2MKYCmXJPJSymM8FgJEzUYcDP9YBm66x10dyE6Zt25C0LZZ9wMBd+FEXj0nVqUsq0qe8+9wweYrr26fed90kN+WbohSfbOrvPvU5ZE2+n7XzLkdRPwjg+93vnwXw1wH8uLv+c9baLYCvCCF+DcBvB/A371AW9pMvtWjF6e4b3Hj6LIBDH4lC3BZD8vgsqQ3UxItdX3AzhFKTcKgUqak+h1C40HDx9s7tfHBFLoS8NxoR0CjFI5rRiIrE261wRzX0WiuE3R1lLJfSSSjiRY1HXus1x05RwEkACLi0ppn03g8O6yiEwHptsFgwjIB3dAd4qY10v+GOvBiZnKDGe9WlhOr2Yit2HykNTk4Mzs81Hj/eR7+21sd6sjvwVZYWmw3B02hUoygkxmNKmBjwks7ztN46vRwGldxsJi4OlnDHZ8K1v3XO/rAzKd/3Ffvj6krtgoECwnlNpidjIfSuvwiGvNSrdgrE1c4fDfsKLoo4pUTbrbd+AqwtoLUGUEJKSt0uLz2w8jpUACV5BLN7xWGvkI6gbdsonJvxGA2/w/wM0vPj9XG2f66p3PumQ/JN8dH7rltTG8Rl9ZG0DaGm59s2GX3LHbJRPJSGSM1ep77AxgL4K4Ly2//FWvszAJ5Zaz8GAGvtx0KI91zaDwD8reDZD921e6I2Eeld8+y74MWL8SGSgb7UxEjuo5xUG/ZlRn2kZU1M8pD6daXpEp925dEGErt2Un1pvzB4018uij6mEutCkKBRFAh81NROwVihqiS2W3rKpWVPDa0zBwjCRc2LluvdNWsNViuD9ZrHXzwS8cqoflHy7+yjZGe4vBSQssSTJ9ZFqOZCx2MWr3hsUZYGxvgFN+yb2BR536ZZZnB6WuH8XOPJky1WK+VMqy02G3oeXiwyB5okjDGuDSSKgkEr6YvGOM++FloXqGtKVgi4FEYj3qNjP+G8PTOC+HbrwUk8r617V39N7vSRGCIBOwd81Nsh+JFSOzNvBQapLHbt7+NFKVVBKePyor8gsuR8Z5lFP0Jw8cDgjtA0Ql9HLKMKrsXApmtDNnRRbZuXn+Wmqm1uhutE06bqdSDbL/8hNFRqkUrfJJ27y2YvteGLy2saF/fJX9ueabt+P8Dm+6y1Hznw8leFEP94YI1eq4UQ4kcB/GhzFm0isIdAKaCTut5EMUBrAw5d5felPu3X1M5dfdIlZh1CTdKcJgbVlU/q/31L+trGpw0++7QEFMbpwbAOXLiAPOdxQ1n6uELKxXjip6693xgL7tjDcvbShdugwsLv8q3lmRMBjXfuZnF7cWQogaKgRc7FReYkS8ZJmXhk5YM+VpVyeimhrofPMzRFjvvX+6xhNHKt6bl4tcqQZQy5cHOj3PGWgA/kSe+/FlWVBQrMGmWZ7dLy2sYBBFpKFQV1gsqSoSuE8Po4cT+mxruX2lCXSNLECuu1L8+6uvjAm7QK8/kSxNYQQjtruJELFaGdqTv7w8eaYlm+Xz0AlSC42YCAKQSNsfVZipokqW3gPnz2rpSal038tIuaeEO4CDdtPFMAsGsT11YHn2db/l15+vlqE2n68Kg+bTd0Lf0s1+I2QNOfP/cCNtbaj9z3cyHEXwCPlj4VQrzvpDXvA3jukn8I4IvB418A8FEiz58B8DMAIDw3765Jx70usHBo3j7PpjRN0ps4Td863feup6/kow9jS/2Py2makF0g6BBpTldduiZEzIja8mx6viu9iT5+2u1Bh/eEa4xXyuVCv1hYZxFDZeH1WmCzyZzfE4H9sYS3iImlNf6a93fi6zoCsA3SemnSPqAipQp8Rmvg8pLgZL0m2BLC4uRE4uREu2CRyh0H+XfzCq77yN0p5s5gjxLbLQNxLhb0ljybESBcXdGx32ql3DFSvfNXMxpZpx/D96TJtHU6SsZJV8bO3w/jPHnneCyPUq7VSjrJTFjHcKELd7oWZakdCENg7bU/3vJgdW+Wze+9wjV1nUYjOF2p3Hl4htOlCZ8Lx9G+DreBaOh9OKx715wEbucZ9k3XZuWum4E4r7isIVKnJkrx5Vh6mErf9P8QStWhDSy2beDuAm768re2DWDXM03g8FBK8edu6gQ2QogZAGmtnbvf/xaA/xbALwD4YQA/7b7/onvkFwD8aSHEHwaVh78bwN/pV523tfgP6byhUoOhZdwHHTr531R6oHnyHrpT60t96hr365AdZJ90ocQmlKTsjxO4IGKnc8NdOvVl1mvjzKW9QrANgmbunbztyeC2lMTXS2N/LJXBH4+QwrQ+bIN1ZsxcvOfzHADrMx7XGI1oubPZSKesLNw7+DzDBaSJ2bENePRCa6SLCyrWnp5SP+bVK4WrK1pujccEQIxsrlEUVHBWyuDyUuLmJoPWGcZjH3JBO6eD1HMxBs5ZHt+1LKWTQsW8J2xT39ZeGmIDT837Z4SwLo6WwF5/yT/HtErVyHM454lwcaHgnBH6Zzw4DMFmTML1X1jfHM0gsm2B6DPnUgtWKOW7L+qSIt2FRzRJU0KgeN80BETEzzRtuvpu2roofOf7AIwi+MTA+D7BTjf1kdg8A/AX3ETMAPxpa+1fEkL8EoCfF0L8CIBfB/B7AcBa+ytCiJ8H8I9ALvpjwy2imhoh1QmfVWOFZad+35XuK6/7BAZdUqima33z7aIuwPGmyk2VdQhDTY3TcJJ7kCF3iyFQw1rlgI3XA4nNeD348EcSIZPW7qMAGIxGPpwAAzcak4FSnr2pOMl/Z7vrSnk9EeOcy2EnOTk9lXj8GFiv6R345sY7qIvBjM/7dlykkDlTJ4ZWWculwMUFTbNPTyWWywzX18DlZYbNhm00n+cYjXzgSY3VigrVl5cWi0WJPDeYTmlh5r0rs30tfKBMwOL8vIa1FpuNcmEcvPdl4TwdS9f+2LXnbZCKoB94L88BayXqOnNm/L4d9uNHqdpFDVfOBw5Bmzc1ZxuG7RQCHN/3hRs//hgS7ndKl6ltHLdJA9qkCilgMJS6+Pib5O2HSGaa3rNr03MfkqdUvnGduvoh7tumNmgCvk191CYdCuuVyqetHQ5vo05gY639MoB/MXH9FYAfaHjmpwD81MG1AtC+qMW7qvtE9X3r1uda1/NtTOaukzrchbRNrL7l9J0w9ynBGsJEuvJpe66pLk2Lwn2Bq/2xD62QSlAawGuvlxculP5bBWkMCFp4jfGHKue9ljo5y6WEMeOoLj6f2/Wj/oh3PMfrWnPh9/GKypJHYtQxQXSEktrN+zHp681YTMYAV1c5ViuL1Yrv/+qVxcmJcZIctQvoCQCjkXDSLVqFrVYWV1cFtM4gRO08A3vlYYu61g548V28T56i2EcE9zoyACAEnfNRjyfUbfHvQ2AY6kfR/411QUSt060JfRfVu+jik4lxYTB43CelcqbcXjHbh9Wo3Ldvs/GuvL3X4ZSydtuGINxdDwX78fMheD0kr6Z7nyWo6UOHgrghYKBvPqm1cSj15ech9Xn3FCiK+dib36B+k3ge7uq4NnHefVDfRbhJdPgmyjuEmnZjQ567zzq8KUpNoKYdQxeTObQfm3a44WIfLwpeR8JLXfz0lLjNIOJ8w+t71/qM5WRxelo76ylKE1arzJljh/VCkI+BED44p3ckqHYKr1lWOzf/lEwwYrWAee1Ewucb6vuEv1kHKamvcnFR7Py1AAbzuYBSW1SVctKPynkzrlHXFYwZQ0qByUSjqjLn2E67kAgM/0CzblqUMQq5f3ftdG4yF2TTB6sULqiocSbdgBBwJvThO/n0Ct7JHmBdcMoMQmS4bbnEMqsqx3pdI8+1k6TtTcm9kz+tvUQtDMHhdWj8f0++nFBPaijA6FpowjFyaB5x+pCGzq22edD1TMwb3uQGuKkeb5LCDa3/f1/lDl0HYzCY6qO4fkOkTs0k9r4R3h4JIV4AWAJ42ZX2SJ85vYtjvzxUOvbNw6Vj3zxMOvbLw6WhffMbrLVPUzceBLABACHE37XW/ra3XY8j3aZjvzxcOvbNw6Vj3zxMOvbLw6X77Js2u7cjHelIRzrSkY50pG8qOgKbIx3pSEc60pGO9C1DDwnY/MzbrsCRknTsl4dLx755uHTsm4dJx355uHRvffNgdGyOdKQjHelIRzrSke5KD0lic6QjHelIRzrSkY50J3rrwEYI8TuFEL8qhPg1IcRPvO36fDuREOKLQoj/RwjxJSHErwgh/qC7/kQI8VeFEP/UfT8OnvlJ11e/KoT4t99e7b89SAihhBB/Xwjxf7r/x755ACSEeCSE+HNCiH/s5s+/cuybt09CiP/c8bJ/KIT4M0KI8bFf3g4JIf6EEOK5EOIfBtcG94UQ4l8WQvwDd+9/FD4eSQu9VWAjhFAA/icA/w6A7wXw7wshvvdt1unbjGoA/6W19p8H8DsA/Jhr/58A8IvW2u8G8IvuP9y9HwLwmwH8TgD/s+vDI705+oMAvhT8P/bNw6D/AcBfstb+c6Bn9i/h2DdvlYQQHwD4AwB+m7X2XwC9J/4Qjv3ytuh/A9s1pEP64o8C+FEw7uR3J/J8jd62xOa3A/g1a+2XrbUlgJ8D8INvuU7fNmSt/dha+/fc7znInD8A++BnXbKfBfDvud8/CODnrLVba+1XAPwa2IdHegMkhPgCgN8F4I8Fl49985ZJCHEG4F8D8McBwFpbWmuvcOybh0AZgImg6+cpgI9w7Je3Qtba/xfARXR5UF8IId4HcGat/ZuWCsH/e/BMI71tYPMBgK8H/z901470GZMQ4jsB/FYAfxvAM2vtxwDBD4D3XLJjf3229EcA/CHcDrh07Ju3T/8MgBcA/ld3TPjHhBAzHPvmrZK19hsA/nswKPPHAK6ttX8Fx355SDS0Lz5wv+PrrfS2gc2bDvJ0pB4khDgB8H8A+M+stTdtSRPXjv31BkgI8bsBPLfW/nLfRxLXjn3zZigD8C8B+KPW2t8KhoNp0w889s1nQE5f4wcBfBeAzwOYCSF+f9sjiWvHfnk71NQXB/XR2wY2HwL4YvD/C6Do8EifEQkhchDU/Clr7Z93lz91IkC47+fu+rG/Pjv6PgC/RwjxVfCI9t8QQvxJHPvmIdCHAD601v5t9//PgUDn2Ddvl/5NAF+x1r6w1lYA/jyAfxXHfnlINLQvPnS/4+ut9LaBzS8B+G4hxHcJIQpQeegX3nKdvm3IaZf/cQBfstb+4eDWLwD4Yff7hwH8xeD6DwkhRkKI7wIVuf7OZ1Xfbyey1v6ktfYL1trvBOfF/22t/f049s1bJ2vtJwC+LoT4Z92lHwDwj3Dsm7dNvw7gdwghpo63/QCoN3jsl4dDg/rCHVfNhRC/w/Xpfxg800jZ/de7P1lrayHEfwLgL4Ma7H/CWvsrb7NO32b0fQD+AwD/QAjx/7lr/zWAnwbw80KIHwGZxe8FAGvtrwghfh5k4jWAH7PW6s+81t/edOybh0H/KYA/5TZkXwbwH4EbxWPfvCWy1v5tIcSfA/D3wHb++6A32xMc++UzJyHEnwHw/QDeFUJ8COC/wWH86z8GLawmAP4v92kv++h5+EhHOtKRjnSkI32r0Ns+ijrSkY50pCMd6UhHujc6ApsjHelIRzrSkY70LUNHYHOkIx3pSEc60pG+ZegIbI50pCMd6UhHOtK3DB2BzZGOdKQjHelIR/qWoSOwOdKRjnSkIx3pSN8ydAQ2RzrSkY50pCMd6VuGjsDmSEc60pGOdKQjfcvQ/w9kXkPp05BhoAAAAABJRU5ErkJggg==\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "with cpy.SingleFrameContext((512, 1024), fov=90, near=1, far=1000) as rc:\n", - " volume = rc.volume(data, spacing=spacing, fmt_hint='uint8')\n", - " rc.mip(sample_rate=500, layers=[(0, 0.2, (0, 0, 1, 0.2)), (0.4, 1, (1, 1, 0, 1))])\n", - " marker_mesh = rc.ball(radius=15)\n", - " marker_material = rc.material(color=(1,0,0,1))\n", - " rc.meshes(marker_mesh, marker_material, volume.map_voxel_coordinates(markers), parent=volume)\n", - " rc.camera.translate(*volume.map_voxel_coordinates([camera_position])[0]) \\\n", - " .look_at(volume.map_voxel_coordinates(markers)[2], up=(0,0,1))\n", - " \n", - "figure(figsize=(8,6))\n", - "imshow(rc.result)\n", - "tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Cutting plane rendering" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Example 7.** Use `rc.plane` to define cutting planes: (we also change the camera position)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "with cpy.SingleFrameContext((512, 1024), fov=90, near=1, far=1000) as rc:\n", - " volume = rc.volume(data, spacing=spacing, fmt_hint='uint8')\n", - " markers_in_volume = volume.map_voxel_coordinates(markers)\n", - " rc.plane((0,0,1), markers_in_volume[0], parent=volume) ## plane through first marker, normal along z-axis\n", - " rc.plane((1,0,0), markers_in_volume[0], parent=volume) ## plane through first marker, normal along x-axis\n", - " marker_mesh = rc.ball(radius=15)\n", - " marker_material = rc.material(color=(1,0,0,1))\n", - " rc.meshes(marker_mesh, marker_material, markers_in_volume, parent=volume)\n", - " rc.camera.translate(*volume.map_voxel_coordinates([[400, 200, 80]])[0]) \\\n", - " .look_at(volume.map_voxel_coordinates([markers.mean(axis=0)]), up=(0,0,1)) \\\n", - " .translate(-35,0,-450)\n", - " \n", - "figure(figsize=(8,6))\n", - "imshow(rc.result)\n", - "tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Example 8.** Add `rc.occluded()` to visualize visually occluded geometry: (note that the markers are half-translucent)" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "with cpy.SingleFrameContext((512, 1024), fov=90, near=1, far=1000) as rc:\n", - " volume = rc.volume(data, spacing=spacing, fmt_hint='uint8')\n", - " markers_in_volume = volume.map_voxel_coordinates(markers)\n", - " rc.plane((0,0,1), markers_in_volume[0], parent=volume) ## plane through first marker, normal along z-axis\n", - " rc.plane((1,0,0), markers_in_volume[0], parent=volume) ## plane through first marker, normal along x-axis\n", - " marker_mesh = rc.ball(radius=15)\n", - " marker_material = rc.material(color=(1,0,0,1))\n", - " rc.meshes(marker_mesh, marker_material, markers_in_volume, parent=volume)\n", - " rc.occluded()\n", - " rc.camera.translate(*volume.map_voxel_coordinates([[400, 200, 80]])[0]) \\\n", - " .look_at(volume.map_voxel_coordinates([markers.mean(axis=0)]), up=(0,0,1)) \\\n", - " .translate(-35,0,-450)\n", - " \n", - "figure(figsize=(8,6))\n", - "imshow(rc.result)\n", - "tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Combining different visualization techniques" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Example 9.** This example shows the combination of maximum intensity projection and cutting planes: (the markers are left out for clarity)" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "with cpy.SingleFrameContext((512, 1024), fov=90, near=1, far=1000) as rc:\n", - " volume = rc.volume(data, spacing=spacing, fmt_hint='uint8')\n", - " markers_in_volume = volume.map_voxel_coordinates(markers)\n", - " rc.plane((0,0,1), markers_in_volume[0], parent=volume) ## plane through first marker, normal along z-axis\n", - " rc.plane((1,0,0), markers_in_volume[0], parent=volume) ## plane through first marker, normal along x-axis\n", - " rc.mip(layers=[(0.4, 1, (0, 1, 0, 1))], sample_rate=500)\n", - " rc.camera.translate(*volume.map_voxel_coordinates([[400, 200, 80]])[0]) \\\n", - " .look_at(volume.map_voxel_coordinates([markers.mean(axis=0)]), up=(0,0,1)) \\\n", - " .translate(-35,0,-450)\n", - " \n", - "figure(figsize=(8,6))\n", - "imshow(rc.result)\n", - "tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "**Example 10.** 3D masks can also be rendered:" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "segmentation_mask_3d = ndi.label(ndi.binary_opening(ndi.gaussian_filter(data, 1) > 0.06))[0]\n", - "\n", - "with cpy.SingleFrameContext((512, 1024), fov=90, near=1, far=1000) as rc:\n", - " rc.volume(data, spacing=spacing, normals=True, fmt_hint='uint8') ## declaration of the volume data\n", - " rc.dvr(translucency=2, sample_rate=500)\n", - " rc.mask(segmentation_mask_3d, 'borders-on-top', spacing=spacing)\n", - " rc.camera.translate(*volume.map_voxel_coordinates([[400, 200, 35]])[0]) \\\n", - " .look_at(volume.map_voxel_coordinates([markers.mean(axis=0)]), up=(0,0,1)) \\\n", - " .rotate((1,0,0), -10, 'deg')\n", - " \n", - "figure(figsize=(8,6))\n", - "imshow(rc.result)\n", - "tight_layout()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Different flavors of mask renderings are available:\n", - "- `borders-on-top`: Borders are rendered above the image (see above)\n", - "- `regions-on-top`: Mask regions are rendered above the image\n", - "- `borders-in-background`: The borders are rendered in the background\n", - "- `regions`: The 3D regions are rendered as solid objects\n", - "\n", - "The mask used for rendering can be either a binary mask or a gray-value mask (e.g., to identify individual objects)." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.8.5" - } - }, - "nbformat": 4, - "nbformat_minor": 4 -} diff --git a/install_libcarna_dev.bash b/install_libcarna_dev.bash new file mode 100755 index 0000000..cae2146 --- /dev/null +++ b/install_libcarna_dev.bash @@ -0,0 +1,21 @@ +#!/bin/bash +set -ex + +if [ -z "$LIBCARNA_SRC_PREFIX" ]; then + echo "LIBCARNA_SRC_PREFIX is not set." + exit 1 +fi +export ROOT=$PWD/$(dirname "$0") +export LIBCARNA_INSTALL_PREFIX="$ROOT/.libcarna-dev" + +# Build development version of LibCarna +cd "$LIBCARNA_SRC_PREFIX" +export BUILD=only_release +export LIBCARNA_NO_INSTALL=1 +export CMAKE_ARGS="-DCMAKE_INSTALL_PREFIX=$LIBCARNA_INSTALL_PREFIX $CMAKE_ARGS" +export CMAKE_ARGS="-DINSTALL_CMAKE_DIR=$LIBCARNA_INSTALL_PREFIX $CMAKE_ARGS" +export CMAKE_ARGS="-DTARGET_NAME_SUFFIX=-dev $CMAKE_ARGS" +bash linux_build-egl.bash + +cd build/make_release +make install diff --git a/linux_build.bash b/linux_build.bash new file mode 100755 index 0000000..30244e2 --- /dev/null +++ b/linux_build.bash @@ -0,0 +1,38 @@ +#!/bin/bash +set -ex + +# Create or update conda environment +export ROOT="$PWD"/$(dirname "$0") +if [ ! -d "$ROOT/.env" ]; then + conda env create -f "$ROOT/environment.yml" --prefix "$ROOT/.env" +else + conda env update -f "$ROOT/environment.yml" --prefix "$ROOT/.env" --prune +fi + +# Activate conda environment +eval "$(conda shell.bash hook)" +conda activate "$ROOT/.env" + +# Setup and check dependencies +export PYBIND11_PREFIX="$CONDA_PREFIX/share/cmake/pybind11" +export CMAKE_MODULE_PATH="$CONDA_PREFIX/share/cmake/Modules" + +# Default to not building the test suite +if [ -z "$LIBCARNA_PYTHON_BUILD_TEST" ]; then + export LIBCARNA_PYTHON_BUILD_TEST="OFF" +else + pip install -r test/requirements.txt +fi + +# Build wheel and test +cd "$ROOT" +python setup.py bdist_wheel + +# Optionally, build the documentation +if [ -v LIBCARNA_PYTHON_BUILD_DOCS ]; then + pip install -r docs/requirements.txt + export LIBCARNA_PYTHON_PATH="$ROOT/build/make_release" + rm -rf $ROOT/docs/build + sphinx-build -M html docs docs/build + cp $ROOT/docs/build/html/examples/*.ipynb $ROOT/examples/ +fi \ No newline at end of file diff --git a/linux_build.sh b/linux_build.sh deleted file mode 100644 index 962d572..0000000 --- a/linux_build.sh +++ /dev/null @@ -1,25 +0,0 @@ -#!/bin/bash -set -e - -# Install dependencies: -sudo apt-get install -y libegl1-mesa-dev libglu1-mesa-dev libglew-dev libboost-iostreams-dev -conda install -y -c conda-forge pybind11 pyyaml - -# Setup and check dependencies: -export PYBIND11_PREFIX="$CONDA_PREFIX/share/cmake/pybind11" -cat "$PYBIND11_PREFIX/pybind11Config.cmake" >/dev/null - -# Get Eigen sources: -wget https://gitlab.com/libeigen/eigen/-/archive/3.2.10/eigen-3.2.10.tar.gz -tar -zxf eigen-3.2.10.tar.gz -C /tmp/ -export CMAKE_PREFIX_PATH="/tmp/eigen-3.2.10:$CMAKE_PREFIX_PATH" - -# Build and install Carna: -git clone https://github.com/kostrykin/Carna.git build_carna -cd build_carna -sh linux_build-egl.sh - -# Build wheel: -cd .. -export CARNAPY_BUILD_TEST="OFF" -python setup.py bdist_wheel diff --git a/misc/VERSIONS.yaml b/misc/VERSIONS.yaml deleted file mode 100644 index cfc7349..0000000 --- a/misc/VERSIONS.yaml +++ /dev/null @@ -1,7 +0,0 @@ -build: - carnapy: 0.1.6 - carna: 3.3.2 - -package: - carna: 3.3.2 - diff --git a/misc/__init__.py.in b/misc/__init__.py.in index a29ad39..987663f 100644 --- a/misc/__init__.py.in +++ b/misc/__init__.py.in @@ -1,3 +1,30 @@ -py_version = '@MAJOR_VERSION@.@MINOR_VERSION@.@PATCH_VERSION@' -version = '@CARNA_VERSION@' +version = '@MAJOR_VERSION@.@MINOR_VERSION@.@PATCH_VERSION@' +libcarna_version = '@LIBCARNA_VERSION@' + +from ._py import * + +from . import data +from ._animation import animate +from ._color import color +from ._cutting_planes import cutting_planes +from ._drr import drr +from ._dvr import dvr +from ._huv import normalize_hounsfield_units +from ._imshow import imshow +from ._material import material +from ._mask_renderer import mask_renderer +from ._mip import mip +from ._opaque_renderer import opaque_renderer +from ._renderer import renderer +from ._spatial import ( + camera, + geometry, + node, + volume, +) + + +import os +if not os.environ.get('LIBCARNA_PYTHON_LOGGING', ''): + logging(False) diff --git a/misc/build-conda-recipe.sh b/misc/build-conda-recipe.sh deleted file mode 100755 index ec5aff0..0000000 --- a/misc/build-conda-recipe.sh +++ /dev/null @@ -1,7 +0,0 @@ -#!/bin/bash - -cd conda-recipe -sh build_recipe.sh --python=3.7 -sh build_recipe.sh --python=3.8 -sh build_recipe.sh --python=3.9 - diff --git a/misc/conda-recipe/bootstrap.sh b/misc/conda-recipe/bootstrap.sh deleted file mode 100755 index babf2d9..0000000 --- a/misc/conda-recipe/bootstrap.sh +++ /dev/null @@ -1,26 +0,0 @@ -#!/usr/bin/env python - -import yaml -with open('../VERSIONS.yaml', 'r') as io: - versions = yaml.safe_load(io) - -import os -from pathlib import Path -root_dir = Path(os.path.abspath(os.path.dirname(__file__))) -input_dir = root_dir / 'carnapy.in' -output_dir = root_dir / 'carnapy' -output_dir.mkdir(parents=True, exist_ok=True) - -from string import Template -values = dict( - VERSION_CARNA_PY = versions['build' ]['carnapy'], - VERSION_CARNA = versions['package']['carna' ], -) -print(f'Configured to build conda package version: {values["VERSION_CARNA_PY"]}') -for filename in ('build.sh', 'meta.yaml'): - with open(str(input_dir / filename), 'r') as io: - source = Template(io.read()) - result = source.substitute(values) - with open(str(output_dir / filename), 'w') as io: - io.write(result) - diff --git a/misc/conda-recipe/build_recipe.sh b/misc/conda-recipe/build_recipe.sh deleted file mode 100755 index 72f532f..0000000 --- a/misc/conda-recipe/build_recipe.sh +++ /dev/null @@ -1,5 +0,0 @@ -#!/bin/bash - -python bootstrap.sh -conda-build -c conda-forge carnapy $* - diff --git a/misc/conda-recipe/carnapy.in/build.sh b/misc/conda-recipe/carnapy.in/build.sh deleted file mode 100644 index afed854..0000000 --- a/misc/conda-recipe/carnapy.in/build.sh +++ /dev/null @@ -1,14 +0,0 @@ -export ROOT_DIR="$$PWD" - -wget "https://github.com/kostrykin/Carna/archive/refs/tags/$VERSION_CARNA.tar.gz" -O carna.tgz -tar -vzxf carna.tgz -cd "Carna-$VERSION_CARNA" -mkdir -p build/make_release -cd "$$ROOT_DIR/Carna-$VERSION_CARNA/build/make_release" -cmake -DCMAKE_BUILD_TYPE=Release -DBUILD_DOC=OFF -DBUILD_TEST=OFF -DBUILD_DEMO=OFF -DCMAKE_INSTALL_PREFIX=$$PREFIX -DCMAKE_PREFIX_PATH=$$PREFIX -DBUILD_EGL=ON ../.. -make VERBOSE=1 -make install - -cd "$$ROOT_DIR" -$$PYTHON setup.py build -$$PYTHON setup.py install --single-version-externally-managed --root=/ diff --git a/misc/conda-recipe/carnapy.in/meta.yaml b/misc/conda-recipe/carnapy.in/meta.yaml deleted file mode 100644 index a1b86e2..0000000 --- a/misc/conda-recipe/carnapy.in/meta.yaml +++ /dev/null @@ -1,52 +0,0 @@ -{% set name = "CarnaPy" %} -{% set version = "$VERSION_CARNA_PY" %} - -package: - name: "{{ name|lower }}" - version: "{{ version }}" - -source: - url: "https://pypi.io/packages/source/{{ name[0]|lower }}/{{ name|lower }}/{{ name }}-{{ version }}.tar.gz" - -build: - number: 0 - -requirements: - build: - - git - - cmake - - pybind11 - - boost-cpp - - eigen - host: - - pyyaml - - pip - - python - - numpy - - matplotlib # for tests only - - scipy # for tests only - run: - - numpy - - python - -test: - imports: - - carna - - carna.py - - carna.base - - carna.helpers - - carna.presets - - carna.egl - -about: - home: "http://evoid.de" - license: BSD - license_family: BSD - license_file: - summary: "Real-time 3D visualization for biomedical data and beyond" - doc_url: - dev_url: "https://github.com/kostrykin/CarnaPy" - -extra: - recipe-maintainers: - - kostrykin diff --git a/misc/distribute_to_pypi.sh b/misc/distribute_to_pypi.sh deleted file mode 100755 index 73a99ca..0000000 --- a/misc/distribute_to_pypi.sh +++ /dev/null @@ -1,13 +0,0 @@ -#!/bin/bash - -export CARNAPY_VERSION=`python - << END -import yaml -with open('VERSIONS.yaml', 'r') as io: - versions = yaml.safe_load(io) -print(versions['build']['carnapy']) -END` - -cd .. -python setup.py sdist -python -m twine upload dist/CarnaPy-$CARNAPY_VERSION.tar.gz - diff --git a/misc/install_local.sh b/misc/install_local.sh deleted file mode 100755 index 62e4872..0000000 --- a/misc/install_local.sh +++ /dev/null @@ -1,6 +0,0 @@ -#!/bin/bash - -cd .. -python setup.py build -python setup.py install --single-version-externally-managed --root=/ - diff --git a/misc/libcarna/_alias.py b/misc/libcarna/_alias.py new file mode 100644 index 0000000..b251451 --- /dev/null +++ b/misc/libcarna/_alias.py @@ -0,0 +1,30 @@ +import functools + + +def kwalias(keyword: str, *aliases: str): + """ + Create an alias for a keyword. + + Arguments: + keyword: The original keyword. + *aliases: The aliases for the keyword. + """ + if keyword in aliases: + raise ValueError(f"Keyword and alias cannot be the same: '{keyword}'.") + + def decorator(func): + + @functools.wraps(func) + def wrapper(*args, **kwargs): + used_aliases = list() + for alias in [keyword] + list(aliases): + if alias in kwargs: + used_aliases.append(alias) + if len(used_aliases) > 1: + raise ValueError(f"Both '{used_aliases[0]}' and '{used_aliases[1]}' provided.") + kwargs[keyword] = kwargs.pop(alias) + return func(*args, **kwargs) + + return wrapper + + return decorator diff --git a/misc/libcarna/_animation.py b/misc/libcarna/_animation.py new file mode 100644 index 0000000..295c9db --- /dev/null +++ b/misc/libcarna/_animation.py @@ -0,0 +1,84 @@ +from typing import ( + Callable, + Iterable, +) + +import numpy as np + +import libcarna +from ._alias import kwalias +from ._axes import AxisHint, resolve_axis_hint + + + +class animate: + """ + Create an animation that can be rendered. + + Arguments: + *step_functions: List of functions that are called for each frame of the animation. Each function is called + with a single argument `t`, which is a float in the range (0, 1]. The function should modify the scene in + place. To obtain a smoothly looping animation, the scene should be in it's initial state at `t=1`. + n_frames: Number of frames to be rendered. + """ + + def __init__(self, *step_functions: list[Callable[[float], None]], n_frames: int = 25): + self.step_functions = step_functions + self.n_frames = n_frames + + def render(self, r: 'libcarna.renderer', *args, **kwargs) -> Iterable[np.ndarray]: + for t in np.linspace(1, 0, num=self.n_frames, endpoint=False)[::-1]: + for step in self.step_functions: + step(t) + yield r.render(*args, **kwargs) + + @staticmethod + def rotate_local(spatial: libcarna.base.Spatial, axis: AxisHint = 'y') -> Callable[[float], None]: + """ + Create a step function for rotating an object's local coordinate system. + + Arguments: + spatial: The spatial object to be animated. + axis: The axis of rotation. Can be 'x', 'y', 'z', or an arbitrary axis (vector with 3 components). + """ + axis = resolve_axis_hint(axis) + base_transform = spatial.local_transform + def step(t: float): + spatial.local_transform = libcarna.math.rotation(axis, radians=2 * np.pi * t) @ base_transform + return step + + @kwalias('amplitude', 'amp') + @staticmethod + def swing_local(spatial: libcarna.base.Spatial, axis: AxisHint = 'y', amplitude: float = 45) -> Callable[[float], None]: + """ + Create a step function for swinging an object's local coordinate system. + + Arguments: + spatial: The spatial object to be animated. + axis: The axis of rotation. Can be 'x', 'y', 'z', or an arbitrary axis (vector with 3 components). + amplitude: The amplitude of the swing in degrees (alias: `amp`). + """ + axis = resolve_axis_hint(axis) + base_transform = spatial.local_transform + def step(t: float): + radians = libcarna.base.math.deg2rad(amplitude) * np.sin(2 * np.pi * t) + spatial.local_transform = libcarna.math.rotation(axis, radians=radians) @ base_transform + return step + + @kwalias('amplitude', 'amp') + @staticmethod + def bounce_local(spatial: libcarna.base.Spatial, axis: AxisHint, amplitude: float = 1.0) -> Callable[[float], None]: + """ + Create a step function for bouncing an object along a given axis. + + Arguments: + spatial: The spatial object to be animated. + axis: The axis of the bounce. Can be 'x', 'y', 'z', or an arbitrary axis (vector with 3 components). + amplitude: The amplitude of the bounce (alias: `amp`). + """ + axis = resolve_axis_hint(axis) + base_transform = spatial.local_transform + def step(t: float): + offset = np.multiply(axis, amplitude * np.sin(2 * np.pi * t)) + spatial.local_transform = libcarna.math.translation(offset) @ base_transform + return step diff --git a/misc/libcarna/_axes.py b/misc/libcarna/_axes.py new file mode 100644 index 0000000..35faad2 --- /dev/null +++ b/misc/libcarna/_axes.py @@ -0,0 +1,35 @@ +from typing import ( + Literal, +) + +import numpy as np + + +AxisLiteral = Literal['x', 'y', 'z'] +AxisHint = AxisLiteral | tuple[float, float, float] | list[float, float, float] + + +def resolve_axis_hint(axis: AxisHint) -> tuple[float, float, float]: + if isinstance(axis, str): + if axis.startswith('-') or axis.startswith('+'): + f, axis = int(axis[0] + '1'), axis[1:] + else: + f = 1 + match axis: + case 'x': + return (f, 0, 0) + case 'y': + return (0, f, 0) + case 'z': + return (0, 0, f) + case _: + raise ValueError(f'Invalid axis hint: {axis}') + elif len(axis) == 3: + axis = tuple(axis) + axis_norm = np.linalg.norm(axis) + if axis_norm == 0: + raise ValueError('Axis hint cannot be a zero vector.') + else: + return tuple(np.divide(axis, axis_norm)) + else: + raise ValueError(f'Invalid axis hint: {axis}') diff --git a/misc/libcarna/_color.py b/misc/libcarna/_color.py new file mode 100644 index 0000000..491b387 --- /dev/null +++ b/misc/libcarna/_color.py @@ -0,0 +1,15 @@ +import libcarna + + +class color(libcarna.base.Color): + + def __init__(self, *args, **kwargs): + if len(args) == 1 and len(kwargs) == 0 and isinstance(args[0], str) and args[0].startswith('#'): + hex_str = args[0][1:] + r = int(hex_str[0:2], 16) + g = int(hex_str[2:4], 16) + b = int(hex_str[4:6], 16) + a = int(hex_str[6:8], 16) if len(hex_str) == 8 else 255 + super().__init__(r, g, b, a) + else: + super().__init__(*args, **kwargs) diff --git a/misc/libcarna/_colorbar.py b/misc/libcarna/_colorbar.py new file mode 100644 index 0000000..ee02030 --- /dev/null +++ b/misc/libcarna/_colorbar.py @@ -0,0 +1,112 @@ +import base64 +import io + +import numpy as np +from PIL import Image + +import libcarna + + +def _sample_down(colorlist, max_resolution): + """ + Downsample the color list to a maximum resolution. + """ + max_resolution = max((max_resolution, 2)) + if len(colorlist) <= max_resolution: + return colorlist + + step = len(colorlist) // max_resolution + return colorlist[::step] + + +class colorbar: + + def __init__( + self, + colorlist: list[libcarna.base.Color], + min_intensity: float, + max_intensity: float, + label: str = '', + ticks: int = 5, + tick_labels: bool = True, + max_resolution: int = 1024, + ): + self.colorlist = _sample_down(colorlist, max_resolution) + self.min_intensity = min_intensity + self.max_intensity = max_intensity + self.label = label + self.ticks = max((ticks, 2)) + self.tick_labels = tick_labels + + def toarray(self) -> np.ndarray: + array = np.full(shape=(len(self.colorlist), 1, 4), fill_value=0, dtype=np.uint8) + for i, color in enumerate(self.colorlist[::-1]): + array[i, :, 0] = int(color.r) + array[i, :, 1] = int(color.g) + array[i, :, 2] = int(color.b) + array[i, :, 3] = int(color.a) + return array + + def topng(self) -> bytes: + array = self.toarray() + buf = io.BytesIO() + Image.fromarray(array, mode='RGBA').save(buf, format='PNG') + buf.seek(0) + return buf.read() + + def tohtml(self) -> str: + # Render the image + png = self.topng() + png_base64_str = base64.b64encode(png).decode('ascii') + + # Create the ticks + ticks_list = list() + step_size = (self.max_intensity - self.min_intensity) / (self.ticks - 1) + for tick_idx, intensity in enumerate(np.linspace(self.max_intensity, self.min_intensity, num=self.ticks)): + height_str = '0' if tick_idx == self.ticks - 1 else f'{100 / (self.ticks - 1)}%' + extra_style = 'transform: translateY(-1px);' if tick_idx == self.ticks - 1 else '' + + # Format the intensity string + if self.tick_labels: + if step_size < 10: + intensity_str = f'{intensity:g}' + elif step_size < 1000: + intensity_str = f'{round(intensity):d}' + elif step_size < 10_000: + intensity_str = f'{intensity / 1000:.1f}k' + if intensity_str in ('0.0k', '-0.0k'): + intensity_str = '0' + else: + intensity_str = f'{round(intensity / 1000):d}k' + if intensity_str in ('0k', '-0k'): + intensity_str = '0' + else: + intensity_str = '' + + ticks_list.append(f''' +
+ {intensity_str} + +
''') + + ticks_html = '\n'.join(ticks_list) + + # Render the HTML + return fr''' +
+
+
+ +
+
+
+ {ticks_html} +
+
+ {self.label} +
''' diff --git a/misc/libcarna/_colormap_helper.py b/misc/libcarna/_colormap_helper.py new file mode 100644 index 0000000..abdbe70 --- /dev/null +++ b/misc/libcarna/_colormap_helper.py @@ -0,0 +1,131 @@ +from typing import Iterable + +import matplotlib as mpl +import numpy as np + +import libcarna +from ._colorbar import colorbar + + +def _sample_colormap(mpl_cmap: mpl.colors.Colormap, n_samples: int) -> list[libcarna.color]: + """ + Sample a colormap from matplotlib and return the list of colors. + """ + return [libcarna.color(mpl_cmap(i)) for i in np.linspace(0, 1, n_samples)] + + +def _mpl_colormaps() -> Iterable[str]: + """ + Get all non-discrete colormaps from matplotlib. Yield pairs of the name and the corresponding colormap. + """ + for cmap_name in mpl.colormaps(): + mpl_cmap = mpl.colormaps[cmap_name] + if isinstance(mpl_cmap, mpl.colors.LinearSegmentedColormap) or ( + isinstance(mpl_cmap, mpl.colors.ListedColormap) and mpl_cmap.N >= 256 + ): + yield cmap_name, mpl_cmap + + +class colormap_helper: + + def __init__( + self, + colormap: libcarna.base.ColorMap, + cmap: str | libcarna.base.ColorMap | None = None, + clim: tuple[float | None, float | None] | None = None, + ): + self.colormap = colormap + self.cmap_choices = list() + cmap = cmap or 'viridis' + + # Import colormaps + for cmap_name, _ in _mpl_colormaps(): + self.cmap_choices.append(cmap_name) + + # Set the requested colormap + if isinstance(cmap, libcarna.base.ColorMap): + self.colormap.set(cmap) + elif isinstance(cmap, str) and cmap in self.cmap_choices: + self(cmap) + else: + raise ValueError(f'Unknown color map: "{cmap}" (available: {", ".join(self.cmap_choices)})') + + # Set the color limits + if clim is not None: + self.limits(*clim) + + def __call__(self, cmap_name: str, n_samples: int = 50, **kwargs): + if cmap_name in self.cmap_choices: + mpl_cmap = mpl.colormaps[cmap_name] + n_samples = n_samples or self.default_n_samples + colors = _sample_colormap(mpl_cmap, n_samples) + self.linear_spline(*colors, **kwargs) + else: + raise ValueError(f'Unknown color map: "{cmap_name}" (available: {", ".join(self.cmap_choices)})') + + def clear(self): + """ + Clear the color map. + """ + self.colormap.clear() + + def linear_segment( + self, + intensity_first: float, + intensity_last: float, + color_first: libcarna.base.Color, + color_last: libcarna.base.Color, + ): + """ + Write a linear segment to the color map. + """ + self.colormap.write_linear_segment( + intensity_first, + intensity_last, + color_first, + color_last, + ) + + def linear_spline(self, *colors, ramp: tuple[float, float] | None = None, rampdegree: int = 1): + """ + Write a linear spline to the color map. The colors are interpolated between the given colors. + + Arguments: + colors: The colors to interpolate between. + ramp: If `ramp` is not `None`, the alpha values of the colors are weighted by a ramp function, that starts + with 0 at `ramp[0]` and ends with 1 at `ramp[1]`. + rampdegree: The degree of the ramp function. 1 is linear, 2 is quadratic, etc. + """ + colors = list(colors) + if ramp is not None: + ramp_width = max(ramp) - min(ramp) + ramp_func = lambda t: np.clip((t - min(ramp)) / ramp_width, 0, 1) ** rampdegree + colors = [ + libcarna.color(color.r, color.g, color.b, round(color.a * ramp_func(t))) + for color, t in zip(colors, np.linspace(0, 1, len(colors))) + ] + self.colormap.write_linear_spline(colors) + + def limits(self, *args) -> tuple[float | None, float | None] | None: + """ + Get or set the limits of the color map. + """ + if len(args) == 0: + return (self.colormap.minimum_intensity, self.colormap.maximum_intensity) + elif len(args) == 2: + cmin, cmax = args + if cmin is not None: + self.colormap.minimum_intensity = cmin + if cmax is not None: + self.colormap.maximum_intensity = cmax + else: + raise ValueError('limits() takes 0 or 2 arguments, but {} were given'.format(len(args))) + + def bar(self, volume: libcarna.base.Node, **kwargs) -> colorbar: + """ + Return a colorbar object for the colormap. + """ + normalized_intensity_limits = self.limits() + raw_intensity_limits = volume.raw(normalized_intensity_limits) + colorlist = self.colormap.color_list + return colorbar(colorlist, *raw_intensity_limits, **kwargs) diff --git a/misc/libcarna/_cutting_planes.py b/misc/libcarna/_cutting_planes.py new file mode 100644 index 0000000..c21285d --- /dev/null +++ b/misc/libcarna/_cutting_planes.py @@ -0,0 +1,65 @@ +import libcarna + +from ._colormap_helper import colormap_helper + + +class cutting_planes(libcarna.presets.CuttingPlanesStage): + """ + Renders cutting planes (cross sections) of volume geometries. + + Arguments: + volume_geometry_type: Geometry type of volumes to be rendered. + plane_geometry_type: Geometry type of planes to be rendered. + cmap: Color map to use for the rendering. If `None`, the default color map is used. + clim: Color limits for the color map. If `None`, the full range of intensities [0, 1] is used (if `cmap` is + `str` or `None`) or the limits of `cmap` are used (if `cmap` is a :class:`libcarna.base.ColorMap` ). + + Example: + + .. literalinclude:: ../test/test_integration.py + :start-after: # .. CuttingPlanesStage: example-setup-start + :end-before: # .. CuttingPlanesStage: example-setup-end + :dedent: 8 + + The normal vector of the planes does not have to necessarily align with the axes. + + In this example, we have a z-plane and a pair of x-planes. The x-planes are positioned on the left and right + faces of the volume. Their distances to the center of the volume calculates as the width of the volume divided + by 2. In addition, a factor of 0.99 is used to position the planes *just about* inside the volume (otherwise, + rounding errors might cause rendering artifacts on some hardware). + + For a more information-rich visualization of the volume, we will make the z-plane bounce between the front and + back faces of the volume. The amplitude is calculated as the depth of the volume divided by 2. + + .. literalinclude:: ../test/test_integration.py + :start-after: # .. CuttingPlanesStage: example-animation-start + :end-before: # .. CuttingPlanesStage: example-animation-end + :dedent: 8 + + The example yields this animation: + + .. image:: ../test/results/expected/test_integration.CuttingPlanesStage.test__animated.png + :width: 400 + """ + + def __init__( + self, + volume_geometry_type: int, + plane_geometry_type: int, + *, + cmap: str | libcarna.base.ColorMap | None = None, + clim: tuple[float | None, float | None] | None = None, + ): + super().__init__(volume_geometry_type, plane_geometry_type) + self.cmap = colormap_helper(self.color_map, cmap, clim) + + def replicate(self): + """ + Replicate the cutting planes renderer. + """ + return cutting_planes( + self.volume_geometry_type, + self.plane_geometry_type, + cmap=self.cmap.colormap, + clim=None, # uses the color limits from `cmap` + ) diff --git a/misc/libcarna/_drr.py b/misc/libcarna/_drr.py new file mode 100644 index 0000000..0140ed7 --- /dev/null +++ b/misc/libcarna/_drr.py @@ -0,0 +1,75 @@ +import libcarna +from ._alias import kwalias + + +class drr(libcarna.presets.DRRStage): + """ + Renders *Digitally Reconstructed Radiographs* (DRR) of volume geometries. + + Arguments: + geometry_type: Geometry type to be rendered. + sample_rate: Sample rate for volume rendering (alias: `sr`). Larger values result in higher quality and less + artifacts, but slower rendering. + water_attenuation: Water attenuation (alias: `waterat`). + base_intensity: Base intensity (alias: `baseint`). + lower_threshold: Lower threshold in Hounsfield Units (alias: `lothres`). + upper_threshold: Upper threshold in Hounsfield Units (alias: `upthres`). + upper_multiplier: Upper multiplier (alias: `upmulti`). + render_inverse: If `True`, the image is rendered as gray-white on black background (alias: `inverse`). + Otherwise, the image is rendered as gray-black on white background. + + Example: + + .. literalinclude:: ../test/test_integration.py + :start-after: # .. DRRStage: example-setup-start + :end-before: # .. DRRStage: example-setup-end + :dedent: 8 + + Rendering the scene as an animation: + + .. image:: ../test/results/expected/test_integration.DRRStage.test__animated.png + :width: 400 + """ + + @kwalias('sample_rate', 'sr') + @kwalias('water_attenuation', 'waterat') + @kwalias('base_intensity', 'baseint') + @kwalias('lower_threshold', 'lothres') + @kwalias('upper_threshold', 'upthres') + @kwalias('upper_multiplier', 'upmulti') + @kwalias('render_inverse', 'inverse') + def __init__( + self, + geometry_type: int, + *, + sample_rate: int = libcarna.presets.VolumeRenderingStage.DEFAULT_SAMPLE_RATE, + water_attenuation: float = libcarna.presets.DRRStage.DEFAULT_WATER_ATTENUATION, + base_intensity: float = libcarna.presets.DRRStage.DEFAULT_BASE_INTENSITY, + lower_threshold: int = libcarna.presets.DRRStage.DEFAULT_LOWER_THRESHOLD, + upper_threshold: int = libcarna.presets.DRRStage.DEFAULT_UPPER_THRESHOLD, + upper_multiplier: float = libcarna.presets.DRRStage.DEFAULT_UPPER_MULTIPLIER, + render_inverse: bool = libcarna.presets.DRRStage.DEFAULT_RENDER_INVERSE, + ): + super().__init__(geometry_type) + self.sample_rate = sample_rate + self.water_attenuation = water_attenuation + self.base_intensity = base_intensity + self.lower_threshold = lower_threshold + self.upper_threshold = upper_threshold + self.upper_multiplier = upper_multiplier + self.render_inverse = render_inverse + + def replicate(self): + """ + Replicate the DRR renderer. + """ + return drr( + self.geometry_type, + sample_rate=self.sample_rate, + water_attenuation=self.water_attenuation, + base_intensity=self.base_intensity, + lower_threshold=self.lower_threshold, + upper_threshold=self.upper_threshold, + upper_multiplier=self.upper_multiplier, + render_inverse=self.render_inverse, + ) diff --git a/misc/libcarna/_dvr.py b/misc/libcarna/_dvr.py new file mode 100644 index 0000000..709e091 --- /dev/null +++ b/misc/libcarna/_dvr.py @@ -0,0 +1,66 @@ +import libcarna +from ._alias import kwalias +from ._colormap_helper import colormap_helper + + +class dvr(libcarna.presets.DVRStage): + """ + Performs *Direct Volume Rendering* (DVR) of volume geometries. + + Arguments: + geometry_type: Geometry type to be rendered. + cmap: Color map to use for the DVR. If `None`, the default color map is used. + clim: Color limits for the color map. If `None`, the full range of intensities [0, 1] is used (if `cmap` is + `str` or `None`) or the limits of `cmap` are used (if `cmap` is a :class:`libcarna.base.ColorMap` ). + sample_rate: Sample rate for volume rendering (alias: `sr`). Larger values result in higher quality and less + artifacts, but slower rendering. + translucency: Translucency value for the DVR, that is used on top of the translucency from the color map + (alias: `transl`). A value of 1 means that the overall translucency is doubled. Larger values result in + more translucency. + diffuse_light: Diffuse light value for the volume rendering. Larger values result in more diffuse light + (alias: `diffuse`). Ambient light is one minus diffuse light. + + Example: + + .. literalinclude:: ../test/test_integration.py + :start-after: # .. DVRStage: example-setup-start + :end-before: # .. DVRStage: example-setup-end + :dedent: 8 + + Rendering the scene as an animation: + + .. image:: ../test/results/expected/test_integration.DVRStage.test__animated.png + :width: 400 + """ + + @kwalias('sample_rate', 'sr') + @kwalias('translucency', 'transl') + @kwalias('diffuse_light', 'diffuse') + def __init__( + self, + geometry_type: int, + *, + cmap: str | libcarna.base.ColorMap | None = None, + clim: tuple[float | None, float | None] | None = None, + sample_rate: int = libcarna.presets.VolumeRenderingStage.DEFAULT_SAMPLE_RATE, + translucency: float = 0, + diffuse_light: float = libcarna.presets.DVRStage.DEFAULT_DIFFUSE_LIGHT, + ): + super().__init__(geometry_type) + self.cmap = colormap_helper(self.color_map, cmap, clim) + self.sample_rate = sample_rate + self.translucency = translucency + self.diffuse_light = diffuse_light + + def replicate(self): + """ + Replicate the DVR. + """ + return dvr( + self.geometry_type, + cmap=self.cmap.colormap, + clim=None, # uses the color limits from `cmap` + sample_rate=self.sample_rate, + translucency=self.translucency, + diffuse_light=self.diffuse_light, + ) diff --git a/misc/libcarna/_huv.py b/misc/libcarna/_huv.py new file mode 100644 index 0000000..fd15e71 --- /dev/null +++ b/misc/libcarna/_huv.py @@ -0,0 +1,18 @@ +import numpy as np +import scipy.ndimage as ndi + + +def normalize_hounsfield_units(data, rel_mode_width=.33): + """ + Normalize `data` to Hounsfield Units (HU) using a heuristic histogram method. + """ + assert 0 < rel_mode_width <= 1, f'Unsupported rel_mode_width: {rel_mode_width}' + data = data - data.min() + h = np.bincount(data.reshape(-1)) + h_peaks_mask = (ndi.maximum_filter(h, size=len(h) / 3) == h) + if h_peaks_mask[-1] and h_peaks_mask.sum() == 4: + h_peaks_mask[-1] = False + h_modes = h_peaks_mask.sum() + assert h_modes == 3, f'Heuristic normalization failed: Histogram has {h_modes} mode(s), but 3 required.' + i_air, i_bone = np.where(h_peaks_mask)[0][np.array((0, -1))] + return (2000 * (data.astype(int) - i_air) / (i_bone - i_air) - 1024).round().clip(-1024, +3071).astype(np.int16) diff --git a/misc/libcarna/_imshow.py b/misc/libcarna/_imshow.py new file mode 100644 index 0000000..8601ab3 --- /dev/null +++ b/misc/libcarna/_imshow.py @@ -0,0 +1,112 @@ +import base64 +import io +import tempfile +from typing import ( + Any, + Iterable, +) + +import numpngw +import numpy as np +import skvideo.io + +try: + from IPython.core.display import HTML as IPythonHTML +except ImportError: + IPythonHTML = None + + +def _render_html_apng(array: np.ndarray | Iterable[np.ndarray], fps: float = 25) -> str: + + # The image is a single frame, create an animation with a single frame + if isinstance(array, np.ndarray) and array.ndim == 3: + return _render_html_apng([array], fps=fps) + + # Assume that the image is a list of frames, create a temporal stack + elif not isinstance(array, np.ndarray): + return _render_html_apng(np.array(list(array)), fps=fps) + + # The image is a temporal stack, create an animated PNG + elif isinstance(array, np.ndarray) and array.ndim == 4: + buf = io.BytesIO() + numpngw.write_apng(buf, array, delay=1000 / fps, use_palette=False) + buf.seek(0) + buf_base64_str = base64.b64encode(buf.read()).decode('ascii') + return f'' + + # The image is not a valid type + else: + raise ValueError('Array must be 3D or 4D data.') + + +def _render_html_h264(array: np.ndarray | Iterable[np.ndarray], fps: float = 25) -> str: + + # The image is a single frame, create an animation with a single frame + if isinstance(array, np.ndarray) and array.ndim == 3: + return _render_html_h264([array], fps=fps) + + # Encode video + with tempfile.NamedTemporaryFile(suffix='.mp4') as mp4_file: + with skvideo.io.FFmpegWriter( + mp4_file.name, + outputdict={ + '-vcodec': 'h264', + '-pix_fmt': 'yuv420p', + '-r': str(fps), + }, + ) as writer: + for frame in array: + writer.writeFrame(frame) + buf = mp4_file.read() + + # Produce HTML + buf_base64_str = base64.b64encode(buf).decode('ascii') + return( + '' + ) + + +html_plugins = dict( + apng=_render_html_apng, + h264=_render_html_h264, +) + + +def imshow(array: np.ndarray | Iterable[np.ndarray], *colorbars, fps: float = 25, format: str = 'auto') -> Any: + """ + Display an image or a sequence of images in a Jupyter notebook. + + Arguments: + array: The image or sequence of images to display. Can be a 3D NumPy array (RGB image) or 4D NumPy array + (stack of RGB images), or an iterable of 3D arrays (sequence of RGB images). + colorbars: Optional colorbars to display alongside the image. + fps: The frames per second for the animation. Default is 25. + format: The format to use for displaying the image. Can be `'apng'` or `'h264'`. Default is `'auto'`, which + will use `'apng'` for single images, and `'h264'` for image stacks or sequences. + """ + assert IPythonHTML is not None, 'Please install IPython to use this function.' + + if format == 'auto': + if isinstance(array, np.ndarray) and (array.ndim == 3 or (array.ndim == 4 and array.shape[0] == 1)): + format = 'apng' + else: + format = 'h264' + + # Resolve the format to the proper plugin + _render_html = html_plugins.get(format, None) + if _render_html is None: + raise ValueError(f'Format "{format}" not supported.') + + # Delegate to the selected plugin + nl = '\n' # Python <3.12 does not allow backslashes in f-strings expressions + return IPythonHTML( + f""" +
+
+ {_render_html(array, fps=fps)} +
+ {nl.join(cb.tohtml() for cb in colorbars)} +
+ """) \ No newline at end of file diff --git a/misc/libcarna/_mask_renderer.py b/misc/libcarna/_mask_renderer.py new file mode 100644 index 0000000..1a44f41 --- /dev/null +++ b/misc/libcarna/_mask_renderer.py @@ -0,0 +1,54 @@ +import libcarna +from ._alias import kwalias + + +class mask_renderer(libcarna.presets.MaskRenderingStage): + """ + Renders 3D masks as either unshaded areas or borders. + + Arguments: + geometry_type: Geometry type to be rendered. + sample_rate: Sample rate for volume rendering (alias: `sr`). Larger values result in higher quality and less + artifacts, but slower rendering. + color: Color to use for the mask (alias: `c`). + filling: If `True`, the mask is filled (alias: `fill`). If `False`, only the borders are rendered. + + Example: + + .. literalinclude:: ../test/test_integration.py + :start-after: # .. MaskRenderingStage: example-setup-start + :end-before: # .. MaskRenderingStage: example-setup-end + :dedent: 8 + + Rendering the scene as an animation: + + .. image:: ../test/results/expected/test_integration.MaskRenderingStage.test__animated.png + :width: 400 + """ + + @kwalias('sample_rate', 'sr') + @kwalias('color', 'c') + @kwalias('filling', 'fill') + def __init__( + self, + geometry_type: int, + *, + sample_rate: int = libcarna.presets.VolumeRenderingStage.DEFAULT_SAMPLE_RATE, + color: libcarna.color = libcarna.presets.MaskRenderingStage.DEFAULT_COLOR, + filling: bool = False, + ): + super().__init__(geometry_type, mask_role=0) + self.sample_rate = sample_rate + self.color = color + self.filling = filling + + def replicate(self): + """ + Replicate the mask renderer. + """ + return mask_renderer( + self.geometry_type, + sample_rate=self.sample_rate, + color=self.color, + filling=self.filling, + ) diff --git a/misc/libcarna/_material.py b/misc/libcarna/_material.py new file mode 100644 index 0000000..00315b0 --- /dev/null +++ b/misc/libcarna/_material.py @@ -0,0 +1,55 @@ +import libcarna + + +def scheme_color(value): + if isinstance(value, libcarna.base.Color): + return value.toarray() + elif isinstance(value, str): + return libcarna.color(value).toarray() + elif hasattr(value, '__len__') and len(value) == 4: + return value + else: + raise ValueError(f'Found "{value}", expected color with 4 components (RGBA).') + + +shader_schemes = { + 'unshaded': { + 'color': scheme_color, + }, + 'solid': { + 'color': scheme_color, + }, +} + + +def material(shader_name: str = 'solid', lw: float = 1, **kwargs) -> libcarna.base.Material: + """ + Create a :class:`libcarna.base.Material` object. + + Arguments: + shader_name: The shader to be used for rendering. + lw: The width of the lines in pixels, if the material is used for drawing lines. + **kwargs: Uniform shader parameters. + """ + assert shader_name in shader_schemes, ( + f'Unknown shader name: "{shader_name}" (supported: {", ".join(shader_schemes.keys())})' + ) + shader_scheme = shader_schemes[shader_name] + + class Material(libcarna.base.Material): + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def __setitem__(self, key, value): + assert key in shader_scheme, ( + f'Unknown shader parameter: "{key}" (supported: {", ".join(shader_scheme.keys())})' + ) + value = shader_scheme[key](value) + super().__setitem__(key, value) + + material = Material(shader_name) + material.line_width = lw + for key, value in kwargs.items(): + material[key] = value + return material diff --git a/misc/libcarna/_mip.py b/misc/libcarna/_mip.py new file mode 100644 index 0000000..d4d4c14 --- /dev/null +++ b/misc/libcarna/_mip.py @@ -0,0 +1,53 @@ +import libcarna +from ._alias import kwalias +from ._colormap_helper import colormap_helper + + +class mip(libcarna.presets.MIPStage): + """ + Renders *Maximum Intensity Projections* (MIP) of volume geometries. + + Arguments: + geometry_type: Geometry type to be rendered. + cmap: Color map to use for the MIP. If `None`, the default color map is used. + clim: Color limits for the color map. If `None`, the full range of intensities [0, 1] is used (if `cmap` is + `str` or `None`) or the limits of `cmap` are used (if `cmap` is a :class:`libcarna.base.ColorMap` ). + sample_rate: Sample rate for volume rendering (alias: `sr`). Larger values result in higher quality and less + artifacts, but slower rendering. + + Example: + + .. literalinclude:: ../test/test_integration.py + :start-after: # .. MIPStage: example-setup-start + :end-before: # .. MIPStage: example-setup-end + :dedent: 8 + + Rendering the scene as an animation: + + .. image:: ../test/results/expected/test_integration.MIPStage.test__animated.png + :width: 400 + """ + + @kwalias('sample_rate', 'sr') + def __init__( + self, + geometry_type: int, + *, + cmap: str | None = None, + clim: tuple[float | None, float | None] | None = None, + sample_rate: int = libcarna.presets.VolumeRenderingStage.DEFAULT_SAMPLE_RATE, + ): + super().__init__(geometry_type) + self.cmap = colormap_helper(self.color_map, cmap, clim) + self.sample_rate = sample_rate + + def replicate(self): + """ + Replicate the MIP stage. + """ + return mip( + self.geometry_type, + cmap=self.cmap.colormap, + sample_rate=self.sample_rate, + clim=None, # uses the color limits from `cmap` + ) diff --git a/misc/libcarna/_opaque_renderer.py b/misc/libcarna/_opaque_renderer.py new file mode 100644 index 0000000..505b141 --- /dev/null +++ b/misc/libcarna/_opaque_renderer.py @@ -0,0 +1,31 @@ +import libcarna + + +class opaque_renderer(libcarna.presets.OpaqueRenderingStage): + """ + Renders opaque geometries (meshes). + + Arguments: + geometry_type: Geometry type to be rendered. + + Example: + + .. literalinclude:: ../test/test_integration.py + :start-after: # .. OpaqueRenderingStage: example-setup-start + :end-before: # .. OpaqueRenderingStage: example-setup-end + :dedent: 8 + + Rendering the scene as an animation: + + .. image:: ../test/results/expected/test_integration.OpaqueRenderingStage.test__animated.png + :width: 400 + """ + + def __init__(self, geometry_type: int): + super().__init__(geometry_type) + + def replicate(self): + """ + Replicate the opaque renderer. + """ + return opaque_renderer(self.geometry_type) diff --git a/misc/libcarna/_py.py b/misc/libcarna/_py.py new file mode 100644 index 0000000..b76bf55 --- /dev/null +++ b/misc/libcarna/_py.py @@ -0,0 +1,57 @@ +import re + +import libcarna.base +import libcarna.egl +import libcarna.presets +import libcarna.helpers + + +def _camel_to_snake(name): + s = re.sub(r'(.)([A-Z][a-z]+)', r'\1_\2', name) + return re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', s).lower() + + +def _replace_suffix(s, old, new): + if s.endswith(old): + return s[:-len(old)] + new + return s + + +def _expand_module(module): + for member_name in dir(module): + + # Skip private members + if member_name.startswith('_'): + continue + + # Resolve target name + target_name = _camel_to_snake(member_name) + target_name = target_name.replace('lib_carna', 'libcarna') + if target_name == 'color_map': + target_name = 'colormap' + elif target_name == 'mask_rendering_stage': + target_name = 'mask_renderer' + elif target_name == 'mesh_factory': + target_name = 'meshes' + else: + target_name = _replace_suffix(target_name, '_rendering_stage', '_renderer') + if target_name != 'render_stage': + target_name = _replace_suffix(target_name, '_stage', '') + + # Skip if the target already exists + if target_name in globals(): + continue + + # Skip blacklisted members + if target_name.startswith('volume_grid_helper_'): + continue + + # Populate the global namespace with the member + member = getattr(module, member_name) + globals()[target_name] = member + + +_expand_module(libcarna.base) +_expand_module(libcarna.egl) +_expand_module(libcarna.presets) +_expand_module(libcarna.helpers) diff --git a/misc/libcarna/_renderer.py b/misc/libcarna/_renderer.py new file mode 100644 index 0000000..700d03d --- /dev/null +++ b/misc/libcarna/_renderer.py @@ -0,0 +1,82 @@ +from typing import Iterable + +import numpy as np + +import libcarna +from ._alias import kwalias + + +class renderer: + """ + Create a renderer, that conveniently combines a :class:`frame_renderer` and a :class:`surface`. + + Arguments: + width: Horizontal rendering resolution. + height: Vertical rendering resolution. + stages: List of stages to be added to the frame renderer. + background_color: Background color of the surface (aliases: `bgcolor`, `bgc`). + gl_context: OpenGL context to be used for rendering (alias: `ctx`). If `None`, a new :class:`egl_context` will + be created. + """ + + width: int + """ + Horizontal rendering resolution. + """ + + height: int + """ + Vertical rendering resolution. + """ + + gl_context: libcarna.gl_context + """ + OpenGL context used for rendering. + """ + + @kwalias('background_color', 'bgcolor', 'bgc') + @kwalias('gl_context', 'ctx') + def __init__( + self, + width: int, + height: int, + stages: Iterable[libcarna.base.RenderStage], + background_color: libcarna.color = libcarna.color.BLACK_NO_ALPHA, + gl_context: libcarna.gl_context | None = None, + ): + self.gl_context = gl_context or libcarna.egl_context() + surface = libcarna.surface(self.gl_context, width, height) + frame_renderer = libcarna.frame_renderer(self.gl_context, surface.width, surface.height) + frame_renderer.set_background_color(background_color) + + # Add stages to the frame renderer + renderer_helper = None + for stage in stages: + if renderer_helper is None: + renderer_helper = libcarna.frame_renderer_helper(frame_renderer) + renderer_helper.add_stage(stage) + if renderer_helper is not None: + renderer_helper.commit() + + # Build method for rendering, that hides the frame renderer (so that it cannot be reshaped, because this would + # require a new surface) + def render(camera: libcarna.base.Camera, root: libcarna.base.Node | None = None) -> np.ndarray: + + # Update camera projection matrix to fit the aspect ratio of the surface + if hasattr(camera, 'update_projection'): + camera.update_projection(surface.width, surface.height) + + # Perform the rendering + surface.begin() + frame_renderer.render(camera, root) + return surface.end() + + self.render = render + self.width = width + self.height = height + + def render(self, camera: libcarna.base.Camera, root: libcarna.base.Node | None = None) -> np.ndarray: + """ + Render scene `root` from `camera` point of view to a NumPy array. + """ + ... diff --git a/misc/libcarna/_spatial.py b/misc/libcarna/_spatial.py new file mode 100644 index 0000000..0902403 --- /dev/null +++ b/misc/libcarna/_spatial.py @@ -0,0 +1,380 @@ +import numpy as np + +import libcarna +from ._alias import kwalias +from ._axes import AxisHint, resolve_axis_hint +from ._transform import transform +from ._typing import ( + Literal, + Self, +) + + +def _transform_into_local(target: libcarna.base.Spatial, rhs: libcarna.base.Spatial) -> np.ndarray: + """ + Compute the transformation from the local coordinate system of a spatial object `rhs` into the local coordinate + system of another spatial object `target`. + """ + if target is rhs: + return transform(np.eye(4)) + else: + return transform(np.linalg.inv(target.world_transform) @ rhs.world_transform) + + +class _spatial_mixin: + + @kwalias('degrees', 'deg') + @staticmethod + def rotation(axis: AxisHint, degrees: float) -> np.ndarray: + axis = resolve_axis_hint(axis) + return libcarna.base.math.rotation(axis, radians=libcarna.base.math.deg2rad(degrees)) + + @staticmethod + def scaling(*factors: float) -> np.ndarray: + if len(factors) == 1: + factors = (factors[0], factors[0], factors[0]) + elif len(factors) != 3: + raise ValueError('Scale factor must be a single value, or a tuple of three values.') + return libcarna.base.math.scaling(*factors) + + @staticmethod + def translation(x: float = 0, y: float = 0, z: float = 0) -> np.ndarray: + return libcarna.base.math.translation(x, y, z) + + def rotate_local(self, *args, **kwargs) -> Self: + """ + Rotate the local coordinate system of this spatial object. + + Arguments: + axis: The axis of rotation. Can be 'x', 'y', 'z', or an arbitrary axis (vector with 3 components). + degrees: The angle of rotation in degrees (alias: `deg`). + """ + self.local_transform = _spatial_mixin.rotation(*args, **kwargs) @ self.local_transform + return self + + def scale_local(self, *args, **kwargs) -> Self: + """ + Scale the local coordinate system of this spatial object. + + Arguments: + factors: The scale factors for the x, y, and z axes. If a single value is provided, it is used for all + three axes. + """ + self.local_transform = _spatial_mixin.scaling(*args, **kwargs) @ self.local_transform + return self + + def translate_local(self, *args, **kwargs) -> Self: + """ + Translate the local coordinate system of this spatial object. + + Arguments: + x: The translation along the x-axis. + y: The translation along the y-axis. + z: The translation along the z-axis. + """ + self.local_transform = self.local_transform @ _spatial_mixin.translation(*args, **kwargs) + return self + + def rotate(self, *args, **kwargs) -> Self: + """ + Rotate this spatial object in its local coordinate system. + + Arguments: + axis: The axis of rotation. Can be 'x', 'y', 'z', or an arbitrary axis (vector with 3 components). + degrees: The angle of rotation in degrees (alias: `deg`). + """ + self.local_transform = self.local_transform @ _spatial_mixin.rotation(*args, **kwargs) + return self + + def scale(self, *args, **kwargs) -> Self: + """ + Scale this spatial object in its local coordinate system. + + Arguments: + factors: The scale factors for the x, y, and z axes. If a single value is provided, it is used for all + three axes. + """ + self.local_transform = self.local_transform @ _spatial_mixin.scaling(*args, **kwargs) + return self + + def translate(self, *args, **kwargs) -> Self: + """ + Translate this spatial object in its local coordinate system. + + Arguments: + x: The translation along the x-axis. + y: The translation along the y-axis. + z: The translation along the z-axis. + """ + self.local_transform = _spatial_mixin.translation(*args, **kwargs) @ self.local_transform + return self + + @kwalias('distance', 'dist', 'd') + def plane(self, normal: AxisHint, distance: float) -> Self: + normal = resolve_axis_hint(normal) + self.local_transform = libcarna.base.math.plane(normal=normal, distance=distance) @ self.local_transform + return self + + def transform_from(self, rhs: libcarna.base.Spatial) -> np.ndarray: + """ + Compute the transformation from the local coordinate system of a spatial object `rhs` into the local coordinate + system of this spatial object. + """ + return _transform_into_local(self, rhs) + + +def _setup_spatial(spatial, parent: libcarna.base.Node | None = None, **kwargs): + if parent is not None: + parent.attach_child(spatial) + for key, value in kwargs.items(): + + # If value is not a `np.ndarray`, check whether it has a `mat` attribute and if it is a `np.ndarray` + if ( + key == 'local_transform' and + not isinstance(value, np.ndarray) and + hasattr(value, 'mat') and + isinstance(value.mat, np.ndarray) + ): + value = value.mat + + setattr(spatial, key, value) + + +def node(tag: str | None = None, *, parent: libcarna.base.Node | None = None, **kwargs) -> libcarna.base.Node: + """ + Create a :class:`carna.base.Node` object, that other spatial objects can be added to. + + Arguments: + tag: An arbitrary string, that helps identifying the object. + parent: Parent node to attach the spatial to, or `None`. + **kwargs: Attributes to be set on the newly created object. + """ + class Node(libcarna.base.Node, _spatial_mixin): + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + node = Node() if tag is None else Node(tag) + _setup_spatial(node, parent, **kwargs) + return node + + +def camera(tag: str | None = None, *, parent: libcarna.base.Node | None = None, **kwargs) -> libcarna.base.Camera: + """ + Create a :class:`carna.base.Camera` object. + + Arguments: + tag: An arbitrary string, that helps identifying the object. + parent: Parent node to attach the spatial to, or `None`. + **kwargs: Attributes to be set on the newly created object. + """ + class Camera(libcarna.base.Camera, _spatial_mixin): + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + def proj(self, projection: np.ndarray | Literal['frustum'], **kwargs) -> Self: + """ + Set the projection matrix of the camera. + """ + if isinstance(projection, np.ndarray): + self.projection = projection + self.update_projection = lambda *args, **kwargs: None + + elif isinstance(projection, str) and projection == 'frustum': + fov_rad = libcarna.base.math.deg2rad(kwargs['fov']) + z_near = kwargs['z_near'] + z_far = kwargs['z_far'] + + def update_projection(width: int, height: int): + self.projection = libcarna.base.math.frustum(fov_rad, height / width, z_near, z_far) + + self.update_projection = update_projection + + else: + raise ValueError(f'Unsupported projection type: {projection}') + return self + + def frustum(self, fov: float, z_near: float, z_far: float) -> Self: + """ + Set a projection matrix that is described by the frustum. + + Wrapper for :func:`libcarna.base.math.frustum` that ensures that the geometry of the frustum fits the + aspect ratio of the renderer. + + Arguments: + fov: Field of view in degrees. + z_near: Near clipping plane. + z_far: Far clipping plane. + """ + return self.proj('frustum', fov=fov, z_near=z_near, z_far=z_far) + + camera = Camera() if tag is None else Camera(tag) + _setup_spatial(camera, parent, **kwargs) + return camera + + +def geometry( + geometry_type: int, + tag: str | None = None, + *, + parent: libcarna.base.Node | None = None, + mesh: libcarna.base.GeometryFeature | None = None, + material: libcarna.base.Material | None = None, + **kwargs, + ) -> libcarna.base.Geometry: + """ + Create a :class:`carna.base.Geometry` object. + + Arguments: + geometry_type: The type of the geometry. + tag: An arbitrary string, that helps identifying the object. + parent: Parent node to attach the spatial to, or `None`. + mesh: A mesh to be attached to this geometry object. + material: A material to be attached to this geometry object. + **kwargs: Attributes to be set on the newly created object. + """ + class Geometry(libcarna.base.Geometry, _spatial_mixin): + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + + geometry = Geometry(geometry_type) if tag is None else Geometry(geometry_type, tag) + _setup_spatial(geometry, parent, **kwargs) + if mesh is not None: + geometry.put_feature(libcarna.mesh_renderer.DEFAULT_ROLE_MESH, mesh) + if material is not None: + geometry.put_feature(libcarna.mesh_renderer.DEFAULT_ROLE_MATERIAL, material) + return geometry + + +def volume( + geometry_type: int, + array: np.ndarray, + tag: str | None = None, + *, + units: Literal['raw', 'hu'] = 'raw', + parent: libcarna.base.Node | None = None, + normals: bool = False, + spacing: np.ndarray | None = None, + extent: np.ndarray | None = None, + **kwargs, + ) -> libcarna.base.Node: + """ + Create a renderable representation of 3D data using the specified `geometry_type`, that can be put anywhere in the + scene graph. The 3D volume is centered in the returned node. + + Arguments: + geometry_type: The type of the geometry. + array: 3D data to be rendered. + tag: An arbitrary string, that helps identifying the created node. + units: The units of the data. If `'hu'`, the data is assumed to be in Hounsfield Units (HU). + parent: Parent node to attach the volume to, or `None`. + normals: Governs normal mapping (if `True`, the 3D normal map will be pre-computed for the volume). + spacing: Specifies the spacing between two adjacent voxel centers. Mutually exclusive with `extent`. + extent: Specifies the spatial size of the whole volume. Mutually exclusive with `spacing`. + **kwargs: Attributes to be set on the created node. + """ + assert array.ndim == 3, 'Array must be 3D data.' + assert (spacing is None) != (extent is None), 'Either spacing or extent must be provided.' + assert np.isnan(array).sum() == 0, 'Array must not contain NaN values.' + assert np.isinf(array).sum() == 0, 'Array must not contain inf values.' + + # Preprocess the data based on the units + array_dtype = array.dtype + match units: + case 'hu': + raw2norm = lambda array: (array + 1024) / 4095 + norm2raw = lambda array: (array * 4095) - 1024 + array = array.clip(-1024, +3071) + case 'raw': + array_offset = float(array.min()) + array_factor = float(array.max() - array_offset) + if array_factor > 0: + raw2norm = lambda array: (array - array_offset) / array_factor + norm2raw = lambda array: (array * array_factor) + array_offset + else: + raw2norm = lambda array: np.full(fill_value=0, shape=array.shape, dtype=np.uint8) + norm2raw = lambda array: np.full(fill_value=array_offset, shape=array.shape, dtype=array_dtype) + case _: + raise ValueError(f'Unsupported units: "{units}"') + array = raw2norm(array) + + # Choose appropriate intensity component + if array.dtype == np.uint8: + intensity_component = 'IntensityVolumeUInt8' + elif array.dtype == bool: + intensity_component = 'IntensityVolumeUInt8' + elif array.dtype == np.uint16: + intensity_component = 'IntensityVolumeUInt16' + elif np.issubdtype(array.dtype, np.floating): + intensity_component = 'IntensityVolumeUInt16' + else: + raise ValueError(f'Unsupported data type: {array.dtype}') + + # Choose appropriate buffer type + if normals: + helper_type_name = f'VolumeGridHelper_{intensity_component}_NormalMap3DInt8' + else: + helper_type_name = f'VolumeGridHelper_{intensity_component}' + + # Create the buffer and load the data + volume_type = getattr(libcarna.helpers, helper_type_name) + helper = volume_type(native_resolution=array.shape) + helper.load_intensities(array) + + # Deduce the parameters for spacing and extent + create_node_kwargs = dict() + if spacing is not None: + create_node_kwargs['spacing'] = volume_type.Spacing(spacing) + extent = np.subtract(array.shape, 1) * spacing + elif extent is not None: + create_node_kwargs['extent'] = volume_type.Extent(extent) + spacing = np.divide(extent, np.subtract(array.shape, 1)) + + # Create a wrapper node, so that it is safe to modify the `.local_transform` property (making such modifications + # directly to the property of the node created by the wrapper is discouraged in the docs) + # https://kostrykin.github.io/LibCarna/html/classLibCarna_1_1helpers_1_1VolumeGridHelper.html#ab03947088a1de662b7a468516e4b5e24 + class WrapperNode(libcarna.base.Node, _spatial_mixin): + + def __init__(self, *args, **kwargs): + super().__init__(*args, **kwargs) + self.extent = extent + self.spacing = spacing + + def transform_into_voxels_from(self, rhs: libcarna.base.Spatial) -> np.ndarray: + """ + Compute the transformation from the local coordinate system of a spatial object `rhs` into the voxel + coordinate system of this volume. + """ + return transform( + libcarna.base.math.scaling(np.subtract(array.shape, 1) / extent) @ + libcarna.base.math.translation(extent / 2) @ + self.transform_from(rhs).mat + ) + + def transform_from_voxels_into(self, lhs: libcarna.base.Spatial) -> np.ndarray: + """ + Compute the transformation from the voxel coordinate system of this volume into the local coordinate system + of a spatial object `lhs`. + """ + return transform(np.linalg.inv(self.transform_into_voxels_from(lhs).mat)) + + def normalized(self, array: np.ndarray) -> np.ndarray: + """ + Convert raw array intensities to the normalized intensities in [0, 1] used for rendering. + """ + return raw2norm(np.asarray(array)) + + def raw(self, array: np.ndarray) -> np.ndarray: + """ + Convert normalized intensities in [0, 1] used for rendering to the raw array intensities. + """ + return norm2raw(np.asarray(array)).astype(array_dtype) + + wrapper_node = WrapperNode(tag) if tag is not None else WrapperNode() + _setup_spatial(wrapper_node, parent, **kwargs) + + # Create volume node + volume_node = helper.create_node(geometry_type=geometry_type, **create_node_kwargs) + wrapper_node.attach_child(volume_node) + return wrapper_node diff --git a/misc/libcarna/_transform.py b/misc/libcarna/_transform.py new file mode 100644 index 0000000..4763b6f --- /dev/null +++ b/misc/libcarna/_transform.py @@ -0,0 +1,16 @@ +import numpy as np + + +class transform: + + def __init__(self, mat: np.ndarray): + self.mat = mat + + def point(self, xyz: np.ndarray = np.zeros(3)) -> np.ndarray: + return (self.mat @ np.array([*xyz, 1.0]))[:3] + + def intpoint(self, *args, **kwargs) -> tuple[int, int, int]: + return tuple(self.point(*args, **kwargs).round().astype(int)) + + def direction(self, xyz: np.ndarray = np.zeros(3)) -> np.ndarray: + return self.mat @ np.array([*xyz, 0.0]) diff --git a/misc/libcarna/_typing.py b/misc/libcarna/_typing.py new file mode 100644 index 0000000..cfef035 --- /dev/null +++ b/misc/libcarna/_typing.py @@ -0,0 +1,6 @@ +import sys + +if sys.version_info >= (3, 11): + from typing import * +else: + from typing_extensions import * diff --git a/misc/libcarna/data.py b/misc/libcarna/data.py new file mode 100644 index 0000000..7b23fc0 --- /dev/null +++ b/misc/libcarna/data.py @@ -0,0 +1,69 @@ +import glob +import tarfile +import tempfile + +import numpy as np +import pooch +import scipy.ndimage as ndi +import skimage.data +import tifffile + +import libcarna + + +def nuclei(): + """ + Returns a sample image of cell nuclei. + + The image is from the Allen Cell WTC-11 hiPSC Single-Cell Image Dataset: https://doi.org/10.1038/s41586-022-05563-7 + (Viana et al. 2023). + + The data is 60 × 256 × 256 pixels (uint16). The spacings should have a ratio of 2:1:1. + """ + return skimage.data.cells3d()[:, 1] + + +def cthead(normalize: bool = False) -> np.ndarray: + """ + Returns a computer tomography (CT) study of a cadaver head: https://graphics.stanford.edu/data/voldata/ + + The data is 256 × 256 × 99 pixels (uint16). The image intensities are *not* normalized to Hounsfield Units. The + spacings should have a ratio of 1:1:2. + + Arguments: + normalize: If True, the image intensities are heuristically normalized to Hounsfield Units (HU). + """ + data_tar_gz_filepath = pooch.retrieve( + 'https://graphics.stanford.edu/data/voldata/cthead-16bit.tar.gz', + known_hash='md5:ea5874800bc1321fecd65ee791ca157b', + ) + with tempfile.TemporaryDirectory() as data_dir_path: + with tarfile.open(data_tar_gz_filepath) as data_tar_gz: + kwargs = dict() + if hasattr(tarfile, 'fully_trusted_filter'): + kwargs['filter'] = tarfile.fully_trusted_filter # required by tarfile >= 3.7.0 + data_tar_gz.extractall(data_dir_path, **kwargs) + data = np.dstack( + [ + tifffile.imread(filepath) for filepath in + sorted(glob.glob(f'{data_dir_path}/cthead-*.tif')) + ] + ) + if normalize: + data = libcarna.normalize_hounsfield_units(data) + return data + +def toy(seed: int = 0): + """ + Returns a toy image of a 3D Gaussian. + + The data is 64 × 64 × 20 pixels (float64). The image intensities are normalized to the range [0, 1]. + + Arguments: + seed: Random seed for reproducibility. + """ + np.random.seed(seed) + data = ndi.gaussian_filter(np.random.rand(64, 64, 20), 10) + data = data - data.min() + data = data / data.max() + return data diff --git a/misc/py.py b/misc/py.py deleted file mode 100644 index e63ebeb..0000000 --- a/misc/py.py +++ /dev/null @@ -1,326 +0,0 @@ -import atexit -import carna -import carna.base -import carna.egl -import carna.presets -import carna.helpers -import numpy as np -import warnings - - -version = carna.version -py_version = carna.py_version - - -# Create the OpenGL context when module is loaded -ctx = carna.egl.Context.create() - -# Release the OpenGL context when module is unloaded -@atexit.register -def shutdown(): - ctx.free() - - -class SpatialWrapper: - def __init__(self, spatial): - self._ = spatial - - def translate(self, *args): - self._.local_transform = self._.local_transform @ carna.base.math.translation4f(*args) - return self - - def rotate(self, axis, amount, units='rad'): - assert units in ('rad', 'deg') - axis = axis / np.linalg.norm(axis) - if units == 'deg': amount = carna.base.math.deg2rad(amount) - self._.local_transform = self._.local_transform @ carna.base.math.rotation4f(axis, amount) - return self - - def scale(self, *args): - self._.local_transform = self._.local_transform @ carna.base.math.scaling4f(*args) - return self - - @property - def position(self): - return self._.local_transform[:3, -1] - - def look(self, direction, up): - direction = np.asarray(direction) / np.linalg.norm(direction) - left = np.cross(direction, up) - left = left / np.linalg.norm(left) - up = np.cross(left, direction) - mat = np.eye(4) - mat[:3, 0] = -left - mat[:3, 1] = up - mat[:3, 2] = direction - mat[:3, 3] = self.position - self._.local_transform = mat - return self - - def look_at(self, point, up): - direction = self.position - point - return self.look(direction, up) - - -class VolumeWrapper(SpatialWrapper): - def __init__(self, volume, data_shape, dimensions=None, spacing=None): - assert (dimensions is None) != (spacing is None) - super().__init__(volume) - if dimensions is None: dimensions = spacing * (np.array(data_shape) - 1)[None, :] - self.dimensions = dimensions - self.data_shape = data_shape - - def map_normalized_coordinates(self, coordinates): - """Maps normalized coordinates to volume coordinates. - """ - coordinates = np.asarray(coordinates) - assert coordinates.ndim == 2 and coordinates.shape[1] == 3 - return (coordinates - 0.5) * self.dimensions - - def map_voxel_coordinates(self, coordinates): - """Maps voxel coordinates to volume coordinates. - """ - coordinates = np.asarray(coordinates) - assert coordinates.ndim == 2 and coordinates.shape[1] == 3 - coordinates = coordinates / np.subtract(self.data_shape, 1)[None, :] - return self.map_normalized_coordinates(coordinates) - - -def deduce_volume_format(dtype, dtype_fallback='float16'): - dtype = str(np.dtype(dtype)) - if dtype in ('float32', 'float64'): - warnings.warn(f'Unsupported data type: {dtype} (will be treated as {dtype_fallback})') - dtype = dtype_fallback - return { - 'uint8' : 'VolumeGrid_UInt8Intensity', - 'uint16' : 'VolumeGrid_UInt16Intensity', - 'float16': 'VolumeGrid_UInt16Intensity', - }[dtype] - - -def preprocess_mask_data(data): - dtype = str(np.dtype(data.dtype)) - if dtype == 'bool': return 'VolumeGrid_UInt8Intensity', data - if (dtype.startswith('int') or dtype.startswith('uint')): - if data.max() < (1 << 8): - return 'VolumeGrid_UInt8Intensity', (data / data.max()).clip(0, 1) - if data.max() < (1 << 16): - return 'VolumeGrid_UInt16Intensity', (data / data.max()).clip(0, 1) - if dtype.startswith('float'): - return 'VolumeGrid_UInt16Intensity', (data / data.max()).clip(0, 1) - else: - raise ValueError(f'Unsupported mask format') - - -class SingleFrameContext: - - GEOMETRY_TYPE_OPAQUE = 0 - GEOMETRY_TYPE_VOLUME = 1 - GEOMETRY_TYPE_PLANE = 2 - GEOMETRY_TYPE_MASK = 3 - - def __init__(self, shape, near, far, fov=None, ortho=None, - max_segment_bytesize=carna.helpers.VolumeGridHelperBase.DEFAULT_MAX_SEGMENT_BYTESIZE): - assert (fov is None) != (ortho is None), f'Either "fov" or "ortho" musst be supplied (fov={fov}, ortho={ortho})' - assert ortho is None or (isinstance(ortho, tuple) and len(ortho) == 4), str(ortho) - self.result = None - self.shape = shape - self.near = near - self.far = far - self.fov = fov - self.ortho = ortho - self.max_segment_bytesize = max_segment_bytesize - - def __enter__(self): - self. result = None - self._camera = carna.base.Camera.create() - self._renderer = carna.base.FrameRenderer.create(ctx, self.shape[1], self.shape[0]) - self._helper = carna.helpers.FrameRendererHelper(self._renderer) - self._extra_stages = {} - self._points = None - self._root = carna.base.Node.create() - self._stages = dict() - self._grids = [] - self._meshes = [] - self._materials = [] - if self.fov is not None: - self._camera.projection = carna.base.math.frustum4f(carna.base.math.deg2rad(self.fov), self.shape[0] / self.shape[1], self.near, self.far) - else: - self._camera.projection = carna.base.math.ortho4f(*self.ortho, self.near, self.far) - self._root.attach_child(self._camera) - return self - - def _get_stage(self, stage_type, *create_args): - if stage_type not in self._stages: - stage = stage_type.create(*create_args) - self._stages[stage_type] = stage - if stage_type is not carna.presets.MaskRenderingStage: - self._helper.add_stage(stage) - return self._stages[stage_type] - - def _render(self): - surface = carna.base.Surface.create(ctx, self._renderer.width, self._renderer.height) - surface.begin() - self._renderer.render(self._camera) - return surface.end() - - def _append_extra_render_stages(self, current_render_time): - assert current_render_time in ('before', 'after') - for stage, scheduled_render_time in self._extra_stages.items(): - if scheduled_render_time == current_render_time: - self._renderer.append_stage(stage) - - def __exit__(self, ex_type, ex_value, ex_traceback): - self._append_extra_render_stages('before') - self._helper.commit(False) - self._append_extra_render_stages('after') - self.result = self._render() - for material in self._materials: material.release() - for mesh in self._meshes: mesh.release() - for grid in self._grids: grid.free() - if self._points is not None: self._points.free() - self._renderer.free() - self._root.free() - - @property - def camera(self): - return SpatialWrapper(self._camera) - - def _get_parent(self, parent): - if isinstance(parent, str) and parent == 'root': return self._root - elif isinstance(parent, SpatialWrapper): return parent._ - else: raise ValueError('parent must be either "root" or SpatialWrapper instance') - - def volume(self, data, dimensions=None, spacing=None, normals=False, fmt_hint=None, parent='root'): - assert data.ndim == 3 - assert (dimensions is None) != (spacing is None) - if dimensions is not None: size_hint = carna.helpers.Dimensions(dimensions) - if spacing is not None: size_hint = carna.helpers.Spacing (spacing) - grid_helper_type = deduce_volume_format(data.dtype if fmt_hint is None else fmt_hint) - if normals: grid_helper_type += '_Int8Normal' - grid = getattr(carna.helpers, grid_helper_type).create(data.shape, self.max_segment_bytesize) - grid.load_data(data) - volume = grid.create_node(SingleFrameContext.GEOMETRY_TYPE_VOLUME, size_hint) - pivot = carna.base.Node.create() - pivot.attach_child(volume) - self._get_parent(parent).attach_child(pivot) - self._grids.append(grid) - return VolumeWrapper(pivot, data.shape, dimensions, spacing) - - def masks(self, flavor='default', **kwargs): - """Configures the mask rendering stage. - """ - assert flavor in ('regions', 'regions-on-top', 'borders-on-top', 'borders-in-background') - mr = self._get_stage(carna.presets.MaskRenderingStage, SingleFrameContext.GEOMETRY_TYPE_MASK) - for key, val in kwargs.items(): - setattr(mr, key, val) - if flavor == 'default' and mr not in self._extra_stages: flavor = 'regions' - if flavor == 'regions': - render_time = 'before' - mr.render_borders = False - if flavor == 'regions-on-top': - render_time = 'after' - mr.render_borders = False - if flavor == 'borders-on-top': - render_time = 'after' - mr.render_borders = True - if flavor == 'borders-in-background': - render_time = 'before' - mr.render_borders = True - self._extra_stages[mr] = render_time - return mr - - def mask(self, data, *args, dimensions=None, spacing=None, parent='root', **kwargs): - mr = self.masks(*args, **kwargs) ## require mask rendering stage - assert (dimensions is None) != (spacing is None) - if dimensions is not None: size_hint = carna.helpers.Dimensions(dimensions) - if spacing is not None: size_hint = carna.helpers.Spacing (spacing) - grid_helper_type, data = preprocess_mask_data(data) - grid = getattr(carna.helpers, grid_helper_type).create(data.shape, self.max_segment_bytesize) - grid.intensities_role = mr.mask_role - grid.load_data(data) - volume = grid.create_node(SingleFrameContext.GEOMETRY_TYPE_MASK, size_hint) - pivot = carna.base.Node.create() - pivot.attach_child(volume) - self._get_parent(parent).attach_child(pivot) - self._grids.append(grid) - return VolumeWrapper(pivot, data.shape, dimensions, spacing) - - def plane(self, *args, parent='root'): - self.planes() ## require cutting planes rendering stage - plane = carna.base.Geometry.create(SingleFrameContext.GEOMETRY_TYPE_PLANE) - plane.local_transform = carna.base.math.plane4f(*args) - self._get_parent(parent).attach_child(plane) - return SpatialWrapper(plane) - - def planes(self): - return self._get_stage(carna.presets.CuttingPlanesStage, SingleFrameContext.GEOMETRY_TYPE_VOLUME, SingleFrameContext.GEOMETRY_TYPE_PLANE) - - def opaque(self): - return self._get_stage(carna.presets.OpaqueRenderingStage, SingleFrameContext.GEOMETRY_TYPE_OPAQUE) - - def occluded(self): - return self._get_stage(carna.presets.OccludedRenderingStage) - - def mip(self, layers=[(0, 1, (1,1,1,1))], **kwargs): - mip = self._get_stage(carna.presets.MIPStage, SingleFrameContext.GEOMETRY_TYPE_VOLUME) - mip.clear_layers() - for layer in layers: - mip.append_layer(carna.presets.MIPLayer.create(*layer)) - for key, val in kwargs.items(): - setattr(mip, key, val) - return mip - - def dvr(self, translucency=0, color_map=[(0, 1, (1,1,1,0), (1,1,1,1))], **kwargs): - dvr = self._get_stage(carna.presets.DVRStage, SingleFrameContext.GEOMETRY_TYPE_VOLUME) - dvr.translucency = translucency - dvr.clear_color_map() - for color_map_entry in color_map: - dvr.write_color_map(*color_map_entry) - for key, val in kwargs.items(): - setattr(dvr, key, val) - return dvr - - def dots(self, data, color, size, parent='root'): - opaque = self.opaque() - if self._points is None: self._points = carna.helpers.PointMarkerHelper.create(SingleFrameContext.GEOMETRY_TYPE_OPAQUE) - dots = [] - for location in data: - dot = self._points.create_point_marker(size, color) - dot.local_transform = carna.base.math.translation4f(*location) - self._get_parent(parent).attach_child(dot) - dots.append(SpatialWrapper(dot)) - return dots - - def material(self, color, shader='solid'): - material = carna.base.Material.create(shader) - material.set_parameter4f('color', color) - self._materials.append(material) - return material - - def box(self, width, height, depth): - box = carna.base.create_box(width, height, depth) - self._meshes.append(box) - return box - - def ball(self, radius, degree=3): - ball = carna.base.create_ball(radius, degree) - self._meshes.append(ball) - return ball - - def mesh(self, mesh, material, parent='root'): - self.opaque() ## require opaque rendering stage - geom = carna.base.Geometry.create(SingleFrameContext.GEOMETRY_TYPE_OPAQUE) - geom.put_feature(carna.presets.OpaqueRenderingStage.ROLE_DEFAULT_MESH, mesh) - geom.put_feature(carna.presets.OpaqueRenderingStage.ROLE_DEFAULT_MATERIAL, material) - self._get_parent(parent).attach_child(geom) - return SpatialWrapper(geom) - - def meshes(self, mesh, material, locations, parent='root'): - geoms = [] - for loc in locations: - geom = self.mesh(mesh, material, parent=parent).translate(*loc) - geoms.append(geom) - return geoms - - diff --git a/setup.py b/setup.py index ea5225c..22804a7 100644 --- a/setup.py +++ b/setup.py @@ -1,35 +1,25 @@ -# Build and install: -# > python setup.py bdist_wheel -# > python -m pip install --force-reinstall CarnaPy/dist/*.whl -# -# Distribute to PyPI: -# > python setup.py sdist -# > python -m twine upload dist/*.tar.gz - -import yaml -with open('misc/VERSIONS.yaml', 'r') as io: - versions = yaml.safe_load(io) - -VERSION_CARNA_PY = versions['build']['carnapy'] -VERSION_CARNA = versions['build']['carna' ] - -import sys import os - +import sys from pathlib import Path +VERSION_LIBCARNA_PYTHON = '0.2.0' +VERSION_LIBCARNA = '3.4.0' + root_dir = Path(os.path.abspath(os.path.dirname(__file__))) -build_dir_debug = root_dir / 'build' / 'make_debug' -build_dir_release = root_dir / 'build' / 'make_release' +build_dirs = dict( + debug = root_dir / 'build' / 'make_debug', + release = root_dir / 'build' / 'make_release', +) if __name__ == '__main__': - (build_dir_debug / 'carna').mkdir(parents=True, exist_ok=True) - (build_dir_release / 'carna').mkdir(parents=True, exist_ok=True) + (build_dirs['debug'] / 'libcarna').mkdir(parents=True, exist_ok=True) + (build_dirs['release'] / 'libcarna').mkdir(parents=True, exist_ok=True) - from setuptools import setup, Extension, find_packages - from setuptools.command.build_ext import build_ext as build_ext_orig + from setuptools import setup, Extension + from setuptools.command.build_ext import build_ext as _build_ext + from setuptools.command.build_py import build_py as _build_py with open(root_dir / 'README.md', encoding='utf-8') as io: long_description = io.read() @@ -39,65 +29,78 @@ class CMakeExtension(Extension): def __init__(self): super().__init__('CMake', sources=[]) - class build_ext(build_ext_orig): - - def run(self): - for ext in self.extensions: - self.build_cmake(ext) - - def build_cmake(self, ext): - version_major, version_minor, version_patch = [int(val) for val in VERSION_CARNA_PY.split('.')] - build_test = os.environ.get('CARNAPY_BUILD_TEST', 'ON') + def build(self, build_ext): + version_major, version_minor, version_patch = [int(val) for val in VERSION_LIBCARNA_PYTHON.split('.')] + build_test = os.environ.get('LIBCARNA_PYTHON_BUILD_TEST', 'ON') assert build_test in ('ON', 'OFF') - get_cmake_args = lambda debug: [ - f'-DCMAKE_BUILD_TYPE={"Debug" if debug else "Release"}', + build_type = os.environ.get('CMAKE_BUILD_TYPE', 'Release') + cmake_args = [ + f'-DCMAKE_BUILD_TYPE={build_type}', f'-DBUILD_TEST={build_test}', - f'-DBUILD_DOC={"OFF" if debug else "ON"}', f'-DMAJOR_VERSION={version_major}', f'-DMINOR_VERSION={version_minor}', f'-DPATCH_VERSION={version_patch}', - f'-DREQUIRED_VERSION_CARNA={VERSION_CARNA}', + f'-DREQUIRED_VERSION_LIBCARNA={VERSION_LIBCARNA}', f'-DPYTHON_EXECUTABLE={sys.executable}', f'-Dpybind11_DIR={os.environ["PYBIND11_PREFIX"]}', + f'-DCMAKE_MODULE_PATH={os.environ.get("CMAKE_MODULE_PATH")}', f'../..', ] - if not self.dry_run: - - os.chdir(str(build_dir_release)) - self.spawn(['cmake'] + get_cmake_args(debug=False)) - self.spawn(['make', 'VERBOSE=1']) + if not build_ext.dry_run: + os.chdir(str(build_dirs[build_type.lower()])) + build_ext.spawn(['cmake'] + cmake_args) + build_ext.spawn(['make', 'VERBOSE=1']) if build_test == 'ON': - self.spawn(['make', 'RUN_TESTSUITE']) + build_ext.spawn(['make', 'RUN_TESTSUITE']) os.chdir(str(root_dir)) + class build_ext(_build_ext): + + def run(self): + for ext in self.extensions: + ext.build(self) + + class build_py(_build_py): + + def run(self): + self.run_command('build_ext') # ensure `build_ext` runs before `build_py` + super().run() + setup( - name = 'CarnaPy', - version = VERSION_CARNA_PY, + name = 'LibCarna-Python', + version = VERSION_LIBCARNA_PYTHON, description = 'General-purpose real-time 3D visualization', long_description = long_description, long_description_content_type = 'text/markdown', author = 'Leonid Kostrykin', author_email = 'leonid.kostrykin@bioquant.uni-heidelberg.de', - url = 'https://github.com/kostrykin/CarnaPy', + url = 'https://github.com/kostrykin/LibCarna-Python', include_package_data = True, - license = 'BSD', + license = 'MIT', + license_files = [ + 'LICENSE', + 'build/make_release/licenses/LICENSE-Carna', + 'build/make_release/licenses/LICENSE-LibCarna', + 'build/make_release/licenses/LICENSE-Eigen', + 'build/make_release/licenses/LICENSE-GLEW', + ], package_dir = { - 'carna': 'build/make_release/carna', + 'libcarna': 'build/make_release/libcarna', }, - packages = ['carna'], + packages = ['libcarna'], package_data = { - 'carna': ['*.so'], + 'libcarna': ['*.so'], }, ext_modules = [CMakeExtension()], cmdclass={ 'build_ext': build_ext, + 'build_py': build_py, }, classifiers = [ - 'Development Status :: 3 - Alpha', + 'Development Status :: 4 - Beta', 'Environment :: GPU', - 'License :: OSI Approved :: BSD License', 'Operating System :: POSIX :: Linux', 'Programming Language :: C++', 'Programming Language :: Python', @@ -108,6 +111,14 @@ def build_cmake(self, ext): ], install_requires = [ 'numpy', + 'numpngw >=0.1.4, <0.2', + 'scikit-video >=1.1.11, <1.2', + 'scipy', + 'scikit-image', + 'tifffile', + 'pooch', + 'matplotlib', + 'typing_extensions', # required for Python 3.10 ], ) diff --git a/src/egl/Context.cpp b/src/egl/Context.cpp deleted file mode 100644 index 688f035..0000000 --- a/src/egl/Context.cpp +++ /dev/null @@ -1,143 +0,0 @@ -#include -#include -#include - -// see: https://developer.nvidia.com/blog/egl-eye-opengl-visualization-without-x-server/ - -namespace Carna -{ - -namespace egl -{ - - - -// ---------------------------------------------------------------------------------- -// REPORT_EGL_ERROR -// ---------------------------------------------------------------------------------- - -#ifndef NO_EGL_ERROR_CHECKING - - #include - - #define REPORT_EGL_ERROR { \ - const unsigned int err = eglGetError(); \ - CARNA_ASSERT_EX( err == EGL_SUCCESS, "EGL Error State in " \ - << __func__ \ - << " [" << err << "] (" << __FILE__ << ":" << __LINE__ << ")" ); } -#else - - #define REPORT_EGL_ERROR - -#endif - - - -// ---------------------------------------------------------------------------------- -// CONFIG_ATTRIBS -// ---------------------------------------------------------------------------------- - -static const EGLint CONFIG_ATTRIBS[] = -{ - EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, - EGL_BLUE_SIZE, 8, - EGL_GREEN_SIZE, 8, - EGL_RED_SIZE, 8, - EGL_DEPTH_SIZE, 8, - EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT, - EGL_NONE -}; - - - -// ---------------------------------------------------------------------------------- -// PBUFFER_ATTRIBS -// ---------------------------------------------------------------------------------- - -static const EGLint PBUFFER_ATTRIBS[] = -{ - EGL_WIDTH, 0, - EGL_HEIGHT, 0, - EGL_NONE -}; - - - -// ---------------------------------------------------------------------------------- -// Context :: Details -// ---------------------------------------------------------------------------------- - -struct Context::Details -{ - EGLDisplay eglDpy; - EGLSurface eglSurf; - EGLContext eglCtx; - - void activate() const; -}; - - -void Context::Details::activate() const -{ - eglMakeCurrent( this->eglDpy, this->eglSurf, this->eglSurf, this->eglCtx ); - REPORT_EGL_ERROR; -} - - - -// ---------------------------------------------------------------------------------- -// Context -// ---------------------------------------------------------------------------------- - -Context::Context( Details* _pimpl ) - : base::GLContext( false ) - , pimpl( _pimpl ) -{ -} - - -Context* Context::create() -{ - unsetenv( "DISPLAY" ); // see https://stackoverflow.com/q/67885750/1444073 - - Details* const pimpl = new Details(); - pimpl->eglDpy = eglGetDisplay( EGL_DEFAULT_DISPLAY ); - EGLint major, minor; - eglInitialize( pimpl->eglDpy, &major, &minor ); - - eglBindAPI( EGL_OPENGL_API ); - REPORT_EGL_ERROR; - - EGLint numConfigs; - EGLConfig eglCfg; - - eglChooseConfig( pimpl->eglDpy, CONFIG_ATTRIBS, &eglCfg, 1, &numConfigs ); - - pimpl->eglSurf = eglCreatePbufferSurface( pimpl->eglDpy, eglCfg, PBUFFER_ATTRIBS ); - CARNA_ASSERT( pimpl->eglSurf != EGL_NO_SURFACE ); - - pimpl->eglCtx = eglCreateContext( pimpl->eglDpy, eglCfg, EGL_NO_CONTEXT, NULL ); - CARNA_ASSERT( pimpl->eglCtx != EGL_NO_CONTEXT ); - - pimpl->activate(); - return new Context( pimpl ); -} - - -Context::~Context() -{ - eglTerminate( pimpl->eglDpy ); -} - - -void Context::activate() const -{ - pimpl->activate(); -} - - - -} // namespace Carna :: egl - -} // namespace Carna - diff --git a/src/egl/EGLContext.cpp b/src/egl/EGLContext.cpp new file mode 100644 index 0000000..f29922d --- /dev/null +++ b/src/egl/EGLContext.cpp @@ -0,0 +1,213 @@ +#define EGL_EGLEXT_PROTOTYPES + +#include +#include +#include +#include +#include +#include + +// see: https://developer.nvidia.com/blog/egl-eye-opengl-visualization-without-x-server/ + + + +// ---------------------------------------------------------------------------------- +// REPORT_EGL_ERROR +// ---------------------------------------------------------------------------------- + +#ifndef NO_EGL_ERROR_CHECKING + + #include + + #define REPORT_EGL_ERROR { \ + const unsigned int err = eglGetError(); \ + LIBCARNA_ASSERT_EX( err == EGL_SUCCESS, "EGL Error State in " \ + << __func__ \ + << " [" << err << "] (" << __FILE__ << ":" << __LINE__ << ")" ); } +#else + + #define REPORT_EGL_ERROR + +#endif + + + +// ---------------------------------------------------------------------------------- +// CONFIG_ATTRIBS +// ---------------------------------------------------------------------------------- + +static const EGLint CONFIG_ATTRIBS[] = +{ + EGL_SURFACE_TYPE, EGL_PBUFFER_BIT, + EGL_BLUE_SIZE, 8, + EGL_GREEN_SIZE, 8, + EGL_RED_SIZE, 8, + EGL_DEPTH_SIZE, 8, + EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT, + EGL_NONE +}; + + + +// ---------------------------------------------------------------------------------- +// PBUFFER_ATTRIBS +// ---------------------------------------------------------------------------------- + +static const EGLint PBUFFER_ATTRIBS[] = +{ + EGL_WIDTH, 0, + EGL_HEIGHT, 0, + EGL_NONE +}; + + + +// ---------------------------------------------------------------------------------- +// LibCarna :: egl :: EGLContext :: Details +// ---------------------------------------------------------------------------------- + +struct LibCarna::egl::EGLContext::Details +{ + ::EGLDisplay eglDpy; + ::EGLSurface eglSurf; + ::EGLContext eglCtx; + + std::string vendor; + std::string renderer; + + void selectDisplay(); + bool initializeDisplay(); + void activate() const; +}; + + +bool LibCarna::egl::EGLContext::Details::initializeDisplay() +{ + EGLint major, minor; + const EGLBoolean initialize = eglInitialize( eglDpy, &major, &minor ); + return initialize == EGL_TRUE; +} + + +void LibCarna::egl::EGLContext::Details::selectDisplay() +{ + eglDpy = eglGetDisplay( EGL_DEFAULT_DISPLAY ); + if( eglDpy == EGL_NO_DISPLAY || !initializeDisplay() ) + { + LibCarna::base::Log::instance().record( LibCarna::base::Log::warning, "EGL_DEFAULT_DISPLAY initialization failed" ); + + /* Load EGL extensions. + */ + PFNEGLQUERYDEVICESEXTPROC eglQueryDevicesEXT = ( PFNEGLQUERYDEVICESEXTPROC ) eglGetProcAddress("eglQueryDevicesEXT"); + PFNEGLGETPLATFORMDISPLAYEXTPROC eglGetPlatformDisplayEXT = ( PFNEGLGETPLATFORMDISPLAYEXTPROC ) eglGetProcAddress("eglGetPlatformDisplayEXT"); + + /* Query EGL devices. + */ + const static int MAX_DEVICES = 8; + EGLDeviceEXT eglDevices[ MAX_DEVICES ]; + EGLint numDevices; + eglQueryDevicesEXT( MAX_DEVICES, eglDevices, &numDevices ); + + std::stringstream msg; + msg << numDevices << " EGL device(s) found"; + LibCarna::base::Log::instance().record( LibCarna::base::Log::debug, msg.str() ); + + /* Try to get displays from the devices. + */ + for( unsigned int deviceIndex = 0; deviceIndex < numDevices; ++deviceIndex ) + { + eglDpy = eglGetPlatformDisplayEXT( EGL_PLATFORM_DEVICE_EXT, eglDevices[ deviceIndex ], 0 ); + if( eglDpy != EGL_NO_DISPLAY && initializeDisplay() ) + { + std::stringstream msg; + msg << "Successfully initialized EGL display from device " << deviceIndex; + LibCarna::base::Log::instance().record( LibCarna::base::Log::debug, msg.str() ); + break; + } + } + } +} + + +void LibCarna::egl::EGLContext::Details::activate() const +{ + eglMakeCurrent( this->eglDpy, this->eglSurf, this->eglSurf, this->eglCtx ); + REPORT_EGL_ERROR; +} + + + +// ---------------------------------------------------------------------------------- +// LibCarna :: egl :: EGLContext +// ---------------------------------------------------------------------------------- + +static std::unordered_set< LibCarna::egl::EGLContext* > eglContextInstances; + + +LibCarna::egl::EGLContext::EGLContext( Details* _pimpl ) + : LibCarna::base::GLContext( false ) + , pimpl( _pimpl ) // TODO: rename to `pimpl` +{ + eglContextInstances.insert( this ); +} + + +LibCarna::egl::EGLContext* LibCarna::egl::EGLContext::create() +{ + using EGLContext = ::EGLContext; + unsetenv( "DISPLAY" ); // see https://stackoverflow.com/q/67885750/1444073 + + Details* const pimpl = new Details(); + pimpl->selectDisplay(); + LIBCARNA_ASSERT( pimpl->eglDpy != EGL_NO_DISPLAY ); + + eglBindAPI( EGL_OPENGL_API ); + REPORT_EGL_ERROR; + + EGLint numConfigs; + EGLConfig eglCfg; + const EGLBoolean chooseConfig = eglChooseConfig( pimpl->eglDpy, CONFIG_ATTRIBS, &eglCfg, 1, &numConfigs ); + LIBCARNA_ASSERT( chooseConfig == EGL_TRUE ); + + pimpl->eglSurf = eglCreatePbufferSurface( pimpl->eglDpy, eglCfg, PBUFFER_ATTRIBS ); + LIBCARNA_ASSERT( pimpl->eglSurf != EGL_NO_SURFACE ); + + const ::EGLContext shareContext = eglContextInstances.empty() ? EGL_NO_CONTEXT : ( *eglContextInstances.begin() )->pimpl->eglCtx; + pimpl->eglCtx = eglCreateContext( pimpl->eglDpy, eglCfg, shareContext, NULL ); + LIBCARNA_ASSERT( pimpl->eglCtx != EGL_NO_CONTEXT ); + + pimpl->activate(); + REPORT_EGL_ERROR; + + pimpl->vendor = ( const char* ) glGetString( GL_VENDOR ); + pimpl->renderer = ( const char* ) glGetString( GL_RENDERER ); + REPORT_EGL_ERROR; + + return new LibCarna::egl::EGLContext( pimpl ); +} + + +LibCarna::egl::EGLContext::~EGLContext() +{ + eglContextInstances.erase( this ); + eglDestroyContext( pimpl->eglDpy, pimpl->eglCtx ); + eglDestroySurface( pimpl->eglDpy, pimpl->eglSurf ); +} + + +void LibCarna::egl::EGLContext::activate() const +{ + pimpl->activate(); +} + + +const std::string& LibCarna::egl::EGLContext::vendor() const +{ + return pimpl->vendor; +} + + +const std::string& LibCarna::egl::EGLContext::renderer() const +{ + return pimpl->renderer; +} diff --git a/src/include/Carna/egl/Context.h b/src/include/Carna/egl/Context.h deleted file mode 100644 index 8622a61..0000000 --- a/src/include/Carna/egl/Context.h +++ /dev/null @@ -1,43 +0,0 @@ -#include -#include - -namespace Carna -{ - -namespace egl -{ - - - -// ---------------------------------------------------------------------------------- -// Context -// ---------------------------------------------------------------------------------- - -class Context : public base::GLContext -{ - - NON_COPYABLE - - struct Details; - const std::unique_ptr< Details > pimpl; - - Context( Details* ); - -public: - - static Context* create(); - - virtual ~Context(); - -protected: - - virtual void activate() const; - -}; // Context - - - -} // namespace Carna :: egl - -} // namespace Carna - diff --git a/src/include/Carna/py/py.h b/src/include/Carna/py/py.h deleted file mode 100644 index f958c51..0000000 --- a/src/include/Carna/py/py.h +++ /dev/null @@ -1,32 +0,0 @@ -namespace Carna -{ - -namespace py -{ - - - -// ---------------------------------------------------------------------------------- -// free -// ---------------------------------------------------------------------------------- - -template< typename T > -void free( T* ptr ) -{ - delete ptr; -} - - - -// ---------------------------------------------------------------------------------- -// DEF_FREE -// ---------------------------------------------------------------------------------- - -#define DEF_FREE( cls ) def( "free", &Carna::py::free< cls > ) - - - -} // namespace Carna :: py - -} // namespace Carna - diff --git a/src/include/LibCarna/egl/EGLContext.hpp b/src/include/LibCarna/egl/EGLContext.hpp new file mode 100644 index 0000000..34a6e28 --- /dev/null +++ b/src/include/LibCarna/egl/EGLContext.hpp @@ -0,0 +1,49 @@ +#pragma once + +#include +#include + +namespace LibCarna +{ + +namespace egl +{ + + + +// ---------------------------------------------------------------------------------- +// EGLContext +// ---------------------------------------------------------------------------------- + +class EGLContext : public base::GLContext +{ + + NON_COPYABLE + + struct Details; + const std::unique_ptr< Details > pimpl; + + EGLContext( Details* ); + +public: + + static EGLContext* create(); + + virtual ~EGLContext(); + + const std::string& vendor() const; + + const std::string& renderer() const; + +protected: + + virtual void activate() const; + +}; // EGLContext + + + +} // namespace LibCarna :: egl + +} // namespace LibCarna + diff --git a/src/include/Carna/py/Surface.h b/src/include/LibCarna/py/Surface.hpp similarity index 51% rename from src/include/Carna/py/Surface.h rename to src/include/LibCarna/py/Surface.hpp index 68913fe..e9321a6 100644 --- a/src/include/Carna/py/Surface.h +++ b/src/include/LibCarna/py/Surface.hpp @@ -1,7 +1,13 @@ -#include -#include +#pragma once -namespace Carna +#include + +#include + +#include +#include + +namespace LibCarna { namespace py @@ -23,7 +29,7 @@ class Surface public: - Surface( const base::GLContext& glContext, unsigned int width, unsigned int height ); + Surface( const LibCarna::py::base::GLContextView& contextView, unsigned int width, unsigned int height ); virtual ~Surface(); @@ -31,11 +37,11 @@ class Surface unsigned int height() const; - const base::GLContext& glContext; + const std::shared_ptr< const LibCarna::py::base::GLContextView > contextView; void begin() const; - const unsigned char* end() const; + pybind11::array_t< unsigned char > end() const; const std::size_t& size; @@ -43,7 +49,7 @@ class Surface -} // namespace Carna :: py +} // namespace LibCarna :: py -} // namespace Carna +} // namespace LibCarna diff --git a/src/include/LibCarna/py/base.hpp b/src/include/LibCarna/py/base.hpp new file mode 100644 index 0000000..6d602be --- /dev/null +++ b/src/include/LibCarna/py/base.hpp @@ -0,0 +1,340 @@ +#pragma once + +#include +#include +#include +#include + +namespace LibCarna +{ + +namespace py +{ + +namespace base +{ + + +class FrameRendererView; + + + +// ---------------------------------------------------------------------------------- +// VIEW_DELEGATE +// ---------------------------------------------------------------------------------- + +#define VIEW_DELEGATE( ViewType, delegate, ... ) \ + []( ViewType& self __VA_OPT__( , __VA_ARGS__ ) ) \ + { \ + return self.delegate; \ + } + + + +// ---------------------------------------------------------------------------------- +// VIEW_DELEGATE_RETURN_SELF +// ---------------------------------------------------------------------------------- + +#define VIEW_DELEGATE_RETURN_SELF( ViewType, delegate, ... ) \ + []( ViewType& self __VA_OPT__( , __VA_ARGS__ ) ) \ + { \ + self.delegate; \ + return self; \ + } + + + +// ---------------------------------------------------------------------------------- +// GLContextView +// ---------------------------------------------------------------------------------- + +class GLContextView : public std::enable_shared_from_this< GLContextView > +{ + +public: + + const std::unique_ptr< LibCarna::base::GLContext > context; + + explicit GLContextView( LibCarna::base::GLContext* context ); + + virtual ~GLContextView(); + +}; // GLContextView + + + +// ---------------------------------------------------------------------------------- +// SpatialView +// ---------------------------------------------------------------------------------- + +class SpatialView : public std::enable_shared_from_this< SpatialView > +{ + +public: + + /* The view that owns the spatial object of this view. The spatial object of this view is owned by this view, if it + * is not owned by any other spatial object. + */ + std::shared_ptr< SpatialView > ownedBy; + + /* The spatial object of this view. + */ + LibCarna::base::Spatial* const spatial; + + explicit SpatialView( LibCarna::base::Spatial* spatial ); + + virtual ~SpatialView(); + +}; // SpatialView + + + +// ---------------------------------------------------------------------------------- +// NodeView +// ---------------------------------------------------------------------------------- + +class NodeView : public SpatialView +{ + +public: + + template< typename... Args > + explicit NodeView( Args... args ); + + explicit NodeView( LibCarna::base::Node* node ); + + virtual ~NodeView(); + + LibCarna::base::Node& node(); + + void attachChild( SpatialView& child ); + + /* Locks objects with shared ownership until this node view dies. + * + * When this node view dies, and the spatial objects of this view is owned by another view, the locked objects are + * propagated to the view that owns the spatial objects of this view. + */ + std::unordered_set< std::shared_ptr< void > > locks; + +}; // NodeView + + +template< typename... Args > +NodeView::NodeView( Args... args ) + : SpatialView::SpatialView( new LibCarna::base::Node( args... ) ) +{ +} + + + +// ---------------------------------------------------------------------------------- +// CameraView +// ---------------------------------------------------------------------------------- + +class CameraView : public SpatialView +{ + +public: + + template< typename... Args > + explicit CameraView( Args... args ); + + LibCarna::base::Camera& camera(); + +}; // CameraView + + +template< typename... Args > +CameraView::CameraView( Args... args ) + : SpatialView::SpatialView( new LibCarna::base::Camera( args... ) ) +{ +} + + + +// ---------------------------------------------------------------------------------- +// GeometryView +// ---------------------------------------------------------------------------------- + +class GeometryView : public SpatialView +{ + +public: + + template< typename... Args > + explicit GeometryView( Args... args ); + + LibCarna::base::Geometry& geometry(); + +}; // GeometryView + + +template< typename... Args > +GeometryView::GeometryView( Args... args ) + : SpatialView::SpatialView( new LibCarna::base::Geometry( args... ) ) +{ +} + + + +// ---------------------------------------------------------------------------------- +// GeometryFeatureView +// ---------------------------------------------------------------------------------- + +class GeometryFeatureView : public std::enable_shared_from_this< GeometryFeatureView > +{ +public: + + /* The geometry feature of this view. + */ + LibCarna::base::GeometryFeature& geometryFeature; + + explicit GeometryFeatureView( LibCarna::base::GeometryFeature& geometryFeature ); + + virtual ~GeometryFeatureView(); + +}; // GeometryFeatureView + + + +// ---------------------------------------------------------------------------------- +// MaterialView +// ---------------------------------------------------------------------------------- + +class MaterialView : public GeometryFeatureView +{ +public: + + template< typename... Args > + explicit MaterialView( Args... args ); + + LibCarna::base::Material& material(); + + template< typename ParameterType > + void setParameter( const std::string& name, const ParameterType& value ); + +}; // MaterialView + + +template< typename... Args > +MaterialView::MaterialView( Args... args ) + : GeometryFeatureView::GeometryFeatureView( LibCarna::base::Material::create( args... ) ) +{ +} + + +template< typename ParameterType > +void MaterialView::setParameter( const std::string& name, const ParameterType& value ) +{ + material().setParameter( name, value ); +} + + + +// ---------------------------------------------------------------------------------- +// RenderStageView +// ---------------------------------------------------------------------------------- + +class RenderStageView : public std::enable_shared_from_this< RenderStageView > +{ + +public: + + /* The object that owns the render stage of this view. The render Stage of this + * view is owned by the view, if it is not owned by any \a FrameRendererView. + */ + std::shared_ptr< FrameRendererView > ownedBy; + + /* The spatial object of this view. + */ + LibCarna::base::RenderStage* const renderStage; + + explicit RenderStageView( LibCarna::base::RenderStage* renderStage ); + + virtual ~RenderStageView(); + +}; // RenderStageView + + + +// ---------------------------------------------------------------------------------- +// MeshRenderingStageView +// ---------------------------------------------------------------------------------- + +class MeshRenderingStageView : public LibCarna::py::base::RenderStageView +{ + +public: + + const static unsigned int DEFAULT_ROLE_MESH; + const static unsigned int DEFAULT_ROLE_MATERIAL; + + explicit MeshRenderingStageView( LibCarna::base::RenderStage* renderStage ); + +}; // MeshRenderingStageView + + + +// ---------------------------------------------------------------------------------- +// FrameRendererView +// ---------------------------------------------------------------------------------- + +class FrameRendererView : public std::enable_shared_from_this< FrameRendererView > +{ + +public: + + const std::shared_ptr< GLContextView > context; + + LibCarna::base::FrameRenderer frameRenderer; + + FrameRendererView + ( GLContextView& context + , unsigned int width + , unsigned int height + , bool fitSquare ); + + void appendStage( const std::shared_ptr< RenderStageView >& rsView ); + + virtual ~FrameRendererView(); + +}; // FrameRendererView + + + +// ---------------------------------------------------------------------------------- +// ColorMapView +// ---------------------------------------------------------------------------------- + +class ColorMapView : public std::enable_shared_from_this< ColorMapView > +{ + +public: + + const static unsigned int DEFAULT_RESOLUTION; + + const std::shared_ptr< RenderStageView > ownedBy; + + LibCarna::base::ColorMap& colorMap; + + ColorMapView( const std::shared_ptr< RenderStageView >& ownedBy, LibCarna::base::ColorMap& colorMap ); + +}; // ColorMapView + + + +// ---------------------------------------------------------------------------------- +// MeshFactoryView +// ---------------------------------------------------------------------------------- + +class MeshFactoryView +{ +}; // MeshFactoryView + + + +} // namespace LibCarna :: py :: base + +} // namespace LibCarna :: py + +} // namespace LibCarna \ No newline at end of file diff --git a/src/include/LibCarna/py/egl.hpp b/src/include/LibCarna/py/egl.hpp new file mode 100644 index 0000000..e5aaf83 --- /dev/null +++ b/src/include/LibCarna/py/egl.hpp @@ -0,0 +1,38 @@ +#pragma once + +#include +#include + +namespace LibCarna +{ + +namespace py +{ + +namespace egl +{ + + + +// ---------------------------------------------------------------------------------- +// EGLContextView +// ---------------------------------------------------------------------------------- + +class EGLContextView : public LibCarna::py::base::GLContextView +{ + +public: + + EGLContextView(); + + LibCarna::egl::EGLContext& eglContext() const; + +}; // EGLContextView + + + +} // namespace LibCarna :: py :: egl + +} // namespace LibCarna :: py + +} // namespace LibCarna \ No newline at end of file diff --git a/src/include/LibCarna/py/helpers.hpp b/src/include/LibCarna/py/helpers.hpp new file mode 100644 index 0000000..c4329a9 --- /dev/null +++ b/src/include/LibCarna/py/helpers.hpp @@ -0,0 +1,46 @@ +#pragma once + +#include +#include + +namespace LibCarna +{ + +namespace py +{ + +namespace helpers +{ + + + +// ---------------------------------------------------------------------------------- +// FrameRendererHelperView +// ---------------------------------------------------------------------------------- + +class FrameRendererHelperView +{ + + std::vector< std::shared_ptr< LibCarna::py::base::RenderStageView > > stages; + +public: + + FrameRendererHelperView( const std::shared_ptr< LibCarna::py::base::FrameRendererView >& frameRendererView ); + + const std::shared_ptr< LibCarna::py::base::FrameRendererView > frameRendererView; + + void add_stage( const std::shared_ptr< LibCarna::py::base::RenderStageView >& stage ); + + void commit(); + + void reset(); + +}; // FrameRendererHelperView + + + +} // namespace LibCarna :: py :: helpers + +} // namespace LibCarna :: py + +} // namespace LibCarna \ No newline at end of file diff --git a/src/include/LibCarna/py/log.hpp b/src/include/LibCarna/py/log.hpp new file mode 100644 index 0000000..f09c05e --- /dev/null +++ b/src/include/LibCarna/py/log.hpp @@ -0,0 +1,31 @@ +#pragma once + +#include + +namespace LibCarna +{ + +namespace py +{ + + + +// ---------------------------------------------------------------------------------- +// NullWriter +// ---------------------------------------------------------------------------------- + +class NullWriter : public LibCarna::base::Log::TextWriter +{ + +public: + + virtual void writeLine( LibCarna::base::Log::Severity, const std::string& ) const override; + +}; // NullWriter + + + +} // namespace LibCarna :: py + +} // namespace LibCarna + diff --git a/src/include/LibCarna/py/presets.hpp b/src/include/LibCarna/py/presets.hpp new file mode 100644 index 0000000..f44170c --- /dev/null +++ b/src/include/LibCarna/py/presets.hpp @@ -0,0 +1,154 @@ +#pragma once + +#include +#include +#include + +namespace LibCarna +{ + +namespace py +{ + +namespace presets +{ + +class MIPStageView; + + + +// ---------------------------------------------------------------------------------- +// OpaqueRenderingStageView +// ---------------------------------------------------------------------------------- + +class OpaqueRenderingStageView : public LibCarna::py::base::MeshRenderingStageView +{ + +public: + + explicit OpaqueRenderingStageView( unsigned int geometryType ); + + LibCarna::presets::OpaqueRenderingStage& opaqueRenderingStage(); + +}; // OpaqueRenderingStageView + + + +// ---------------------------------------------------------------------------------- +// VolumeRenderingStageView +// ---------------------------------------------------------------------------------- + +class VolumeRenderingStageView : public LibCarna::py::base::RenderStageView +{ + +public: + + const static unsigned int DEFAULT_SAMPLE_RATE; + + explicit VolumeRenderingStageView( LibCarna::presets::VolumeRenderingStage* renderStage ); + + LibCarna::presets::VolumeRenderingStage& volumeRenderingStage(); + +}; // VolumeRenderingStageView + + + +// ---------------------------------------------------------------------------------- +// MaskRenderingStageView +// ---------------------------------------------------------------------------------- + +class MaskRenderingStageView : public VolumeRenderingStageView +{ + +public: + + explicit MaskRenderingStageView( unsigned int geometryType, unsigned int maskRole ); + + LibCarna::presets::MaskRenderingStage& maskRenderingStage(); + +}; // MaskRenderingStageView + + + +// ---------------------------------------------------------------------------------- +// MIPStageView +// ---------------------------------------------------------------------------------- + +class MIPStageView : public VolumeRenderingStageView +{ + +public: + + explicit MIPStageView( unsigned int geometryType, unsigned int colorMapResolution ); + + LibCarna::presets::MIPStage& mipStage(); + + std::shared_ptr< base::ColorMapView > colorMap(); + +}; // MIPStageView + + + +// ---------------------------------------------------------------------------------- +// CuttingPlanesStageView +// ---------------------------------------------------------------------------------- + +class CuttingPlanesStageView : public LibCarna::py::base::RenderStageView +{ + +public: + + explicit CuttingPlanesStageView + ( unsigned int volumeGeometryType + , unsigned int planeGeometryType + , unsigned int colorMapResolution ); + + LibCarna::presets::CuttingPlanesStage& cuttingPlanesStage(); + + std::shared_ptr< base::ColorMapView > colorMap(); + +}; // CuttingPlanesStageView + + + +// ---------------------------------------------------------------------------------- +// DVRStageView +// ---------------------------------------------------------------------------------- + +class DVRStageView : public VolumeRenderingStageView +{ + +public: + + explicit DVRStageView( unsigned int geometryType, unsigned int colorMapResolution ); + + LibCarna::presets::DVRStage& dvrStage(); + + std::shared_ptr< base::ColorMapView > colorMap(); + +}; // DVRStageView + + + +// ---------------------------------------------------------------------------------- +// DRRStage +// ---------------------------------------------------------------------------------- + +class DRRStageView : public VolumeRenderingStageView +{ + +public: + + explicit DRRStageView( unsigned int geometryType ); + + LibCarna::presets::DRRStage& drrStage(); + +}; // DRRStageView + + + +} // namespace LibCarna :: py :: presets + +} // namespace LibCarna :: py + +} // namespace LibCarna \ No newline at end of file diff --git a/src/py/Surface.cpp b/src/py/Surface.cpp index 306e588..322b048 100644 --- a/src/py/Surface.cpp +++ b/src/py/Surface.cpp @@ -1,10 +1,10 @@ -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include -namespace Carna +namespace LibCarna { namespace py @@ -16,10 +16,10 @@ namespace py // createRenderTexture // ---------------------------------------------------------------------------------- -static base::Texture< 2 >* createRenderTexture( const base::GLContext& glContext ) +static LibCarna::base::Texture< 2 >* createRenderTexture( const LibCarna::base::GLContext& glContext ) { glContext.makeCurrent(); - return base::Framebuffer::createRenderTexture(); + return LibCarna::base::Framebuffer::createRenderTexture(); } @@ -30,25 +30,25 @@ static base::Texture< 2 >* createRenderTexture( const base::GLContext& glContext struct Surface::Details { - Details( const base::GLContext& glContext, unsigned int width, unsigned int height ); + Details( const LibCarna::base::GLContext& glContext, unsigned int width, unsigned int height ); - const base::GLContext& glContext; + const LibCarna::base::GLContext& glContext; const std::size_t frameSize; const std::unique_ptr< unsigned char[] > frame; - const std::unique_ptr< base::Texture< 2 > > renderTexture; - const std::unique_ptr< base::Framebuffer > fbo; - std::unique_ptr< base::Framebuffer::Binding > fboBinding; + const std::unique_ptr< LibCarna::base::Texture< 2 > > renderTexture; + const std::unique_ptr< LibCarna::base::Framebuffer > fbo; + std::unique_ptr< LibCarna::base::Framebuffer::Binding > fboBinding; void grabFrame(); }; -Surface::Details::Details( const base::GLContext& glContext, unsigned int width, unsigned int height ) +Surface::Details::Details( const LibCarna::base::GLContext& glContext, unsigned int width, unsigned int height ) : glContext( glContext ) , frameSize( width * height * 3 ) , frame( new unsigned char[ frameSize ] ) , renderTexture( createRenderTexture( glContext ) ) - , fbo( new base::Framebuffer( width, height, *renderTexture ) ) + , fbo( new LibCarna::base::Framebuffer( width, height, *renderTexture ) ) { } @@ -67,9 +67,9 @@ void Surface::Details::grabFrame() // Surface // ---------------------------------------------------------------------------------- -Surface::Surface( const base::GLContext& glContext, unsigned int width, unsigned int height ) - : pimpl( new Details( glContext, width, height ) ) - , glContext( glContext ) +Surface::Surface( const LibCarna::py::base::GLContextView& contextView, unsigned int width, unsigned int height ) + : pimpl( new Details( *contextView.context, width, height ) ) + , contextView( contextView.shared_from_this() ) , size( pimpl->frameSize ) { } @@ -77,7 +77,7 @@ Surface::Surface( const base::GLContext& glContext, unsigned int width, unsigned Surface::~Surface() { - glContext.makeCurrent(); + pimpl->glContext.makeCurrent(); } @@ -95,21 +95,30 @@ unsigned int Surface::height() const void Surface::begin() const { - glContext.makeCurrent(); - pimpl->fboBinding.reset( new base::Framebuffer::Binding( *pimpl->fbo ) ); + pimpl->glContext.makeCurrent(); + pimpl->fboBinding.reset( new LibCarna::base::Framebuffer::Binding( *pimpl->fbo ) ); } -const unsigned char* Surface::end() const +pybind11::array_t< unsigned char > Surface::end() const { pimpl->grabFrame(); pimpl->fboBinding.reset(); - return pimpl->frame.get(); + const unsigned char* const pixelData = pimpl->frame.get(); + + pybind11::buffer_info buf; // performs flipping + buf.itemsize = sizeof( unsigned char ); + buf.format = pybind11::format_descriptor< unsigned char >::value; + buf.ndim = 3; + buf.shape = { height(), width(), 3 }; + buf.strides = { -buf.itemsize * 3 * width(), buf.itemsize * 3, buf.itemsize }; + buf.ptr = const_cast< unsigned char* >( pixelData ) + buf.itemsize * 3 * width() * ( height() - 1 ); + return pybind11::array( buf ); } -} // namespace Carna :: py +} // namespace LibCarna :: py -} // namespace Carna +} // namespace LibCarna diff --git a/src/py/base.cpp b/src/py/base.cpp index 958b997..cf81cb2 100644 --- a/src/py/base.cpp +++ b/src/py/base.cpp @@ -1,215 +1,645 @@ +#include + #include #include +#include namespace py = pybind11; using namespace pybind11::literals; // enables the _a literal -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include "Surface.cpp" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +//#include +#include +#include +#include +#include + +using namespace LibCarna::py; +using namespace LibCarna::py::base; + -using namespace Carna::base; -using namespace Carna::py; -py::array_t< unsigned char > Surface__end( const Surface& surface ) +// ---------------------------------------------------------------------------------- +// GLContextView +// ---------------------------------------------------------------------------------- + +GLContextView::GLContextView( LibCarna::base::GLContext* context ) + : context( context ) { - const unsigned char* pixelData = surface.end(); - py::buffer_info buf; // performs flipping - buf.itemsize = sizeof( unsigned char ); - buf.format = py::format_descriptor< unsigned char >::value; - buf.ndim = 3; - buf.shape = { surface.height(), surface.width(), 3 }; - buf.strides = { -buf.itemsize * 3 * surface.width(), buf.itemsize * 3, buf.itemsize }; - buf.ptr = const_cast< unsigned char* >( pixelData ) + buf.itemsize * 3 * surface.width() * (surface.height() - 1); - return py::array( buf ); } -template< typename VectorElementType , int dimension > -Eigen::Matrix< float, dimension, 1 > normalized( const Eigen::Matrix< VectorElementType, dimension, 1 >& vector ) + +GLContextView::~GLContextView() { - const float length = std::sqrt( static_cast< float >( math::length2( vector ) ) ); - if( length > 0 ) return vector / length; - else return vector; } -math::Matrix4f math__plane4f_by_distance( const math::Vector3f& normal, float distance ) + + +// ---------------------------------------------------------------------------------- +// SpatialView +// ---------------------------------------------------------------------------------- + +SpatialView::SpatialView( LibCarna::base::Spatial* spatial ) + : ownedBy( nullptr ) + , spatial( spatial ) { - return math::plane4f( normalized( normal ), distance ); } -math::Matrix4f math__plane4f_by_support( const math::Vector3f& normal, const math::Vector3f& support ) + +SpatialView::~SpatialView() { - return math::plane4f( normalized( normal ), support ); + if( ownedBy.get() == nullptr ) + { + /* The spatial object of this view is not owned by any other spatial object, + * thus it is safe to delete the object, when the last reference dies. + */ + delete spatial; + } } -// see: https://pybind11.readthedocs.io/en/stable/advanced/misc.html#generating-documentation-using-sphinx -PYBIND11_MODULE(base, m) + +// ---------------------------------------------------------------------------------- +// NodeView +// ---------------------------------------------------------------------------------- + +NodeView::NodeView( LibCarna::base::Node* node ) + : SpatialView::SpatialView( node ) { +} - py::class_< Carna::base::GLContext >( m, "GLContext" ); - py::class_< Spatial >( m, "Spatial" ) - .def_property_readonly( "has_parent", &Spatial::hasParent ) - .def( "detach_from_parent", &Spatial::detachFromParent, py::return_value_policy::reference ) - .def_property_readonly( "parent", py::overload_cast<>( &Spatial::parent, py::const_ ) ) - .def( "find_root", py::overload_cast<>( &Spatial::findRoot, py::const_ ), py::return_value_policy::reference ) - .def_property( "movable", &Spatial::isMovable, &Spatial::setMovable ) - .def_property( "tag", &Spatial::tag, &Spatial::setTag ) - .def_readwrite( "local_transform", &Spatial::localTransform ) - .DEF_FREE( Spatial ); +NodeView::~NodeView() +{ + if( auto parentNodeView = std::dynamic_pointer_cast< NodeView >( ownedBy ) ) + { + /* The spatial object of this view is owned by another spatial object, thus the locks are propagated. + */ + parentNodeView->locks.insert( locks.begin(), locks.end() ); + } +} - py::class_< Node, Spatial >( m, "Node" ) - .def_static( "create", []( const std::string& tag ) { - return new Node( tag ); - } - , py::return_value_policy::reference, "tag"_a = "" ) - .def( "attach_child", &Node::attachChild ) - .def( "detach_child", &Node::detachChild, py::return_value_policy::reference ) - .def( "has_child", &Node::hasChild ) - .def( "delete_all_children", &Node::deleteAllChildren ) - .def( "children", &Node::children ); - py::class_< Camera, Spatial >( m, "Camera" ) - .def_static( "create", []() - { - return new Camera(); - } - , py::return_value_policy::reference ) - .def_property( "projection", &Camera::projection, &Camera::setProjection ) - .def_property( "orthogonal_projection_hint", &Camera::isOrthogonalProjectionHintSet, &Camera::setOrthogonalProjectionHint ) - .def_property_readonly( "view_transform", &Camera::viewTransform ); - - py::class_< GeometryFeature, std::unique_ptr< GeometryFeature, py::nodelete > >( m, "GeometryFeature" ) - .def( "release", &GeometryFeature::release ); - - py::class_< Material, GeometryFeature, std::unique_ptr< Material, py::nodelete > >( m, "Material" ) - .def_static( "create", []( const std::string& shaderName ) - { - return &Material::create( shaderName ); - } - , py::return_value_policy::reference, "shaderName"_a ) - .def( "set_parameter4f", &Material::setParameter< math::Vector4f > ) - .def( "set_parameter3f", &Material::setParameter< math::Vector4f > ) - .def( "set_parameter2f", &Material::setParameter< math::Vector4f > ) - .def( "clear_parameters", &Material::clearParameters ) - .def( "remove_parameter", &Material::removeParameter ) - .def( "has_parameter", &Material::hasParameter ); - - py::class_< BoundingVolume, std::unique_ptr< BoundingVolume, py::nodelete > >( m, "BoundingVolume" ); - - py::class_< Geometry, Spatial >( m, "Geometry" ) - .def_static( "create", []( const unsigned int geometryType, const std::string& tag ) - { - return new Geometry( geometryType, tag ); - } - , py::return_value_policy::reference, "geometryType"_a, "tag"_a = "" ) - .def( "put_feature", &Geometry::putFeature ) - .def( "remove_feature", py::overload_cast< GeometryFeature& >( &Geometry::removeFeature ) ) - .def( "remove_feature_role", py::overload_cast< unsigned int >( &Geometry::removeFeature ) ) - .def( "clear_features", &Geometry::clearFeatures ) - .def( "has_feature", py::overload_cast< const GeometryFeature& >( &Geometry::hasFeature, py::const_ ) ) - .def( "has_feature_role", py::overload_cast< unsigned int >( &Geometry::hasFeature, py::const_ ) ) - .def( "feature", &Geometry::feature, py::return_value_policy::reference ) - .def( "features_count", &Geometry::featuresCount ) - .def_property( "bounding_volume", py::overload_cast<>( &Geometry::boundingVolume, py::const_ ), &Geometry::setBoundingVolume ) - .def_property_readonly( "has_bounding_volume", &Geometry::hasBoundingVolume ) - .def_readonly( "geometry_type", &Geometry::geometryType ); +LibCarna::base::Node& NodeView::node() +{ + return static_cast< LibCarna::base::Node& >( *spatial ); +} - py::class_< Surface >( m, "Surface" ) - .def_static( "create", []( const GLContext& glContext, unsigned int width, unsigned int height ) - { - return new Surface( glContext, width, height ); - } - , py::return_value_policy::reference, "glContext"_a, "width"_a, "height"_a ) - .def_property_readonly( "width", &Surface::width ) - .def_property_readonly( "height", &Surface::height ) - .def_property_readonly( "gl_context", []( const Surface& self ) - { - return &self.glContext; - } - , py::return_value_policy::reference ) - .def( "begin", &Surface::begin ) - .def( "end", &Surface__end ) - .DEF_FREE( Surface ); - - py::class_< RenderStage >( m, "RenderStage" ) - .def_property( "enabled", &RenderStage::isEnabled, &RenderStage::setEnabled ) - .def_property_readonly( "renderer", py::overload_cast<>( &RenderStage::renderer, py::const_ ) ) - .DEF_FREE( RenderStage ); - - py::class_< RenderStageSequence >( m, "RenderStageSequence" ) - .def_property_readonly( "stages", &RenderStageSequence::stages ) - .def( "append_stage", &RenderStageSequence::appendStage ) - .def( "clear_stages", &RenderStageSequence::clearStages ) - .def( "stage_at", &RenderStageSequence::stageAt ); - - py::class_< FrameRenderer, RenderStageSequence >( m, "FrameRenderer" ) - .def_static( "create", []( GLContext& glContext, unsigned int width, unsigned int height, bool fitSquare ) - { - return new FrameRenderer( glContext, width, height, fitSquare ); - } - , py::return_value_policy::reference, "glContext"_a, "width"_a, "height"_a, "fitSquare"_a = false ) - .def_property_readonly( "gl_context", &FrameRenderer::glContext ) - .def_property_readonly( "width", &FrameRenderer::width ) - .def_property_readonly( "height", &FrameRenderer::height ) - .def( "set_background_color", &FrameRenderer::setBackgroundColor ) - .def( "reshape", py::overload_cast< unsigned int, unsigned int >( &FrameRenderer::reshape ) ) - .def( "set_fit_square", []( FrameRenderer* self, bool fitSquare ) - { - self->reshape( self->width(), self->height(), fitSquare ); - }, "fitSquare"_a ) - .def( "render", []( FrameRenderer* self, Camera& cam, Node* root ){ - if( root == nullptr ) self->render( cam ); - else self->render( cam, *root ); - }, "cam"_a, "root"_a = nullptr ) - .DEF_FREE( FrameRenderer ); - py::class_< BlendFunction >( m, "BlendFunction" ) - .def( py::init< int, int >() ) - .def_readonly( "source_factor", &BlendFunction::sourceFactor ) - .def_readonly( "destination_factor", &BlendFunction::destinationFactor ); +void NodeView::attachChild( SpatialView& child ) +{ + /* Verify that the child is not already attached to another parent. + */ + LIBCARNA_ASSERT_EX( !child.spatial->hasParent(), "Child already has a parent." ); - m.def( "create_box", []( float width, float height, float depth ) + /* Check for circular relations (verify that `this` is not a child of `child`). + */ + bool circular = false; + if( LibCarna::base::Node* const childNode = dynamic_cast< LibCarna::base::Node* >( child.spatial ) ) { - return static_cast< GeometryFeature* >( &MeshFactory< PNVertex >::createBox( width, height, depth ) ); + childNode->visitChildren( + true, + [ &circular, this ]( const LibCarna::base::Spatial& spatial ) + { + if( &spatial == this->spatial ) + { + circular = true; + } + } + ); } - , py::return_value_policy::reference, "width"_a, "height"_a, "depth"_a ); + LIBCARNA_ASSERT_EX( !circular, "Circular relations are forbidden." ); + + /* Update scene graph structure. + */ + child.ownedBy = this->shared_from_this(); + this->node().attachChild( child.spatial ); +} + + + +// ---------------------------------------------------------------------------------- +// CameraView +// ---------------------------------------------------------------------------------- + +LibCarna::base::Camera& CameraView::camera() +{ + return static_cast< LibCarna::base::Camera& >( *spatial ); +} + + + +// ---------------------------------------------------------------------------------- +// GeometryView +// ---------------------------------------------------------------------------------- + +LibCarna::base::Geometry& GeometryView::geometry() +{ + return static_cast< LibCarna::base::Geometry& >( *spatial ); +} + + + +// ---------------------------------------------------------------------------------- +// GeometryFeatureView +// ---------------------------------------------------------------------------------- + +GeometryFeatureView::GeometryFeatureView( LibCarna::base::GeometryFeature& geometryFeature ) + : geometryFeature( geometryFeature ) +{ +} + + +GeometryFeatureView::~GeometryFeatureView() +{ + geometryFeature.release(); +} + + + +// ---------------------------------------------------------------------------------- +// MaterialView +// ---------------------------------------------------------------------------------- + +LibCarna::base::Material& MaterialView::material() +{ + return static_cast< LibCarna::base::Material& >( geometryFeature ); +} + + + +// ---------------------------------------------------------------------------------- +// RenderStageView +// ---------------------------------------------------------------------------------- + +RenderStageView::RenderStageView( LibCarna::base::RenderStage* renderStage ) + : ownedBy( nullptr ) + , renderStage( renderStage ) +{ +} - m.def( "create_point", []() + +RenderStageView::~RenderStageView() +{ + if( ownedBy.get() == nullptr ) { - return static_cast< GeometryFeature* >( &MeshFactory< PVertex >::createPoint() ); + /* The render stage of this view is not owned by any \a FrameRendererView, + * thus it is safe to delete the object, when the last reference dies. + */ + delete renderStage; } - , py::return_value_policy::reference ); +} + + + +// ---------------------------------------------------------------------------------- +// MeshRenderingStageView +// ---------------------------------------------------------------------------------- + +const unsigned int MeshRenderingStageView::DEFAULT_ROLE_MESH = LibCarna::base::MeshRenderingMixin::DEFAULT_ROLE_MESH; +const unsigned int MeshRenderingStageView::DEFAULT_ROLE_MATERIAL = LibCarna::base::MeshRenderingMixin::DEFAULT_ROLE_MATERIAL; + + +MeshRenderingStageView::MeshRenderingStageView( LibCarna::base::RenderStage* renderStage ) + : RenderStageView::RenderStageView( renderStage ) +{ +} + + + +// ---------------------------------------------------------------------------------- +// FrameRendererView +// ---------------------------------------------------------------------------------- + +FrameRendererView::FrameRendererView + ( GLContextView& context + , unsigned int width + , unsigned int height + , bool fitSquare) + : context( context.shared_from_this() ) + , frameRenderer( *( context.context ), width, height, fitSquare ) +{ +} + + +void FrameRendererView::appendStage( const std::shared_ptr< RenderStageView >& rsView ) +{ + /* Verify that the render stage was not already added to another frame renderer. + */ + LIBCARNA_ASSERT_EX( rsView->ownedBy.get() == nullptr, "Render stage was already added to a frame renderer." ); + + /* Add the render stage to the frame renderer (and take ownership). + */ + rsView->ownedBy = this->shared_from_this(); + frameRenderer.appendStage( rsView->renderStage ); +} + + +FrameRendererView::~FrameRendererView() +{ +} + + + +// ---------------------------------------------------------------------------------- +// ColorMapView +// ---------------------------------------------------------------------------------- + +const unsigned int ColorMapView::DEFAULT_RESOLUTION = LibCarna::base::ColorMap::DEFAULT_RESOLUTION; + + +ColorMapView::ColorMapView + ( const std::shared_ptr< RenderStageView >& ownedBy + , LibCarna::base::ColorMap& colorMap ) + + : ownedBy( ownedBy ) + , colorMap( colorMap ) +{ +} + - m.def( "create_ball", []( float radius, unsigned int degree ) + +// ---------------------------------------------------------------------------------- +// configureLog +// ---------------------------------------------------------------------------------- + +static void configureLog( bool enabled ) +{ + if( enabled ) + { + // TODO: use ::py::print to print log messages to `sys.stdout` so they can be tested + // https://pybind11.readthedocs.io/en/stable/advanced/pycpp/utilities.html#using-python-s-print-function-in-c + LibCarna::base::Log::instance().setWriter( new LibCarna::base::Log::StdWriter() ); + } + else { - return static_cast< GeometryFeature* >( &MeshFactory< PNVertex >::createBall( radius, degree ) ); + LibCarna::base::Log::instance().setWriter( new NullWriter() ); } - , py::return_value_policy::reference, "radius"_a, "degree"_a = 3 ); +} - py::module math = m.def_submodule( "math" ); - math.def( "ortho4f", &math::ortho4f ); - math.def( "frustum4f", py::overload_cast< float, float, float, float >( &math::frustum4f ) ); - math.def( "deg2rad", &math::deg2rad ); - math.def( "rotation4f", static_cast< math::Matrix4f( * )( const math::Vector3f&, float ) >( &math::rotation4f ) ); - math.def( "translation4f", static_cast< math::Matrix4f( * )( float, float, float ) >( &math::translation4f ) ); - math.def( "scaling4f", static_cast< math::Matrix4f( * )( float, float, float ) >( &math::scaling4f ) ); - math.def( "plane4f", math__plane4f_by_distance ); - math.def( "plane4f", math__plane4f_by_support ); -} +// ---------------------------------------------------------------------------------- +// PYBIND11_MODULE: base +// ---------------------------------------------------------------------------------- + +PYBIND11_MODULE( base, m ) +{ + + py::register_exception< LibCarna::base::LibCarnaException >( m, "LibCarnaException" ); + py::register_exception< LibCarna::base::AssertionFailure >( m, "AssertionFailure" ); + + m.def( "logging", + []( bool enabled ) + { + configureLog( enabled ); + }, + "enabled"_a = true + ); + + py::class_< GLContextView, std::shared_ptr< GLContextView > >( m, "GLContext" ) + .doc() = "Wraps and represents an OpenGL context."; + + py::class_< SpatialView, std::shared_ptr< SpatialView > >( m, "Spatial" ) + .def_property_readonly( "has_parent", + VIEW_DELEGATE( SpatialView, spatial->hasParent() ) + ) + .def( "detach_from_parent", + []( SpatialView& self ) + { + self.ownedBy.reset(); + self.spatial->detachFromParent(); + } + ) + .def_property( "is_movable", + VIEW_DELEGATE( SpatialView, spatial->isMovable() ), + VIEW_DELEGATE( SpatialView, spatial->setMovable( movable ), bool movable ) + ) + .def_property( "tag", + VIEW_DELEGATE( SpatialView, spatial->tag() ), + VIEW_DELEGATE( SpatialView, spatial->setTag( tag ), const std::string& tag ) + ) + .def_property( "local_transform", + VIEW_DELEGATE( SpatialView, spatial->localTransform ), + VIEW_DELEGATE( SpatialView, spatial->localTransform = localTransform, const LibCarna::base::math::Matrix4f& localTransform ) + ) + .def( "update_world_transform", + VIEW_DELEGATE( SpatialView, spatial->updateWorldTransform() ) + ) + .def_property_readonly( "world_transform", + VIEW_DELEGATE( SpatialView, spatial->worldTransform() ) + ); + + py::class_< NodeView, std::shared_ptr< NodeView >, SpatialView >( m, "Node" ) + .def( py::init< const std::string& >(), "tag"_a = "" ) + .def( "attach_child", &NodeView::attachChild ) + .def( "children", + VIEW_DELEGATE( NodeView, node().children() ) + ); + + py::class_< CameraView, std::shared_ptr< CameraView >, SpatialView >( m, "Camera" ) + .def( py::init<>() ) + .def_property( "projection", + VIEW_DELEGATE( CameraView, camera().projection() ), + VIEW_DELEGATE( CameraView, camera().setProjection( projection ), const LibCarna::base::math::Matrix4f& projection ) + ) + .def_property( "orthogonal_projection_hint", + VIEW_DELEGATE( CameraView, camera().isOrthogonalProjectionHintSet() ), + VIEW_DELEGATE( CameraView, camera().setOrthogonalProjectionHint( orthogonalProjectionHint ), bool orthogonalProjectionHint ) + ) + .def_property_readonly( "view_transform", + VIEW_DELEGATE( CameraView, camera().viewTransform() ) + ); + + py::class_< GeometryFeatureView, std::shared_ptr< GeometryFeatureView > >( m, "GeometryFeature" ); + + py::class_< GeometryView, std::shared_ptr< GeometryView >, SpatialView >( m, "Geometry" ) + .def( py::init< unsigned int, const std::string& >(), "geometry_type"_a, "tag"_a = "" ) + .def_property_readonly( "geometry_type", + VIEW_DELEGATE( GeometryView, geometry().geometryType ) + ) + .def_property_readonly( "features_count", + VIEW_DELEGATE( GeometryView, geometry().featuresCount() ) + ) + .def( "put_feature", + VIEW_DELEGATE( GeometryView, geometry().putFeature( role, feature.geometryFeature ), unsigned int role, GeometryFeatureView& feature ) + ) + .def( "remove_feature", + VIEW_DELEGATE( GeometryView, geometry().removeFeature( role ), unsigned int role ) + ) + .def( "remove_feature", + VIEW_DELEGATE( GeometryView, geometry().removeFeature( feature.geometryFeature ), GeometryFeatureView& feature ) + ) + .def( "clear_features", + VIEW_DELEGATE( GeometryView, geometry().clearFeatures() ) + ) + .def( "has_feature", + VIEW_DELEGATE( GeometryView, geometry().hasFeature( role ), unsigned int role ) + ) + .def( "has_feature", + VIEW_DELEGATE( GeometryView, geometry().hasFeature( feature.geometryFeature ), GeometryFeatureView& feature ) + ); + + py::class_< MaterialView, std::shared_ptr< MaterialView >, GeometryFeatureView >( m, "Material" ) + .def( py::init< const std::string& >(), "shader_name"_a ) + .def( "__setitem__", &MaterialView::setParameter< LibCarna::base::math::Vector4f > ) + .def( "__setitem__", &MaterialView::setParameter< LibCarna::base::math::Vector3f > ) + .def( "__setitem__", &MaterialView::setParameter< LibCarna::base::math::Vector2f > ) + .def( "__setitem__", &MaterialView::setParameter< float > ) + .def( "clear_parameters", + VIEW_DELEGATE( MaterialView, material().clearParameters() ) + ) + .def( "remove_parameter", + VIEW_DELEGATE( MaterialView, material().removeParameter( name ), const std::string& name ) + ) + .def( "has_parameter", + VIEW_DELEGATE( MaterialView, material().hasParameter( name ), const std::string& name ) + ) + .def_property( "line_width", + VIEW_DELEGATE( MaterialView, material().lineWidth() ), + VIEW_DELEGATE( MaterialView, material().setLineWidth( lineWidth ), float lineWidth ) + ); + + py::class_< Surface >( m, "Surface" ) + .def( py::init< const GLContextView&, unsigned int, unsigned int >(), "gl_context"_a, "width"_a, "height"_a ) + .def_property_readonly( "width", &Surface::width ) + .def_property_readonly( "height", &Surface::height ) + .def( "begin", &Surface::begin ) + .def( "end", &Surface::end ); + + py::class_< RenderStageView, std::shared_ptr< RenderStageView > >( m, "RenderStage" ) + .def_property( "enabled", + VIEW_DELEGATE( RenderStageView, renderStage->isEnabled() ), + VIEW_DELEGATE( RenderStageView, renderStage->setEnabled( enabled ), bool enabled ) + ) + .def_property_readonly( "renderer", + VIEW_DELEGATE( RenderStageView, ownedBy.get() ) + ); + + py::class_< MeshRenderingStageView, std::shared_ptr< MeshRenderingStageView >, RenderStageView >( m, "MeshRenderingStage" ) + .def_readonly_static( "DEFAULT_ROLE_MESH", &MeshRenderingStageView::DEFAULT_ROLE_MESH ) + .def_readonly_static( "DEFAULT_ROLE_MATERIAL", &MeshRenderingStageView::DEFAULT_ROLE_MATERIAL ); + + py::class_< FrameRendererView, std::shared_ptr< FrameRendererView > >( m, "FrameRenderer" ) + .def( py::init< GLContextView&, unsigned int, unsigned int, bool >(), + "gl_context"_a, "width"_a, "height"_a, "fit_square"_a = false + ) + .def( "append_stage", + &FrameRendererView::appendStage, + "stage"_a + ) + .def_property_readonly( "gl_context", + VIEW_DELEGATE( FrameRendererView, context.get() ) + ) + .def_property_readonly( "width", + VIEW_DELEGATE( FrameRendererView, frameRenderer.width() ) + ) + .def_property_readonly( "height", + VIEW_DELEGATE( FrameRendererView, frameRenderer.height() ) + ) + .def( "set_background_color", + VIEW_DELEGATE( FrameRendererView, frameRenderer.setBackgroundColor( color ), const LibCarna::base::Color& color ), + "color"_a + ) + .def( "reshape", + VIEW_DELEGATE( FrameRendererView, + frameRenderer.reshape( width, height ), + unsigned int width, unsigned int height + ), + "width"_a, "height"_a + ) + .def( "reshape", + VIEW_DELEGATE( FrameRendererView, + frameRenderer.reshape( width, height, fitSquare ), + unsigned int width, unsigned int height, bool fitSquare + ), + "width"_a, "height"_a, "fit_square"_a = false + ) + .def( "render", + []( FrameRendererView& self, CameraView& camera, NodeView* root ) { + if( root == nullptr ) + { + self.frameRenderer.render( camera.camera() ); + } + else + { + self.frameRenderer.render( camera.camera(), root->node() ); + } + }, + "camera"_a, "root"_a = nullptr + ); + + py::class_< MeshFactoryView >( m, "MeshFactory" ) + .def_static( "create_box", + []( float width, float height, float depth ) + { + return new GeometryFeatureView( LibCarna::base::MeshFactory< LibCarna::base::PNVertex >::createBox( width, height, depth ) ); + }, + "width"_a, "height"_a, "depth"_a + ) + .def_static( "create_ball", + []( float radius, unsigned int degree ) + { + return new GeometryFeatureView( LibCarna::base::MeshFactory< LibCarna::base::PNVertex >::createBall( radius, degree ) ); + }, + "radius"_a, "degree"_a=4 + ) + .def_static( "create_point", + []() + { + return new GeometryFeatureView( LibCarna::base::MeshFactory< LibCarna::base::PVertex >::createPoint() ); + } + ) + .def_static( "create_line_strip", + []( const std::vector< LibCarna::base::math::Vector3f >& points ) + { + return new GeometryFeatureView( LibCarna::base::MeshFactory< LibCarna::base::PVertex >::createLineStrip( points ) ); + }, + "points"_a + ); + + m.def_submodule( "math" ) + .def( "ortho", &LibCarna::base::math::ortho4f, "left"_a, "right"_a, "bottom"_a, "top"_a, "z_near"_a, "z_far"_a ) + .def( "frustum", + py::overload_cast< float, float, float, float, float, float >( &LibCarna::base::math::frustum4f ), + "left"_a, "right"_a, "bottom"_a, "top"_a, "z_near"_a, "z_far"_a + ) + .def( "frustum", + py::overload_cast< float, float, float, float >( &LibCarna::base::math::frustum4f ), + "fov"_a, "height_over_width"_a, "z_near"_a, "z_far"_a + ) + .def( "deg2rad", &LibCarna::base::math::deg2rad, "degrees"_a ) + .def( "rad2deg", &LibCarna::base::math::rad2deg, "radians"_a ) + .def( "rotation", &LibCarna::base::math::rotation4f< LibCarna::base::math::Vector3f >, "axis"_a, "radians"_a ) + .def( "translation", &LibCarna::base::math::translation4f< LibCarna::base::math::Vector3f >, "offset"_a ) + .def( "translation", + static_cast< LibCarna::base::math::Matrix4f( * )( float, float, float ) >( &LibCarna::base::math::translation4f ), + "tx"_a, "ty"_a, "tz"_a + ) + .def( "scaling", &LibCarna::base::math::scaling4f< float >, "factors"_a ) + .def( "scaling", + static_cast< LibCarna::base::math::Matrix4f( * )( float, float, float ) >( &LibCarna::base::math::scaling4f ), + "sx"_a, "sy"_a, "sz"_a ) + .def( "scaling", static_cast< LibCarna::base::math::Matrix4f( * )( float ) >( &LibCarna::base::math::scaling4f ), "uniform_factor"_a ) + .def( "plane", + []( const LibCarna::base::math::Vector3f& normal, float distance ) + { + return LibCarna::base::math::plane4f( normal.normalized(), distance ); + }, + "normal"_a, "distance"_a + ) + .def( "plane", + []( const LibCarna::base::math::Vector3f& normal, const LibCarna::base::math::Vector3f& support ) + { + return LibCarna::base::math::plane4f( normal.normalized(), support ); + }, + "normal"_a, "support"_a + ); + + py::class_< LibCarna::base::Color >( m, "Color" ) + .def_readonly_static( "WHITE", &LibCarna::base::Color::WHITE ) + .def_readonly_static( "WHITE_NO_ALPHA", &LibCarna::base::Color::WHITE_NO_ALPHA ) + .def_readonly_static( "BLACK", &LibCarna::base::Color::BLACK ) + .def_readonly_static( "BLACK_NO_ALPHA", &LibCarna::base::Color::BLACK_NO_ALPHA ) + .def_readonly_static( "RED", &LibCarna::base::Color::RED ) + .def_readonly_static( "RED_NO_ALPHA", &LibCarna::base::Color::RED_NO_ALPHA ) + .def_readonly_static( "GREEN", &LibCarna::base::Color::GREEN ) + .def_readonly_static( "GREEN_NO_ALPHA", &LibCarna::base::Color::GREEN_NO_ALPHA ) + .def_readonly_static( "BLUE", &LibCarna::base::Color::BLUE ) + .def_readonly_static( "BLUE_NO_ALPHA", &LibCarna::base::Color::BLUE_NO_ALPHA ) + .def( py::init< unsigned char, unsigned char, unsigned char, unsigned char >(), "r"_a, "g"_a, "b"_a, "a"_a ) + .def( py::init< const LibCarna::base::math::Vector4f& >(), "rgba"_a ) + .def( py::init<>() ) + .def_readwrite( "r", &LibCarna::base::Color::r ) + .def_readwrite( "g", &LibCarna::base::Color::g ) + .def_readwrite( "b", &LibCarna::base::Color::b ) + .def_readwrite( "a", &LibCarna::base::Color::a ) + .def( + "__eq__", + []( LibCarna::base::Color& self, LibCarna::base::Color& other ) + { + return self == other; + } + ) + .def( + "toarray", + []( LibCarna::base::Color& self ) + { + return static_cast< const LibCarna::base::math::Vector4f& >( self ); + } + ); + + py::class_< ColorMapView, std::shared_ptr< ColorMapView > >( m, "ColorMap" ) + .def_readonly_static( "DEFAULT_RESOLUTION", &ColorMapView::DEFAULT_RESOLUTION ) + .def_readonly_static( "DEFAULT_MINIMUM_INTENSITY", &LibCarna::base::ColorMap::DEFAULT_MINIMUM_INTENSITY ) + .def_readonly_static( "DEFAULT_MAXIMUM_INTENSITY", &LibCarna::base::ColorMap::DEFAULT_MAXIMUM_INTENSITY ) + .def( "clear", + VIEW_DELEGATE( ColorMapView, colorMap.clear() ) + ) + .def( "write_linear_segment", + VIEW_DELEGATE_RETURN_SELF + ( const std::shared_ptr< ColorMapView > + , get()->colorMap.writeLinearSegment( intensityFirst, intensityLast, colorFirst, colorLast ) + , float intensityFirst + , float intensityLast + , const LibCarna::base::Color& colorFirst + , const LibCarna::base::Color& colorLast ), + "intensity_first"_a, "intensity_last"_a, "color_first"_a, "color_last"_a + ) + .def( "write_linear_spline", + VIEW_DELEGATE_RETURN_SELF + ( const std::shared_ptr< ColorMapView > + , get()->colorMap.writeLinearSpline( colors ) + , const std::vector< LibCarna::base::Color >& colors ), + "colors"_a + ) + .def_property_readonly( + "color_list", + VIEW_DELEGATE( ColorMapView, colorMap.getColorList() ) + ) + .def_property( + "minimum_intensity", + VIEW_DELEGATE + ( const std::shared_ptr< ColorMapView > + , get()->colorMap.minimumIntensity() ), + VIEW_DELEGATE + ( const std::shared_ptr< ColorMapView > + , get()->colorMap.setMinimumIntensity( minimumIntensity ) + , float minimumIntensity ) + ) + .def_property( + "maximum_intensity", + VIEW_DELEGATE + ( const std::shared_ptr< ColorMapView > + , get()->colorMap.maximumIntensity() ), + VIEW_DELEGATE + ( const std::shared_ptr< ColorMapView > + , get()->colorMap.setMaximumIntensity( maximumIntensity ) + , float maximumIntensity ) + ) + .def( "set", + VIEW_DELEGATE_RETURN_SELF + ( const std::shared_ptr< ColorMapView > + , get()->colorMap = other->colorMap + , const std::shared_ptr< ColorMapView >& other ), + "other"_a + ); + +/* + py::class_< BlendFunction >( m, "BlendFunction" ) + .def( py::init< int, int >() ) + .def_readonly( "source_factor", &BlendFunction::sourceFactor ) + .def_readonly( "destination_factor", &BlendFunction::destinationFactor ); +*/ + +} \ No newline at end of file diff --git a/src/py/egl.cpp b/src/py/egl.cpp index 22a66cf..aecf840 100644 --- a/src/py/egl.cpp +++ b/src/py/egl.cpp @@ -1,3 +1,5 @@ +#include + #include #include @@ -5,17 +7,40 @@ namespace py = pybind11; using namespace pybind11::literals; // enables the _a literal -#include -#include +#include + +using namespace LibCarna::py::egl; + -using namespace Carna::egl; -PYBIND11_MODULE(egl, m) +// ---------------------------------------------------------------------------------- +// EGLContextView +// ---------------------------------------------------------------------------------- + +EGLContextView::EGLContextView() + : LibCarna::py::base::GLContextView( LibCarna::egl::EGLContext::create() ) { +} - py::class_< Context, Carna::base::GLContext >( m, "Context" ) - .def_static( "create", &Context::create, py::return_value_policy::reference ) - .DEF_FREE( Context ); +LibCarna::egl::EGLContext& EGLContextView::eglContext() const +{ + return static_cast< LibCarna::egl::EGLContext& >( *context ); } + + +// ---------------------------------------------------------------------------------- +// PYBIND11_MODULE: egl +// ---------------------------------------------------------------------------------- + +PYBIND11_MODULE( egl, m ) +{ + + py::class_< EGLContextView, std::shared_ptr< EGLContextView >, LibCarna::py::base::GLContextView >( m, "EGLContext" ) + .def( py::init<>() ) + .def_property_readonly( "vendor", VIEW_DELEGATE( EGLContextView, eglContext().vendor() ) ) + .def_property_readonly( "renderer", VIEW_DELEGATE( EGLContextView, eglContext().renderer() ) ) + .doc() = "Create a :class:`carna.base.GLContext` using EGL (useful for off-screen rendering)."; + +} \ No newline at end of file diff --git a/src/py/helpers.cpp b/src/py/helpers.cpp index 9f04f13..3307dc5 100644 --- a/src/py/helpers.cpp +++ b/src/py/helpers.cpp @@ -5,18 +5,64 @@ namespace py = pybind11; using namespace pybind11::literals; // enables the _a literal -#include -#include -#include -#include -#include -#include -#include -#include -#include //debug +#include +#include +#include +#include +#include +/* +#include +#include +#include +#include +#include +*/ -using namespace Carna::base; -using namespace Carna::helpers; +using namespace LibCarna::py; +using namespace LibCarna::py::base; +using namespace LibCarna::py::helpers; + + + +// ---------------------------------------------------------------------------------- +// addVolumeGridHelperIntensityComponent +// ---------------------------------------------------------------------------------- + +template< typename VolumeGridHelperType, typename VolumeGridHelperClass > +void addVolumeGridHelperIntensityComponent( VolumeGridHelperClass& cls ) +{ + const static auto DEFAULT_ROLE_INTENSITIES = VolumeGridHelperType::DEFAULT_ROLE_INTENSITIES; + cls.def_readonly_static( + "DEFAULT_ROLE_INTENSITIES", + &DEFAULT_ROLE_INTENSITIES + ); + cls.def_property( + "intensities_role", + &VolumeGridHelperType::intensitiesRole, + &VolumeGridHelperType::setIntensitiesRole + ); +} + + + +// ---------------------------------------------------------------------------------- +// addVolumeGridHelperNormalsComponent +// ---------------------------------------------------------------------------------- + +template< typename VolumeGridHelperType, typename VolumeGridHelperClass > +void addVolumeGridHelperNormalsComponent( VolumeGridHelperClass& cls ) +{ + const static auto DEFAULT_ROLE_NORMALS = VolumeGridHelperType::DEFAULT_ROLE_NORMALS; + cls.def_readonly_static( + "DEFAULT_ROLE_NORMALS", + &DEFAULT_ROLE_NORMALS + ); + cls.def_property( + "normals_role", + &VolumeGridHelperType::normalsRole, + &VolumeGridHelperType::setNormalsRole + ); +} @@ -24,46 +70,233 @@ using namespace Carna::helpers; // defineVolumeGridHelper // ---------------------------------------------------------------------------------- -template< typename VolumeGridHelperType, typename Module > -void defineVolumeGridHelper( Module& m, const char* name ) +const static auto VolumeGridHelperBase__DEFAULT_MAX_SEGMENT_BYTESIZE = \ + ([](){ return LibCarna::helpers::VolumeGridHelperBase::DEFAULT_MAX_SEGMENT_BYTESIZE; })(); + + +template< typename VolumeGridHelperType, typename VolumeGridHelperClass > +void defineVolumeGridHelper( VolumeGridHelperClass& cls ) { - auto cl = py::class_< VolumeGridHelperType, VolumeGridHelperBase >( m, name ) - .def_static( "create", []( const math::Vector3ui& nativeResolution, std::size_t maxSegmentBytesize ) - { - return new VolumeGridHelperType( nativeResolution, maxSegmentBytesize ); - } - , py::return_value_policy::reference, "nativeResolution"_a, "maxSegmentBytesize"_a = ([](){ return VolumeGridHelperBase::DEFAULT_MAX_SEGMENT_BYTESIZE; })() ) - .def( "load_data", []( VolumeGridHelperType* self, py::array_t< double > data, bool test ) - { - const auto rawData = data.unchecked< 3 >(); - const auto voxel2intensity = [ &rawData, test ]( const math::Vector3ui voxel ) + cls + .def( + py::init< const LibCarna::base::math::Vector3ui&, std::size_t >(), + "native_resolution"_a, "max_segment_bytesize"_a = VolumeGridHelperBase__DEFAULT_MAX_SEGMENT_BYTESIZE + ) + .def( + "load_intensities", + []( VolumeGridHelperType& self, py::array_t< double > intensityData ) { - if (test) { - return 0.f; - } - else return static_cast< float >( rawData( voxel.x(), voxel.y(), voxel.z() ) ); - }; - return self->loadIntensities( voxel2intensity ); - } - , "data"_a, "test"_a = false ) - .def_property( "intensities_role", &VolumeGridHelperType::intensitiesRole, &VolumeGridHelperType::setIntensitiesRole ) - .def( "create_node", py::overload_cast< unsigned int, const VolumeGridHelperBase::Spacing& >( &VolumeGridHelperType::createNode, py::const_ ), py::return_value_policy::reference ) - .def( "create_node", py::overload_cast< unsigned int, const VolumeGridHelperBase::Dimensions& >( &VolumeGridHelperType::createNode, py::const_ ), py::return_value_policy::reference ) + const auto rawData = intensityData.unchecked< 3 >(); + return self.loadIntensities( + [ &rawData ]( const LibCarna::base::math::Vector3ui& voxel ) + { + return static_cast< float >( rawData( voxel.x(), voxel.y(), voxel.z() ) ); + } + ); + } + , "intensity_data"_a ) + .def( + "create_node", + [] + ( std::shared_ptr< VolumeGridHelperType > self + , unsigned int geometryType + , const LibCarna::helpers::VolumeGridHelperBase::Spacing& spacing ) + { + std::shared_ptr< NodeView > nodeView( new NodeView( self->createNode( geometryType, spacing ) ) ); + nodeView->locks.insert( self ); + return nodeView; + }, + "geometry_type"_a, "spacing"_a + ) + .def( + "create_node", + [] + ( std::shared_ptr< VolumeGridHelperType > self + , unsigned int geometryType + , const LibCarna::helpers::VolumeGridHelperBase::Extent& extent ) + { + std::shared_ptr< NodeView > nodeView( new NodeView( self->createNode( geometryType, extent ) ) ); + nodeView->locks.insert( self ); + return nodeView; + }, + "geometry_type"_a, "extent"_a + ) + /* .def( "release_geometry_features", &VolumeGridHelperType::releaseGeometryFeatures ) .DEF_FREE( VolumeGridHelperType ); + */ + .doc() = R"(Computes the partitioning grid of volume data and the corresponding normal map. Also creates scene + nodes that represent the volume data within a scene. + + Arguments: + native_resolution: The resolution the partitioning grid is to be prepared for. This is the resolution that + will be expected when the data is loaded. + max_segment_bytesize: Maximum memory size of a single volume segment in bytes. Determines the partitioning + of the volume into a regular grid of segments.)"; } // ---------------------------------------------------------------------------------- -// PYBIND11_MODULE: helpers +// FrameRendererHelperView // ---------------------------------------------------------------------------------- -const static auto VolumeGridHelperBase__DEFAULT_MAX_SEGMENT_BYTESIZE = ([](){ return VolumeGridHelperBase::DEFAULT_MAX_SEGMENT_BYTESIZE; })(); +FrameRendererHelperView::FrameRendererHelperView( const std::shared_ptr< LibCarna::py::base::FrameRendererView >& frameRendererView ) + : frameRendererView( frameRendererView ) +{ +} + + +void FrameRendererHelperView::add_stage( const std::shared_ptr< LibCarna::py::base::RenderStageView >& stage ) +{ + stages.push_back( stage ); +} + + +void FrameRendererHelperView::reset() +{ + stages.clear(); +} + + +void FrameRendererHelperView::commit() +{ + /* Verify that the render stages are not already added to another frame renderer. + */ + for( const std::shared_ptr< LibCarna::py::base::RenderStageView >& rsView : stages ) + { + LIBCARNA_ASSERT_EX( rsView->ownedBy.get() == nullptr, "Render stage was already added to a frame renderer." ); + } + + /* Add the render stages to the frame renderer (that also takes the ownership). + * + * Note that there might be still `RenderStageView` objects around, that reference + * the render stages that are currently inside the targeted frame renderer. Hence, + * we are not allowed to clear the frame renderer here. + */ + LibCarna::helpers::FrameRendererHelper< > frameRendererHelper( frameRendererView->frameRenderer ); + for( const std::shared_ptr< LibCarna::py::base::RenderStageView >& rsView : stages ) + { + rsView->ownedBy = frameRendererView; + frameRendererHelper << rsView->renderStage; + } + + frameRendererHelper.commit( false ); +} + + + +// ---------------------------------------------------------------------------------- +// PYBIND11_MODULE: helpers +// ---------------------------------------------------------------------------------- -PYBIND11_MODULE(helpers, m) +PYBIND11_MODULE( helpers, m ) { + py::class_< FrameRendererHelperView >( m, "FrameRendererHelper" ) + .def( py::init< const std::shared_ptr< FrameRendererView >& >() ) + .def( "add_stage", &FrameRendererHelperView::add_stage, "stage"_a ) + .def( "commit", &FrameRendererHelperView::commit ) + .def( "reset", &FrameRendererHelperView::reset ); + + /* The exposed VolumeGridHelper classes need to use a shared holder, due to their lazy data uploading behavior: + * https://kostrykin.github.io/LibCarna/html/classLibCarna_1_1base_1_1ManagedTexture3D.html#a37f03f311b2d1bd87ccb12f545d70f04 + */ + auto VolumeGridHelperBase = py::class_< + LibCarna::helpers::VolumeGridHelperBase, std::shared_ptr< LibCarna::helpers::VolumeGridHelperBase > + >( m, "VolumeGridHelperBase" ) + .def_readonly_static( "DEFAULT_MAX_SEGMENT_BYTESIZE", &VolumeGridHelperBase__DEFAULT_MAX_SEGMENT_BYTESIZE ) + .def_readonly( "native_resolution", &LibCarna::helpers::VolumeGridHelperBase::nativeResolution ); + + py::class_< LibCarna::helpers::VolumeGridHelperBase::Spacing >( VolumeGridHelperBase, "Spacing" ) + .def( py::init< const LibCarna::base::math::Vector3f& >() ) + .def_readwrite( "units", &LibCarna::helpers::VolumeGridHelperBase::Spacing::units ) + .doc() = "Specifies the spacing between two adjacent voxel centers."; + + py::class_< LibCarna::helpers::VolumeGridHelperBase::Extent >( VolumeGridHelperBase, "Extent" ) + .def( py::init< const LibCarna::base::math::Vector3f& >() ) + .def_readwrite( "units", &LibCarna::helpers::VolumeGridHelperBase::Extent::units ) + .doc() = "Specifies the spatial size of the whole dataset."; + + /* VolumeGridHelper_IntensityVolumeUInt16 + */ + auto VolumeGridHelper_IntensityVolumeUInt16 = py::class_< + LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt16 >, + std::shared_ptr< LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt16 > >, + LibCarna::helpers::VolumeGridHelperBase + >( m, "VolumeGridHelper_IntensityVolumeUInt16" ); + defineVolumeGridHelper< + LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt16 > + >( + VolumeGridHelper_IntensityVolumeUInt16 + ); + addVolumeGridHelperIntensityComponent< LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt16 > >( + VolumeGridHelper_IntensityVolumeUInt16 + ); + + /* VolumeGridHelper_IntensityVolumeUInt16_NormalMap3DInt8 + */ + auto VolumeGridHelper_IntensityVolumeUInt16_NormalMap3DInt8 = py::class_< + LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt16, LibCarna::base::NormalMap3DInt8 >, + std::shared_ptr< LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt16, LibCarna::base::NormalMap3DInt8 > >, + LibCarna::helpers::VolumeGridHelperBase + >( m, "VolumeGridHelper_IntensityVolumeUInt16_NormalMap3DInt8" ); + defineVolumeGridHelper< + LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt16, LibCarna::base::NormalMap3DInt8 > + >( + VolumeGridHelper_IntensityVolumeUInt16_NormalMap3DInt8 + ); + addVolumeGridHelperIntensityComponent< + LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt16, LibCarna::base::NormalMap3DInt8 > + >( + VolumeGridHelper_IntensityVolumeUInt16_NormalMap3DInt8 + ); + addVolumeGridHelperNormalsComponent< + LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt16, LibCarna::base::NormalMap3DInt8 > + >( + VolumeGridHelper_IntensityVolumeUInt16_NormalMap3DInt8 + ); + + /* VolumeGridHelper_IntensityVolumeUInt8 + */ + auto VolumeGridHelper_IntensityVolumeUInt8 = py::class_< + LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt8 >, + std::shared_ptr< LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt8 > >, + LibCarna::helpers::VolumeGridHelperBase + >( m, "VolumeGridHelper_IntensityVolumeUInt8" ); + defineVolumeGridHelper< + LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt8 > + >( + VolumeGridHelper_IntensityVolumeUInt8 + ); + addVolumeGridHelperIntensityComponent< LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt8 > >( + VolumeGridHelper_IntensityVolumeUInt8 + ); + + /* VolumeGridHelper_IntensityVolumeUInt8_NormalMap3DInt8 + */ + auto VolumeGridHelper_IntensityVolumeUInt8_NormalMap3DInt8 = py::class_< + LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt8, LibCarna::base::NormalMap3DInt8 >, + std::shared_ptr< LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt8, LibCarna::base::NormalMap3DInt8 > >, + LibCarna::helpers::VolumeGridHelperBase + >( m, "VolumeGridHelper_IntensityVolumeUInt8_NormalMap3DInt8" ); + defineVolumeGridHelper< + LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt8, LibCarna::base::NormalMap3DInt8 > + >( + VolumeGridHelper_IntensityVolumeUInt8_NormalMap3DInt8 + ); + addVolumeGridHelperIntensityComponent< + LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt8, LibCarna::base::NormalMap3DInt8 > + >( + VolumeGridHelper_IntensityVolumeUInt8_NormalMap3DInt8 + ); + addVolumeGridHelperNormalsComponent< + LibCarna::helpers::VolumeGridHelper< LibCarna::base::IntensityVolumeUInt8, LibCarna::base::NormalMap3DInt8 > + >( + VolumeGridHelper_IntensityVolumeUInt8_NormalMap3DInt8 + ); + + /* const static auto PointMarkerHelper__DEFAULT_POINT_SIZE = ([](){ return PointMarkerHelper::DEFAULT_POINT_SIZE; })(); py::class_< PointMarkerHelper >( m, "PointMarkerHelper" ) @@ -93,27 +326,6 @@ PYBIND11_MODULE(helpers, m) .def_readonly( "point_size", &PointMarkerHelper::pointSize ) .def_static( "reset_default_color", &PointMarkerHelper::resetDefaultColor ) .DEF_FREE( PointMarkerHelper ); + */ - py::class_< VolumeGridHelperBase >( m, "VolumeGridHelperBase" ) - .def_readonly_static( "DEFAULT_MAX_SEGMENT_BYTESIZE", &VolumeGridHelperBase__DEFAULT_MAX_SEGMENT_BYTESIZE ); - - py::class_< VolumeGridHelperBase::Spacing >( m, "Spacing" ) - .def( py::init< const math::Vector3f& >() ); - - py::class_< VolumeGridHelperBase::Dimensions >( m, "Dimensions" ) - .def( py::init< const math::Vector3f& >() ); - - defineVolumeGridHelper< VolumeGridHelper< IntensityVolumeUInt16 > >( m, "VolumeGrid_UInt16Intensity" ); - defineVolumeGridHelper< VolumeGridHelper< IntensityVolumeUInt16, NormalMap3DInt8 > >( m, "VolumeGrid_UInt16Intensity_Int8Normal" ); - - defineVolumeGridHelper< VolumeGridHelper< IntensityVolumeUInt8 > >( m, "VolumeGrid_UInt8Intensity" ); - defineVolumeGridHelper< VolumeGridHelper< IntensityVolumeUInt8, NormalMap3DInt8 > >( m, "VolumeGrid_UInt8Intensity_Int8Normal" ); - - py::class_< FrameRendererHelper< > >( m, "FrameRendererHelper" ) - .def( py::init< RenderStageSequence& >() ) - .def( "add_stage", &FrameRendererHelper< >::operator<< ) - .def( "reset", &FrameRendererHelper< >::reset ) - .def( "commit", &FrameRendererHelper< >::commit, "clear"_a = true ); - -} - +} \ No newline at end of file diff --git a/src/py/log.cpp b/src/py/log.cpp new file mode 100644 index 0000000..82c8e58 --- /dev/null +++ b/src/py/log.cpp @@ -0,0 +1,13 @@ +#include + +using namespace LibCarna::py; + + + +// ---------------------------------------------------------------------------------- +// NullWriter +// ---------------------------------------------------------------------------------- + +void NullWriter::writeLine( LibCarna::base::Log::Severity, const std::string& ) const +{ +} \ No newline at end of file diff --git a/src/py/presets.cpp b/src/py/presets.cpp index df14f42..33d1e25 100644 --- a/src/py/presets.cpp +++ b/src/py/presets.cpp @@ -5,42 +5,363 @@ namespace py = pybind11; using namespace pybind11::literals; // enables the _a literal -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include +#include +#include +/* +#include +#include +#include +#include +*/ -using namespace Carna::base; -using namespace Carna::presets; +using namespace LibCarna::py; +using namespace LibCarna::py::base; +using namespace LibCarna::py::presets; -void CuttingPlanesStage__set_windowing( CuttingPlanesStage* self, float min, float max ) + + +// ---------------------------------------------------------------------------------- +// OpaqueRenderingStageView +// ---------------------------------------------------------------------------------- + +OpaqueRenderingStageView::OpaqueRenderingStageView( unsigned int geometryType ) + : MeshRenderingStageView::MeshRenderingStageView( new LibCarna::presets::OpaqueRenderingStage( geometryType ) ) { - const auto level = (min + max) / 2; - const auto width = max - min; - self->setWindowingLevel( level ); - self->setWindowingWidth( width ); } -PYBIND11_MODULE(presets, m) + +LibCarna::presets::OpaqueRenderingStage& OpaqueRenderingStageView::opaqueRenderingStage() { + return static_cast< LibCarna::presets::OpaqueRenderingStage& >( *renderStage ); +} - py::class_< OpaqueRenderingStage, RenderStage >( m, "OpaqueRenderingStage" ) - .def_static( "create", []( unsigned int geometryType ) - { - return new OpaqueRenderingStage( geometryType ); - } - , py::return_value_policy::reference, "geometryType"_a ) - .def_property_readonly_static( "ROLE_DEFAULT_MATERIAL", []( py::object ) { return OpaqueRenderingStage::ROLE_DEFAULT_MATERIAL; } ) - .def_property_readonly_static( "ROLE_DEFAULT_MESH", []( py::object ) { return OpaqueRenderingStage::ROLE_DEFAULT_MESH; } ); + +// ---------------------------------------------------------------------------------- +// VolumeRenderingStageView +// ---------------------------------------------------------------------------------- + +const unsigned int VolumeRenderingStageView::DEFAULT_SAMPLE_RATE = LibCarna::presets::VolumeRenderingStage::DEFAULT_SAMPLE_RATE; + + +VolumeRenderingStageView::VolumeRenderingStageView( LibCarna::presets::VolumeRenderingStage* renderStage ) + : RenderStageView::RenderStageView( renderStage ) +{ +} + + +LibCarna::presets::VolumeRenderingStage& VolumeRenderingStageView::volumeRenderingStage() +{ + return static_cast< LibCarna::presets::VolumeRenderingStage& >( *renderStage ); +} + + + +// ---------------------------------------------------------------------------------- +// MaskRenderingStageView +// ---------------------------------------------------------------------------------- + +MaskRenderingStageView::MaskRenderingStageView( unsigned int geometryType, unsigned int maskRole ) + : VolumeRenderingStageView::VolumeRenderingStageView( + new LibCarna::presets::MaskRenderingStage( geometryType, maskRole ) + ) +{ +} + + +LibCarna::presets::MaskRenderingStage& MaskRenderingStageView::maskRenderingStage() +{ + return static_cast< LibCarna::presets::MaskRenderingStage& >( *renderStage ); +} + + + +// ---------------------------------------------------------------------------------- +// MIPStageView +// ---------------------------------------------------------------------------------- + +const static auto MIP_STAGE__ROLE_INTENSITIES = LibCarna::presets::MIPStage::ROLE_INTENSITIES; + + +MIPStageView::MIPStageView( unsigned int geometryType, unsigned int colorMapResolution ) + : VolumeRenderingStageView::VolumeRenderingStageView( + new LibCarna::presets::MIPStage( geometryType, colorMapResolution ) + ) +{ +} + + +LibCarna::presets::MIPStage& MIPStageView::mipStage() +{ + return static_cast< LibCarna::presets::MIPStage& >( *renderStage ); +} + +std::shared_ptr< base::ColorMapView > MIPStageView::colorMap() +{ + return std::shared_ptr< base::ColorMapView >( + new base::ColorMapView( this->shared_from_this(), mipStage().colorMap ) + ); +} + + + +// ---------------------------------------------------------------------------------- +// CuttingPlanesStageView +// ---------------------------------------------------------------------------------- + +const static auto CUTTING_PLANES_STAGE__ROLE_INTENSITIES = LibCarna::presets::CuttingPlanesStage::ROLE_INTENSITIES; + + +CuttingPlanesStageView::CuttingPlanesStageView + ( unsigned int volumeGeometryType + , unsigned int planeGeometryType + , unsigned int colorMapResolution ) + + : RenderStageView::RenderStageView( + new LibCarna::presets::CuttingPlanesStage( volumeGeometryType, planeGeometryType, colorMapResolution ) + ) +{ +} + + +LibCarna::presets::CuttingPlanesStage& CuttingPlanesStageView::cuttingPlanesStage() +{ + return static_cast< LibCarna::presets::CuttingPlanesStage& >( *renderStage ); +} + +std::shared_ptr< base::ColorMapView > CuttingPlanesStageView::colorMap() +{ + return std::shared_ptr< base::ColorMapView >( + new base::ColorMapView( this->shared_from_this(), cuttingPlanesStage().colorMap ) + ); +} + + + +// ---------------------------------------------------------------------------------- +// DVRStageView +// ---------------------------------------------------------------------------------- + +const static auto DVR_STAGE__ROLE_INTENSITIES = LibCarna::presets::DVRStage::ROLE_INTENSITIES; +const static auto DVR_STAGE__ROLE_NORMALS = LibCarna::presets::DVRStage::ROLE_NORMALS; + + +DVRStageView::DVRStageView( unsigned int geometryType, unsigned int colorMapResolution ) + : VolumeRenderingStageView::VolumeRenderingStageView( + new LibCarna::presets::DVRStage( geometryType, colorMapResolution ) + ) +{ +} + + +LibCarna::presets::DVRStage& DVRStageView::dvrStage() +{ + return static_cast< LibCarna::presets::DVRStage& >( *renderStage ); +} + +std::shared_ptr< base::ColorMapView > DVRStageView::colorMap() +{ + return std::shared_ptr< base::ColorMapView >( + new base::ColorMapView( this->shared_from_this(), dvrStage().colorMap ) + ); +} + + + +// ---------------------------------------------------------------------------------- +// DRRStageView +// ---------------------------------------------------------------------------------- + +const static auto DRR_STAGE__ROLE_INTENSITIES = LibCarna::presets::DRRStage::ROLE_INTENSITIES; + + +DRRStageView::DRRStageView( unsigned int geometryType ) + : VolumeRenderingStageView::VolumeRenderingStageView( + new LibCarna::presets::DRRStage( geometryType ) + ) +{ +} + + +LibCarna::presets::DRRStage& DRRStageView::drrStage() +{ + return static_cast< LibCarna::presets::DRRStage& >( *renderStage ); +} + + + +// ---------------------------------------------------------------------------------- +// PYBIND11_MODULE: presets +// ---------------------------------------------------------------------------------- + +PYBIND11_MODULE( presets, m ) +{ + + /* OpaqueRenderingStage + */ + py::class_< OpaqueRenderingStageView, std::shared_ptr< OpaqueRenderingStageView >, MeshRenderingStageView >( + m, "OpaqueRenderingStage" + ) + .def( py::init< unsigned int >(), "geometry_type"_a ) + .def_property_readonly( "geometry_type", + VIEW_DELEGATE( OpaqueRenderingStageView, opaqueRenderingStage().LibCarna::base::MeshRenderingMixin::geometryType ) + ); + + /* VolumeRenderingStage + */ + py::class_< VolumeRenderingStageView, std::shared_ptr< VolumeRenderingStageView >, RenderStageView >( + m, "VolumeRenderingStage" + ) + .def_readonly_static( "DEFAULT_SAMPLE_RATE", &VolumeRenderingStageView::DEFAULT_SAMPLE_RATE ) + .def_property_readonly( "geometry_type", + VIEW_DELEGATE( VolumeRenderingStageView, volumeRenderingStage().geometryType ) + ) + .def_property( "sample_rate", + VIEW_DELEGATE( VolumeRenderingStageView, volumeRenderingStage().sampleRate() ), + VIEW_DELEGATE( VolumeRenderingStageView, volumeRenderingStage().setSampleRate( sampleRate ), unsigned int sampleRate ) + ); + + /* MaskRenderingStage + * + * `color` is not bound as a property, to prevent assignments of the form `.color.r = 0`, which would not work. + */ + py::class_< MaskRenderingStageView, std::shared_ptr< MaskRenderingStageView >, VolumeRenderingStageView >( + m, "MaskRenderingStage" + ) + .def_readonly_static( "DEFAULT_ROLE_MASK", &LibCarna::presets::MaskRenderingStage::DEFAULT_ROLE_MASK ) + .def_readonly_static( "DEFAULT_COLOR", &LibCarna::presets::MaskRenderingStage::DEFAULT_COLOR ) + .def_readonly_static( "DEFAULT_FILLING", &LibCarna::presets::MaskRenderingStage::DEFAULT_FILLING ) + .def( + py::init< unsigned int, unsigned int >(), + "geometry_type"_a, "mask_role"_a = LibCarna::presets::MaskRenderingStage::DEFAULT_ROLE_MASK + ) + .def_property_readonly( + "mask_role", + VIEW_DELEGATE( MaskRenderingStageView, maskRenderingStage().maskRole ) + ) + .def_property( // TODO: This shouldn't be a property, see comment above. + "color", + VIEW_DELEGATE( MaskRenderingStageView, maskRenderingStage().color() ), + VIEW_DELEGATE( MaskRenderingStageView, maskRenderingStage().setColor( color ), const LibCarna::base::Color& color ) + ) + .def_property( + "filling", + VIEW_DELEGATE( MaskRenderingStageView, maskRenderingStage().isFilling() ), + VIEW_DELEGATE( MaskRenderingStageView, maskRenderingStage().setFilling( filling ), bool filling ) + ); + + /* MIPStage + */ + py::class_< MIPStageView, std::shared_ptr< MIPStageView >, VolumeRenderingStageView >( m, "MIPStage" ) + .def_readonly_static( "ROLE_INTENSITIES", &MIP_STAGE__ROLE_INTENSITIES ) + .def( + py::init< unsigned int, unsigned int >(), + "geometry_type"_a, "color_map_resolution"_a = ColorMapView::DEFAULT_RESOLUTION + ) + .def_property_readonly( "color_map", &MIPStageView::colorMap ); + + /* CuttingPlanesStage + */ + py::class_< CuttingPlanesStageView, std::shared_ptr< CuttingPlanesStageView >, RenderStageView >( m, "CuttingPlanesStage" ) + .def_readonly_static( "ROLE_INTENSITIES", &CUTTING_PLANES_STAGE__ROLE_INTENSITIES ) + .def_readonly_static( "DEFAULT_WINDOWING_WIDTH", &LibCarna::presets::CuttingPlanesStage::DEFAULT_WINDOWING_WIDTH ) + .def_readonly_static( "DEFAULT_WINDOWING_LEVEL", &LibCarna::presets::CuttingPlanesStage::DEFAULT_WINDOWING_LEVEL ) + .def( + py::init< unsigned int, unsigned int, unsigned int >(), + "volume_geometry_type"_a, + "plane_geometry_type"_a, + "color_map_resolution"_a = ColorMapView::DEFAULT_RESOLUTION + ) + .def_property_readonly( "volume_geometry_type", + VIEW_DELEGATE( CuttingPlanesStageView, cuttingPlanesStage().volumeGeometryType ) + ) + .def_property_readonly( "plane_geometry_type", + VIEW_DELEGATE( CuttingPlanesStageView, cuttingPlanesStage().planeGeometryType ) + ) + .def_property( + "windowing_width", + VIEW_DELEGATE( CuttingPlanesStageView, cuttingPlanesStage().windowingWidth() ), + VIEW_DELEGATE( CuttingPlanesStageView, cuttingPlanesStage().setWindowingWidth( windowingWidth ), float windowingWidth ) + ) + .def_property( + "windowing_level", + VIEW_DELEGATE( CuttingPlanesStageView, cuttingPlanesStage().windowingLevel() ), + VIEW_DELEGATE( CuttingPlanesStageView, cuttingPlanesStage().setWindowingLevel( windowingLevel ), float windowingLevel ) + ) + .def_property_readonly( "color_map", &CuttingPlanesStageView::colorMap ); + + /* DVRStage + */ + py::class_< DVRStageView, std::shared_ptr< DVRStageView >, VolumeRenderingStageView >( m, "DVRStage" ) + .def_readonly_static( "ROLE_INTENSITIES", &DVR_STAGE__ROLE_INTENSITIES ) + .def_readonly_static( "ROLE_NORMALS", &DVR_STAGE__ROLE_NORMALS ) + .def_readonly_static( "DEFAULT_TRANSLUCENCY", &LibCarna::presets::DVRStage::DEFAULT_TRANSLUCENCY ) + .def_readonly_static( "DEFAULT_DIFFUSE_LIGHT", &LibCarna::presets::DVRStage::DEFAULT_DIFFUSE_LIGHT ) + .def( + py::init< unsigned int, unsigned int >(), + "geometry_type"_a, "color_map_resolution"_a = ColorMapView::DEFAULT_RESOLUTION + ) + .def_property_readonly( "color_map", &DVRStageView::colorMap ) + .def_property( + "translucency", + VIEW_DELEGATE( DVRStageView, dvrStage().translucency() ), + VIEW_DELEGATE( DVRStageView, dvrStage().setTranslucency( translucency ), float translucency ) + ) + .def_property( + "diffuse_light", + VIEW_DELEGATE( DVRStageView, dvrStage().diffuseLight() ), + VIEW_DELEGATE( DVRStageView, dvrStage().setDiffuseLight( diffuseLight ), float diffuseLight ) + ); + + /* DRRStage + */ + py::class_< DRRStageView, std::shared_ptr< DRRStageView >, VolumeRenderingStageView >( m, "DRRStage" ) + .def_readonly_static( "ROLE_INTENSITIES", &DVR_STAGE__ROLE_INTENSITIES ) + .def_readonly_static( "DEFAULT_WATER_ATTENUATION", &LibCarna::presets::DRRStage::DEFAULT_WATER_ATTENUATION ) + .def_readonly_static( "DEFAULT_BASE_INTENSITY", &LibCarna::presets::DRRStage::DEFAULT_BASE_INTENSITY ) + .def_readonly_static( "DEFAULT_LOWER_THRESHOLD", &LibCarna::presets::DRRStage::DEFAULT_LOWER_THRESHOLD.value ) + .def_readonly_static( "DEFAULT_UPPER_THRESHOLD", &LibCarna::presets::DRRStage::DEFAULT_UPPER_THRESHOLD.value ) + .def_readonly_static( "DEFAULT_UPPER_MULTIPLIER", &LibCarna::presets::DRRStage::DEFAULT_UPPER_MULTIPLIER ) + .def_readonly_static( "DEFAULT_RENDER_INVERSE", &LibCarna::presets::DRRStage::DEFAULT_RENDER_INVERSE ) + .def( py::init< unsigned int >(), "geometry_type"_a ) + .def_property( + "water_attenuation", + VIEW_DELEGATE( DRRStageView, drrStage().waterAttenuation() ), + VIEW_DELEGATE( DRRStageView, drrStage().setWaterAttenuation( waterAttenuation ), float waterAttenuation ) + ) + .def_property( + "base_intensity", + VIEW_DELEGATE( DRRStageView, drrStage().baseIntensity() ), + VIEW_DELEGATE( DRRStageView, drrStage().setBaseIntensity( baseIntensity ), float baseIntensity ) + ) + .def_property( + "lower_threshold", + VIEW_DELEGATE( DRRStageView, drrStage().lowerThreshold().value ), + VIEW_DELEGATE( DRRStageView, drrStage().setLowerThreshold( LibCarna::base::HUV( lowerThreshold ) ), short lowerThreshold ) + ) + .def_property( + "upper_threshold", + VIEW_DELEGATE( DRRStageView, drrStage().upperThreshold().value ), + VIEW_DELEGATE( DRRStageView, drrStage().setUpperThreshold( LibCarna::base::HUV(upperThreshold ) ), short upperThreshold ) + ) + .def_property( + "upper_multiplier", + VIEW_DELEGATE( DRRStageView, drrStage().upperMultiplier() ), + VIEW_DELEGATE( DRRStageView, drrStage().setUpperMultiplier( upperMultiplier ), float upperMultiplier ) + ) + .def_property( + "render_inverse", + VIEW_DELEGATE( DRRStageView, drrStage().isRenderingInverse() ), + VIEW_DELEGATE( DRRStageView, drrStage().setRenderingInverse( renderInverse ), bool renderInverse ) + ); + +/* py::class_< OccludedRenderingStage, RenderStage >( m, "OccludedRenderingStage" ) .def_static( "create", []() { @@ -53,93 +374,6 @@ PYBIND11_MODULE(presets, m) .def( "enable_stage", &OccludedRenderingStage::enableStage ) .def( "disable_stage", &OccludedRenderingStage::disableStage ) .def( "is_stage_enabled", &OccludedRenderingStage::isStageEnabled ); +*/ - py::class_< VolumeRenderingStage, RenderStage >( m, "VolumeRenderingStage" ) - .def_property( "sample_rate", &VolumeRenderingStage::sampleRate, &VolumeRenderingStage::setSampleRate ); - - const static auto MIPLayer__LAYER_FUNCTION_ADD = ([](){ return MIPLayer::LAYER_FUNCTION_ADD; })(); - const static auto MIPLayer__LAYER_FUNCTION_REPLACE = ([](){ return MIPLayer::LAYER_FUNCTION_REPLACE; })(); - - py::class_< MIPLayer >( m, "MIPLayer" ) - .def_static( "create", []( float min, float max, const math::Vector4f& color, const BlendFunction& function ) - { - return new MIPLayer( min, max, color, function ); - } - , py::return_value_policy::reference, "min"_a, "max"_a, "color"_a, "function"_a = MIPLayer__LAYER_FUNCTION_REPLACE ) - .def_readonly_static( "LAYER_FUNCTION_ADD", &MIPLayer__LAYER_FUNCTION_ADD ) - .def_readonly_static( "LAYER_FUNCTION_REPLACE", &MIPLayer__LAYER_FUNCTION_REPLACE ) - .DEF_FREE( MIPLayer ); - - py::class_< MIPStage, VolumeRenderingStage >( m, "MIPStage" ) - .def_static( "create", []( unsigned int geometryType ) - { - return new MIPStage( geometryType ); - } - , py::return_value_policy::reference, "geometryType"_a ) - .def_property_readonly_static( "ROLE_INTENSITIES", []( py::object ) { return MIPStage::ROLE_INTENSITIES; } ) - .def( "ascend_layer", &MIPStage::ascendLayer ) - .def( "append_layer", &MIPStage::appendLayer ) - .def( "remove_layer", &MIPStage::removeLayer ) - .def_property_readonly( "layers_count", &MIPStage::layersCount ) - .def( "layer", py::overload_cast< std::size_t >( &MIPStage::layer, py::const_ ) ) - .def( "clear_layers", &MIPStage::clearLayers ); - - py::class_< CuttingPlanesStage, RenderStage >( m, "CuttingPlanesStage" ) - .def_static( "create", []( unsigned int volumeGeometryType, unsigned int planeGeometryType ) - { - const auto cps = new CuttingPlanesStage( volumeGeometryType, planeGeometryType ); - CuttingPlanesStage__set_windowing( cps, 0.f, 1.f ); - return cps; - } - , py::return_value_policy::reference, "volumeGeometryType"_a, "planeGeometryType"_a ) - .def_property_readonly_static( "ROLE_INTENSITIES", []( py::object ) { return CuttingPlanesStage::ROLE_INTENSITIES; } ) - .def_property_readonly( "min_intensity", &CuttingPlanesStage::minimumIntensity ) - .def_property_readonly( "max_intensity", &CuttingPlanesStage::maximumIntensity ) - .def( "set_windowing", &CuttingPlanesStage__set_windowing ) - .def_property( "rendering_inverse", &CuttingPlanesStage::isRenderingInverse, &CuttingPlanesStage::setRenderingInverse ); - - py::class_< DVRStage, VolumeRenderingStage >( m, "DVRStage" ) - .def_static( "create", []( unsigned int geometryType ) - { - return new DVRStage( geometryType ); - } - , py::return_value_policy::reference, "geometryType"_a ) - .def_property_readonly_static( "DEFAULT_TRANSLUCENCY", []( py::object ) { return DVRStage::DEFAULT_TRANSLUCENCE; } ) - .def_property_readonly_static( "DEFAULT_DIFFUSE_LIGHT", []( py::object ) { return DVRStage::DEFAULT_DIFFUSE_LIGHT; } ) - .def_property_readonly_static( "ROLE_INTENSITIES", []( py::object ) { return DVRStage::ROLE_INTENSITIES; } ) - .def_property_readonly_static( "ROLE_NORMALS", []( py::object ) { return DVRStage::ROLE_NORMALS; } ) - .def_property( "translucency", &DVRStage::translucence, &DVRStage::setTranslucence ) - .def_property( "diffuse_light", &DVRStage::diffuseLight, &DVRStage::setDiffuseLight ) - .def( "clear_color_map", &DVRStage::clearColorMap ) - .def( "write_color_map", []( DVRStage* self, float min, float max, const math::Vector4f& color1, const math::Vector4f& color2 ) - { - self->writeColorMap( min, max, color1, color2 ); - } - , "min"_a, "max"_a, "color1"_a, "color2"_a ); - - py::class_< MaskRenderingStage, VolumeRenderingStage >( m, "MaskRenderingStage" ) - .def_static( "create", []( unsigned int geometryType, unsigned int maskRole ) - { - MaskRenderingStage* const mr = new MaskRenderingStage( geometryType, maskRole ); - mr->setRenderBorders( true ); - return mr; - } - , py::return_value_policy::reference, "geometryType"_a, "maskRole"_a = MaskRenderingStage::DEFAULT_ROLE_MASK ) - .def_readonly( "mask_role", &MaskRenderingStage::maskRole ) - .def_property_readonly_static( "DEFAULT_COLOR", []( py::object ) { return MaskRenderingStage::DEFAULT_COLOR; } ) - .def_property_readonly_static( "DEFAULT_ROLE_MASK", []( py::object ) { return MaskRenderingStage::DEFAULT_ROLE_MASK; } ) - .def_property - ( "color" - , []( MaskRenderingStage* self ) -> math::Vector4f - { - return self->color(); - } - , []( MaskRenderingStage* self, const math::Vector4f& color ) - { - self->setColor( color ); - } - ) - .def_property( "render_borders", &MaskRenderingStage::renderBorders, &MaskRenderingStage::setRenderBorders ); - -} - +} \ No newline at end of file diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index d453ff7..03900f9 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -1,31 +1,43 @@ -cmake_minimum_required(VERSION 2.8.7) +cmake_minimum_required( VERSION 3.5 ) ############################################ # Run the tests ############################################ -set(TEST_FILES +set( TEST_FILES test_base - test_presets + test_cutting_planes + test_data + test_drr + test_dvr + test_egl test_helpers - test_py - test_py_demo1 - test_py_demo2 - test_py_demo3 - test_py_demo4 - test_py_demo5 + test_integration + test_mask_renderer + test_material + test_mip + test_opaque_renderer + test_presets + test_spatial ) -configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/test_tools.py - ${CMAKE_CURRENT_BINARY_DIR}/../test_tools.py @ONLY) +configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/testsuite.py + ${CMAKE_CURRENT_BINARY_DIR}/../testsuite.py COPYONLY ) + +execute_process( + COMMAND ${CMAKE_COMMAND} -E copy_directory + ${CMAKE_CURRENT_SOURCE_DIR}/results + ${CMAKE_CURRENT_BINARY_DIR}/../test/results ) foreach( TEST_FILE ${TEST_FILES} ) - configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/${TEST_FILE}.py - ${CMAKE_CURRENT_BINARY_DIR}/../${TEST_FILE}.py COPYONLY) + configure_file( + ${CMAKE_CURRENT_SOURCE_DIR}/${TEST_FILE}.py + ${CMAKE_CURRENT_BINARY_DIR}/../${TEST_FILE}.py COPYONLY ) add_custom_target( ${TEST_FILE} - COMMAND ${PYTHON_EXECUTABLE} -Xfaulthandler -c "import ${TEST_FILE}" + COMMAND ${PYTHON_EXECUTABLE} -Xfaulthandler -m unittest ${TEST_FILE} WORKING_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/.." DEPENDS ${MODULES} COMMENT "Running ${TEST_FILE}..." @@ -36,4 +48,4 @@ add_custom_target( RUN_TESTSUITE DEPENDS ${TEST_FILES} COMMENT "Running test suite..." -) +) \ No newline at end of file diff --git a/test/__init__.py b/test/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/test/renderings/helpers.FrameRendererHelper.uint16.png b/test/renderings/helpers.FrameRendererHelper.uint16.png deleted file mode 100644 index cee8b27..0000000 Binary files a/test/renderings/helpers.FrameRendererHelper.uint16.png and /dev/null differ diff --git a/test/renderings/helpers.FrameRendererHelper.uint8.png b/test/renderings/helpers.FrameRendererHelper.uint8.png deleted file mode 100644 index f536218..0000000 Binary files a/test/renderings/helpers.FrameRendererHelper.uint8.png and /dev/null differ diff --git a/test/renderings/presets.CuttingPlanesStage.png b/test/renderings/presets.CuttingPlanesStage.png deleted file mode 100644 index 70a1053..0000000 Binary files a/test/renderings/presets.CuttingPlanesStage.png and /dev/null differ diff --git a/test/renderings/presets.DVRStage.png b/test/renderings/presets.DVRStage.png deleted file mode 100644 index ef2fbfb..0000000 Binary files a/test/renderings/presets.DVRStage.png and /dev/null differ diff --git a/test/renderings/presets.MIPStage.png b/test/renderings/presets.MIPStage.png deleted file mode 100644 index 19e3104..0000000 Binary files a/test/renderings/presets.MIPStage.png and /dev/null differ diff --git a/test/renderings/presets.MaskRenderingStage.png b/test/renderings/presets.MaskRenderingStage.png deleted file mode 100644 index bd9c447..0000000 Binary files a/test/renderings/presets.MaskRenderingStage.png and /dev/null differ diff --git a/test/renderings/presets.MaskRenderingStage.render_borders.png b/test/renderings/presets.MaskRenderingStage.render_borders.png deleted file mode 100644 index e066410..0000000 Binary files a/test/renderings/presets.MaskRenderingStage.render_borders.png and /dev/null differ diff --git a/test/renderings/presets.OpaqueRenderingStage.png b/test/renderings/presets.OpaqueRenderingStage.png deleted file mode 100644 index 495e093..0000000 Binary files a/test/renderings/presets.OpaqueRenderingStage.png and /dev/null differ diff --git a/test/renderings/py.demo1.png b/test/renderings/py.demo1.png deleted file mode 100644 index 9b0a61a..0000000 Binary files a/test/renderings/py.demo1.png and /dev/null differ diff --git a/test/renderings/py.demo2.png b/test/renderings/py.demo2.png deleted file mode 100644 index a1ef8a5..0000000 Binary files a/test/renderings/py.demo2.png and /dev/null differ diff --git a/test/renderings/py.demo3.borders-in-background.png b/test/renderings/py.demo3.borders-in-background.png deleted file mode 100644 index ba86190..0000000 Binary files a/test/renderings/py.demo3.borders-in-background.png and /dev/null differ diff --git a/test/renderings/py.demo3.borders-on-top.png b/test/renderings/py.demo3.borders-on-top.png deleted file mode 100644 index e008fc4..0000000 Binary files a/test/renderings/py.demo3.borders-on-top.png and /dev/null differ diff --git a/test/renderings/py.demo3.regions-on-top.png b/test/renderings/py.demo3.regions-on-top.png deleted file mode 100644 index a39dece..0000000 Binary files a/test/renderings/py.demo3.regions-on-top.png and /dev/null differ diff --git a/test/renderings/py.demo3.regions.png b/test/renderings/py.demo3.regions.png deleted file mode 100644 index aaab72e..0000000 Binary files a/test/renderings/py.demo3.regions.png and /dev/null differ diff --git a/test/renderings/py.demo4.normalized.ms-front.png b/test/renderings/py.demo4.normalized.ms-front.png deleted file mode 100644 index 1bcd899..0000000 Binary files a/test/renderings/py.demo4.normalized.ms-front.png and /dev/null differ diff --git a/test/renderings/py.demo4.normalized.ms-left.png b/test/renderings/py.demo4.normalized.ms-left.png deleted file mode 100644 index b31da5b..0000000 Binary files a/test/renderings/py.demo4.normalized.ms-left.png and /dev/null differ diff --git a/test/renderings/py.demo4.normalized.ms-top.png b/test/renderings/py.demo4.normalized.ms-top.png deleted file mode 100644 index cc68633..0000000 Binary files a/test/renderings/py.demo4.normalized.ms-top.png and /dev/null differ diff --git a/test/renderings/py.demo4.normalized.ss-front.png b/test/renderings/py.demo4.normalized.ss-front.png deleted file mode 100644 index 633a886..0000000 Binary files a/test/renderings/py.demo4.normalized.ss-front.png and /dev/null differ diff --git a/test/renderings/py.demo4.normalized.ss-left.png b/test/renderings/py.demo4.normalized.ss-left.png deleted file mode 100644 index d01291c..0000000 Binary files a/test/renderings/py.demo4.normalized.ss-left.png and /dev/null differ diff --git a/test/renderings/py.demo4.normalized.ss-top.png b/test/renderings/py.demo4.normalized.ss-top.png deleted file mode 100644 index e8ea320..0000000 Binary files a/test/renderings/py.demo4.normalized.ss-top.png and /dev/null differ diff --git a/test/renderings/py.demo5.png b/test/renderings/py.demo5.png deleted file mode 100644 index e256164..0000000 Binary files a/test/renderings/py.demo5.png and /dev/null differ diff --git a/test/requirements.txt b/test/requirements.txt new file mode 100644 index 0000000..444754c --- /dev/null +++ b/test/requirements.txt @@ -0,0 +1 @@ +apng==0.3.4 \ No newline at end of file diff --git a/test/results/README.md b/test/results/README.md new file mode 100644 index 0000000..2387122 --- /dev/null +++ b/test/results/README.md @@ -0,0 +1,5 @@ +This directory contains the images used for verification of test results: +- `expected`: Generic test verification images +- `expected_mesa`: Test verification images for software rendering + +If no vendor-specific test image exists in `expected_*`, the generic image from `expected` is used for verificaiton. diff --git a/test/results/expected/test_integration.CuttingPlanesStage.test.png b/test/results/expected/test_integration.CuttingPlanesStage.test.png new file mode 100644 index 0000000..cda2af8 Binary files /dev/null and b/test/results/expected/test_integration.CuttingPlanesStage.test.png differ diff --git a/test/results/expected/test_integration.CuttingPlanesStage.test__animated.png b/test/results/expected/test_integration.CuttingPlanesStage.test__animated.png new file mode 100644 index 0000000..5bb8565 Binary files /dev/null and b/test/results/expected/test_integration.CuttingPlanesStage.test__animated.png differ diff --git a/test/results/expected/test_integration.DRRStage.test.png b/test/results/expected/test_integration.DRRStage.test.png new file mode 100644 index 0000000..6dcbc49 Binary files /dev/null and b/test/results/expected/test_integration.DRRStage.test.png differ diff --git a/test/results/expected/test_integration.DRRStage.test__animated.png b/test/results/expected/test_integration.DRRStage.test__animated.png new file mode 100644 index 0000000..c84e2a3 Binary files /dev/null and b/test/results/expected/test_integration.DRRStage.test__animated.png differ diff --git a/test/results/expected/test_integration.DVRStage.test.png b/test/results/expected/test_integration.DVRStage.test.png new file mode 100644 index 0000000..30eb36a Binary files /dev/null and b/test/results/expected/test_integration.DVRStage.test.png differ diff --git a/test/results/expected/test_integration.DVRStage.test__animated.png b/test/results/expected/test_integration.DVRStage.test__animated.png new file mode 100644 index 0000000..e8fbcc7 Binary files /dev/null and b/test/results/expected/test_integration.DVRStage.test__animated.png differ diff --git a/test/results/expected/test_integration.MIPStage.test.png b/test/results/expected/test_integration.MIPStage.test.png new file mode 100644 index 0000000..cff22fb Binary files /dev/null and b/test/results/expected/test_integration.MIPStage.test.png differ diff --git a/test/results/expected/test_integration.MIPStage.test__animated.png b/test/results/expected/test_integration.MIPStage.test__animated.png new file mode 100644 index 0000000..591b149 Binary files /dev/null and b/test/results/expected/test_integration.MIPStage.test__animated.png differ diff --git a/test/results/expected/test_integration.MaskRenderingStage.test.png b/test/results/expected/test_integration.MaskRenderingStage.test.png new file mode 100644 index 0000000..c78b882 Binary files /dev/null and b/test/results/expected/test_integration.MaskRenderingStage.test.png differ diff --git a/test/results/expected/test_integration.MaskRenderingStage.test__animated.png b/test/results/expected/test_integration.MaskRenderingStage.test__animated.png new file mode 100644 index 0000000..43670fa Binary files /dev/null and b/test/results/expected/test_integration.MaskRenderingStage.test__animated.png differ diff --git a/test/results/expected/test_integration.OpaqueRenderingStage.test.png b/test/results/expected/test_integration.OpaqueRenderingStage.test.png new file mode 100644 index 0000000..afbe270 Binary files /dev/null and b/test/results/expected/test_integration.OpaqueRenderingStage.test.png differ diff --git a/test/results/expected/test_integration.OpaqueRenderingStage.test__animated.png b/test/results/expected/test_integration.OpaqueRenderingStage.test__animated.png new file mode 100644 index 0000000..b1b6a5c Binary files /dev/null and b/test/results/expected/test_integration.OpaqueRenderingStage.test__animated.png differ diff --git a/test/results/expected_mesa/test_integration.DRRStage.test.png b/test/results/expected_mesa/test_integration.DRRStage.test.png new file mode 100644 index 0000000..fbfbcdb Binary files /dev/null and b/test/results/expected_mesa/test_integration.DRRStage.test.png differ diff --git a/test/results/expected_mesa/test_integration.DRRStage.test__animated.png b/test/results/expected_mesa/test_integration.DRRStage.test__animated.png new file mode 100644 index 0000000..eb3eafe Binary files /dev/null and b/test/results/expected_mesa/test_integration.DRRStage.test__animated.png differ diff --git a/test/results/expected_mesa/test_integration.DVRStage.test.png b/test/results/expected_mesa/test_integration.DVRStage.test.png new file mode 100644 index 0000000..45a20bd Binary files /dev/null and b/test/results/expected_mesa/test_integration.DVRStage.test.png differ diff --git a/test/results/expected_mesa/test_integration.DVRStage.test__animated.png b/test/results/expected_mesa/test_integration.DVRStage.test__animated.png new file mode 100644 index 0000000..51a6b19 Binary files /dev/null and b/test/results/expected_mesa/test_integration.DVRStage.test__animated.png differ diff --git a/test/results/expected_mesa/test_integration.MaskRenderingStage.test__animated.png b/test/results/expected_mesa/test_integration.MaskRenderingStage.test__animated.png new file mode 100644 index 0000000..7619dca Binary files /dev/null and b/test/results/expected_mesa/test_integration.MaskRenderingStage.test__animated.png differ diff --git a/test/test_base.py b/test/test_base.py index fd1d30d..e06182e 100644 --- a/test/test_base.py +++ b/test/test_base.py @@ -1,65 +1,429 @@ -import carna.base as base -import carna.egl as egl import numpy as np -import faulthandler -faulthandler.enable() - -# ========================== -# Scene Graph Manipulation 1 -# ========================== - -node1 = base.Node.create() -assert node1.children() == 0 -node2 = base.Node.create() -node1.attach_child(node2) -assert node1.children() == 1 -node1.free() - -# ========================== -# Scene Graph Manipulation 2 -# ========================== - -node1 = base.Node.create("root") -assert node1.tag == "root" -node2 = base.Node.create() -assert not node2.has_parent -node1.attach_child(node2) -assert node2.has_parent -assert node2.parent is node1 -node2 = node2.detach_from_parent() -assert np.allclose(node2.local_transform, np.eye(4)) -node1.free() -node2.free() - -# ========================== -# Math -# ========================== - -assert np.allclose(base.math.scaling4f(1, 1, 1), np.eye(4)) -assert np.allclose(base.math.translation4f(0, 0, 0), np.eye(4)) -assert np.allclose(base.math.rotation4f([0, 1, 0], 0), np.eye(4)) - -# ========================== -# Basic Rendering -# ========================== - -root = base.Node.create() -cam = base.Camera.create() -cam.local_transform = base.math.rotation4f([0, 1, 0], base.math.deg2rad(20) ) @ base.math.translation4f(0, 0, 350) -cam.projection = base.math.frustum4f(base.math.deg2rad(90), 1, 10, 2000) -root.attach_child(cam) - -ctx = egl.Context.create() -surface = base.Surface.create(ctx, 100, 100) -renderer = base.FrameRenderer.create( ctx, 100, 100 ) -surface.begin() -#renderer.render(cam) -result = surface.end() -assert result.shape == (100, 100, 3) -assert result.sum() == 0 -renderer.free() -surface.free() -ctx.free() -root.free() +import libcarna.base +import testsuite + +class SpatialMixin: + + ClientSpatialType = None + client_spatial_init_kwargs = dict() + + def test__movable(self): + node1 = self.ClientSpatialType(**self.client_spatial_init_kwargs) + self.assertTrue(node1.is_movable) + node1.is_movable = False + self.assertFalse(node1.is_movable) + + def test__tag(self): + node1 = self.ClientSpatialType(**self.client_spatial_init_kwargs) + self.assertEqual(node1.tag, '') + node1.tag = 'Test' + self.assertEqual(node1.tag, 'Test') + + def test__localTransform(self): + node1 = self.ClientSpatialType(**self.client_spatial_init_kwargs) + np.testing.assert_array_almost_equal(node1.local_transform, np.eye(4)) + node1.local_transform = np.arange(16).reshape(4, 4) + np.testing.assert_array_almost_equal(node1.local_transform, np.arange(16).reshape(4, 4)) + + def test__worldTransform(self): + node1 = libcarna.base.Node() + node1.local_transform = np.eye(4) * 2 + node1.update_world_transform() + node2 = self.ClientSpatialType(**self.client_spatial_init_kwargs) + node1.attach_child(node2) + node2.local_transform = np.eye(4) / 3 + node2.update_world_transform() + np.testing.assert_array_almost_equal(node1.world_transform, np.eye(4) * 2) + np.testing.assert_array_almost_equal(node2.world_transform, np.eye(4) * 2 / 3) + + def test__detach_from_parent(self): + node1 = libcarna.base.Node() + node2 = self.ClientSpatialType(**self.client_spatial_init_kwargs) + self.assertFalse(node2.has_parent) + node1.attach_child(node2) + self.assertTrue(node2.has_parent) + node2.detach_from_parent() + self.assertFalse(node2.has_parent) + + +class Node(testsuite.LibCarnaTestCase, SpatialMixin): + + ClientSpatialType = libcarna.base.Node + + def test__tag(self): + super().test__tag() + node1 = libcarna.base.Node('Test 2') + self.assertEqual(node1.tag, 'Test 2') + + def test__attach_child(self): + node1 = libcarna.base.Node() + self.assertEqual(node1.children(), 0) + node2 = libcarna.base.Node() + node1.attach_child(node2) + self.assertEqual(node1.children(), 1) + + def test__attach_child__circular(self): + node1 = libcarna.base.Node() + node2 = libcarna.base.Node() + node1.attach_child(node2) + with self.assertRaises(libcarna.base.AssertionFailure): + node2.attach_child(node1) + + def test__attach_child__nonfree(self): + node1 = libcarna.base.Node() + node2 = libcarna.base.Node() + node3 = libcarna.base.Node() + node1.attach_child(node2) + with self.assertRaises(libcarna.base.AssertionFailure): + node3.attach_child(node2) + + +class Camera(testsuite.LibCarnaTestCase, SpatialMixin): + + ClientSpatialType = libcarna.base.Camera + + def test__projection(self): + camera = libcarna.base.Camera() + camera.projection = np.arange(16).reshape(4, 4) + np.testing.assert_array_almost_equal(camera.projection, np.arange(16).reshape(4, 4)) + + def test__orthogonal_projection_hint(self): + camera = libcarna.base.Camera() + self.assertFalse(camera.orthogonal_projection_hint) + camera.orthogonal_projection_hint = True + self.assertTrue(camera.orthogonal_projection_hint) + + def test__view_transform(self): + camera = libcarna.base.Camera() + camera.update_world_transform() + np.testing.assert_array_almost_equal(camera.view_transform, np.eye(4)) + camera.local_transform = 2 * np.eye(4) + camera.update_world_transform() + np.testing.assert_array_almost_equal(camera.view_transform, 0.5 * np.eye(4)) + + +class Geometry(testsuite.LibCarnaTestCase, SpatialMixin): + + ClientSpatialType = libcarna.base.Geometry + client_spatial_init_kwargs = dict( + geometry_type=0, + ) + + def test__geometry_type(self): + geoemtry1 = libcarna.base.Geometry(geometry_type=0) + geoemtry2 = libcarna.base.Geometry(geometry_type=1) + self.assertEqual(geoemtry1.geometry_type, 0) + self.assertEqual(geoemtry2.geometry_type, 1) + + def test__features_count(self): + geoemtry1 = libcarna.base.Geometry(geometry_type=0) + self.assertEqual(geoemtry1.features_count, 0) + + def test__put_feature(self): + geoemtry1 = libcarna.base.Geometry(geometry_type=0) + feature1 = libcarna.base.Material('solid') + feature2 = libcarna.base.Material('solid') + geoemtry1.put_feature(10, feature1) + self.assertEqual(geoemtry1.features_count, 1) + geoemtry1.put_feature(11, feature1) + self.assertEqual(geoemtry1.features_count, 1) + geoemtry1.put_feature(10, feature2) + self.assertEqual(geoemtry1.features_count, 2) + + def test__remove_feature__by_role(self): + geoemtry1 = libcarna.base.Geometry(geometry_type=0) + feature1 = libcarna.base.Material('solid') + geoemtry1.put_feature(10, feature1) + geoemtry1.remove_feature(10) + self.assertEqual(geoemtry1.features_count, 0) + + def test__remove_feature__by_feature(self): + geoemtry1 = libcarna.base.Geometry(geometry_type=0) + feature1 = libcarna.base.Material('solid') + geoemtry1.put_feature(10, feature1) + geoemtry1.remove_feature(feature1) + self.assertEqual(geoemtry1.features_count, 0) + + def test__clear_features(self): + geoemtry1 = libcarna.base.Geometry(geometry_type=0) + feature1 = libcarna.base.Material('solid') + feature2 = libcarna.base.Material('solid') + geoemtry1.put_feature(10, feature1) + geoemtry1.put_feature(11, feature2) + geoemtry1.clear_features() + self.assertEqual(geoemtry1.features_count, 0) + + def test__has_feature(self): + geoemtry1 = libcarna.base.Geometry(geometry_type=0) + feature1 = libcarna.base.Material('solid') + feature2 = libcarna.base.Material('solid') + self.assertFalse(geoemtry1.has_feature(10)) + self.assertFalse(geoemtry1.has_feature(11)) + self.assertFalse(geoemtry1.has_feature(feature1)) + self.assertFalse(geoemtry1.has_feature(feature2)) + geoemtry1.put_feature(10, feature1) + self.assertTrue (geoemtry1.has_feature(10)) + self.assertFalse(geoemtry1.has_feature(11)) + self.assertTrue (geoemtry1.has_feature(feature1)) + self.assertFalse(geoemtry1.has_feature(feature2)) + + +class Material(testsuite.LibCarnaTestCase): + + def setUp(self): + super().setUp() + self.material = libcarna.base.Material('solid') + + def test__color(self): + self.material['color'] = (1, 0, 0) + self.material['color'] = (1, 1, 0) + + def test__has_parameter(self): + self.assertFalse(self.material.has_parameter('color')) + self.material['color'] = (1, 0, 0) + self.assertTrue(self.material.has_parameter('color')) + + def test__remove_parameter(self): + self.material.remove_parameter('color') + self.assertFalse(self.material.has_parameter('color')) + self.material['color'] = (1, 0, 0) + self.material.remove_parameter('color') + self.assertFalse(self.material.has_parameter('color')) + + +class MeshFactory(testsuite.LibCarnaTestCase): + + def test__create_box(self): + box = libcarna.base.MeshFactory.create_box( width=1, height=2, depth=3 ) + del box + + def test__create_ball(self): + ball = libcarna.base.MeshFactory.create_ball( radius=1, degree=3 ) + del ball + + def test__create_point(self): + point = libcarna.base.MeshFactory.create_point() + del point + + +class MeshRenderingStage(testsuite.LibCarnaTestCase): + + def test(self): + self.assertNotEqual( + libcarna.base.MeshRenderingStage.DEFAULT_ROLE_MESH, + libcarna.base.MeshRenderingStage.DEFAULT_ROLE_MATERIAL, + ) + + +class math(testsuite.LibCarnaTestCase): + + def test__ortho(self): + np.testing.assert_array_almost_equal( + libcarna.base.math.ortho(left=-1, right=1, bottom=-1, top=1, z_near=0.1, z_far=1000), + np.array( + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, -0.002, -1.0002], + [0, 0, 0, 1], + ], + ), + ) + + def test__frustum(self): + np.testing.assert_array_almost_equal( + libcarna.base.math.frustum(left=-1, right=1, bottom=-1, top=1, z_near=0.1, z_far=1000), + np.array( + [ + [0.1, 0 , 0, 0], + [0 , 0.1, 0, 0], + [0 , 0 , -1.0002, -0.20002], + [0 , 0 , -1, 0], + ], + ), + ) + + def test__frustum__by_fov(self): + np.testing.assert_array_almost_equal( + libcarna.base.math.frustum(fov=np.pi / 2, height_over_width=1, z_near=0.1, z_far=1000), + np.array( + [ + [1, 0, 0, 0], + [0, 1, 0, 0], + [0, 0, -1.0002, -0.20002], + [0, 0, -1, 0], + ], + ), + ) + + def test__deg2rad(self): + np.testing.assert_array_almost_equal( + libcarna.base.math.deg2rad(180), + np.pi, + ) + + def test__rad2deg(self): + np.testing.assert_array_almost_equal( + libcarna.base.math.rad2deg(np.pi), + 180, + decimal=4, + ) + + def test__rotation__axis_is_column_vector(self): + np.testing.assert_array_almost_equal( + libcarna.base.math.rotation(axis=np.array([[0], [1], [0]]), radians=np.pi), + np.array( + [ + [-1, 0, 0, 0], + [ 0, 1, 0, 0], + [ 0, 0, -1, 0], + [ 0, 0, 0, 1], + ], + ), + ) + + def test__rotation__axis_is_list(self): + np.testing.assert_array_almost_equal( + libcarna.base.math.rotation(axis=[0, 1, 0], radians=np.pi), + np.array( + [ + [-1, 0, 0, 0], + [ 0, 1, 0, 0], + [ 0, 0, -1, 0], + [ 0, 0, 0, 1], + ], + ), + ) + + def test__translation__offset_is_column_vector(self): + np.testing.assert_array_almost_equal( + libcarna.base.math.translation(offset=np.array([[1], [2], [3]])), + np.array( + [ + [1, 0, 0, 1], + [0, 1, 0, 2], + [0, 0, 1, 3], + [0, 0, 0, 1], + ], + ), + ) + + def test__translation__offset_is_list(self): + np.testing.assert_array_almost_equal( + libcarna.base.math.translation(offset=[1, 2, 3]), + np.array( + [ + [1, 0, 0, 1], + [0, 1, 0, 2], + [0, 0, 1, 3], + [0, 0, 0, 1], + ], + ), + ) + + def test__translation__offset_is_explicit(self): + np.testing.assert_array_almost_equal( + libcarna.base.math.translation(tx=1, ty=2, tz=3), + np.array( + [ + [1, 0, 0, 1], + [0, 1, 0, 2], + [0, 0, 1, 3], + [0, 0, 0, 1], + ], + ), + ) + + def test__scaling__offset_is_column_vector(self): + np.testing.assert_array_almost_equal( + libcarna.base.math.scaling(factors=np.array([[1], [2], [3]])), + np.array( + [ + [1, 0, 0, 0], + [0, 2, 0, 0], + [0, 0, 3, 0], + [0, 0, 0, 1], + ], + ), + ) + + def test__scaling__offset_is_list(self): + np.testing.assert_array_almost_equal( + libcarna.base.math.scaling(factors=[1, 2, 3]), + np.array( + [ + [1, 0, 0, 0], + [0, 2, 0, 0], + [0, 0, 3, 0], + [0, 0, 0, 1], + ], + ), + ) + + def test__scaling__uniform_factor(self): + f = 2.5 + np.testing.assert_array_almost_equal( + libcarna.base.math.scaling(uniform_factor=f), + np.array( + [ + [f, 0, 0, 0], + [0, f, 0, 0], + [0, 0, f, 0], + [0, 0, 0, 1], + ], + ), + ) + + def test__plane__by_distance(self): + np.testing.assert_array_almost_equal( + libcarna.base.math.plane(normal=[0, 2, 0], distance=2), + np.array( + [ + [0, -1, 0, 0], + [0, 0, 1, 2], + [1, 0, 0, 0], + [0, 0, 0, 1], + ], + ), + ) + + def test__plane__by_support(self): + np.testing.assert_array_almost_equal( + libcarna.base.math.plane(normal=[0, 2, 0], support=[0, 2, 0]), + np.array( + [ + [0, -1, 0, 0], + [0, 0, 1, 2], + [1, 0, 0, 0], + [0, 0, 0, 1], + ], + ), + ) + + def test__plane__zero_normal(self): + with self.assertRaises(libcarna.base.AssertionFailure): + libcarna.base.math.plane(normal=[0, 0, 0], distance=0) + + +class Color(testsuite.LibCarnaTestCase): + + def test__eq__(self): + self.assertTrue(libcarna.base.Color.WHITE == libcarna.base.Color.WHITE) + self.assertTrue(libcarna.base.Color.WHITE != libcarna.base.Color.WHITE_NO_ALPHA) + + def test__init__4ub(self): + self.assertEqual(libcarna.base.Color(255, 255, 255, 0), libcarna.base.Color.WHITE_NO_ALPHA) + + def test__init__array(self): + self.assertEqual(libcarna.base.Color((1., 1., 1., 0.)), libcarna.base.Color.WHITE_NO_ALPHA) + + def test__rgba(self): + self.assertEqual(libcarna.base.Color.GREEN.r, 0) + self.assertEqual(libcarna.base.Color.GREEN.g, 255) + self.assertEqual(libcarna.base.Color.GREEN.b, 0) + self.assertEqual(libcarna.base.Color.GREEN.a, 255) + + def test__toarray(self): + np.testing.assert_array_equal(libcarna.base.Color.GREEN.toarray(), (0., 1., 0., 1.)) diff --git a/test/test_cutting_planes.py b/test/test_cutting_planes.py new file mode 100644 index 0000000..baf0575 --- /dev/null +++ b/test/test_cutting_planes.py @@ -0,0 +1,22 @@ +import numpy as np + +import libcarna +import testsuite + + +class cutting_planes(testsuite.LibCarnaTestCase): + + def test__replicate(self): + GEOMETRY_TYPE_VOLUME = 1 + GEOMETRY_TYPE_PLANE = 2 + cp1 = libcarna.cutting_planes( + GEOMETRY_TYPE_VOLUME, + GEOMETRY_TYPE_PLANE, + cmap='viridis', + clim=(0.3, 0.4), + ) + cp2 = cp1.replicate() + self.assertEqual(cp2.volume_geometry_type, GEOMETRY_TYPE_VOLUME) + self.assertEqual(cp2.plane_geometry_type , GEOMETRY_TYPE_PLANE ) + self.assertEqual(cp2.cmap.colormap.color_list, cp1.cmap.colormap.color_list) + np.testing.assert_array_almost_equal(cp2.cmap.limits(), (0.3, 0.4)) diff --git a/test/test_data.py b/test/test_data.py new file mode 100644 index 0000000..cbe8a6a --- /dev/null +++ b/test/test_data.py @@ -0,0 +1,24 @@ +import numpy as np + +import libcarna +import testsuite + + +class drr(testsuite.LibCarnaTestCase): + + def test__nuclei(self): + img = libcarna.data.nuclei() + self.assertEqual(img.shape, (60, 256, 256)) + self.assertEqual(img.dtype, np.uint16) + + def test__cthead(self): + img = libcarna.data.cthead() + self.assertEqual(img.shape, (256, 256, 99)) + self.assertEqual(img.dtype, np.uint16) + + def test__toy(self): + img = libcarna.data.toy() + self.assertEqual(img.shape, (64, 64, 20)) + self.assertEqual(img.dtype, np.float64) + self.assertEqual(np.min(img), 0.0) + self.assertEqual(np.max(img), 1.0) diff --git a/test/test_drr.py b/test/test_drr.py new file mode 100644 index 0000000..131f4a9 --- /dev/null +++ b/test/test_drr.py @@ -0,0 +1,27 @@ +import libcarna +import testsuite + + +class drr(testsuite.LibCarnaTestCase): + + def test__replicate(self): + GEOMETRY_TYPE_VOLUME = 1 + drr1 = libcarna.drr( + GEOMETRY_TYPE_VOLUME, + sr=400, + waterat=1e-3, + baseint=2, + lothres=-200, + upthres=+800, + upmulti=2, + inverse=True, + ) + drr2 = drr1.replicate() + self.assertEqual(drr2.geometry_type, GEOMETRY_TYPE_VOLUME) + self.assertEqual(drr2.sample_rate, 400) + self.assertAlmostEqual(drr2.water_attenuation, 1e-3) + self.assertAlmostEqual(drr2.base_intensity, 2) + self.assertEqual(drr2.lower_threshold, -200) + self.assertEqual(drr2.upper_threshold, +800) + self.assertAlmostEqual(drr2.upper_multiplier, 2) + self.assertEqual(drr2.render_inverse, True) diff --git a/test/test_dvr.py b/test/test_dvr.py new file mode 100644 index 0000000..b4aeb14 --- /dev/null +++ b/test/test_dvr.py @@ -0,0 +1,21 @@ +import libcarna +import testsuite + + +class dvr(testsuite.LibCarnaTestCase): + + def test__replicate(self): + GEOMETRY_TYPE_VOLUME = 1 + dvr1 = libcarna.dvr( + GEOMETRY_TYPE_VOLUME, + cmap='viridis', + sr=400, + transl=1, + diffuse=0.5, + ) + dvr2 = dvr1.replicate() + self.assertEqual(dvr2.geometry_type, GEOMETRY_TYPE_VOLUME) + self.assertEqual(dvr2.cmap.colormap.color_list, dvr1.cmap.colormap.color_list) + self.assertEqual(dvr2.sample_rate, 400) + self.assertEqual(dvr2.translucency, 1) + self.assertEqual(dvr2.diffuse_light, 0.5) diff --git a/test/test_egl.py b/test/test_egl.py new file mode 100644 index 0000000..46fab4b --- /dev/null +++ b/test/test_egl.py @@ -0,0 +1,41 @@ +import gc + +import libcarna.egl + +import testsuite + + +class EGLContext(testsuite.LibCarnaTestCase): + + def test__init__(self): + """ + Test simple creation and destruction of an EGL context. + """ + ctx = libcarna.egl.EGLContext() + del ctx + + def test__stack(self): + """ + Test destruction of the active EGL context while another EGL context still exists (and will be activated by LibCarna). + """ + ctx1 = libcarna.egl.EGLContext() + ctx2 = libcarna.egl.EGLContext() + del ctx2 + gc.collect() + del ctx1 + + def test__vendor(self): + """ + Test the "vendor" string of the EGL context. + """ + ctx = libcarna.egl.EGLContext() + self.assertIsInstance(ctx.vendor, str) + self.assertGreater(len(ctx.vendor), 0) + + def test__renderer(self): + """ + Test the "renderer" string of the EGL context. + """ + ctx = libcarna.egl.EGLContext() + self.assertIsInstance(ctx.renderer, str) + self.assertGreater(len(ctx.renderer), 0) diff --git a/test/test_helpers.py b/test/test_helpers.py index 9a3c540..806540a 100644 --- a/test/test_helpers.py +++ b/test/test_helpers.py @@ -1,114 +1,114 @@ -import test_tools -import carna.base as base -import carna.presets as presets -import carna.egl as egl -import carna.helpers as helpers -import math +import libcarna.helpers import numpy as np -import scipy.ndimage as ndi - -import faulthandler -faulthandler.enable() - -def test_helpers(VolumeGridClass, result_suffix): - - w = 200 - h = 100 - - # ============================ - # Scene construction - # ============================ - - GEOMETRY_TYPE_OPAQUE = 0 - GEOMETRY_TYPE_VOLUME = 1 - - root = base.Node.create() - - cam = base.Camera.create() - cam.local_transform = base.math.translation4f(0, 0, 250) - cam.projection = base.math.frustum4f(base.math.deg2rad(90), 1, 10, 2000) @ base.math.scaling4f(1, w/h, 1) - root.attach_child(cam) - - box_size = 50 - box_offset = math.sqrt(2 * ((box_size / 2) ** 2)) - - box_mesh = base.create_box(box_size, box_size, 0) - material1 = base.Material.create('unshaded') - material2 = base.Material.create('unshaded') - material3 = base.Material.create('unshaded') - material1.set_parameter4f('color', [0, 1, 0, 1]) - material2.set_parameter4f('color', [0, 0, 1, 1]) - material3.set_parameter4f('color', [0, 1, 1, 1]) - - box1 = base.Geometry.create(GEOMETRY_TYPE_OPAQUE) - box1.put_feature(presets.OpaqueRenderingStage.ROLE_DEFAULT_MESH, box_mesh) - box1.put_feature(presets.OpaqueRenderingStage.ROLE_DEFAULT_MATERIAL, material1) - box1.local_transform = base.math.translation4f(0, +box_offset, 0) @ base.math.rotation4f([0, 0, 1], base.math.deg2rad(45)) # top - root.attach_child(box1) - - box2 = base.Geometry.create(GEOMETRY_TYPE_OPAQUE) - box2.put_feature(presets.OpaqueRenderingStage.ROLE_DEFAULT_MESH, box_mesh) - box2.put_feature(presets.OpaqueRenderingStage.ROLE_DEFAULT_MATERIAL, material2) - box2.local_transform = base.math.translation4f(+box_offset, 0, -20) @ base.math.rotation4f([0, 0, 1], base.math.deg2rad(45)) # right - root.attach_child(box2) - - box3 = base.Geometry.create(GEOMETRY_TYPE_OPAQUE) - box3.put_feature(presets.OpaqueRenderingStage.ROLE_DEFAULT_MESH, box_mesh) - box3.put_feature(presets.OpaqueRenderingStage.ROLE_DEFAULT_MATERIAL, material3) - box3.local_transform = base.math.translation4f(-box_offset, 0, +20) @ base.math.rotation4f([0, 0, 1], base.math.deg2rad(45)) #left - root.attach_child(box3) - - box_mesh .release() - material1.release() - material2.release() - material3.release() - - data = np.ones((100, 100, 100), bool) - data_center = np.subtract(data.shape, 1) // 2 - data[tuple(data_center)] = False - data = ndi.distance_transform_edt(data) - data = np.exp(-(data ** 2) / (2 * (25 ** 2))) - - grid_helper = VolumeGridClass.create(data.shape) - grid_helper.load_data(data) - volume = grid_helper.create_node(GEOMETRY_TYPE_VOLUME, helpers.Dimensions([100, 100, 100])) - root.attach_child(volume) - - # ============================ - # presets.FrameRendererHelper - # ============================ - - rs_opaque = presets.OpaqueRenderingStage.create(GEOMETRY_TYPE_OPAQUE) - rs_occluded = presets.OccludedRenderingStage.create() - rs_dvr = presets.DVRStage.create(GEOMETRY_TYPE_VOLUME) - rs_dvr.translucency = 0 - rs_dvr.write_color_map(0.2, 1, [1.0, 0.0, 0.0, 0.0], [1.0, 1.0, 0.0, 0.2]) - - ctx = egl.Context.create() - surface = base.Surface.create(ctx, w, h) - renderer = base.FrameRenderer.create(ctx, w, h) - - renderer_helper = helpers.FrameRendererHelper(renderer) - renderer_helper.add_stage(rs_dvr) - renderer_helper.add_stage(rs_opaque) - renderer_helper.add_stage(rs_occluded) - renderer_helper.commit() - - surface.begin() - renderer.render(cam) - result = surface.end() - test_tools.assert_rendering(f'helpers.FrameRendererHelper.{result_suffix}', result) - - # ============================ - # Clean up - # ============================ - - grid_helper.free() - root.free() - surface.free() - renderer.free() - ctx.free() - -test_helpers(helpers.VolumeGrid_UInt16Intensity, 'uint16') -test_helpers(helpers.VolumeGrid_UInt8Intensity , 'uint8' ) +import testsuite + + +class VolumeGridHelper: + + def create(self): + return self.VolumeGridHelper( + native_resolution=(512, 512, 200), + ) + + def create_with_max_segment_bytesize(self): + return self.VolumeGridHelper( + native_resolution=(64, 64, 20), + max_segment_bytesize=64 * 64 * 64 * 4, + ) + + def test__init(self): + self.create() + + def test__init__with_max_segment_bytesize(self): + self.create_with_max_segment_bytesize() + + def test__native_resolution(self): + helper1 = self.create() + helper2 = self.create_with_max_segment_bytesize() + self.assertEqual(tuple(helper1.native_resolution), (512, 512, 200)) + self.assertEqual(tuple(helper2.native_resolution), (64, 64, 20)) + + def test__load_intensities(self): + np.random.seed(0) + data = np.random.rand(64, 64, 20) + helper = self.create_with_max_segment_bytesize() + helper.load_intensities(data) + + def test__create_node__with_spacing(self): + helper = self.create() + helper.create_node( + geometry_type=1, + spacing=self.VolumeGridHelper.Spacing((0.1, 0.1, 0.2)), + ) + + def test__create_node__with_extent(self): + helper = self.create() + helper.create_node( + geometry_type=1, + extent=self.VolumeGridHelper.Extent((100, 100, 80)), + ) + + +class VolumeGridHelper_IntensityComponent: + + def test__intensity_role(self): + helper = self.create() + self.assertEqual(helper.intensities_role, self.VolumeGridHelper.DEFAULT_ROLE_INTENSITIES) + for i in [helper.intensities_role + 1, helper.intensities_role + 2]: + helper.intensities_role = i + self.assertEqual(helper.intensities_role, i) + + def test__DEFAULT_ROLE_INTENSITIES(self): + self.assertEqual(self.VolumeGridHelper.DEFAULT_ROLE_INTENSITIES, 0) + + +class VolumeGridHelper_NormalsComponent: + + def test__normals_role(self): + helper = self.create() + self.assertEqual(helper.normals_role, self.VolumeGridHelper.DEFAULT_ROLE_NORMALS) + for i in [helper.normals_role + 1, helper.normals_role + 2]: + helper.normals_role = i + self.assertEqual(helper.normals_role, i) + + def test__DEFAULT_ROLE_NORMALS(self): + self.assertEqual(self.VolumeGridHelper.DEFAULT_ROLE_NORMALS, 1) + + +class VolumeGridHelper_IntensityVolumeUInt16( + testsuite.LibCarnaTestCase, + VolumeGridHelper, + VolumeGridHelper_IntensityComponent, +): + + VolumeGridHelper = libcarna.helpers.VolumeGridHelper_IntensityVolumeUInt16 + + +class VolumeGridHelper_IntensityVolumeUInt16_NormalMap3DInt8( + testsuite.LibCarnaTestCase, + VolumeGridHelper, + VolumeGridHelper_IntensityComponent, + VolumeGridHelper_NormalsComponent, +): + + VolumeGridHelper = libcarna.helpers.VolumeGridHelper_IntensityVolumeUInt16_NormalMap3DInt8 + + +class VolumeGridHelper_IntensityVolumeUInt8( + testsuite.LibCarnaTestCase, + VolumeGridHelper, + VolumeGridHelper_IntensityComponent, +): + + VolumeGridHelper = libcarna.helpers.VolumeGridHelper_IntensityVolumeUInt8 + + +class VolumeGridHelper_IntensityVolumeUInt8_NormalMap3DInt8( + testsuite.LibCarnaTestCase, + VolumeGridHelper, + VolumeGridHelper_IntensityComponent, + VolumeGridHelper_NormalsComponent, +): + + VolumeGridHelper = libcarna.helpers.VolumeGridHelper_IntensityVolumeUInt8_NormalMap3DInt8 diff --git a/test/test_integration.py b/test/test_integration.py new file mode 100644 index 0000000..0d81bb2 --- /dev/null +++ b/test/test_integration.py @@ -0,0 +1,461 @@ +import numpy as np + +import libcarna +import testsuite + + +class VolumeGridHelper_IntensityVolumeUInt16(testsuite.LibCarnaTestCase): + + def test(self): + data = libcarna.data.toy() + helper = libcarna.helpers.VolumeGridHelper_IntensityVolumeUInt16( + native_resolution=data.shape, + ) + helper.load_intensities(data) + node = helper.create_node( + geometry_type=1, + spacing=libcarna.helpers.VolumeGridHelper_IntensityVolumeUInt16.Spacing((0.1, 0.1, 0.2)), + ) + root = libcarna.node() + root.attach_child(node) + + +class FrameRenderer(testsuite.LibCarnaTestCase): + + def setUp(self): + super().setUp() + self.ctx = libcarna.egl_context() + self.frame_renderer = libcarna.frame_renderer(self.ctx, 800, 600) + + def tearDown(self): + del self.ctx + del self.frame_renderer + super().tearDown() + + def test__gl_context(self): + self.assertIs(self.frame_renderer.gl_context, self.ctx) + + def test__width(self): + self.assertEqual(self.frame_renderer.width, 800) + + def test__height(self): + self.assertEqual(self.frame_renderer.height, 600) + + def test__reshape(self): + for tidx, fit_square in enumerate((True, False, None)): + with self.subTest(fit_square=fit_square): + if fit_square is None: + kwargs = dict() + else: + kwargs = dict(fit_square=fit_square) + self.frame_renderer.reshape(801 + tidx, 601 + tidx, **kwargs) + self.assertEqual(self.frame_renderer.width, 801 + tidx) + self.assertEqual(self.frame_renderer.height, 601 + tidx) + + def test__render__without_stages(self): + root = libcarna.node() + camera = libcarna.camera(parent=root) + self.frame_renderer.render(camera) + + def test__render__without_stages__with_root(self): + root = libcarna.node() + camera = libcarna.camera(parent=root) + self.frame_renderer.render(camera, root) + + def test__append_stage(self): + opaque_renderer = libcarna.opaque_renderer(0) + self.frame_renderer.append_stage(opaque_renderer) + + def test__render(self): + opaque_renderer = libcarna.opaque_renderer(0) + self.frame_renderer.append_stage(opaque_renderer) + root = libcarna.node() + camera = libcarna.camera() + root.attach_child(camera) + self.frame_renderer.render(camera) + + +class OpaqueRenderingStage(testsuite.LibCarnaRenderingTestCase): + + def setUp(self): + # .. OpaqueRenderingStage: example-setup-start + GEOMETRY_TYPE_OPAQUE = 1 + + # Create mesh + box = libcarna.meshes.create_box(40, 40, 40) + + # Create scene + root = libcarna.node() + + libcarna.geometry( + GEOMETRY_TYPE_OPAQUE, + parent=root, + mesh=box, + material=libcarna.material('solid', color='#ff0000'), + ).translate(-10, -10, -40) + + libcarna.geometry( + GEOMETRY_TYPE_OPAQUE, + parent=root, + mesh=box, + material=libcarna.material('solid', color='#00ff00'), + ).translate(+10, +10, +40) + + camera = libcarna.camera( + parent=root, + ).frustum(fov=90, z_near=1, z_far=1e3).translate(z=250) + + # Create renderer + r = libcarna.renderer(800, 600, [ + libcarna.opaque_renderer(GEOMETRY_TYPE_OPAQUE), + ] + ) + # .. OpaqueRenderingStage: example-setup-end + + self.r, self.camera = r, camera + + def test(self): + r, camera = self.r, self.camera + + # .. OpaqueRenderingStage: example-single-frame-start + array = r.render(camera) + # .. OpaqueRenderingStage: example-single-frame-end + + # Verify result + self.assert_image_almost_expected(array, vendor=r.gl_context.vendor) + + def test__animated(self): + r, camera = self.r, self.camera + + # .. OpaqueRenderingStage: example-animation-start + # Define animation + animation = libcarna.animate( + libcarna.animate.rotate_local(camera), + n_frames=50, + ) + + # Render animation + frames = list(animation.render(r, camera)) + # .. OpaqueRenderingStage: example-animation-end + + # Verify result + self.assert_image_almost_expected(np.array(frames), vendor=r.gl_context.vendor) + + +class MaskRenderingStage(testsuite.LibCarnaRenderingTestCase): + + def setUp(self): + # .. MaskRenderingStage: example-setup-start + GEOMETRY_TYPE_VOLUME = 2 + + # Create volume + data = (libcarna.data.toy() > 0.68) + + # Create scene + root = libcarna.node() + + libcarna.volume( + GEOMETRY_TYPE_VOLUME, + data, + parent=root, + spacing=(1, 1, 2), + ) + + camera = libcarna.camera( + parent=root, + ).frustum(fov=90, z_near=1, z_far=500).translate(z=100) + + # Create renderer + r = libcarna.renderer(800, 600, [ + libcarna.mask_renderer(GEOMETRY_TYPE_VOLUME), + ] + ) + # .. MaskRenderingStage: example-setup-end + + self.r, self.camera = r, camera + + def test(self): + r, camera = self.r, self.camera + + # Render scene + array = r.render(camera) + + # Verify result + self.assert_image_almost_expected(array, vendor=r.gl_context.vendor) + + def test__animated(self): + r, camera = self.r, self.camera + + # Define animation + animation = libcarna.animate( + libcarna.animate.rotate_local(camera), + n_frames=50, + ) + + # Render animation + frames = list(animation.render(r, camera)) + + # Verify result + self.assert_image_almost_expected(np.array(frames), vendor=r.gl_context.vendor) + + +class MIPStage(testsuite.LibCarnaRenderingTestCase): + + def setUp(self): + # .. MIPStage: example-setup-start + GEOMETRY_TYPE_VOLUME = 2 + + # Create data + data = libcarna.data.toy() + + # Create scene + root = libcarna.node() + + libcarna.volume( + GEOMETRY_TYPE_VOLUME, + data, + parent=root, + spacing=(1, 1, 2), + ) + + camera = libcarna.camera( + parent=root, + ).frustum(fov=90, z_near=1, z_far=500).translate(z=100) + + # Create renderer + r = libcarna.renderer(800, 600, [ + libcarna.mip(GEOMETRY_TYPE_VOLUME, cmap='jet'), + ] + ) + # .. MIPStage: example-setup-end + + self.r, self.camera = r, camera + + def test(self): + r, camera = self.r, self.camera + + # Render scene + array = r.render(camera) + + # Verify result + self.assert_image_almost_expected(array, vendor=r.gl_context.vendor) + + def test__animated(self): + r, camera = self.r, self.camera + + # Define animation + animation = libcarna.animate( + libcarna.animate.rotate_local(camera), + n_frames=50, + ) + + # Render animation + frames = list(animation.render(r, camera)) + + # Verify result + self.assert_image_almost_expected(np.array(frames), vendor=r.gl_context.vendor) + + +class CuttingPlanesStage(testsuite.LibCarnaRenderingTestCase): + + def setUp(self): + # .. CuttingPlanesStage: example-setup-start + GEOMETRY_TYPE_VOLUME = 2 + GEOMETRY_TYPE_PLANE = 3 + + # Create volume + data = libcarna.data.toy() + + # Create scene + root = libcarna.node() + + volume = libcarna.volume( + GEOMETRY_TYPE_VOLUME, + data, + parent=root, + spacing=(1, 1, 2), + ) + + zplane = libcarna.geometry( # create z-plane + GEOMETRY_TYPE_PLANE, + parent=volume, + ).plane(normal='z', distance=0) + + for axis in ('-x', '+x'): # create left and right planes + libcarna.geometry( + GEOMETRY_TYPE_PLANE, + parent=volume, + ).plane(normal=axis, dist=0.99 * volume.extent[0] / 2) + + camera = libcarna.camera( + parent=root, + ).frustum(fov=90, z_near=1, z_far=500).translate(z=100) + + # Create renderer + r = libcarna.renderer(800, 600, [ + libcarna.cutting_planes( + volume_geometry_type=GEOMETRY_TYPE_VOLUME, + plane_geometry_type=GEOMETRY_TYPE_PLANE, + clim=(0.5, 1), + ), + ] + ) + # .. CuttingPlanesStage: example-setup-end + + self.r, self.volume, self.zplane, self.camera = r, volume, zplane, camera + + def test(self): + r, camera = self.r, self.camera + + # Render scene + array = r.render(camera) + + # Verify result + self.assert_image_almost_expected(array, vendor=r.gl_context.vendor) + + def test__animated(self): + r, volume, zplane, camera = self.r, self.volume, self.zplane, self.camera + + # .. CuttingPlanesStage: example-animation-start + # Define animation + animation = libcarna.animate( + libcarna.animate.bounce_local( + zplane, + axis='z', + amplitude=volume.extent[2] / 2, + ), + n_frames=50, + ) + + # Render animation + frames = list(animation.render(r, camera)) + # .. CuttingPlanesStage: example-animation-end + + # Verify result + self.assert_image_almost_expected(np.array(frames), vendor=r.gl_context.vendor) + + +class DVRStage(testsuite.LibCarnaRenderingTestCase): + + def setUp(self): + # .. DVRStage: example-setup-start + GEOMETRY_TYPE_VOLUME = 2 + + # Create volume + data = libcarna.data.toy() + + # Create scene + root = libcarna.node() + + libcarna.volume( + GEOMETRY_TYPE_VOLUME, + data, + parent=root, + spacing=(1, 1, 2), + normals=True, + ) + + camera = libcarna.camera( + parent=root, + ).frustum(fov=90, z_near=1, z_far=500).translate(z=100) + + # Create renderer + dvr = libcarna.dvr( + GEOMETRY_TYPE_VOLUME, sr=800, transl=0.1, diffuse=0.8, + ) + dvr.cmap.clear() + dvr.cmap.linear_segment( + 0.7, 1.0, + libcarna.color(0, 150, 255, 150), + libcarna.color(255, 0, 255, 255), + ) + r = libcarna.renderer(800, 600, [dvr]) + # .. DVRStage: example-setup-end + + self.r, self.camera = r, camera + + def test(self): + r, camera = self.r, self.camera + + # Render scene + array = r.render(camera) + + # Verify result + self.assert_image_almost_expected(array, vendor=r.gl_context.vendor) + + def test__animated(self): + r, camera = self.r, self.camera + + # Define animation + animation = libcarna.animate( + libcarna.animate.rotate_local(camera), + n_frames=50, + ) + + # Render animation + frames = list(animation.render(r, camera)) + + # Verify result + self.assert_image_almost_expected(np.array(frames), vendor=r.gl_context.vendor) + + +class DRRStage(testsuite.LibCarnaRenderingTestCase): + + def setUp(self): + # .. DRRStage: example-setup-start + GEOMETRY_TYPE_VOLUME = 2 + + # Create volume + data = libcarna.data.toy() + + # Create scene + root = libcarna.node() + + libcarna.volume( + GEOMETRY_TYPE_VOLUME, + data, + parent=root, + spacing=(1, 1, 2), + ) + + camera = libcarna.camera( + parent=root, + ).frustum(fov=90, z_near=1, z_far=500).translate(z=100) + + # Create renderer + r = libcarna.renderer( + 800, 600, [ + libcarna.drr( + GEOMETRY_TYPE_VOLUME, sr=800, inverse=True, + lothres=0, upthres=1000, upmulti=3, + ), + ], + bgcolor=libcarna.color.WHITE_NO_ALPHA, + ) + # .. DRRStage: example-setup-end + + self.r, self.camera = r, camera + + def test(self): + r, camera = self.r, self.camera + + # Render scene + array = r.render(camera) + + # Verify result + self.assert_image_almost_expected(array, vendor=r.gl_context.vendor) + + def test__animated(self): + r, camera = self.r, self.camera + + # Define animation + animation = libcarna.animate( + libcarna.animate.rotate_local(camera), + n_frames=50, + ) + + # Render animation + frames = list(animation.render(r, camera)) + + # Verify result + self.assert_image_almost_expected(np.array(frames), vendor=r.gl_context.vendor) diff --git a/test/test_mask_renderer.py b/test/test_mask_renderer.py new file mode 100644 index 0000000..88e7913 --- /dev/null +++ b/test/test_mask_renderer.py @@ -0,0 +1,19 @@ +import libcarna +import testsuite + + +class mask_renderer(testsuite.LibCarnaTestCase): + + def test__replicate(self): + GEOMETRY_TYPE_VOLUME = 1 + mask_renderer1 = libcarna.mask_renderer( + GEOMETRY_TYPE_VOLUME, + sr=500, + color=libcarna.color.RED, + fill=True, + ) + mask_renderer2 = mask_renderer1.replicate() + self.assertEqual(mask_renderer2.geometry_type, GEOMETRY_TYPE_VOLUME) + self.assertEqual(mask_renderer2.sample_rate, 500) + self.assertEqual(mask_renderer2.color, libcarna.color.RED) + self.assertEqual(mask_renderer2.filling, True) diff --git a/test/test_material.py b/test/test_material.py new file mode 100644 index 0000000..1b57721 --- /dev/null +++ b/test/test_material.py @@ -0,0 +1,24 @@ +import libcarna + +import testsuite + + +class material(testsuite.LibCarnaTestCase): + + def test__color__int(self): + for shader_name in ('unshaded', 'solid'): + with self.subTest(shader_name=shader_name): + with self.assertRaises(ValueError): + libcarna.material('unshaded', color=4) + + def test__color__str(self): + for shader_name in ('unshaded', 'solid'): + with self.subTest(shader_name=shader_name): + with self.assertRaises(TypeError): + libcarna.material('unshaded', color='teal') + + def test__color__3d(self): + for shader_name in ('unshaded', 'solid'): + with self.subTest(shader_name=shader_name): + with self.assertRaises(ValueError): + libcarna.material('unshaded', color=(1, 0, 0)) diff --git a/test/test_mip.py b/test/test_mip.py new file mode 100644 index 0000000..8adbedf --- /dev/null +++ b/test/test_mip.py @@ -0,0 +1,17 @@ +import libcarna +import testsuite + + +class mip(testsuite.LibCarnaTestCase): + + def test__replicate(self): + GEOMETRY_TYPE_VOLUME = 1 + mip1 = libcarna.mip( + GEOMETRY_TYPE_VOLUME, + cmap='jet', + sr=400, + ) + mip2 = mip1.replicate() + self.assertEqual(mip2.geometry_type, GEOMETRY_TYPE_VOLUME) + self.assertEqual(mip2.cmap.colormap.color_list, mip1.cmap.colormap.color_list) + self.assertEqual(mip2.sample_rate, 400) diff --git a/test/test_opaque_renderer.py b/test/test_opaque_renderer.py new file mode 100644 index 0000000..f951037 --- /dev/null +++ b/test/test_opaque_renderer.py @@ -0,0 +1,11 @@ +import libcarna +import testsuite + + +class opaque_renderer(testsuite.LibCarnaTestCase): + + def test__replicate(self): + GEOMETRY_TYPE_OPAQUE = 1 + opaque_renderer1 = libcarna.opaque_renderer(GEOMETRY_TYPE_OPAQUE) + mipopaque_renderer2 = opaque_renderer1.replicate() + self.assertEqual(mipopaque_renderer2.geometry_type, GEOMETRY_TYPE_OPAQUE) diff --git a/test/test_presets.py b/test/test_presets.py index 0acc9aa..6817b07 100644 --- a/test/test_presets.py +++ b/test/test_presets.py @@ -1,175 +1,164 @@ -import test_tools -import carna.base as base -import carna.presets as presets -import carna.egl as egl -import carna.helpers as helpers +import libcarna.presets import numpy as np -import scipy.ndimage as ndi - -import faulthandler -faulthandler.enable() - -# ============================ -# presets.OpaqueRenderingStage -# ============================ - -w = 200 -h = 100 - -root = base.Node.create() - -cam = base.Camera.create() -cam.local_transform = base.math.translation4f(0, 0, 250) -cam.projection = base.math.frustum4f(base.math.deg2rad(90), 1, 10, 2000) @ base.math.scaling4f(1, w/h, 1) -root.attach_child(cam) - -box_mesh = base.create_box(40, 40, 40) -ball_mesh = base.create_ball(35) -material1 = base.Material.create('unshaded') -material2 = base.Material.create('unshaded') -material3 = base.Material.create('solid') -material1.set_parameter4f('color', [1, 0, 0, 1]) -material2.set_parameter4f('color', [0, 1, 0, 1]) -material3.set_parameter4f('color', [0, 0, 1, 1]) - -GEOMETRY_TYPE_OPAQUE = 0 - -box1 = base.Geometry.create(GEOMETRY_TYPE_OPAQUE) -box1.put_feature(presets.OpaqueRenderingStage.ROLE_DEFAULT_MESH, box_mesh) -box1.put_feature(presets.OpaqueRenderingStage.ROLE_DEFAULT_MATERIAL, material1) -box1.local_transform = base.math.translation4f(-10, -10, -40) -root.attach_child(box1) - -box2 = base.Geometry.create(GEOMETRY_TYPE_OPAQUE) -box2.put_feature(presets.OpaqueRenderingStage.ROLE_DEFAULT_MESH, box_mesh) -box2.put_feature(presets.OpaqueRenderingStage.ROLE_DEFAULT_MATERIAL, material2) -box2.local_transform = base.math.translation4f(+10, +10, +40) -root.attach_child(box2) - -ball = base.Geometry.create(GEOMETRY_TYPE_OPAQUE) -ball.put_feature(presets.OpaqueRenderingStage.ROLE_DEFAULT_MESH, ball_mesh) -ball.put_feature(presets.OpaqueRenderingStage.ROLE_DEFAULT_MATERIAL, material3) -ball.local_transform = base.math.translation4f(-20, +25, 40) -root.attach_child(ball) - -box_mesh .release() -ball_mesh.release() -material1.release() -material2.release() - -ctx = egl.Context.create() -surface = base.Surface.create(ctx, w, h) -renderer = base.FrameRenderer.create( ctx, w, h ) - -opaque = presets.OpaqueRenderingStage.create(GEOMETRY_TYPE_OPAQUE) -renderer.append_stage(opaque) - -surface.begin() -renderer.render(cam) -result = surface.end() -test_tools.assert_rendering('presets.OpaqueRenderingStage', result) - -renderer.free() -cam.detach_from_parent() -root.free() - -# ============================ -# presets.MIPStage -# ============================ - -GEOMETRY_TYPE_VOLUME = 1 - -data = np.ones((100, 100, 100), bool) -data_center = np.subtract(data.shape, 1) // 2 -data[tuple(data_center)] = False -data = ndi.distance_transform_edt(data) -data = np.exp(-(data ** 2) / (2 * (25 ** 2))) - -root = base.Node.create() -grid_helper = helpers.VolumeGrid_UInt16Intensity.create(data.shape); -grid_helper.load_data( data ) -volume = grid_helper.create_node(GEOMETRY_TYPE_VOLUME, helpers.Dimensions([100, 100, 100])) -root.attach_child(volume) -root.attach_child(cam) - -renderer = base.FrameRenderer.create(ctx, w, h) -mip = presets.MIPStage.create(GEOMETRY_TYPE_VOLUME) -mip.append_layer( presets.MIPLayer.create(0, 1, [1, 1, 1, 1])) -renderer.append_stage(mip) - -surface.begin() -renderer.render(cam) -result = surface.end() -test_tools.assert_rendering('presets.MIPStage', result) - -# ============================ -# presets.CuttingPlanesStage -# ============================ - -GEOMETRY_TYPE_PLANE = 2 - -cps = presets.CuttingPlanesStage.create(GEOMETRY_TYPE_VOLUME, GEOMETRY_TYPE_PLANE) -renderer.clear_stages() -renderer.append_stage(cps); - -plane = base.Geometry.create(GEOMETRY_TYPE_PLANE) -plane.local_transform = base.math.plane4f([1, 1, 1], 0) -root.attach_child(plane); - -surface.begin() -renderer.render(cam) -result = surface.end() -test_tools.assert_rendering('presets.CuttingPlanesStage', result) - -# ============================ -# presets.DVRStage -# ============================ - -dvr = presets.DVRStage.create(GEOMETRY_TYPE_VOLUME) -dvr.write_color_map(0.2, 1, [1.0, 0.0, 0.0, 0.9], [1.0, 1.0, 0.0, 1.0]) -renderer.clear_stages() -renderer.append_stage(dvr) - -surface.begin() -renderer.render(cam) -result = surface.end() -test_tools.assert_rendering('presets.DVRStage', result) - -# ============================ -# presets.MaskRenderingStage -# ============================ - -GEOMETRY_TYPE_MASK = 3 - -mr = presets.MaskRenderingStage.create(GEOMETRY_TYPE_MASK) -renderer.clear_stages() -renderer.append_stage(mr) - -mask_grid_helper = helpers.VolumeGrid_UInt8Intensity.create(data.shape); -mask_grid_helper.load_data( data > 0.5 ) -mask = mask_grid_helper.create_node(GEOMETRY_TYPE_MASK, helpers.Dimensions([100, 100, 100])) -root.attach_child(mask) - -mr.render_borders = False -surface.begin() -renderer.render(cam) -result = surface.end() -test_tools.assert_rendering('presets.MaskRenderingStage', result) - -mr.render_borders = True -surface.begin() -renderer.render(cam) -result = surface.end() -test_tools.assert_rendering('presets.MaskRenderingStage.render_borders', result) - -# ============================ -# Clean up -# ============================ - -renderer.free() -mask_grid_helper.free() -grid_helper.free() -root.free() -surface.free() -ctx.free() + +import testsuite + + +class VolumeRenderingStage(testsuite.LibCarnaTestCase): + + def create(self): + return None # VolumeRenderingStage has no public constructor + + def test__DEFAULT_SAMPLE_RATE(self): + self.assertEqual(libcarna.presets.VolumeRenderingStage.DEFAULT_SAMPLE_RATE, 200) + + def test__init__(self): + self.create() + + def test__sample_rate(self): + rs = self.create() + if rs is not None: # create is overridden in subclasses + self.assertEqual(rs.sample_rate, libcarna.presets.VolumeRenderingStage.DEFAULT_SAMPLE_RATE) + for sample_rate in (rs.sample_rate + 100, rs.sample_rate + 200): + rs.sample_rate = sample_rate + self.assertEqual(rs.sample_rate, sample_rate) + + +class MaskRenderingStage(VolumeRenderingStage): + + def create(self): + return libcarna.presets.MaskRenderingStage(geometry_type=1) + + def test__DEFAULT_ROLE_MASK(self): + self.assertEqual(libcarna.presets.MaskRenderingStage.DEFAULT_ROLE_MASK, 2) + + def test__DEFAULT_COLOR(self): + self.assertEqual(libcarna.presets.MaskRenderingStage.DEFAULT_COLOR.r, 0) + self.assertEqual(libcarna.presets.MaskRenderingStage.DEFAULT_COLOR.g, 255) + self.assertEqual(libcarna.presets.MaskRenderingStage.DEFAULT_COLOR.b, 0) + self.assertEqual(libcarna.presets.MaskRenderingStage.DEFAULT_COLOR.a, 255) + + def test__DEFAULT_FILLING(self): + self.assertEqual(libcarna.presets.MaskRenderingStage.DEFAULT_FILLING, True) + + def test__mask_role(self): + rs = self.create() + self.assertEqual(rs.mask_role, libcarna.presets.MaskRenderingStage.DEFAULT_ROLE_MASK) + for mask_role in (rs.mask_role + 1, rs.mask_role + 2): + rs = libcarna.presets.MaskRenderingStage(geometry_type=1, mask_role=mask_role) + self.assertEqual(rs.mask_role, mask_role) + + def test__color(self): + rs = self.create() + self.assertEqual(rs.color, libcarna.presets.MaskRenderingStage.DEFAULT_COLOR) + for color_r in (50, 100, 150): + color = libcarna.base.Color(color_r, 255, 0, 255) + rs.color = color + self.assertEqual(rs.color, color) + + def test__filling(self): + rs = self.create() + self.assertEqual(rs.filling, True) + for filling in (False, True): + rs.filling = filling + self.assertEqual(rs.filling, filling) + + +class ColorMapMixin: + + def test__color_map(self): + """ + Test that, despite that `.color_map` returns a new `ColorMapView` each time it is called, the actual color map + is shared between the `ColorMapView` instances. + """ + rs = self.create() + cmap1 = rs.color_map + cmap1.write_linear_spline([libcarna.color.RED, libcarna.color.BLUE]) + cmap2 = rs.color_map + self.assertEqual(cmap1.color_list, cmap2.color_list) + + def test__color_map__color_list(self): + rs = self.create() + self.assertEqual(rs.color_map.color_list[0], libcarna.color.BLACK_NO_ALPHA) + self.assertEqual(rs.color_map.color_list[-1], libcarna.color.BLACK_NO_ALPHA) + + def test__color_map__write_linear_segment(self): + rs = self.create() + cmap = rs.color_map + cmap.write_linear_segment(0.0, 0.5, libcarna.color.RED, libcarna.color.BLUE) + self.assertEqual(cmap.color_list[0], libcarna.color.RED) + self.assertEqual(cmap.color_list[len(cmap.color_list) // 2], libcarna.color.BLUE) + + def test__color_map__write_linear_spline(self): + rs = self.create() + cmap = rs.color_map + cmap.write_linear_spline([libcarna.color.RED, libcarna.color.GREEN, libcarna.color.BLUE]) + self.assertEqual(cmap.color_list[0], libcarna.color.RED) + self.assertEqual(cmap.color_list[len(cmap.color_list) // 2], libcarna.color.GREEN) + self.assertEqual(cmap.color_list[-1], libcarna.color.BLUE) + + def test__color_map__clear(self): + rs = self.create() + cmap = rs.color_map + cmap.write_linear_segment(0.0, 0.5, libcarna.color.RED, libcarna.color.BLUE) + cmap.clear() + self.assertEqual(cmap.color_list[0], libcarna.color.BLACK_NO_ALPHA) + + +class MIPStage(VolumeRenderingStage, ColorMapMixin): + + def create(self): + return libcarna.presets.MIPStage(geometry_type=1) + + def test__ROLE_INTENSITIES(self): + self.assertEqual(libcarna.presets.MIPStage.ROLE_INTENSITIES, 0) + + +class DVRStage(VolumeRenderingStage, ColorMapMixin): + + def create(self): + return libcarna.presets.DVRStage(geometry_type=1) + + def test__ROLE_INTENSITIES(self): + self.assertEqual(libcarna.presets.DVRStage.ROLE_INTENSITIES, 0) + + def test__ROLE_NORMALS(self): + self.assertEqual(libcarna.presets.DVRStage.ROLE_NORMALS, 1) + + def test__DEFAULT_TRANSLUCENCY(self): + self.assertEqual(libcarna.presets.DVRStage.DEFAULT_TRANSLUCENCY, 50) + + def test__DEFAULT_DIFFUSE_LIGHT(self): + self.assertEqual(libcarna.presets.DVRStage.DEFAULT_DIFFUSE_LIGHT, 1) + + def test__translucency(self): + rs = self.create() + self.assertEqual(rs.translucency, libcarna.presets.DVRStage.DEFAULT_TRANSLUCENCY) + for translucency in (0.3, 0.5, 0.7): + rs.translucency = translucency + self.assertAlmostEqual(rs.translucency, translucency, places=5) + + def test__diffuse_light(self): + rs = self.create() + self.assertEqual(rs.diffuse_light, libcarna.presets.DVRStage.DEFAULT_DIFFUSE_LIGHT) + for diffuse_light in (0.3, 0.5, 0.7): + rs.diffuse_light = diffuse_light + self.assertAlmostEqual(rs.diffuse_light, diffuse_light, places=5) + + +class CuttingPlanesStage(testsuite.LibCarnaTestCase): + + def test__windowing_level(self): + rs = libcarna.presets.CuttingPlanesStage(volume_geometry_type=1, plane_geometry_type=2) + self.assertEqual(rs.windowing_level, libcarna.presets.CuttingPlanesStage.DEFAULT_WINDOWING_LEVEL) + for windowing_level in (0.3, 0.5, 0.7): + rs.windowing_level = windowing_level + self.assertAlmostEqual(rs.windowing_level, windowing_level, places=5) + + def test__windowing_width(self): + rs = libcarna.presets.CuttingPlanesStage(volume_geometry_type=1, plane_geometry_type=2) + self.assertEqual(rs.windowing_width, libcarna.presets.CuttingPlanesStage.DEFAULT_WINDOWING_WIDTH) + for windowing_width in (0.3, 0.5, 0.7): + rs.windowing_level = windowing_width + self.assertAlmostEqual(rs.windowing_level, windowing_width, places=5) diff --git a/test/test_py.py b/test/test_py.py deleted file mode 100644 index 733784a..0000000 --- a/test/test_py.py +++ /dev/null @@ -1,30 +0,0 @@ -import test_tools -import carna.py as cpy -import math -import numpy as np -import scipy.ndimage as ndi - -import faulthandler -faulthandler.enable() - -# ============================ -# deduce_volume_format -# ============================ - -assert 'UInt8Intensity' in cpy.deduce_volume_format('uint8') -assert 'UInt8Intensity' in cpy.deduce_volume_format(np.uint8) -assert 'UInt16Intensity' in cpy.deduce_volume_format('uint16') -assert 'UInt16Intensity' in cpy.deduce_volume_format(np.uint16) -assert 'UInt16Intensity' in cpy.deduce_volume_format('float16') -assert 'UInt16Intensity' in cpy.deduce_volume_format(np.float16) - -whitelist = [np.uint8, np.uint16, np.float16, np.float32, np.float64] -illegal_formats = [t for t in sum(np.sctypes.values(), []) if t not in whitelist] - -for fmt in illegal_formats: - try: - cpy.deduce_volume_format(fmt) - assert False - except: - pass - diff --git a/test/test_py_demo1.py b/test/test_py_demo1.py deleted file mode 100644 index 6640797..0000000 --- a/test/test_py_demo1.py +++ /dev/null @@ -1,42 +0,0 @@ -import test_tools -import carna.py as cpy -import math -import numpy as np -import scipy.ndimage as ndi - -import faulthandler -faulthandler.enable() - -# ============================ -# Define volume data -# ============================ - -data = np.ones((100, 100, 100), bool) -data_center = np.subtract(data.shape, 1) // 2 -data[tuple(data_center)] = False -data = ndi.distance_transform_edt(data) -data = np.exp(-(data ** 2) / (2 * (25 ** 2))) - -# ============================ -# Define opaque data -# ============================ - -dots = [[-100, -100, 0], [ 100, 100, 0]] -boxes = [[ 100, -100, 0], [-100, 100, 0]] - -# ============================ -# Perform rendering -# ============================ - -with cpy.SingleFrameContext((100, 200), fov=90, near=1, far=1000) as rc: - rc.dots(dots, color=(0,1,0,1), size=8) - green = rc.material((0,1,0,1)) - box = rc.box(20, 20, 20) - for loc in boxes: - rc.mesh(box, green).translate(*loc) - rc.volume(data, dimensions=(100, 100, 100), fmt_hint=np.uint8) - rc.mip() - rc.camera.translate(0, 0, 250) - -test_tools.assert_rendering('py.demo1', rc.result) - diff --git a/test/test_py_demo2.py b/test/test_py_demo2.py deleted file mode 100644 index 897a180..0000000 --- a/test/test_py_demo2.py +++ /dev/null @@ -1,45 +0,0 @@ -import test_tools -import carna.py as cpy -import math -import numpy as np -import scipy.ndimage as ndi - -import faulthandler -faulthandler.enable() - -# ============================ -# Create toy volume data -# ============================ - -def gaussian_filter3d(img, sigma): - for i in range(3): - img = ndi.gaussian_filter1d(img, sigma, axis=i) - return img - -np.random.seed(0) -data = gaussian_filter3d(np.random.randn(256, 256, 32), 20) ## create low-frequency random data -data = 0.5 ** 3 + (data - 0.5) ** 3 ## spread intensity distribution to create sharper intensity gradients -data += 1e-4 * np.random.randn(*data.shape) ## add white image noise -data[data < 0] = 0 ## normalize data to [0, ...) -data /= data.max() ## normalize data to [0, 1] - -# ============================ -# Define points of interest -# ============================ - -poi_list = [[ 50, -30, 5], [-100, 100, 10]] - -# ============================ -# Perform rendering -# ============================ - -with cpy.SingleFrameContext((512, 512), fov=90, near=1, far=1000) as rc: - green = rc.material((0,1,0,1)) - box = rc.box(20, 20, 20) - rc.meshes(box, green, poi_list) - rc.volume(data, spacing=(1, 1, 1), normals=True, fmt_hint=np.uint16) - rc.dvr(diffuse_light=1, sample_rate=1000) - rc.camera.rotate((1.5, 1, 0), 45, 'deg').translate(10, -25, 160).rotate((0, 0, 1), 35, 'deg') - -test_tools.assert_rendering('py.demo2', rc.result) - diff --git a/test/test_py_demo3.py b/test/test_py_demo3.py deleted file mode 100644 index 0337338..0000000 --- a/test/test_py_demo3.py +++ /dev/null @@ -1,94 +0,0 @@ -import test_tools -import carna.py as cpy -import math -import numpy as np -import scipy.ndimage as ndi - -import faulthandler -faulthandler.enable() - -test = test_tools.BatchTest() - -# ========================================= -# Create toy volume data -# ========================================= - -def gaussian_filter3d(img, sigma): - for i in range(3): - img = ndi.gaussian_filter1d(img, sigma, axis=i) - return img - -np.random.seed(0) -data0 = gaussian_filter3d(np.random.randn(256, 256, 32), 20) ## create low-frequency random data -data0 = 0.5 ** 3 + (data0 - 0.5) ** 3 ## spread intensity distribution to create sharper intensity gradients -data0[data0 < 0] = 0 ## normalize data to [0, ...) -data0 /= data0.max() ## normalize data to [0, 1] -data = (data0 + 1e-2 * np.random.randn(*data0.shape)).clip(0, 1) ## add white image noise - -# ========================================= -# Define points of interest -# ========================================= - -poi_list = [[ 50, -30, 5], [-100, 100, 10]] - -# ========================================= -# Perform rendering (regions) -# ========================================= - -with cpy.SingleFrameContext((512, 512), fov=90, near=1, far=1000) as rc: - green = rc.material((0,1,0,1)) - box = rc.box(20, 20, 20) - rc.meshes(box, green, poi_list) - rc.volume(data, spacing=(1, 1, 1), normals=True, fmt_hint=np.uint16) - rc.dvr(diffuse_light=1, sample_rate=1000) - rc.camera.rotate((1.5, 1, 0), 45, 'deg').translate(10, -25, 160).rotate((0, 0, 1), 35, 'deg') - rc.mask(ndi.label(data0 > 0.2)[0], 'regions', spacing=(1, 1, 1), color=(1, 0, 0, 1), sample_rate=1000) - -test_tools.assert_rendering('py.demo3.regions', rc.result, batch=test) - -# ========================================= -# Perform rendering (regions-on-top) -# ========================================= - -with cpy.SingleFrameContext((512, 512), fov=90, near=1, far=1000) as rc: - green = rc.material((0,1,0,1)) - box = rc.box(20, 20, 20) - rc.meshes(box, green, poi_list) - rc.volume(data, spacing=(1, 1, 1), normals=True, fmt_hint=np.uint16) - rc.dvr(diffuse_light=1, sample_rate=1000) - rc.camera.rotate((1.5, 1, 0), 45, 'deg').translate(10, -25, 160).rotate((0, 0, 1), 35, 'deg') - rc.mask(ndi.label(data0 > 0.2)[0], 'regions-on-top', spacing=(1, 1, 1), color=(1, 0, 0, 1), sample_rate=1000) - -test_tools.assert_rendering('py.demo3.regions-on-top', rc.result, batch=test) - -# ========================================= -# Perform rendering (borders-on-top) -# ========================================= - -with cpy.SingleFrameContext((512, 512), fov=90, near=1, far=1000) as rc: - green = rc.material((0,1,0,1)) - box = rc.box(20, 20, 20) - rc.meshes(box, green, poi_list) - rc.volume(data, spacing=(1, 1, 1), normals=True, fmt_hint=np.uint16) - rc.dvr(diffuse_light=1, sample_rate=1000) - rc.camera.rotate((1.5, 1, 0), 45, 'deg').translate(10, -25, 160).rotate((0, 0, 1), 35, 'deg') - rc.mask(ndi.label(data0 > 0.2)[0], 'borders-on-top', spacing=(1, 1, 1), color=(1, 0, 0, 1)) - -test_tools.assert_rendering('py.demo3.borders-on-top', rc.result, batch=test) - -# ========================================= -# Perform rendering (borders-in-background) -# ========================================= - -with cpy.SingleFrameContext((512, 512), fov=90, near=1, far=1000) as rc: - green = rc.material((0,1,0,1)) - box = rc.box(20, 20, 20) - rc.meshes(box, green, poi_list) - rc.volume(data, spacing=(1, 1, 1), normals=True, fmt_hint=np.uint16) - rc.dvr(diffuse_light=1, sample_rate=1000) - rc.camera.rotate((1.5, 1, 0), 45, 'deg').translate(10, -25, 160).rotate((0, 0, 1), 35, 'deg') - rc.mask(ndi.label(data0 > 0.2)[0], 'borders-in-background', spacing=(1, 1, 1), color=(1, 0, 0, 1)) - -test_tools.assert_rendering('py.demo3.borders-in-background', rc.result, batch=test) -test.finish() - diff --git a/test/test_py_demo4.py b/test/test_py_demo4.py deleted file mode 100644 index 0aa8f3f..0000000 --- a/test/test_py_demo4.py +++ /dev/null @@ -1,88 +0,0 @@ -import test_tools -import carna.py as cpy -import math -import numpy as np -import scipy.ndimage as ndi - -import faulthandler -faulthandler.enable() - -# ========================================= -# Create toy volume data -# ========================================= - -data = np.full((16, 8, 4), False) -data[0,0,:] = True -data[0,:,0] = True -data[:,0,0] = True -data[-1,-1,:] = True -data[-1,:,-1] = True -data[:,-1,-1] = True -data[data.shape[0]//2,data.shape[1]//2,data.shape[2]//2] = True - -# ========================================= -# Define corners (normalized coordinates) -# ========================================= - -corners = [ - [0, 0, 0], - [0, 0, 1], - [0, 1, 0], - [0, 1, 1], - [1, 0, 0], - [1, 0, 1], - [1, 1, 0], - [1, 1, 1], -] - -# ========================================= -# Perform rendering (single segment) -# ========================================= - -ss_test = test_tools.BatchTest() - -for view in ('front', 'left', 'top'): - with cpy.SingleFrameContext((512, 512), ortho=(-10,+10,-10,+10), near=0.1, far=100, max_segment_bytesize=(2 + np.max(data.shape)) ** 3) as rc: - if view == 'left': rc.camera.rotate((0, 1, 0), -90, 'deg') - if view == 'top' : rc.camera.rotate((1, 0, 0), -90, 'deg') - rc.camera.translate(0, -0.5, 15) - mask = rc.mask(data, 'regions', spacing=(1, 1, 1), color=(1, 0, 0, 1), sample_rate=1000) - green = rc.material((0,1,0,1)) - ball = rc.box(1, 1, 1) - rc.meshes(ball, green, mask.map_normalized_coordinates(corners), parent=mask) - - test_tools.assert_rendering(f'py.demo4.normalized.ss-{view}', rc.result, batch=ss_test) - -ss_test.finish() - -# ========================================= -# Perform rendering (multiple segments) -# ========================================= - -ms_test = test_tools.BatchTest() - -for view in ('front', 'left', 'top'): - with cpy.SingleFrameContext((512, 512), ortho=(-10,+10,-10,+10), near=0.1, far=100, max_segment_bytesize=np.prod(data.shape) // 2) as rc: - if view == 'left': rc.camera.rotate((0, 1, 0), -90, 'deg') - if view == 'top' : rc.camera.rotate((1, 0, 0), -90, 'deg') - rc.camera.translate(0, -0.5, 15) - mask = rc.mask(data, 'regions', spacing=(1, 1, 1), color=(1, 0, 0, 1), sample_rate=1000) - green = rc.material((0,1,0,1)) - ball = rc.box(1, 1, 1) - rc.meshes(ball, green, mask.map_normalized_coordinates(corners), parent=mask) - - test_tools.assert_rendering(f'py.demo4.normalized.ms-{view}', rc.result, batch=ms_test) - -ms_test.finish() - -# ========================================= -# Check corners in voxel coordinates -# ========================================= - -corners_voxels = corners * np.subtract(data.shape, 1) -mapped_corners = mask.map_normalized_coordinates(corners) - -test = test_tools.BatchTest() -test.assert_allclose(mapped_corners, mask.map_voxel_coordinates(corners_voxels), 'map_voxel_coordinates') -test.finish() - diff --git a/test/test_py_demo5.py b/test/test_py_demo5.py deleted file mode 100644 index 692cb5d..0000000 --- a/test/test_py_demo5.py +++ /dev/null @@ -1,45 +0,0 @@ -import test_tools -import carna.py as cpy -import math -import numpy as np -import scipy.ndimage as ndi - -import faulthandler -faulthandler.enable() - -# ============================ -# Create toy volume data -# ============================ - -def gaussian_filter3d(img, sigma): - for i in range(3): - img = ndi.gaussian_filter1d(img, sigma, axis=i) - return img - -np.random.seed(0) -data = gaussian_filter3d(np.random.randn(256, 256, 32), 20) ## create low-frequency random data -data = 0.5 ** 3 + (data - 0.5) ** 3 ## spread intensity distribution to create sharper intensity gradients -data += 1e-4 * np.random.randn(*data.shape) ## add white image noise -data[data < 0] = 0 ## normalize data to [0, ...) -data /= data.max() ## normalize data to [0, 1] - -# ============================ -# Define points of interest -# ============================ - -poi_list = [[ 50, -30, 5], [-100, 100, 10], [110, -110, 0]] - -# ============================ -# Perform rendering -# ============================ - -with cpy.SingleFrameContext((256, 512), fov=90, near=1, far=1000) as rc: - green = rc.material((0,1,0,1)) - box = rc.box(20, 20, 20) - rc.meshes(box, green, poi_list) - rc.volume(data, spacing=(1, 1, 1), normals=True, fmt_hint=np.uint8) - rc.dvr(diffuse_light=1, sample_rate=1000) - rc.camera.translate(128, -128, 64).look_at((0, 0, 0), (0, 0, 1)).translate(0, 0, 100) - -test_tools.assert_rendering('py.demo5', rc.result) - diff --git a/test/test_spatial.py b/test/test_spatial.py new file mode 100644 index 0000000..be81c04 --- /dev/null +++ b/test/test_spatial.py @@ -0,0 +1,203 @@ +import numpy as np + +import libcarna + +import testsuite + + +class node(testsuite.LibCarnaTestCase): + + def setUp(self): + super().setUp() + self.root = libcarna.node() + self.node1 = libcarna.node(parent=self.root).translate_local(0, 0, 1) + pivot = libcarna.node(parent=self.root) + self.node2 = libcarna.node(parent=pivot).scale_local(0.5) + self.root.update_world_transform() + + def test__transform_from__identity(self): + np.testing.assert_array_almost_equal(self.node1.transform_from(self.node1).mat, np.eye(4)) + np.testing.assert_array_almost_equal(self. root.transform_from(self. root).mat, np.eye(4)) + + def test__transform_from__node1_from_node2(self): + np.testing.assert_array_almost_equal( + self.node1.transform_from(self.node2).mat, + np.linalg.inv(self.node1.world_transform) @ self.node2.world_transform, + ) + + def test__transform_from__node2_from_node1(self): + np.testing.assert_array_almost_equal( + self.node2.transform_from(self.node1).mat, + np.linalg.inv(self.node2.world_transform) @ self.node1.world_transform, + ) + + +class volume(testsuite.LibCarnaTestCase): + + GEOMETRY_TYPE_VOLUME = 1 + + def setUp(self): + super().setUp() + self.array = np.zeros((65, 49, 21), dtype=np.uint8) + self.root = libcarna.node() + self.volume = libcarna.volume( + self.GEOMETRY_TYPE_VOLUME, + self.array, + parent=self.root, + spacing=(1, 1, 1), + ).translate_local(0, 0, 5) + self.root.update_world_transform() + + def test__transform_into_voxels_from(self): + np.testing.assert_array_almost_equal( + self.volume.transform_into_voxels_from(self.root).point(), + (32., 24., 5.,), + ) + + def test__extent(self): + np.testing.assert_array_almost_equal( + self.volume.extent, + (64., 48., 20.), + ) + + def test__spacing(self): + np.testing.assert_array_almost_equal( + self.volume.spacing, + (1., 1., 1.), + ) + + def test__int16__hu(self): + """ + Test creating the volume from data in Hounsfield Units. All image identities are identical. + """ + array = np.zeros((40, 30, 20), dtype=np.int16) + assert list(np.unique(array)) == [0] # precondition: all values are 0 + volume = libcarna.volume(self.GEOMETRY_TYPE_VOLUME, array, spacing=(1, 1, 1), units='hu') + np.testing.assert_array_almost_equal( + volume.normalized([-1024, +3071]), [0, 1], + ) + np.testing.assert_array_almost_equal( + volume.raw([0, 1]), [-1024, +3071], + ) + + def test__uint8__raw__full_range(self): + """ + Test creating the volume from `uint8` data. The image intensities span the full range between 0 and 255. + """ + array = np.zeros((40, 30, 20), dtype=np.uint8) + array.fill(0) + array.flat[0] = 0xFF + assert list(np.unique(array)) == [0, 0xFF] # precondition: values span the full range + volume = libcarna.volume(self.GEOMETRY_TYPE_VOLUME, array, spacing=(1, 1, 1)) + np.testing.assert_array_almost_equal( + volume.normalized([0, 0x7F, 0xFF]), [0, 0x7F / 0xFF, 1], + ) + np.testing.assert_array_almost_equal( + volume.raw([0, 0x7F / 0xFF, 1]), [0, 0x7F, 0xFF], + ) + + def test__uint8__raw__part_range(self): + """ + Test creating the volume from `uint8` data. The image intensities are between 100 and 150. + """ + array = np.zeros((40, 30, 20), dtype=np.uint8) + array.fill(100) + array.flat[0] = 150 + assert list(np.unique(array)) == [100, 150] # precondition: values are between 100 and 150 + volume = libcarna.volume(self.GEOMETRY_TYPE_VOLUME, array, spacing=(1, 1, 1)) + np.testing.assert_array_almost_equal( + volume.normalized([100, 125, 150]), [0, 0.5, 1], + ) + np.testing.assert_array_almost_equal( + volume.raw([0, 0.5, 1]), [100, 125, 150], + ) + + def test__uint8__raw__uniform(self): + """ + Test creating the volume from `uint8` data. All image intensities are identical. + """ + array = np.full((40, 30, 20), 3, dtype=np.uint8) + assert list(np.unique(array)) == [3] # precondition: all values are 3 + volume = libcarna.volume(self.GEOMETRY_TYPE_VOLUME, array, spacing=(1, 1, 1)) + np.testing.assert_array_almost_equal( + volume.normalized([1, 3, 5]), [0, 0, 0], + ) + np.testing.assert_array_almost_equal( + volume.raw([0, 0.5, 1]), [3, 3, 3], + ) + + def test__uint16__raw__full_range(self): + """ + Test creating the volume from `uint16` data. The image intensities span the full range between 0 and 0xFFFF. + """ + array = np.zeros((40, 30, 20), dtype=np.uint16) + array.fill(0) + array.flat[0] = 0xFFFF + assert list(np.unique(array)) == [0, 0xFFFF] # precondition: values span the full range + volume = libcarna.volume(self.GEOMETRY_TYPE_VOLUME, array, spacing=(1, 1, 1)) + np.testing.assert_array_almost_equal( + volume.normalized([0, 0x7FFF, 0xFFFF]), [0, 0x7FFF / 0xFFFF, 1], + ) + np.testing.assert_array_almost_equal( + volume.raw([0, 0x7FFF / 0xFFFF, 1]), [0, 0x7FFF, 0xFFFF], + ) + + def test__uint16__raw__part_range(self): + """ + Test creating the volume from `uint16` data. The image intensities are between 100 and 150. + """ + array = np.zeros((40, 30, 20), dtype=np.uint16) + array.fill(100) + array.flat[0] = 150 + assert list(np.unique(array)) == [100, 150] # precondition: values are between 100 and 150 + volume = libcarna.volume(self.GEOMETRY_TYPE_VOLUME, array, spacing=(1, 1, 1)) + np.testing.assert_array_almost_equal( + volume.normalized([100, 125, 150]), [0, 0.5, 1], + ) + np.testing.assert_array_almost_equal( + volume.raw([0, 0.5, 1]), [100, 125, 150], + ) + + def test__uint16__raw__uniform(self): + """ + Test creating the volume from `uint16` data. All image intensities are identical. + """ + array = np.full((40, 30, 20), 3, dtype=np.uint16) + assert list(np.unique(array)) == [3] # precondition: all values are 3 + volume = libcarna.volume(self.GEOMETRY_TYPE_VOLUME, array, spacing=(1, 1, 1)) + np.testing.assert_array_almost_equal( + volume.normalized([1, 3, 5]), [0, 0, 0], + ) + np.testing.assert_array_almost_equal( + volume.raw([0, 0.5, 1]), [3, 3, 3], + ) + + def test__float__raw(self): + """ + Test creating the volume from `float` data. The image intensities are between -1 and +3. + """ + array = np.zeros((40, 30, 20), dtype=float) + array.fill(-1) + array.flat[0] = +3 + assert list(np.unique(array)) == [-1, +3] # precondition: values are between -1 and +3 + volume = libcarna.volume(self.GEOMETRY_TYPE_VOLUME, array, spacing=(1, 1, 1)) + np.testing.assert_array_almost_equal( + volume.normalized([-1, +1, +3]), [0, 0.5, 1], + ) + np.testing.assert_array_almost_equal( + volume.raw([0, 0.5, 1]), [-1, +1, +3], + ) + + def test__float__raw__uniform(self): + """ + Test creating the volume from `float` data. All image intensities are identical. + """ + array = np.full((40, 30, 20), -3, dtype=float) + assert list(np.unique(array)) == [-3] # precondition: all values are -3 + volume = libcarna.volume(self.GEOMETRY_TYPE_VOLUME, array, spacing=(1, 1, 1)) + np.testing.assert_array_almost_equal( + volume.normalized([-1, +1, +3]), [0, 0, 0], + ) + np.testing.assert_array_almost_equal( + volume.raw([0, 0.5, 1]), [-3, -3, -3], + ) diff --git a/test/test_tools.py b/test/test_tools.py deleted file mode 100644 index e6c93bf..0000000 --- a/test/test_tools.py +++ /dev/null @@ -1,83 +0,0 @@ -import pathlib -import matplotlib.pyplot as plt -import numpy as np - -SOURCE_PATH = pathlib.Path('@CMAKE_CURRENT_SOURCE_DIR@') - -class Color: - PURPLE = '\033[95m' - CYAN = '\033[96m' - DARKCYAN = '\033[36m' - BLUE = '\033[94m' - GREEN = '\033[92m' - YELLOW = '\033[93m' - RED = '\033[91m' - BOLD = '\033[1m' - UNDERLINE = '\033[4m' - END = '\033[0m' - -def get_expected_rendering(name): - expected_img_path = SOURCE_PATH / f'renderings/{name}.png' - assert expected_img_path.is_file(), expected_img_path - return expected_img_path - -def fail_test(name, *results, suffix=''): - if isinstance(suffix, str) and len(suffix) > 0: suffix = f' ({suffix})' - print(f'{Color.BOLD}{Color.RED}Test failed: {name}{Color.END}{suffix}') - if len(results) == 0: return - if len(results) == 1: results = (results[0], '') - for result_idx in range(len(results) // 2): - result, suffix = results[2 * result_idx], results[2 * result_idx + 1] - output_path = f'/tmp/{name}{suffix}.png' - print(f'{Color.BOLD}Result written to: {output_path}{Color.END}') - plt.imsave(output_path, result) - -def pass_test(name, suffix=''): - if isinstance(suffix, str) and len(suffix) > 0: suffix = f' ({suffix})' - print(f'{Color.BOLD}{Color.GREEN}Test passed: {name}{Color.END}{suffix}') - -class BatchTest: - def __init__(self): - self.success = True - - def assert_true(self, statement, hint): - if not self.update(statement): fail_test(hint) - else: pass_test(hint) - return statement - - def assert_allclose(self, expected, actual, hint): - if not self.assert_true(np.allclose(expected, actual), hint): - print('====== Expected: ======') - print(expected) - print('======= Actual: =======') - print(actual) - print('=======================') - - def update(self, value): - self.success = self.success and value - return value - - def finish(self): - assert self.success, 'Batch test failed' - -def assert_rendering(name, result, max_abs_error=2/255, max_abs_error_exceed_count=250, max_rms_error=0.005, defer=False, batch=None): - if batch is not None: defer = True - try: - expected_img_path = get_expected_rendering(name) - expected_img = plt.imread(expected_img_path)[:, :, :3] - assert result.shape == expected_img.shape, f'Expected shape {expected_img.shape} but found {result.shape}' - assert result.dtype == np.uint8, f'Expected dtype {np.uint8} but dtype {result.dtype}' - result_f = result / 255 - abs_error = np.abs(expected_img - result_f).max() - rms_error = np.sqrt(((expected_img - result_f) ** 2).mean()) - abs_error_exceed_count = (np.abs(expected_img - result_f) > max_abs_error).sum() - hint = f'Abs error: {abs_error:g}, exceeded: {abs_error_exceed_count} times, RMS error: {rms_error:g}' - assert abs_error_exceed_count <= max_abs_error_exceed_count and rms_error <= max_rms_error, hint - pass_test(name, hint) - return True - except Exception as ex: - fail_test(name, result, suffix=str(ex)) - if not defer: raise - if batch is not None: batch.update(False) - return False - diff --git a/test/testsuite.py b/test/testsuite.py new file mode 100644 index 0000000..1004843 --- /dev/null +++ b/test/testsuite.py @@ -0,0 +1,131 @@ +import glob +import io +import pathlib +import re +import unittest + +import faulthandler +faulthandler.enable() + +import matplotlib.pyplot as plt +import numpy as np +import scipy.ndimage as ndi +from apng import APNG +from numpngw import write_apng +from PIL import Image + + +def _imread(path: str) -> np.ndarray: + """ + Reads a PNG as a `YXC` array, and APNG as a `TYXC` array. + """ + + def read_png_frame(buf) -> np.ndarray: + with Image.open(io.BytesIO(buf)) as im: + array = np.array(im) + array = array[:, :, :3] # Ignore alpha channel if present + return array + + im = APNG.open(path) + array = np.array( + [ + read_png_frame(frame[0].to_bytes()) + for frame in im.frames + ] + ) + + # Convert `TYXC` to `YXC` format (APNG -> PNG) + if array.shape[0] == 1 and array.ndim == 4: + array = array[0] + + return array + + +def _imsave(path: str, array: np.ndarray): + if array.ndim == 4: + + # Palette APNG cannot be read proplery by the apng library + write_apng(path, array, delay=40, use_palette=False) + + else: + plt.imsave(path, array) + + +class LibCarnaTestCase(unittest.TestCase): + + pass + + +class LibCarnaRenderingTestCase(LibCarnaTestCase): + + @staticmethod + def _get_expected_image_filepath(filename: str, vendor: str | None) -> str: + results_path = pathlib.Path('test/results') + if vendor is None: + return str(results_path / 'expected' / filename) + else: + for filepath in glob.glob(str(results_path / 'expected_*' / filename)): + m = re.match(r'^.*/expected_(.*)/.*$', filepath) + if m is not None and m.group(1).lower() in re.split(r'[^a-zA-Z0-9]', vendor.lower()): + return filepath + return LibCarnaRenderingTestCase._get_expected_image_filepath(filename, vendor=None) + + def assert_image_almost_equal( + self, + actual: np.ndarray, + expected: str | np.ndarray, + blur: float = 1, + threshold: float = 1, + max_differing_pixels: int = 0, + vendor: str | None = None, + ): + """ + Compare two images, `actual` and `expected`, and assert that they are almost equal. + + The comparison is done by, first, blurring out small details in the images, and then counting the number of + pixels for which the channel-wise difference exceeds a certain` threshold`. The test fails if the number of + differing pixels exceeds `max_differing_pixels`. + + The comparison is performed individually for each frame of an image sequence. + """ + assert not np.issubdtype(actual.dtype, np.floating) + + # If `expected` is a string, read the image from the path. + if isinstance(expected, str): + expected = _imread(LibCarnaRenderingTestCase._get_expected_image_filepath(expected, vendor=vendor)) + + # If the image is in floating point format, convert it to [0, 255] range. + if np.issubdtype(expected.dtype, np.floating): + expected = (expected * 255) + + # Define routine for pairwise comparison of `actual` and `expected` frames. + def verify_frame(actual, expected): + if blur > 0: + actual = ndi.gaussian_filter(actual.astype(float), sigma=blur, axes=(0, 1)) + expected = ndi.gaussian_filter(expected.astype(float), sigma=blur, axes=(0, 1)) + self.assertLessEqual((np.max(np.abs(actual - expected), axis=2) > threshold).sum(), max_differing_pixels) + + # If the image is a single frame, compare it directly. + self.assertEqual(actual.shape, expected.shape) + if actual.ndim == 3: + verify_frame(actual, expected) + + # If the image is a multi-frame image sequence, compare each frame of the sequence. + elif actual.ndim == 4: + for actual_frame, expected_frame in zip(actual, expected): + verify_frame(actual_frame, expected_frame) + + # Complain that we don't know how to handle the shape of the image. + else: + raise ValueError(f'Unsupported array shape: {actual.shape}') + + def assert_image_almost_expected(self, actual, **kwargs): + expected = f'{self.id()}.png' + try: + self.assert_image_almost_equal(actual, expected, **kwargs) + except: + actual_path = pathlib.Path('test/results/actual') / f'{expected}' + actual_path.parent.mkdir(parents=True, exist_ok=True) + _imsave(actual_path, actual) + print(f'Test result was written to: {actual_path.resolve()}') + raise \ No newline at end of file